Ordinaire, ce n'est que deux mots: paresse et paresse; le
succès n'est que deux mots: épreuve et diligence; l'
excellence n'est que deux mots: vous et moi.
Suivez-moi pour apprendre JAVA, le seau de la famille Spring et les connaissances sur le fonctionnement et la maintenance de Linux à partir de 0, et vous emmener d'un adolescent ignorant au sommet de la vie et épouser Bai Fumei!
Suivez le compte public WeChat [ IT est très fiable ], et partagez votre expérience technique chaque jour ~
java8 流 —stream
1 Introduction à java8
Java 8 (également connu sous le nom de jdk 1.8) est une version majeure du développement du langage Java. Oracle Corporation a publié Java 8 le 18 mars 2014. Il prend en charge la programmation fonctionnelle, un nouveau moteur JavaScript, une nouvelle API de date, une nouvelle API Stream, etc. Java8 est une version révolutionnaire, stable et entièrement fonctionnelle .
À l'heure actuelle, pratiquement toutes les entreprises utilisent la version jdk8 comme environnement de compilation et d'exécution du système Java de l'entreprise. Basée sur jdk8, elle présente les caractéristiques ou avantages suivants:
(1) jdk8 a des fonctions parfaites : jdk8 peut presque répondre au développement de tous les projets java;
(2) Gratuit : jdk8 est gratuit et les versions ultérieures telles que jdk11 sont facturées, ce qui représente des performances à très faible coût pour de nombreuses entreprises;
(3) jdk8 a ajouté plusieurs nouveaux points forts : traitement de flux (flux parallèle), expression lamda, nouvelle API de date et facultatif.
2 java8 流 ： flux
2.1 Préparer les données de test
Nous définissons une méthode getUsers () qui renvoie une collection List d'objets utilisateur User pour les tests Api ultérieurs.
Définissez la classe User.java:
package com.hc.alltest.all.java8.stream;
import java.io.Serializable;
import java.util.List;
import java.util.Objects;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 用户
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable, Comparable {
/**
* 用户名
*/
private String name;
/**
* 年龄
*/
private Integer age;
/**
* 兴趣爱好
*/
private List<String> hobbies;
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
User user = (User) o;
return Objects.equals(getName(), user.getName());
}
@Override
public int hashCode() {
return Objects.hash(getName());
}
/**
* 默认排序：age升序
*/
@Override
public int compareTo(Object o) {
User user = (User) o;
return this.age - user.getAge();
}
}
Méthode pour obtenir la liste des utilisateurs: getUsers ()
/**
* 获取用户列表
*/
private static List<User> getUsers() {
List<User> users = new ArrayList<>();
users.add(User.builder().name("张三").age(10).hobbies(Arrays.asList("篮球", "乒乓球")).build());
users.add(User.builder().name("李四").age(30).hobbies(Arrays.asList("游泳", "篮球")).build());
users.add(User.builder().name("王五").age(20).hobbies(Arrays.asList("小说", "音乐")).build());
users.add(User.builder().name("小六").age(15).hobbies(Arrays.asList("跑步", "篮球")).build());
users.add(User.builder().name("李四").age(15).hobbies(Collections.emptyList()).build());
return users;
}
2.2 filtre
Filtrez les utilisateurs âgés de plus de 20 ans dans la collection.
/**
* 1.filter：筛选出年龄大于20岁的用户
*/
private static void filterTest() {
List<User> users = getUsers();
users = users.stream()
.filter(user -> user.getAge() > 20)
.collect(Collectors.toList());
log.info("筛选出年龄大于20岁的用户：{}", users);
}
2.3 Déduplication distincte
Déduplication (le même nom est considéré comme le même utilisateur). Besoin de remplacer les méthodes equals () et hashCode () de la classe User.java.
/**
* 2.distinct：去重（name相同认为是同一用户）
*/
private static void distinctTest() {
//users集合里面有两个name为“李四”的用户
List<User> users = getUsers();
users = users.stream()
.distinct()
.collect(Collectors.toList());
log.info("去重（name相同认为是同一用户）：{}", users);
}
2,4 comptage
Comptez le nombre d'éléments de collection.
/**
* 3.count：统计集合元素个数
*/
private static void countTest() {
List<User> users = getUsers();
long count = users.stream()
.count();
log.info("集合元素个数：{}", count);
}
2.5 pour chaque parcours
Traverse (boucle) traitant tous les éléments de la collection.
/**
* 4.forEach：遍历（循环）处理集合所有元素
*/
private static void forEachTest() {
List<User> users = getUsers();
users.stream()
.forEach(user -> {
//业务处理
log.info("遍历当前元素为：{}", user);
});
}
2.6 Tri par défaut trié
Les éléments de la collection sont triés par défaut (triés par âge dans l'ordre croissant). La classe User.java doit implémenter l'interface Comparable et implémenter la méthode abstraite d'interface int compareTo (Object o).
/**
* 5.sorted：集合元素默认排序（按age升序排序）
*/
private static void defaultSortedTest() {
List<User> users = getUsers();
users = users.stream()
.sorted()
.collect(Collectors.toList());
log.info("默认排序后：{}", users);
}
2.7 tri trié dans l'ordre spécifié
Les éléments de l'ensemble sont triés (triés par ordre croissant par âge).
/**
* 6.sorted：集合元素指定排序（按age升序排序）
*/
private static void specifySortedTest() {
List<User> users = getUsers();
users = users.stream()
//.sorted((u1, u2) -> u1.getAge() - u2.getAge())
.sorted(Comparator.comparingInt(User::getAge))
.collect(Collectors.toList());
log.info("指定排序后：{}", users);
}
2.8 ordre inverse inversé
Les éléments de l'ensemble sont triés (triés par ordre croissant d'âge) et inversés.
/**
* 7.reversed：集合元素指定排序（按age升序排序）,并取反序
*/
private static void reverseTest() {
List<User> users = getUsers();
users = users.stream()
// .sorted((u1, u2) -> u2.getAge() - u1.getAge())
.sorted(Comparator.comparingInt(User::getAge).reversed())
.collect(Collectors.toList());
log.info("指定排序,并取反序：{}", users);
}
2.9 findFirst pour obtenir le premier élément
Prenez le premier élément de l'ensemble.
/**
* 8.findFirst：取集合中第一个元素
*/
private static void findFirstTest() {
List<User> users = getUsers();
User firstUser = users.stream()
.findFirst()
.orElse(null);
log.info("集合中第一个元素为：{}", firstUser);
}
2.10 findAny obtient n'importe quel élément de l'ensemble
Prenez n'importe quel élément de l'ensemble.
/**
* 9.findAny：取集合中任意一个元素
*/
private static void findAnyTest() {
List<User> users = getUsers();
User anyUser = users.stream()
.findAny()
.orElse(null);
log.info("集合中任意一个元素为：{}", anyUser);
}
2,11 min minimum
Prenez l'élément le plus jeune de l'ensemble ...
/**
* 10.min：取集合中年龄最小的元素
*/
private static void minTest() {
List<User> users = getUsers();
User anyUser = users.stream()
//.min((u1, u2) -> u1.getAge() - u2.getAge())
.min(Comparator.comparingInt(User::getAge))
.orElse(null);
log.info("集合中年龄最小的元素为：{}", anyUser);
}
2,12 max
Prenez l'élément le plus ancien de l'ensemble.
/**
* 11.max：取集合中年龄最大的元素
*/
private static void maxTest() {
List<User> users = getUsers();
User anyUser = users.stream()
//.max((u1, u2) -> u1.getAge() - u2.getAge())
.max(Comparator.comparingInt(User::getAge))
.orElse(null);
log.info("集合中年龄最大的元素为：{}", anyUser);
}
2.13 anyMatch n'importe quel élément correspondant
Si un élément de l'ensemble satisfait à la condition, il renvoie true; sinon, il retourne false.
/**
* 12.anyMatch：集合中任意一个元素满足条件，返回true；反之，返回false
*/
private static void anyMatchTest() {
List<User> users = getUsers();
boolean matchFlag = users.stream()
.anyMatch(user -> Objects.equals(user.getName(), "李四"));
log.info("集合中是否存在名为'李四'的元素：{}", matchFlag);
}
2.14 allMatch tous les éléments correspondent
Si tous les éléments de la collection remplissent la condition, renvoie true; sinon, renvoie false.
/**
* 13.allMatch：集合中所有元素满足条件，返回true；反之，返回false
*/
private static void allMatchTest() {
List<User> users = getUsers();
boolean matchFlag = users.stream()
.allMatch(user -> user.getAge() > 20);
log.info("集合中所有元素的年龄是否都大于20岁：{}", matchFlag);
}
2.15 aucunMatch tous les éléments ne correspondent pas
Si tous les éléments de la collection ne satisfont pas à la condition, renvoie true; sinon, renvoie false.
/**
* 14.noneMatch：集合中所有元素都不满足条件，返回true；反之，返回false
*/
private static void noneMatchTest() {
List<User> users = getUsers();
boolean matchFlag = users.stream()
.noneMatch(user -> user.getAge() <= 20);
log.info("集合中是否所有元素的年龄都不小于等于20岁：{}", matchFlag);
}
2.16 mappage de la valeur d'ensemble de la carte
Définir le mappage de valeur.
/**
* 15.map：集合值映射
*/
private static void mapTest() {
List<User> users = getUsers();
List<String> names = users.stream()
// .map(user -> user.getName())
.map(User::getName)
.collect(Collectors.toList());
log.info("集合中所有对象的名称集合为：{}", names);
}
2.17 Mappage à plat de la valeur définie flatMap
Cartographie plate des valeurs de consigne.
/**
* 16.flatMap：集合值扁平映射
*/
private static void flatMapTest() {
List<User> users = getUsers();
List<String> allHobbies = users.stream()
.flatMap(user -> user.getHobbies().stream())
.collect(Collectors.toList());
log.info("集合中所有用户的所有兴趣爱好列表：{}", allHobbies);
}
2.18 carte + évaluation d'agrégation réduite
Évaluation globale.
/**
* 17.map+reduce：聚合求值
*/
private static void mapReduceTest() {
List<User> users = getUsers();
int ageSum = users.stream()
// .map(user -> user.getAge())
.map(User::getAge)
.reduce(0, (age1, age2) -> age1 + age2);
log.info("集合中所有用户年龄总和：{}", ageSum);
}
2.19 flux parallèle parallèle
Traitement de flux parallèle.
/**
* 18.parallel：并行流处理
*/
private static void parallelStreamTest() {
List<User> users = getUsers();
//下面两种方式等效
users.stream()
.parallel()
.forEach(user -> {
//业务处理
log.info(".stream.parallel并行遍历当前元素为：{}", user);
});
users.parallelStream()
.parallel()
.forEach(user -> {
//业务处理
log.info(".parallelStream并行遍历当前元素为：{}", user);
});
}Suivez le compte public WeChat et répondez " Je veux diffuser du code source " pour obtenir gratuitement le code source de la démonstration, Java et les didacticiels vidéo associés de ce didacticiel ~
