Comment utiliser Stream en Java8-javaDidacticiel-php.cn

1. Pourquoi les vétérans expérimentés préfèrent utiliser Stream

Avantages en termes de performances (grand volume de données) Par rapport aux itérateurs, il est plus rapide
Prend en charge le traitement série et parallèle, Traitement parallèlePlus Peut utiliser pleinement le processeur ressources
Stream est un flux pour calculer des données, il ne stocke pas les données lui-même
Prend en charge la programmation fonctionnelle
Le code est élégant, ce qui rend le code plus efficace, propre et concis

2. Comment utiliser Stream

Trois étapes :

Créer un StreamStream
中间操作
终止操作

3. Stream 的创建

Stream 的创建都会依赖于数据源，通常是容器或者数组 Stream 流的创建大致分为4中，最为常用的就是通过集合创建

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class CreateStreamDemo {
    public static void main(String[] args) {
        // 1 通过集合创建Stream也是用的最多的一种形式
        List<String> strList = new ArrayList<>();
        strList.add("a");
        strList.add("b");
        strList.add("c");
        // 创建串行操作流
        Stream<String> stream = strList.stream();
        // 创建并行操作流
        Stream<String> parallelStream = strList.parallelStream();
        // 2 通过数组创建Stream
        int[] arr = new int[]{1,2,3};
        IntStream intStream = Arrays.stream(arr);
        // 3 通过Stream.of
        Stream<Integer> integerStream = Stream.of(1,2,3);
        Stream<String> stringStream = Stream.of("a","b","c");
        // 4 无限流
        // 每隔五个数取一个
        Stream.iterate(0, t -> t + 5).forEach(System.out::println); // 迭代
        Stream.generate(Math::random).forEach(System.out::println); // 生成
    }
}

Copier après la connexion

4. Stream 中间操作

Stream 中间操作，我们最为常用的就是过滤，去重，排序本章包含我们开发最常用的对对象的去重，和更据对象中的对个属性组合排序

import com.zhj.java8.bean.Student;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;
import java.util.stream.Stream;
import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.toCollection;

public class MiddleStreamDemo {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student(1,"小华",23,1));
        students.add(new Student(1,"小华",23,2));
        students.add(new Student(2,"小米",20,2));
        students.add(new Student(3,"小果",30,3));
        students.add(new Student(4,"小维",18,2));
        // 过滤
        students.stream().filter(stu -> stu.getAge() > 20).forEach(System.out::println);
        // 去重
        // 对对象去重是根据引用去重，内容重复并不会去重，除非重写equals和hashCode方法
        System.out.println("----------去重----------");
        System.out.println("去重1----------");
        students.stream().distinct().forEach(System.out::println);
        // 对集合中对象某些属性去重，不重写equals和hashCode方法，只能借助其他数据结构来辅助去重
        // 单个属性可以stu -> stu.getId()
        // 多个属性可以stu -> stu.getId() + ";" + stu.getName()
        System.out.println("去重2----------");
        ArrayList<Student> distinctList = students.stream().collect(
                collectingAndThen(toCollection(() -> new TreeSet<>(Comparator.comparing(stu -> stu.getId() + ";" + stu.getName()))), ArrayList::new)
        );
        distinctList.stream().forEach(System.out::println);
        // 排序 支持定义排序方式
        // sorted 默认使用 自然序排序， 其中的元素必须实现Comparable 接口
        System.out.println("----------排序----------");
        System.out.println("排序1----------");
        students.stream().sorted().forEach(System.out::println);
        // sorted(Comparator<? super T> comparator) ：我们可以使用lambada 来创建一个Comparator 实例。可以按照升序或着降序来排序元素。
        System.out.println("排序2----------");
        students.stream()
                .sorted(Comparator.comparing(Student::getAge,Comparator.reverseOrder())) // ,Comparator.reverseOrder() 逆序
                .forEach(System.out::println);
        // 创建比较器，通过对比较器内容的定义实现对多个属性进行排序，类似sql中连续的orderBy
        System.out.println("排序3----------");
        students.stream().sorted(
                (s1,s2) -> {
                    if (s1.getAge() == s2.getAge()) {
                        return s1.getSex().compareTo(s2.getSex());
                    } else {
                        return -s1.getAge().compareTo(s2.getAge());
                    }
                }
        ).forEach(System.out::println);
        System.out.println("排序4----------");
        Comparator<Student> studentComparator = (s1,s2) -> {
            Integer age1 = s1.getAge();
            Integer age2 = s2.getAge();
            if (age1 != age2) return age1 - age2;
            Integer sex1 = s1.getSex();
            Integer sex2 = s2.getSex();
            if (sex1 != sex2) return sex2 - sex1;
            return 0;
        };
        students.stream().sorted(studentComparator).forEach(System.out::println);
        // 截取 截取前三个元素
        System.out.println("----------截取----------");
        students.stream().limit(3).forEach(System.out::println);
        // 跳过 跳过前3个元素
        System.out.println("----------跳过----------");
        students.stream().skip(3).forEach(System.out::println);
        // 映射
        System.out.println("----------映射----------");
        System.out.println("映射Map----------");
        // map接收Lambda,将元素转换其他形式，或者是提取信息，并将其映射成一个新的元素
        Stream<Stream<Student>> streamStream1 = students.stream().map(str -> filterStudent(str));
        streamStream1.forEach(sm -> sm.forEach(System.out::println));
        System.out.println("映射flatMap----------");
        // map接收Lambda,将流中的每一个元素转换成另一个流，然后把所有流连成一个流 扁平化映射
        Stream<Student> studentStream2 = students.stream().flatMap(str -> filterStudent(str));
        studentStream2.forEach(System.out::println);
        // 消费
        System.out.println("----------消费----------");
        students.stream().peek(stu -> stu.setAge(100)).forEach(System.out::println);
    }
    public static Stream<Student> filterStudent(Student student) {
        student = new Student();
        return Stream.of(student);
    }
}

