Expression lambda et traitement de flux Stream

1. Avantages des expressions Lambda

1) JDK8 a commencé à prendre en charge les expressions Lambda pour rendre la programmation plus élégante

2) Les classes internes anonymes et les déclarations et appels de fonction peuvent être réalisés de manière plus concise en utilisant Lambda

3) Le traitement de flux basé sur Lambda simplifie grandement les opérations sur les collections

        Mettre en œuvre le code hérité de tri des collections

        List<String> names = Arrays.asList("peter","anna","mike");
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return b.compareTo(a);
            }
        });

        Utilisez des expressions Lambda pour réaliser les fonctions ci-dessus

        List<String> names = Arrays.asList("peter","anna","mike");
        Collections.sort(names, (a, b) -> b.compareTo(a));

Deux, format de syntaxe d'expression Lambda

        Les expressions lambda ne peuvent implémenter des interfaces qu'avec une et une seule méthode abstraite, appelées interfaces fonctionnelles 

3. Programmation fonctionnelle

        La programmation fonctionnelle est un style de programmation basé sur des interfaces fonctionnelles et exprimé à l'aide de lambdas.

        L'idée de la programmation fonctionnelle est d'amener le code à l'exécution sous forme de données réutilisables . La programmation fonctionnelle met l'accent sur "que voulez-vous faire" plutôt que sur "comment voulez-vous le faire". comme suit

    public void test(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);
        filter(list, n -> n%2 == 1);
        filter(list, n -> n%2 == 0);
    }
    public static void filter(List<Integer> list, Predicate<Integer> predicate) {
        for (Integer num: list) {
            if(predicate.test(num)){
                System.out.printf(num+"");
            }
        }
    }

        Une interface fonctionnelle est une interface avec une et une seule méthode abstraite. Il existe un grand nombre d'interfaces fonctionnelles en Java, telles que java.lang.Runnable. Java8 fournit une série de nouvelles interfaces fonctionnelles, situées dans java.util.function.

        Predicate<T> : reçoit un paramètre et renvoie une valeur booléenne, qui est utilisée pour tester si les données entrantes répondent aux exigences de jugement. Le prédicat doit implémenter la méthode test() pour un jugement logique.

       Consumer<T> : reçoit un paramètre, ne renvoie pas de résultat et possède une méthode d'acceptation.

       IntConsumer : Consommateur dont le paramètre est un entier

        Function<T,R> : recevez un paramètre et devez renvoyer des données, il existe une méthode d'application

        Lors de la personnalisation d'une interface fonctionnelle, vous pouvez utiliser l'annotation @FunctionalInterface pour informer le compilateur qu'il s'agit d'une interface fonctionnelle, et vous pouvez vérifier ou non la méthode abstraite.

4. Comparaison de la programmation fonctionnelle et de la programmation orientée objet

Cinq, traitement de flux de flux

        Le traitement de flux de flux est une technologie de traitement multi-données basée sur Lambda. Le flux de données abstrait fortement le traitement des données de collecte et simplifie considérablement la quantité de code. Stream peut effectuer une série de traitements tels que l'itération, la déduplication, le filtrage, le tri et l'agrégation sur la collection.

//        获取List集合中最大的偶数
        Optional<Integer> op = Arrays.asList(1,2,3,4,5,6,7,8,9).stream()
                .filter(x -> x%2 == 0)
                .sorted((a,b) -> b-a)
                .findFirst();
        System.out.println(op.get());

        Méthodes courantes de traitement de flux

 collect : collecter des données de streaming et générer une nouvelle liste/ensemble 

        exemple d'utilisation de méthode

        // 偶数求和        
        List<String> list = Arrays.asList("1","2","3","4");
        int sum = list.stream()
                .mapToInt(s -> Integer.parseInt(s))
                .filter(num -> num%2 == 0)
                .sum();

        // 首字母转大写
        List<String> list = Arrays.asList("lily","andy","jack","smith");
        List<String> result = list.stream()
                .map(s -> s.substring(0,1).toUpperCase() + s.substring(1))
                .collect(Collectors.toList());

         // 将所有奇数从小到大排序，且不许出现重复
        List<Integer> list = Arrays.asList(11, 2, 38, 4, 52, 6, 7, 11);
        List<Integer> result = list.stream()
                .distinct()     //去除重复流数据
                .filter( n -> n%2 == 1)
                .sorted((a,b) -> b-a)       //排序
                .collect(Collectors.toList());

6. Cinq façons de créer des objets de flux

1) Créer basé sur un tableau

String[] arr = {"Lily", "Andy", "Jackson"};
Stream<String> stream = Stream.of(arr);
stream.forEach(s -> System.out.println(s));

2) Créer basé sur la collection 

List<String> list = new ArrayList<>();
list.add("Lily");
list.add("Andy");
Stream stream = list.stream();

3) Utilisez la méthode de génération pour créer un flux de longueur infinie

Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(100000));
stream.limit(10).forEach(i -> System.out.println(i));

4) Créer un flux basé sur un itérateur

Stream<Integer> stream = Stream.iterate(1, n -> n+1).limit(100);

5) Créer un flux basé sur une séquence de caractères 

// 可以处理汉字，会自动转为unicode码
String str = "abcdefg嘿嘿";
IntStream stream = str.chars();
stream.forEach(c -> System.out.println((char)c));