JAVA中流（Stream）的操作

流是一次性的，用过之后会自动关闭。

一、IntStream、DoubleStream和Stream

import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Stream02 {
    public static void main(String[] args) {
        // 定义List集合
        List<String> list = List.of("a", "b", "c","d","e","f");
        // 跳过一个元素，取出后续三个元素
        Stream<String> s1 = list.stream().skip(1).limit(3);
        // 遍历s1
        s1.forEach(System.out::println);

        // 定义一个数组
        int[] num = {1,2,3,4,5};
        // IntStream不支持Integer数组，只能用int数组
        IntStream ls = Arrays.stream(num);
        // 获取num数组中所有元素之和
        System.out.println(ls.sum());

        // 将多个Integer类型的元素转换为流
        Stream<Integer> is2 = Stream.of(1,2,3,4,5);
        // 使用filter过滤输出大于3的元素
        ls.filter(e -> e > 3).forEach(System.out::print);

        // 生成随机5个double类型的元素并转换成流
        DoubleStream ds = DoubleStream.generate(Math::random).limit(5);
        // 输出所有元素
        ds.forEach(System.out::println);

        // 获取10个1到100之间的元素并转换为double类型，最后转换成流
        DoubleStream ds2 = DoubleStream.generate(() -> new Random().nextInt(1,100)).limit(10);
        // 输出所有元素
        ds2.forEach(System.out::print);

        // 获取10个1到100之间的元素并从小到大排序最后转换成流
        // 输出所有元素
        IntStream is3 = IntStream.generate(() -> new Random().nextInt(1, 100)).limit(10).sorted();
        is3.forEach(System.out::println);

        // 获取从0开始每次增大2的10个元素
        Stream<Integer> s2 = Stream.iterate(0, t -> t + 2).limit(10);
        // 输出所有元素
        s2.forEach(System.out::print);
    }
}

其他类型类推即可。

二、流的重要操作

定义Book对象，生成get、set、有参、无参构造等方法，重写hashCode()和equals（）

public class Book {
    private Integer id;
    private String bookName;
    private String author;
    private Integer price;
}

import java.util.ArrayList;
import java.util.List;

public class Demo02 {
    public static void main(String[] args) {
        //建立对象集合
        List<Book> books = new ArrayList<>(List.of(
                new Book(1, "《java基础入门》", "李四", 38),
                new Book(20, "《html基础》", "王四", 28),
                new Book(15, "《企业java项目初步》", "赵四", 18),
                new Book(33, "《mysql》", "张四", 88),
                new Book(33, "《mysql》", "张四", 88),
                new Book(9, "《数据库视频》", "李四", 55)));

        // 判断所有书记是不是价格都超过20元
        System.out.println(books.stream().allMatch(e -> e.getPrice() > 20));

        // 判断是否有书籍价格大于50
        System.out.println(books.stream().anyMatch(e -> e.getPrice() > 50));

        // 判断书籍价格大于50的有多少本
        System.out.println(books.stream().filter(e -> e.getPrice() > 50).count());

        // 判断书籍价格是否没有大于100的
        System.out.println(books.stream().noneMatch(e -> e.getPrice() >100));

        // 获取满足条件的第一条数据
        System.out.println(books.stream().filter(e -> e.getPrice() > 50).findFirst().get());

        // findAny在并行流（在结果中添加parallel()），随机返回一个对象，即多线程
        // for (int i = 0; i < 1000; i++) {
        //     System.out.println(books.stream().filter(e -> e.getPrice() > 50).parallel().findAny().get());
        // }
    }
}

三、流与其它类型之间的转换

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Stream05 {
    public static void main(String[] args) {
        //建立对象集合
        List<Book> books = new ArrayList<>(List.of(
                new Book(1, "《java基础入门》", "李四", 38),
                new Book(20, "《html基础》", "王四", 28),
                new Book(15, "《企业java项目初步》", "赵四", 18),
                new Book(33, "《mysql》", "张四", 88),
                new Book(33, "《mysql》", "张四", 88),
                new Book(9, "《数据库视频》", "李四", 55)));

        Stream<Book> stream = books.stream();

        // IntStream is = stream.mapToInt(e -> e.getId());
        // is.forEach(System.out::print);

        // Stream<String> s = stream.map(e -> e.getBookName());
        // s.forEach(System.out::println);

        // 流转List集合
        // List<Book> alist = stream.collect(Collectors.toList());
        // alist.forEach(System.out::print);

        // 流转Set集合
        // 将所有书籍名称放入set
        // Stream<String> stringStream = stream.map(Book::getAuthor);
        // Set<String> set = stringStream.collect(Collectors.toSet());
        // System.out.println(set);

        // 将所有Book对象放入set
        // Set<Book> collect = stream.collect(Collectors.toSet());
        // collect.forEach(System.out::println);

        // 流转Array数组
        // Object[] objects = stream.toArray();
        // for (Object object : objects) {
        //     System.out.println(object);
        // }

        // 合并，使用逗号隔开
        System.out.println(stream.map(Book::getAuthor).collect(Collectors.joining(",")));
    }
}