Habilidades de caso de uso de expresiones lambda en java

1. [Interfaz funcional]: una interfaz tiene solo un método abstracto, como Runnable, Comparator, etc. Siempre que se necesite un objeto de interfaz funcional, se pueden utilizar expresiones lambda.

2. [Referencia de método]: pasa los parámetros de la expresión lambda como un parámetro a un método, y su efecto de ejecución es el mismo, entonces la expresión lambda
se puede expresar usando la Referencia de método, y los dos métodos siguientes son equivalentes:

  (x) -> System.out.println(x)
  System.out::println

La referencia de método tiene principalmente tres formas:
1.Object :: instanceMethod
2.Class :: staticMethod
3.Class :: instanceMethod

Para los dos primeros métodos, los parámetros de expresión lambda correspondientes y los parámetros del método son los mismos, por ejemplo:

  System.out::println
  (x) -> System.out.println(x)

Matemáticas :: pow

  (x, y) -> Math.pow(x, y)

Para el tercer método, en el cuerpo de la expresión lambda correspondiente, el primer parámetro se usa como objeto, se llama al método y los otros parámetros

  String::compareToIgnoreCase
  (s1, s2) -> s1.compareToIgnoreCase(s2)

La referencia de constructor es similar a la referencia de método, excepto que es un método especial: nuevo. El constructor que se llame depende del contexto, como por ejemplo:

  List<String> labels = ...;
  Stream<Button> stream = labels.stream().map(Button::new);

Button :: new es equivalente a (x) -> Button (x), por lo que el constructor llamado es: Button (x);
Además de crear un solo objeto, también puede crear una matriz de objetos. Los siguientes dos métodos son equivalente:

  int[]::new 
  (x) -> new int[x]

====== Mapa ======

1. Recorrido del mapa

itemsMap.forEach((k,v)->System.out.println("Item : " + k + " Count : " + v));

====== Lista ======

1. Clasificación de listas

1), lista ascendente

    //原始版
    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 descendente

words.sort(Comparator.comparing(Word::getName).reversed());

2. Recorrido de lista

words.forEach(System.out::println);

3. Lista para asignar (deduplicación de claves)

Map<String, Word> wordMapMap = wordList.stream().collect(Collectors.toMap(Word::getName, k -> k, (k1, k2) -> k1));

Lista a mapa (la clave no se puede repetir)

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));

Agrupación múltiple

Map<String, Map<Integer, List<Word>>> map2 = words.stream().collect(Collectors.groupingBy(Word::getName,Collectors.groupingBy(Word::getCountry)));

5. Filtrado de partidos

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, resumen de estadísticas de lista

int sum = wordList.stream().mapToInt(Word::getCountry).sum();

double sum = words.stream().mapToDouble(Word::getCountry).sum();

7. Estadísticas de grupo

Map<String, Long> collectCnt = wordList.stream().collect(Collectors.groupingBy(Word::getName, Collectors.counting()));

8. Estadísticas de grupo

Map<String, LongSummaryStatistics> map3 = words.stream().collect(Collectors.groupingBy(Word::getName,Collectors.summarizingLong(Word::getCountry)));

Estadísticas de agrupación múltiple

Map<String, Map<Integer, LongSummaryStatistics>> map3 = words.stream().collect(Collectors.groupingBy(Word::getName,Collectors.groupingBy(Word::getCountry,Collectors.summarizingLong(Word::getCountry))));

9. Deduplicación (vuelva a escribir los iguales y el código hash de Word de acuerdo con la situación real)

List<Word> list1= list.stream().distinct().collect(Collectors.toList());

10. Ensamblaje de datos

String result = words.stream().map(Word::getName).collect(Collectors.joining("," , "[" , "]"));

12. Colección de objetos a colección 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. Clasificación
de matrices 1), orden de matrices ascendente -> versión original

Arrays.sort(people, (first, second) -> Integer.compare(first.length(),  second.length()));

Matriz ascendente -> versión Lite

Arrays.sort(people, Comparator.comparingInt(String::hashCode));

2), matriz descendente

Arrays.sort(people, (second, first) -> Integer.compare(first.length(), second.length()));

2. Array cuenta el número de ciertos elementos

long num = Arrays.stream(name).filter(x -> x.equals("tiger")).count();

3. La matriz se filtra y se convierte en una colección.

List<String> filterList = Arrays.stream(name).filter(x -> !x.equals("赵强")).collect(Collectors.toList());

4. Filtrado de matrices y adición de sufijos a los elementos

List<String> filterList = Arrays.stream(name).filter(x -> !x.equals("tiger")).map(y -> y.concat(".jpg")).collect(Collectors.toList());

5. Arreglo de suma estadí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();

====== Suma ======

  BinaryOperator<Integer> add = Integer::sum;
  Integer x = add.apply(20, 30);

====== Hilo ======

    private static void lambdaRunnable() {
        int age = 20;
        Runnable r2 = () -> {
            System.out.println(age);
            System.out.println("Hello world two!"+age);
        };
        r2.run();
    }

Habilidades de caso de uso de expresiones lambda en java

Supongo que te gusta