java Stream流

定义学生类集合、字符串数组、正数数组

List<Student> list = new ArrayList<>();
for (int i = 0; i < 5; i++) {
    list.add(new Student("" + i, new Random().nextInt(22), new Random().nextInt(100)));
}
String[] words = {"aA", "Bb", "cC", "Dd"};
int[] nums = {4, 3, 2, 7, 4, 2, 7, 2};

生成Stream流

// 1 生成Stream流
// 1.1 调用Collection集合的stream()方法生成Stream流
Stream<Student> studentStream = list.stream();
// 1.2 调用Arrays.stream(数组)从数组上生成Stream流
Stream<String> stringStream = Arrays.stream(words);
IntStream intStream = Arrays.stream(nums);
// 1.3 调用Stream.of(T... data)可以根据若干数据生成Stream流
Stream<Integer> integerStream = Stream.of(23, 45, 23, 65, 75, 23);

终端操作

// 2 终端操作
// // //注意：Stream流是一次性的，进行了终端操作后，流就失效了
// 2.1 forEach(Consumer<? super T> action) 遍历流中的每个元素，形参时Consumer，可以使用Lambda表达式
// integerStream.forEach(x -> System.out.println(x));
integerStream.forEach(System.out::println); // 方法引用
// 2.2 collect(Collector<? super T,A,R> collector) 归约
Set<String> set = stringStream.collect(Collectors.toSet());
System.out.println(set);
// stringStream进行完终端操作后，该Stream流就失效了，如果还想使用Stream流对数组中的元素进行操作，重新获得Stream流，流的基本操作可以连接为一个复杂的操作流水线
String s = Arrays.stream(words) //生成新的Stream流
        .collect(Collectors.joining("--")); //使用--对流中的元素进行连接，返回字符串
System.out.println(s);
List<String> strList = Arrays.stream(words)
        .collect(Collectors.toList()); //把流中元素归约到List集合中
System.out.println(strList);
// 2.3 boolean allMatch(Predicate<? super T> predicate) 判断流中的元素是否都匹配predicate条件
boolean result = list.stream() //根据list集合生成Stream流，流中元素时Student对象
        .allMatch(stu -> stu.getScore() > 60); //判断流中的对象成绩是否都大于60
System.out.println(result);
// 2.4 boolean anyMatch(Predicate<? super T> predicate) 判断流中的是否存在某一个数据符合predicate条件
result = Arrays.stream(words) //根据数组生成Stream流
        .anyMatch(str -> str.length() > 5); //判断是否存在某个字符串长度大于5
System.out.println(result);
// 2.5 long count() 统计流中元素的数量
long count = Arrays.stream(words).count(); //流中元素的数量
System.out.println(count);
// 2.6 Optional<T> max(Comparator<? super T> comparator) 返回最大的元素
OptionalInt max = intStream.max(); //返回最大的元素，OptionalInt是可以为空的整数
System.out.println(max);
int xx = max.getAsInt();
System.out.println(xx);
// 2.7 Optional<T> min(comparator<? super T> comparator) 返回最小的元素
Optional<Student> min = list.stream() //根据list集合生成Stream流，流中元素是Student对象
        .min(Comparator.comparing(Student::getAge)); //比较年龄，返回年龄最小的
System.out.println(min.get());
Optional<Student> maxScore = list.stream()
        .max((stu1, stu2) -> stu1.score - stu2.score); //比较学生的成绩，返回最后一个，当前学生成绩升序，最后一个就是成绩最高的
System.out.println(maxScore.get());
maxScore = list.stream()
        .max(Comparator.comparing(Student::getScore).reversed()); //根据学生成绩逆序，最后一个就是成绩最低的
System.out.println(maxScore.get());
System.out.println("--------");
// 2.8 Object[] toArray() 把流中的元素转换为数组
Object[] objects = list.stream().toArray();

中间操作

// 3 中间操作
// 3.1 Stream<T> filter(Predicate<? super T> predicate) 筛选符合条件的数据
list.stream() //生成Stream流
        .filter(stu -> stu.score > 60) //筛选成绩高于60分的同学
        .forEach(System.out::println);
// 3.2 Stream<R> map(Function<? super T, ?extends R> mapper) 对流中的每个元素都执行mapper操作
list.stream()
        .filter(stu -> stu.getScore() < 60) //筛选成绩不及格的同学
        .map(Student::getName) //对流中的每个元素执行Student类中定义的getName方法，返回字符串，现在流中的数据是学生姓名
        .forEach(System.out::println);
// 3.3 Stream<T> distinct() 去掉流中的重复的元素
list.stream()
        .map(Student::getAge) //对流中的每个对象都执行getAge方法，返回学生的年龄，现在流中的元素是整数了
        .distinct() //去掉重复的数据
        .forEach(System.out::println);
// 3.4 Stream<T> sorted() 排序，要求流中的元素本身具有比较大小的能力
Arrays.stream(words)
        .sorted()
        .forEach(str -> System.out.println(str + "\t"));
System.out.println();
// 3.5 Stream<T> sorted(COmparator<? super T> comparator) 根据指定的Comparator比较器进行排序
list.stream()
        .sorted(Comparator.comparing(Student::getAge)) //年龄升序
        .forEach(System.out::println);
System.out.println("--------------------------");
list.stream()
        .sorted(Comparator.comparing(Student::getScore).reversed()) //成绩降序
        .forEach(System.out::println);
System.out.println("------------------");
// 3.6 Stream<T> limit(long maxSize) 截取前maxSize个元素
list.stream()
        .sorted(Comparator.comparing(Student::getName)) //姓名升序
        .limit(4) //截取前4个元素
        .forEach(System.out::println);
// 3.7 flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
String[] strArr = {"good", "nice", "OK"};
Stream<String[]> arrayStream = Stream.of(words, strArr); //当前Stream流中的元素是数组
// 需求：把arrayStream流中数组元素取出来组成一个新的Stream流
// 流中的元素是数组，或者List集合等容器，当需要把这些容器中的数据取出来组成新的Stream流时，可以使用flatMap
Stream<String> strStream = arrayStream.flatMap(Arrays::stream); //对arrayStream流中的每个元素（数组），执行Arrays类中定义的stream流，现在流中的元素就是字符串
strStream.forEach(str -> System.out.println(str + "\t"));
System.out.println();

静态内部类——Student类

// 定义一个静态内部类
static class Student {
    private String name;
    private Integer age;
    private Integer score;
    public Student(String name, Integer age, Integer score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
    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 getScore() {
        return score;
    }
    public void setScore(Integer score) {
        this.score = score;
    }
}