Copier après la connexion

Student

public class Student implements Comparable<Student> {
    private Integer id;
    private String name;
    private Integer age;
    private Integer sex;
    public Student() {
    }
    public Student(Integer id, String name, Integer age, Integer sex) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Integer getSex() {
        return sex;
    }
    public void setSex(Integer sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "Student{" +
                "id=&#39;" + id + &#39;\&#39;&#39; +
                ", name=&#39;" + name + &#39;\&#39;&#39; +
                ", age=&#39;" + age + &#39;\&#39;&#39; +
                ", sex=" + sex +
                &#39;}&#39;;
    }
    @Override
    public int compareTo(Student o) {
        return this.getAge() - o.getAge();
    }
}

Copier après la connexion

5. Stream 终止操作

Stream 的终止操作，最常用的就是讲处理过的数据收集到新的容器中，同时可以实现向Sql聚合函数，分组的一些效果

package com.zhj.java8.stream;
import com.zhj.java8.bean.Student;
import java.util.*;
import java.util.stream.Collectors;
public class TerminationStreamDemo {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student(1,"小华",23,1));
        students.add(new Student(2,"小米",20,2));
        students.add(new Student(3,"小果",30,3));
        students.add(new Student(4,"小维",18,2));
        students.add(new Student(5,"小华",23,2));
        System.out.println("--------------------匹配聚合操作--------------------");
        // allMatch：接收一个 Predicate 函数，当流中每个元素都符合该断言时才返回true，否则返回false
        boolean allMatch = students.stream().allMatch(stu -> stu.getAge() > 10);
        System.out.println("全部符合大于10岁条件：" + allMatch);
        // noneMatch：接收一个 Predicate 函数，当流中每个元素都不符合该断言时才返回true，否则返回false
        boolean noneMatch = students.stream().noneMatch(stu -> stu.getAge() > 10);
        System.out.println("全部不符合大于10岁条件：" + noneMatch);
        // anyMatch：接收一个 Predicate 函数，只要流中有一个元素满足该断言则返回true，否则返回false
        boolean anyMatch = students.stream().anyMatch(stu -> stu.getAge() > 20);
        System.out.println("含有任意符合大于20岁条件：" + anyMatch);
        // findFirst：返回流中第一个元素
        Student findFirst = students.stream().findFirst().get();
        System.out.println("第一个学生：" + findFirst);
        // findAny：返回流中的任意元素
        Student findAny = students.stream().findAny().get();
        System.out.println("任意一个学生：" + findAny);
        //  count：返回流中元素的总个数
        long count = students.stream().count();
        System.out.println("学生总数：" + count);
        // max：返回流中元素最大值
        Student max = students.stream().max(Student::compareTo).get();
        System.out.println("年龄最大学生：" + max);
        // max：返回流中元素最大值
        Student min = students.stream().min(Student::compareTo).get();
        System.out.println("年龄最小学生：" + min);
        System.out.println("--------------------规约操作--------------------");
        System.out.println("学生年龄总和：" + students.stream().map(Student::getAge).reduce(Integer::sum));
        System.out.println("学生年龄最大：" + students.stream().map(Student::getAge).reduce(Integer::max));
        System.out.println("--------------------收集操作--------------------");
        List<Student> list = students.stream().collect(Collectors.toList());
        Set<Student> set = students.stream().collect(Collectors.toSet());
        Map<Integer, String> map = students.stream().collect(Collectors.toMap(Student::getId, Student::getName));
        String joinName = students.stream().map(Student::getName).collect(Collectors.joining(",", "(", ")"));
        // 总数
        students.stream().collect(Collectors.counting());
        // 最大年龄
        students.stream().map(Student::getAge).collect(Collectors.maxBy(Integer::compare)).get();
        // 年龄和
        students.stream().collect(Collectors.summingInt(Student::getAge));
        // 平均年龄
        students.stream().collect(Collectors.averagingDouble(Student::getAge));
        // 信息合集
        DoubleSummaryStatistics statistics = students.stream().collect(Collectors.summarizingDouble(Student::getAge));
        System.out.println("count:" + statistics.getCount() + ",max:" + statistics.getMax() + ",sum:" + statistics.getSum() + ",average:" + statistics.getAverage());
        // 分组
        Map<Integer, List<Student>> collect = students.stream().collect(Collectors.groupingBy(Student::getSex));
        System.out.println(collect);
        //多重分组,先根据性别分再根据年龄分
        Map<Integer, Map<Integer, List<Student>>> typeAgeMap = list.stream().collect(Collectors.groupingBy(Student::getSex, Collectors.groupingBy(Student::getAge)));
        //分区
        //分成两部分，一部分大于20岁，一部分小于等于20岁
        Map<Boolean, List<Student>> partMap = list.stream().collect(Collectors.partitioningBy(v -> v.getAge() > 20));
        //规约
        Integer allAge = list.stream().map(Student::getAge).collect(Collectors.reducing(Integer::sum)).get();
        System.out.println(allAge);
    }
}

