1. [Interface funcional]: Uma interface tem apenas um método abstrato, como Runnable, Comparator, etc. Sempre que um objeto de Interface Funcional é necessário, expressões lambda podem ser usadas.
2. [Referência do método]: Passe os parâmetros da expressão lambda como um parâmetro para um método, e seu efeito de execução é o mesmo, então a expressão lambda
pode ser expressa usando a Referência do método e os dois métodos a seguir são equivalentes:
(x) -> System.out.println(x)
System.out::println
Referência de método tem principalmente três formas: 1.Object ::
instanceMethod
2.Class :: staticMethod
3.Class :: instanceMethod
Para os dois primeiros métodos, os parâmetros de expressão lambda e os parâmetros de método correspondentes são os mesmos, por exemplo:
System.out::println
(x) -> System.out.println(x)
Math :: pow
(x, y) -> Math.pow(x, y)
Para o terceiro método, no corpo da expressão lambda correspondente, o primeiro parâmetro é usado como o objeto, o método é chamado e os outros parâmetros
String::compareToIgnoreCase
(s1, s2) -> s1.compareToIgnoreCase(s2)
A referência do construtor é semelhante à referência do método, exceto que é um método especial: novo. Qual construtor é chamado depende do contexto, como:
List<String> labels = ...;
Stream<Button> stream = labels.stream().map(Button::new); Button :: new é equivalente a (x) -> Button (x), então o construtor chamado é: Button (x);
Além de criar um único objeto, você também pode criar uma matriz de objetos. Os dois métodos a seguir são equivalente:
int[]::new
(x) -> new int[x]====== Mapa ======
1. Travessia do mapa
itemsMap.forEach((k,v)->System.out.println("Item : " + k + " Count : " + v));
====== Lista ======
1. Classificação da lista
1), lista crescente
//原始版
words.sort((Word first, Word second) -> first.getName().compareTo(second.getName()));
//精简版
Collections.sort(words, Comparator.comparing(Word::getName));
//精简版，推荐使用这种
words.sort(Comparator.comparing(Word::getName));
//多重排序（连个都升序）
words.sort(Comparator.comparing(Word::getName).thenComparingInt(Word::getCountry));
//多重排序（第一个升，第二个降）
words.sort(Comparator.comparing(Word::getName).reversed().thenComparingInt(Word::getCountry).reversed());
2), lista decrescente
words.sort(Comparator.comparing(Word::getName).reversed());
2. Listar traversal
words.forEach(System.out::println);
3. Lista para mapear (desduplicação principal)
Map<String, Word> wordMapMap = wordList.stream().collect(Collectors.toMap(Word::getName, k -> k, (k1, k2) -> k1));
Lista para mapa (a chave não pode ser repetida)
Map<Integer,Word> userMap = wordList.stream().collect(Collectors.toMap(Word::getCountry, k -> k));
4. Grupo
Map<String, List<Word>> groupMap = wordList.stream().collect(Collectors.groupingBy(Word::getName));
Agrupamento múltiplo
Map<String, Map<Integer, List<Word>>> map2 = words.stream().collect(Collectors.groupingBy(Word::getName,Collectors.groupingBy(Word::getCountry)));
5. Filtro de correspondência
List<Word> filterList = wordList.stream().filter(v -> v.getName().equals("tiger")).collect(Collectors.toList());
wordList.stream().filter(v -> v.getName().contains("老")).forEach(System.out::println);
List<Word> filterList = wordList.stream().filter(v -> v.getCountry() > 2).collect(Collectors.toList());
Predicate<Word> equals1 = v -> v.getCountry().equals(1);
Predicate<Word> contains1 = v -> v.getName().contains("tiger");
List<Word> filterList = wordList.stream().filter(contains1.and(equals1)).collect(Collectors.toList());
List<Double> filteredCost = cost.stream().filter(x -> x > 25.0).collect(Collectors.toList());
6, soma de estatísticas de lista
int sum = wordList.stream().mapToInt(Word::getCountry).sum();
double sum = words.stream().mapToDouble(Word::getCountry).sum();
7. Estatísticas de grupo
Map<String, Long> collectCnt = wordList.stream().collect(Collectors.groupingBy(Word::getName, Collectors.counting()));
8. Estatísticas de grupo
Map<String, LongSummaryStatistics> map3 = words.stream().collect(Collectors.groupingBy(Word::getName,Collectors.summarizingLong(Word::getCountry)));
Estatísticas de agrupamento múltiplo
Map<String, Map<Integer, LongSummaryStatistics>> map3 = words.stream().collect(Collectors.groupingBy(Word::getName,Collectors.groupingBy(Word::getCountry,Collectors.summarizingLong(Word::getCountry))));
9. Desduplicação (reescrever o código igual e hash do Word de acordo com a situação real)
List<Word> list1= list.stream().distinct().collect(Collectors.toList());
10. Montagem de dados
String result = words.stream().map(Word::getName).collect(Collectors.joining("," , "[" , "]"));
12. Coleção de objetos para coleção de atributos
List<String> result = words.stream().map(Word::getName).collect(Collectors.toList());
List<String> result = words.stream().map(y -> y.getName().concat(".jpg")).collect(Collectors.toList());
====== Matriz ======
1. Classificação da matriz
1), ordem crescente da matriz -> versão original
Arrays.sort(people, (first, second) -> Integer.compare(first.length(), second.length()));
Array ascendente -> versão Lite
Arrays.sort(people, Comparator.comparingInt(String::hashCode));
2), matriz decrescente
Arrays.sort(people, (second, first) -> Integer.compare(first.length(), second.length()));
2. Array conta o número de certos elementos
long num = Arrays.stream(name).filter(x -> x.equals("tiger")).count();
3. A matriz é filtrada e convertida em uma coleção
List<String> filterList = Arrays.stream(name).filter(x -> !x.equals("赵强")).collect(Collectors.toList());
4. Filtragem de matriz e adição de sufixos aos elementos
List<String> filterList = Arrays.stream(name).filter(x -> !x.equals("tiger")).map(y -> y.concat(".jpg")).collect(Collectors.toList());
5. Array soma estatística
int num = Arrays.stream(arr).reduce(0, Integer::sum);
double sum = Arrays.asList(10.0, 20.0, 30.0).stream().map(x -> x + x * 0.05).reduce(Double::sum).get();
double sum = Stream.of(10.0, 20.0, 30.0).map(x -> x + x * 0.05).reduce(Double::sum).get();
int sum = Stream.of(1, 2, 3, 4, 5).map(x -> x + x * 5).reduce(Integer::sum).get();
====== Soma ======
BinaryOperator<Integer> add = Integer::sum;
Integer x = add.apply(20, 30);
====== Tópico ======
private static void lambdaRunnable() {
int age = 20;
Runnable r2 = () -> {
System.out.println(age);
System.out.println("Hello world two!"+age);
};
r2.run();
}