Flux Java8, résumé de l'expression lambda

Flux Java8, résumé de l'expression lambda

Puisque le prochain site est Java 8, je résumerai principalement les exemples de code que j'ai souvent utilisés pour la révision.

référence http://www.ne.jp/asahi/hishidama/home/tech/java/stream.html

1. Basique

   1. List.forEach

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

C'est la même chose que

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

C'est la même chose que

    ```
    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. Fréquent

2. Créer une carte à partir de la 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,"grand arbre"),new Employee(3,"Tanaka"));
   Map<Integer,String> map = lists.stream().collect(Collectors.toMap(Employee::getId,Employee::getName));
   ```
   

3. Processus dans la liste Stream.map ()

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

4. Stream.filter () Réduire

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

5. Stream.sorted Trié

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

6. Utilisez si bien

7. Stream.of () Création de flux

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

8. Stream.anyMatch () Vérifier les données correspondantes

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

Tout comme ci-dessus sont allMatch (toutes les valeurs correspondent) et noneMatch (toutes les valeurs ne correspondent pas).

1. List.stream (). FlatMap (l-> l.stream ()) Combine des listes dans une liste en une seule

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