Analyser les instances de flux Stream en Java

Stream

L'article précédent parlait d'une nouvelle fonctionnalité de Java 8 : les expressions Lambda, si elles sont utilisées habilement en entreprise, elles peuvent économiser beaucoup de code et paraître beaucoup plus soignées. Ensuite, cet article introduira une autre nouveauté : StreamStream, ne vous méprenez pas ! ! ! Pas pour jouer à des jeuxsteam ! !

1. Qu'est-ce que Stream :

Stream est un nouveau concept proposé par Java 8. Ce n'est pas un Stream d'entrée et de sortie (cela n'a rien à voir avec le flux IO en fait) , mais une fonction qui utilise Programmatique Outils pour opérer sur les classes de collection. En bref, il s'agit d'une opération de traitement des données de collection dans une méthode d'itération interne. L'itération interne peut donner plus de contrôle à la classe de collection. Les fonctions de Stream et Iterator sont similaires, sauf qu'Iterator est une opération qui traite les données de collecte sous forme d'itération externe.

Bien sûr, Stream a aussi ses propres caractéristiques :

1 Ce n'est pas une structure de données et ne stocke pas de données. Il définit simplement un ensemble d'opérations sur l'ensemble de données d'origine

2. c'est-à-dire qu'à chaque accès, seul un élément du flux effectuera cette série d'opérations sur cet élément

3. Étant donné que les données ne sont pas enregistrées, chaque flux ne peut être utilisé qu'une seule fois.

Schéma d'implémentation du flux Stream :

2. Créer un flux :

Si vous souhaitez utiliser le flux Stream pour exploiter une collection, vous devez convertir le tableau ou la collection en flux Stream avant de pouvoir l'exploiter

Documentation officielle Stream :

https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/stream/Stream.html

Examinons d'abord quatre méthodes :

1.filter : utiliser des expressions lambda pour implémenter le filtrage conditionnel

2.limit : intercepter le flux, intercepter une section du flux

3.skip : ignorer le débordement

4.distinct : supprimer les doublons

Créer un flux :

public class Test {
    public static void main(String[] args) {
        String [] arr = {"东","南","西","北"};
        //将数组转换成Stream
        Stream<String> stream = Arrays.stream(arr);
        stream = Stream.of(arr);
        stream = Stream.of("东","南","西","北");
        //将list集合转换成stream
        List<String> list = Arrays.asList("aa","cc","bb","aa","dd");
        stream = list.stream();
        //排序、去重、遍历
        list.stream().sorted().distinct().forEach(System.out::println);
        //用过Stream流操作完集合后还可以再转换成一个新的集合
        List<String> newList = list.stream().sorted().distinct().collect(Collectors.toList());
        System.out.println(newList.toString());
    }
}

Sortie :

//Le résultat après parcours et déduplication :
aa
bb
cc
jj
//Utilisé Une fois que le flux Stream exploite la collection, celle-ci peut être convertie en une nouvelle collection
[aa, bb, cc, dd]

Quatre méthodes de fonctionnement : Classe Personne :

Cette classe a beaucoup de code, qui ne sont pas tous Les méthodes get/set sont écrites, ne les oubliez pas lorsque vous les utilisez ! !

public class Person {
    private String  name;
    private Integer age;
    private  String country;
    private  char sex;
    @Override
    public String toString() {
        return "信息表：{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", country='" + country + '\'' +
                ", sex=" + sex +
                '}';
    }
//这里节省的get/set代码
//重写toString（） 和 equals 和 hashcode 方法
    @Override
    public boolean equals(Object o){
        if(this == o)
            return true;
        if(o == null || getClass() != o.getClass())
            return false;
        Person person = (Person) o;
        if(country != null){
            if(this.country.equals(person.country)){
                return  true;
            }else{
                return false;
            }
        }
        return false;
    }
    @Override
    public int hashCode(){
        return Objects.hash(country);
    }
}

Classe de test :

Expressions lambda combinées à écrire

public class Test {
    public static void main(String[] args) {
        List<Person> perosnList = new ArrayList<>();
        perosnList.add(new Person("王一", 30, "中国", &#39;M&#39;));
        perosnList.add(new Person("张三", 19, "美国", &#39;F&#39;));
        perosnList.add(new Person("李四", 29, "日本", &#39;F&#39;));
        perosnList.add(new Person("小美", 74, "英国", &#39;M&#39;));
        perosnList.add(new Person("熊二", 15, "意大利", &#39;F&#39;));
        perosnList.add(new Person("熊大", 66, "韩国", &#39;F&#39;));
        //返回年龄大于20岁的学生集合
        System.out.println("返回年龄大于20岁的学生集合");
        perosnList.stream().filter(p -> p.getAge() > 20).forEach(System.out::println);
        //返回年龄大于50岁的学生集合
        System.out.println("返回年龄大于50岁的集合");
        List<Person> list = perosnList.stream().filter(p -> p.getAge() > 50).collect(Collectors.toList());
        System.out.println(list);
        //返回年龄大于20岁的中国学生
        System.out.println("返回年龄大于20岁的中国人");
        perosnList.stream().filter(p -> p.getAge() > 20).filter(p -> p.getCountry().equals("韩国")).forEach(System.out::println);
        //年龄大于20  中国  性别M
        System.out.println("返回年龄大于20  中国  性别M");
        perosnList.stream().filter(p -> p.getAge() > 20 && p.getCountry().equals("中国") && p.getSex() == &#39;M&#39;).forEach(System.out::println);
    }
}

Regardez les résultats :

Renvoyer la collection des étudiants de plus de 20 ans
Tableau d'information : {name='王一' , age=30, country='China', sex=M}
Tableau d'informations : {name='李思', age=29, country='Japan', sex=F}
Tableau d'informations : {name='Xiao Mei ', age=74, country='UK', sex=M}
Tableau d'informations : {name='Xiong Da', age=66, country='South Korea', sex=F}
Renvoie la collection de personnes plus de 50 ans
[Tableau d'informations : {name='Xiaomei', age=74, country='UK', sex=M}, Tableau d'informations : {name='Xiong Da', age=66, country=' Corée du Sud', sex =F}]
Renvoie les Chinois âgés de plus de 20 ans
Tableau d'information : {name='Xiong Da', age=66, country='South Korea', sex=F}
Renvoie les personnes qui ont plus de 20 ans Chine Sexe M
Tableau d'information : {name='王一', age=30, country='China', sex=M}

Résumé :

L'utilisation de Stream Stream peut facilement exploiter des tableaux ou des collections, et peut être combiné avec des expressions Lambda pour créer L'expression est claire et nette. En fait, puisqu'il s'agit d'une nouvelle fonctionnalité lancée par Java, elle doit être utile.

3. Flux de cartographie cartographique de Stream

public class Test {
    public static void main(String[] args) {
        //map的作用是迭代取到每个list元素，再通过map里面的函数进行相应的操作
        List<String> list1 = Arrays.asList("a","bb","ccc","dddd");
        //通过map取到每个集合元素的长度并返回
        Stream<Integer> stream = list1.stream().map(p->p.length());
        stream.forEach(System.out::println);
        System.out.println("----------------");
        List<String> userList = new ArrayList<>();
        userList.add("周杰伦.tom");
        userList.add("尼古拉斯.赵四");
        userList.add("牛顿.巴基斯");
        userList.add("赵少华.思密达");
        List<String> uList = userList.stream().map(p->p.substring(p.indexOf(".")+1,
                p.length())).collect(Collectors.toList());
        System.out.println(uList.toString());
    }
}

Sortie :

1
2
3
4
----------------
[tom, Zhao Si, Pakistan , Smecta]

4. Recherche et correspondance de flux

Il existe également une  anyMatch(Predicate predicate) méthode dans Stream :

Renvoyer si un élément de ce flux correspond au mot fourni

Démo :

public class Test {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("周杰伦","王力宏","孙燕姿","林俊杰");
        boolean flag1 = list.stream().anyMatch(ele->ele.contains("燕"));
        System.out.println("有没有名字包含燕的同学："+flag1);
        //判断开头:
        boolean flag2 = list.stream().anyMatch(ele->ele.startsWith("王"));
        System.out.println("有没有名字开头是王的同学："+flag2);
        //判断结尾:
        boolean flag3 = list.stream().anyMatch(ele->ele.endsWith("杰"));
        System.out.println("有没有名字结尾是杰的同学："+flag3);
        // anyMatch是匹配所有的，要满足条件
        boolean flag4 = list.stream().anyMatch(ele->ele.length()>2);
        System.out.println("所有同学的名字都是两个字以上的吗"+flag4);
        boolean flag5 = list.stream().anyMatch(ele->ele.startsWith("王"));
        System.out.println("所有同学的名字都有王吗？"+flag5);
        //noneMatch
        boolean flag6 = list.stream().noneMatch(ele->ele.contains("燕"));
        System.out.println("集合中都没有包含&#39;燕&#39;这个字吗"+flag5);
    }
}

Sortie :

Y a-t-il des camarades de classe dont les noms incluent Yan : vrai
Y a-t-il des camarades de classe dont les noms commencent par Wang : vrai
Y a-t-il des camarades de classe dont les noms se terminent par Jie : vrai
Tous les noms des élèves sont Li Est-il vrai qu'il y a Il y a plus de 1 caractères ? Tous les noms des élèves portent-ils Wang ? true
La collection ne contient pas le mot « Yan » ? true

L'utilisation de la méthode dans anyMatch() peut facilement faire correspondre les informations de ce flux.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!