Java8-Stream, Zusammenfassung des Lambda-Ausdrucks

Java8-Stream, Zusammenfassung des Lambda-Ausdrucks

Da die nächste Site Java 8 ist, werde ich hauptsächlich die Codebeispiele zusammenfassen, die ich häufig zur Überprüfung verwendet habe.

Referenz http://www.ne.jp/asahi/hishidama/home/tech/java/stream.html

1. Grundlegend

   1. List.forEach

      List<Integer> list = Arrays.asList(1,2,3);
      list.forEach(System.out :: println);
      

Dies ist das gleiche wie

    ```
    List<Integer> list = Arrays.asList(1,2,3);
    for(int i: list){
    	System.out.println(i);
    }
    ```

1. Map.forEach

    ```
    Map<Integer,String> map = new HashMap<>();
    map.put(1,"a");
    map.put(2,"b");
    map.forEach((k,v) -> System.out.println(v));
    ```

Dies ist das gleiche wie

    ```
    Map<Integer,String> map = new HashMap<>();
    map.put(1,"a");
    map.put(2,"b");
    for(Entry<Integer, String> entry : map.entrySet()) {
      System.out.println(entry.getValue());
    }
    ```

1. Häufig

2. Erstellen Sie eine Karte aus der Liste Stream.collect (Collectors.toMap ())

   ```
   class Employee {
     private int id;
     private String name;
   
     public Employee(int id,String name){
       this.id = id;
       this.name = name;
     }
   
     public int getId() {
       return this.id;
     }
   
     public String getName() {
       return this.name;
     }
   }
   
   List<Employee> list = Arrays.asList(new Employee(1,"Sato"),new Employee(2,"großer Baum"),new Employee(3,"Tanaka"));
   Map<Integer,String> map = lists.stream().collect(Collectors.toMap(Employee::getId,Employee::getName));
   ```
   

3. In Stream.map () Liste verarbeiten

   ```
   List<Integer> list = Arrays.asList(1,2,3);
   List<Integer> list2 = list.stream().map(i -> i * 2).collect(Collectors.toList());
   ```
   

4. Stream.filter () Eingrenzen

   ```
   List<Integer> list = Arrays.asList(1,2,3);
   list.stream().filter(i -> i < 3).forEach(System.out :: println);
   ```
   

5. Stream.sorted Sorted

   ```
   List<Integer> list = Arrays.asList(1,3,2);
   list.stream().sorted(Comparator.comparing(i -> i)).forEach(System.out :: println);
   ```
   

6. Verwenden Sie so gut

7. Stream.of () Stream-Erstellung

   ```
   Stream<Integer> stream = Stream.of(1,2,3);
   ```
   

8. Stream.anyMatch () Auf übereinstimmende Daten prüfen

   ```
   List<Integer> list = Arrays.asList(1,2,3);
   boolean m = list.stream().anyMatch(i -> i == 2);
   ```
   

Ähnlich wie oben sind allMatch (alle Werte stimmen überein) und noneMatch (alle Werte stimmen nicht überein).

1. List.stream (). FlatMap (l-> l.stream ()) Kombiniert Listen in List zu einer

   ```
   List<List<Integer>> list = Arrays.asList(Arrays.asList(1,2,3),Arrays.asList(4,5,6));
   List<Integer> list2 = list.stream().flatMap(l -> l.stream()).collect(Collectors.toList());
   ```