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