Interface de prédicat
Introduction à l'interface Predicate
Predicate est une interface fonctionnelle qui peut utiliser des expressions Lambda comme paramètres. Java 8 ajoute une nouvelle removeIf(Predicate filter)méthode à la collection , qui peut supprimer tous les éléments qui remplissent les conditions de filtrage par lots.
Exemples d'utilisation de l'interface de prédicat
Méthodes de collecte des tests removeIf().
Exemple 1
1) Exécuter la classe:
public class DemoApplication {
public static void main(String[] args) {
// 创建集合
Collection collection = new HashSet();
// 添加元素
collection.add("book01");
collection.add("book02");
collection.add("book03");
collection.add("b05");
collection.add("b06");
Collection collectionNew = new HashSet();
// 使用Lambda表达式遍历传入新的集合
collection.forEach(str -> collectionNew.add(str));
System.out.println("collectionNew: " + collectionNew);
// 使用Lambda表达式进行过滤（目标类型是Predicate）
collection.removeIf(filter -> ((String)filter).length() < 5);
// 使用Lambda表达式遍历打印
collection.forEach(str -> System.out.println(str));
}
}
2) Résultat de l'opération:
collectionNew: [book02, book01, b05, book03, b06]
book02
book01
book03
A partir des résultats ci - dessus, nous pouvons voir un appel collection Collection removeIf()méthodes, filtre lot peut répondre aux conditions de la longueur de l' élément de collecte est inférieur à 5, le programme est une expression lambda à filtre entrant: collection.removeIf(filter -> ((String)filter).length() < 5);.
Exemple 2 Méthode
utilisant l'interface Predicate 1) Créez une classe d'outils:boolean test(T t);
import java.util.Collection;
import java.util.function.Predicate;
/**
* @author andya
* @create 2020-03-24 14:08
*/
public class PredicateUtil {
public static int countCollectionElement(Collection collection, Predicate predicate){
int total = 0;
for (Object object : collection) {
//通过Predicate的test()方法判断对象是否满足过滤条件
if (predicate.test(object)) {
total ++;
}
}
return total;
}
}
2) Exécuter la classe:
public class DemoApplication {
public static void main(String[] args) {
// 创建集合
Collection collection = new HashSet();
// 添加元素
collection.add("book_java编程思想");
collection.add("book_c++核心技术");
collection.add("book_java核心技术");
collection.add("book_计算机网络");
collection.add("book01");
collection.add("book02");
Collection collectionNew = new HashSet();
// 使用Lambda表达式遍历传入新的集合
collection.forEach(str -> collectionNew.add(str));
System.out.println("collectionNew: " + collectionNew);
System.out.println("包含java关键字的个数：" +
PredicateUtil.countCollectionElement(collection, ele -> ((String)ele).contains("java")));
System.out.println("长度小于7的个数：" +
PredicateUtil.countCollectionElement(collection, ele -> ((String)ele).length() < 7));
System.out.println("以book_为前缀的个数：" +
PredicateUtil.countCollectionElement(collection, ele -> ((String)ele).startsWith("book_")));
}
}
3) Résultat de l'opération:
collectionNew: [book02, book01, book_java编程思想, book_java核心技术, book_计算机网络, book_c++核心技术]
包含java关键字的个数：2
长度小于7的个数：2
以book_为前缀的个数：4
Une countCollectionElement()méthode est définie qui utilise Predicate pour passer dynamiquement des paramètres afin de déterminer si chaque élément de collection remplit les conditions de filtrage.
Interface de flux
Présentation de l'interface de flux de flux
De nouvelles fonctionnalités Java 8 ont également ajouté le streaming, comme Stream, IntStream, DoubleStream, LongStream et d'autres API. Chaque API de streaming fournit également le générateur correspondant, tel que Stream.Builder, IntStream.Builder, DoubleStream.Builder, LongStream.Builder.
Étapes d'utilisation du flux
- Utilisez Stream et d'autres
builder()méthodes de classe API pour créer la classe Builder correspondante de Stream; - Appelez la
add()méthode Builder pour ajouter plusieurs éléments au flux; - Appelez la
build()méthode de Builder pour obtenir le Stream correspondant; - Appelez la méthode d'agrégation Stream;
Exemple d'utilisation de flux
public class DemoApplication {
public static void main(String[] args) {
//通过xxxStream的builder()方法去创建Builder
IntStream intStream = IntStream.builder()
.add(1)
.add(-2)
.add(3)
.add(10)
.build();
// 聚集方法（每次只能使用其中一条去执行，其他代码需注释，否则会报错）
System.out.println("intStream的元素最大值是： " + intStream.max().getAsInt());
System.out.println("intStream的元素最小值是： " + intStream.min().getAsInt());
System.out.println("intStream的元素平均值是： " + intStream.average());
System.out.println("intStream的元素总和是： " + intStream.sum());
System.out.println("intStream的元素个数是： " + intStream.count());
System.out.println("intStream是否包含任何元素平方大于10： "
+ intStream.anyMatch(ele -> ele * ele > 10));
System.out.println("intStream的所有元素立方是否大于10: "
+ intStream.allMatch(ele -> ele * ele * ele > 10));
// 每个元素都加1后映射成新的Stream
IntStream intStreamNew = intStream.map(ele -> ele + 1);
intStreamNew.forEach(ele -> System.out.println(ele));
}
}
Résultat de l'opération: mettez tous les résultats d'exécution de la méthode d'agrégation ci-dessus dans un seul affichage, en fait, un seul peut être exécuté;
intStream的元素最大值是： 10
intStream的元素最小值是： -2
intStream的元素平均值是： OptionalDouble[3.0]
intStream的元素总和是： 12
intStream的元素个数是： 4
intStream是否包含任何元素平方大于10： true
intStream的所有元素立方是否大于10: false
2
-1
4
11
Dans l'exemple ci-dessus, il existe deux méthodes d'agrégation: "méthode intermédiaire" et "méthode finale".
- Méthodes intermédiaires : les opérations intermédiaires permettent au flux de rester ouvert et aux méthodes suivantes d'être appelées directement, telles que les
map()méthodes avec une valeur de retour d'un autre flux; - Méthode de fin : la méthode de fin est l'opération finale
sum()effectuée sur le flux . Si la méthode est exécutée, le flux n'est pas disponible. Si elle est utilisée à nouveau, une erreur sera signaléeException in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
Méthodes courantes de Stream
Méthode intermédiaire
filter(Predicate predicate): Filtre les éléments du flux qui ne remplissent pas les conditions de filtrage des prédicats.mapToXxx(ToXxxFunction mapper): Utilisez ToXxxFunction pour effectuer une conversion un-à-un sur les éléments du flux. La méthode renvoie tous les éléments générés par la transformation ToXxxFunction dans le nouveau flux.peek(Consumer action): Utilisez chaque élément tour à tour. Le flux renvoyé contient les mêmes éléments que le flux d'origine et est utilisé pour le débogage.distinct(): Méthode dynamique pour trier tous les éléments répétés dans le flux;sorted(): Il est utilisé pour s'assurer que les éléments du flux sont dans un état ordonné lors des visites suivantes, et c'est également une méthode avec état.limit(long maxSize): Il est utilisé pour garantir le nombre maximal d'éléments accessibles lors des accès ultérieurs au flux. Il s'agit d'une méthode de court-circuit avec état.
Méthode de fin
forEach(Consumer action): Parcourez tous les éléments du flux et exécutez l'action.toArray(): Convertir tous les éléments du flux en un tableau.reduce(): Utilisé pour fusionner des éléments dans une opération.min(): Renvoie la valeur minimale des éléments du flux.max(): Renvoie la valeur maximale des éléments du flux.sum(): Renvoie la somme des éléments du flux.count(): Renvoie le nombre de tous les éléments du flux.anyMatch(Predicate predicate): Déterminez si le flux contient au moins un élément qui remplit la condition de filtre de prédicat.allMatch(Predicate predicate): Déterminez si tous les éléments du flux remplissent la condition de filtre de prédicat.noneMatch(Predicate predicate): Déterminez si tous les éléments du flux ne remplissent pas la condition de filtre de prédicat.findFirst(): Renvoie le premier élément du flux.findAny(): Retourne n'importe quel élément du flux.
La méthode stream () dans Collection
public class DemoApplication {
public static void main(String[] args) {
// 创建集合
Collection collection = new HashSet();
// 添加元素
collection.add("book_java编程思想");
collection.add("book_c++核心技术");
collection.add("book_java核心技术");
collection.add("book_计算机网络");
collection.add("book01");
collection.add("book02");
collection.forEach(ele -> System.out.println(ele));
System.out.println("-------------------------------------");
System.out.println("包含java关键字的个数："
+ collection.stream().filter(ele -> ((String)ele).contains("java")).count());
System.out.println("长度小于7的个数："
+ collection.stream().filter(ele -> ((String)ele).length() < 7).count());
System.out.println("以book_为前缀的个数："
+ collection.stream().filter(ele -> ((String)ele).startsWith("book_")).count());
System.out.println("-------------------------------------");
//先调用Collection的stream()方法将集合转化为Stream；
//再调用Stream的mapToInt()方法获取Stream对象的IntStream对象；
//最后调用forEach()方法遍历IntStream中的元素。
Collection collectionLength = new ArrayList();
collection.stream().mapToInt(ele -> ((String)ele).length())
.forEach(ele -> ((ArrayList) collectionLength).add(ele));
//等价于collectionLength.forEach(ele -> System.out.println(ele));
collectionLength.forEach(System.out::println);
}
}
Résultat de l'opération
book02
book01
book_java编程思想
book_java核心技术
book_计算机网络
book_c++核心技术
-------------------------------------
包含java关键字的个数：2
长度小于7的个数：2
以book_为前缀的个数：4
-------------------------------------
6
6
13
13
10
12
De collection.stream().filter(Predicate<? super T> predicate).count()cette façon, vous pouvez remplacer la méthode PredicateUtil créée plus haut dans l'article.
stream()La méthode est la suivante:
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
filter()La méthode est la suivante:
Stream<T> filter(Predicate<? super T> predicate);
En plus d'utiliser directement l'interface de flux Stream pour traiter les éléments de la collection Collection, nous pouvons également stream()renvoyer le flux correspondant à la collection via la méthode de l' interface Collection .
Les étapes sont les suivantes:
- Appelez d'abord la
stream()méthode de Collection pour convertir la collection en Stream; - Appelez ensuite la
mapToInt()méthode Stream pour obtenir l'objet IntStream de l'objet Stream; - Enfin, appelez la
forEach()méthode pour parcourir les éléments dans IntStream.
Ouvrage de référence "Crazy Java"