Copier après la connexion

6. Stream 特性

中间操作惰性执行

多个中间操作的话，不会多次循环，多个转换操作只会在终止操作的时候融合起来，一次循环完成。

内部迭代
找到符合条件的数据后边的迭代不会进行
流的末端操作只有一次

异常：stream has already been operated upon or closed

Opération intermédiaire

🎜🎜Opération de terminaison🎜🎜🎜🎜3. La création de Le Stream dépend de la source de données, généralement un conteneur ou un tableau. Stream La création de flux est grossièrement divisée en 4 types. Le plus couramment utilisé est de le créer. à travers une collection🎜rrreee🎜 4. Opérations intermédiaires de flux🎜🎜Stream Opérations intermédiaires, nos plus couramment utilisées sont le filtrage, la déduplication et le tri Ce chapitre comprend la déduplication des objets et la mise à jour les plus couramment utilisées. objets dans les objets. Tri par combinaison d'attributs🎜rrreee🎜🎜Étudiant🎜🎜rrreee🎜5. Opération de terminaison de flux🎜🎜Opération de terminaison de Stream, la plus couramment utilisée consiste à collecter les données traitées dans un nouveau conteneur. , et il peut être implémenté en même temps Certains effets du regroupement sur les fonctions d'agrégation SQL 🎜rrreee🎜6. Fonctionnalités de flux 🎜🎜🎜Les opérations intermédiaires sont exécutées paresseusement 🎜🎜🎜S'il y a plusieurs opérations intermédiaires, elles ne seront pas bouclées plusieurs fois, 🎜Plusieurs opérations de conversion ne seront exécutées que lorsque l'opération de fusion sera terminée, un cycle est terminé🎜. 🎜🎜🎜🎜Itération interne🎜🎜🎜🎜Les itérations suivantes après avoir trouvé des données répondant aux critères ne seront pas effectuées🎜🎜🎜🎜L'opération de fin du flux n'est effectuée qu'une seule fois🎜🎜🎜🎜🎜Exception : 🎜stream a déjà été opéré ou fermé 🎜🎜signifie que le flux a été fermé, car lorsque nous utilisons l'opération de fin, le 🎜stream est fermé et ne peut pas être appelé à nouveau🎜. nous ne pouvons qu'en rouvrir un nouveau. 🎜

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!