【Java中Steam流的用法】流创建，中间，终止操作filter limit skip distinct map flatMap sorted，reduce，收集。集合和对象互相转换

Java中Steam流的用法及使用备忘

https://blog.csdn.net/qq_17847881/article/details/128401697

文章目录

Java中Steam流的用法及使用备忘
一. 流的常用创建方法
1-1 使用Collection下的 stream() 和 parallelStream() 方法
1-2 使用Arrays 中的 stream() 方法，将数组转成流
1-3 使用Stream中的静态方法：of()、iterate()、generate()
1-4 使用 BufferedReader.lines() 方法，将每行内容转成流
1-5 使用 Pattern.splitAsStream() 方法，将字符串分隔成流
二、流的中间操作
2-1 筛选、去重与切片：filter、distinct、skip、limit
2-2 映射：map、flatMap
2-3 归约：统计-计算-逻辑处理：reduce
2-4 排序：sorted
2-4-1 函数式接口排序
2-4-2 LocalDate 和 LocalDateTime 排序
三. 流的终止操作 allMatch,noneMatch,anyMatch,findFirst,findAny,count,max,min
3-1 普通收集 – 收集为List
3-2 普通收集 – 收集流为数组(Array)
3-3 普通收集 – 收集为Set
3-4 高级收集 – 收集为Map
3-5 高级收集 – 分组收集
四. Steam拓展
4-1 集合与对象互转
4-2 集合转对象
4-3 Java Steam中的并发操作实例
Java中Steam流的用法及使用备忘

一. 流的常用创建方法

1-1 使用Collection下的 stream() 和 parallelStream() 方法

List<String> list = new ArrayList<>();

Stream<String> stream = list.stream(); //获取一个顺序流

Stream<String> parallelStream = list.parallelStream(); //获取一个并行流

1-2 使用Arrays 中的 stream() 方法，将数组转成流

Integer[] nums = new Integer[10];

Stream<Integer> stream = Arrays.stream(nums);

1-3 使用Stream中的静态方法：of()、iterate()、generate()

// 1. of()
Stream<Integer> stream = Stream.of(1,2,3,4,5,6);

// 2. iterate()
 void accept(T t)  public void println(Object x)
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 2).limit(6);

iterate.forEach((x) -> {
            System.out.println(x);
        });

stream2.forEach(System.out::println); // 0 2 4 6 8 10

// 3. generate()  消费型接口 generate(Supplier<T> s) 是 T get();
//public static double random() 
Stream<Double> stream3 = Stream.generate(Math::random).limit(2);
stream3.forEach(System.out::println);

1-4 使用 BufferedReader.lines() 方法，将每行内容转成流

BufferedReader reader = new BufferedReader(new FileReader("F:\\test_stream.txt"));

Stream<String> lineStream = reader.lines();

lineStream.forEach(System.out::println);

IO流有：

• 字节流

  • 文件 FileInputStream 输入流 和 Output 输出流
  • 对象 ObjectInputSteam
  • 缓冲 BufferInputSteam

• 字符流

  • 转换 FileInputStream 和 FileOutputStream

    • 文件 FileReader 输入流，FileWriter 输出流

  • 缓冲 BufferReader，BufferWriter

  • 转换流使用 装饰着模式

• 访问数组 ByteArrayInputStream

• 字符 CharArrayReader

• 打印流 PrintStream PrintWriter

• 特殊流 DatalnputStream DataOutputStream

1-5 使用 Pattern.splitAsStream() 方法，将字符串分隔成流

Pattern pattern = Pattern.compile(",");

Stream<String> stringStream = pattern.splitAsStream("a,b,c,d");

stringStream.forEach(System.out::println);

二、流的中间操作

filter limit skip distinct map flatMap sorted

// 1. 筛选与切片
filter：过滤流中的某些元素

limit skip distinct sorted 都是有状态操作，这些操作只有拿到前面处理后的所有元素之后才能继续下去。
    
limit(n)：获取前n个元素
    
skip(n)：跳过前n元素，配合limit(n)可实现分页
    
distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素
    
// 2. 映射
map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
    
flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
    
// 3. 消费 peek , 类似map，	
//		map接收的是一个Function表达式，有返回值；
//		而peek接收的是Consumer表达式，没有返回值。

// 4. 排序
sorted()：自然排序，流中元素需实现Comparable接口
sorted(Comparator com)：定制排序，自定义Comparator排序器

我的简单使用

        List<String> list = Arrays.asList("1", "2", "3");

        list.stream().limit(2).skip(1).distinct();

        //转换为 Integer
        Stream<Integer> is = list.stream().map((x) -> {
            return new Integer(x) + 1;
        });
        //转换为String
        Stream<String> integerStream = list.stream().map((x) -> {
            return x + 1;
        });

        List<Integer> ins = Arrays.asList(1, 2, 3);
        ins.stream().map(x -> x + 1).forEach(System.out::println);

        integerStream.forEach(v -> System.out.println(v));

        List<Integer> ins = Arrays.asList(1, 2, 3);
        //Predicate<? super T> predicate
        Stream<Integer> ins2 = ins.stream().filter(v -> v > 2);
        ins2.forEach(v -> System.out.println(v));

2-1 筛选、去重与切片：filter、distinct、skip、limit

过滤 去重 跳过 取前2个

// 实例：集合内元素>5,去重，跳过前两位，取剩下元素的两个返回为新集合
Stream<Integer> stream = Stream.of(6, 4, 6, 7, 3, 9, 8, 10, 12, 14, 14);

Stream<Integer> newStream = stream.filter(s -> s > 5) //6 6 7 9 8 10 12 14 14
    
 .distinct() //6 7 9 8 10 12 14
 .skip(2) //9 8 10 12 14
 .limit(2); //9 8

newStream.forEach(System.out::println);

2-2 映射：map、flatMap

.collect(Collectors.toList());

// 1. map的使用实例   stream.map(x->x.getId());
List<String> list = Arrays.asList("a,b,c", "1,2,3");

//		map接收的是一个Function表达式，有返回值；

// 去掉字符串中所有的 ,
List<String> collect = list.stream().map(s -> s.replaceAll(",", "")).collect(Collectors.toList());

// collect集合内容为：{abc,123}
System.out.println(collect);

// 2. flatMap 	接收一个函数作为参数，将流中的每个值都换成另一个流，
//				然后把所有流连接成一个流。
Stream<String> stringStream = list.stream().flatMap(s -> {
	// 将字符串以,分割后得到一个字符串数组
	String[] split = s.split(",");
	// 然后将每个字符串数组对应流返回，flatMap会自动把返回的所有流连接成一个流
	Stream<String> stream = Arrays.stream(split);
	return stream;
});

//flatMap
//(Function<? super T, ? extends Stream<? extends R>> mapper);

// stringStream.collect(Collectors.toList())的集合内容为：{a,b,c,1,2,3}
System.out.println(stringStream.collect(Collectors.toList()));

2-3 归约：统计-计算-逻辑处理：reduce

List<String> memberNames = new ArrayList<>();
memberNames.add("Amitabh");
memberNames.add("Shekhar");
memberNames.add("Aman");
memberNames.add("Rahul");
memberNames.add("Shahrukh");
memberNames.add("Salman");
memberNames.add("Yana");
memberNames.add("Lokesh");

// 将集合中的元素按照#连接成字符串，并返回放置在Optional<String>中
Optional<String> reduced = memberNames.stream()
        .reduce((s1,s2) -> s1 + "#" + s2);
// 有值则取出打印显示        
reduced.ifPresent(System.out::println);  
// 输出内容：   Amitabh#Shekhar#Aman#Rahul#Shahrukh#Salman#Yana#Lokesh

// 计算统计实例：
    /**
     * T reduce(T identity, BinaryOperator<T> accumulator);
     * identity：它允许用户提供一个循环计算的初始值。
     * accumulator：计算的累加器，
     */
    private static void testReduce() {
        
        //T reduce(T identity, BinaryOperator<T> accumulator);
        System.out.println("给定个初始值，求和");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (sum, item) -> sum + item));
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::sum));
		// 输出：110

        System.out.println("给定个初始值，求min");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (min, item) -> Math.min(min, item)));
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::min));
        // 输出：1

        System.out.println("给定个初始值，求max");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (max, item) -> Math.max(max, item)));
        System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::max));
        // 输出：100
 
        
        
        //Optional<T> reduce(BinaryOperator<T> accumulator);
        // 注意返回值，上面的返回是T,泛型，传进去啥类型，返回就是啥类型。
        // 下面的返回的则是Optional类型
        System.out.println("无初始值，求和");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::sum).orElse(0)); 
        // 输出：10
        Integer sum=Stream.of(1, 2, 3, 4).reduce((x,y)->x+y).get();
        System.out.println(sum);  // 输出：10
        
        System.out.println("无初始值，求max");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::max).orElse(0));
        // 输出：4 
        
        System.out.println("无初始值，求min");
        System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::min).orElse(0));
        // 输出：1
    }

    	//3
        System.out.println(Stream.of(1, 2, 3).reduce(Math::max).get());
        System.out.println(Stream.of(1, 2, 3).reduce((a, b) -> (a >= b) ? a : b).get());

2-4 排序：sorted

// 按照默认字典顺序排序
stream.sorted(); 

Stream.of(3,4,2).sorted().forEach(System.out::println);

// 按照sortNo排序
stream.sorted((x,y)->Integer.compare(x.getSortNo(),y.getSortNo()));

        Stream.of(3, 4, 2).sorted().forEach(System.out::println);

        ArrayList<XUser> a = new ArrayList();
        XUser x1 = new XUser("10", 10, 10);
        a.add(x1);

        XUser x2 = new XUser("2", 2, 2);
        a.add(x2);

        a.stream().sorted(Comparator.comparingInt(XUser::getSortNo)).forEach(System.out::println);
        a.stream().sorted((x, y) -> Integer.compare(x.getSortNo(), y.getSortNo()));



    @AllArgsConstructor
    @Data
    public static class XUser {
        String userName;
        Integer deptId;
        Integer sortNo;
    }

2-4-1 函数式接口排序

// 正向排序（默认）
pendingPeriod.stream().sorted(Comparator.comparingInt(ReservoirPeriodResult::getId));

// 逆向排序
pendingPeriod.stream().sorted(Comparator.comparingInt(ReservoirPeriodResult::getId).reversed());

sorted( Comparator.comparingInt(XUser::getSortNo) .reversed())

2-4-2 LocalDate 和 LocalDateTime 排序

// 准备测试数据
Stream<DateModel> stream = Stream.of(new DateModel(LocalDate.of(2020, 1, 1))
, new DateModel(LocalDate.of(2021, 1, 1)), new DateModel(LocalDate.of(2022, 1, 1)));


// 正向排序（默认）
stream.sorted(Comparator.comparing(DateModel::getLocalDate))
.forEach(System.out::println);

//使用过的流，在逆向排序。报错
stream.sorted(Comparator.comparing(DateModel::getLocalDate).reversed())
.forEach(System.out::println);

//每个流，只能使用一次，否则会报： stream has already been
Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed

    
    @AllArgsConstructor
    @Data
    public static class DateModel {
        LocalDate localDate;
    }

public final class LocalDate
        implements Temporal, TemporalAdjuster, ChronoLocalDate, Serializable {
        
        }

//这个接口，实现了 Comparable
public interface ChronoLocalDate
        extends Temporal, TemporalAdjuster, Comparable<ChronoLocalDate> {}

三. 流的终止操作

allMatch,noneMatch,anyMatch,findFirst,findAny,count,max,min

// 匹配和聚合
allmatch，noneMatch，anyMatch用于对集合中对象的某一个属性值是否存在判断。
	allMatch全部符合该条件返回true，
	noneMatch全部不符合该断言返回true
	anyMatch 任意一个元素符合该断言返回true

// 实例：
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
boolean allMatch = list.stream().allMatch(e -> e > 10); //false

boolean noneMatch = list.stream().noneMatch(e -> e > 10); //true

boolean anyMatch = list.stream().anyMatch(e -> e > 4); //true

List<String> memberNames = Arrays.asList("1", "Args", "Lisi", "Lili", "C");

// 其他一些方法
findFirst：返回流中第一个元素
		String firstMatchedName = memberNames.stream()
	            .filter((s) -> s.startsWith("L"))
	            .findFirst().get();

findAny：返回流中的任意元素
count：返回流中元素的总个数
	long totalMatched = memberNames.stream()
	    .filter((s) -> s.startsWith("A"))
	    .count();
max：返回流中元素最大值
min：返回流中元素最小值

        ArrayList<String> memberNames = new ArrayList();
        memberNames.add("1");
        memberNames.add("B11");
        memberNames.add("A");

        long totalMatched = memberNames.stream()
                .filter((s) -> s.startsWith("A"))
                .count();//为1
        System.out.println(totalMatched);

		//传统的写法
        String s2 = memberNames.stream().max((x, y) -> x.length() - y.length()).get();
        System.out.println(s2);

        //为 B11
        String s = memberNames.stream().max(Comparator.comparingInt(String::length)).get();
        System.out.println(s);
        /*max：返回流中元素最大值
        min：返回流中元素最小值*/
        //为1
        String s1 = memberNames.stream().min(Comparator.comparingInt(String::length)).get();
        System.out.println(s1);

3-1 普通收集 – 收集为List

.collect(Collectors.toList());

        List<Student> userVos = new ArrayList<>();
        userVos.add(new Student(1, 1, "1", 1, 1));

        // 默认返回的类型为ArrayList，可通过Collectors.toCollection(LinkedList::new)
        //		显示指明使用其它数据结构作为返回值容器。
        List<String> collect = Stream.of("1", "2").collect(Collectors.toList());
        System.out.println(collect);

        // 由集合创建流的收集需注意：仅仅修改流字段中的内容，没有返回新类型，
        //		如下操作直接修改原始集合，无需处理返回值。
        List<Integer> collect1 = userVos.stream().map(e -> e.getDeptId() + 1)
                .collect(Collectors.toList());
        System.out.println(collect1);

        // 收集偶数集合的实例：
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 1; i < 10; i++) {
            list.add(i);
        }


        Stream<Integer> stream = list.stream();

        List<Integer> evenNumbersList = stream.filter(i -> i % 2 == 0)
                .collect(Collectors.toList());

        System.out.print(evenNumbersList);

    @AllArgsConstructor
    @Data
    public static class Student {
        Integer deptName;
        Integer id;
        String userName;
        Integer deptId;
        Integer sortNo;
    }

3-2 普通收集 – 收集流为数组(Array)

.toArray(Integer[]::new)

// list 为 {1,2,3,.....100}
Stream<Integer> stream = list.stream();
Integer[] evenNumbersArr = stream.filter(i -> i%2 == 0).toArray(Integer[]::new);

3-3 普通收集 – 收集为Set

// 默认返回类型为HashSet，可通过Collectors.toCollection(TreeSet::new)
//		显示指明使用其它数据结构作为返回值容器。
Set<String> collect = stream.collect(Collectors.toSet());

3-4 高级收集 – 收集为Map

//	默认返回类型为HashMap，可通过Collectors.toCollection(LinkedHashMap::new)
//		显示指明使用其它数据结构作为返回值容器

// 测试实体类
@Data
@AllArgsConstructor
public class Entity {
    private Integer id;
    private String name;
}

// 模拟从数据库中查询批量的数据
List<Entity> entityList = Stream.of(new Entity(1,"A"), 
new Entity(2,"B"), new Entity(3,"C")).collect(Collectors.toList());

// 将集合数据转化成id与name的Map
Map<Integer, String> hashMap = entityList.stream()
.collect(Collectors.toMap(Entity::getId, Entity::getName));

3-5 高级收集 – 分组收集

        List<XUser> xUsers = new ArrayList<>();
        xUsers.add(new XUser("1", 1, 1));
        xUsers.add(new XUser("2", 2, 2));

        // 默认使用List作为分组后承载容器
        Map<Integer, List<XUser>> hashMap =
                xUsers.stream().collect(Collectors.groupingBy(XUser::getDeptId));

        //{1=[MyTest.XUser(userName=1, deptId=1, sortNo=1)], 2=[MyTest.XUser(userName=2, deptId=2, sortNo=2)]}
        System.out.println(hashMap);

        // 显示指明使用List作为分组后承载容器
		//{1=[TestCreate.XUser(userName=1, deptId=1, sortNo=1)], 2=[TestCreate.XUser(userName=2, deptId=2, sortNo=2)]}
		//结果一样，多加了参数 Collectors.toList()
        Map<Integer, List<XUser>> hashMap2 =
                xUsers.stream().collect(Collectors.groupingBy(XUser::getDeptId, Collectors.toList()));
        System.out.println(hashMap2);

        // 映射后再分组
        //{1=[1], 2=[2]}
        Map<Integer, List<String>> hashMap3 = xUsers.stream().collect(
            	//在用 部门ID 分组
                Collectors.groupingBy(XUser::getDeptId,
                        //userName 映射成 list
                        Collectors.mapping(XUser::getUserName, Collectors.toList())
                ));
        System.out.println(hashMap3);


    @AllArgsConstructor
    @Data
    public static class XUser {
        String userName;
        Integer deptId;
        Integer sortNo;
    }

四. Steam拓展

4-1 集合与对象互转

/**
 * 将单个对象转化为集合
 *
 * @param t   对象实例
 * @param <T> 对象类型
 * @param <C> 集合类型
 * @return 包含对象的集合实例
 */
public static <T, C extends Collection<T>> Collection<T> toCollection(T t) {
    return toCollection(t, ArrayList::new);
}

/**
 * 用户自定义返回的集合实例类型:  将单个对象转化为集合
 *
 * @param t        对象实例
 * @param supplier 集合工厂
 * @param <T>      对象类型
 * @param <C>      集合类型
 * @return 包含对象的集合实例
 */
public static <T, C extends Collection<T>> Collection<T> toCollection(T t, Supplier<C> supplier) {
    return Stream.of(t).collect(Collectors.toCollection(supplier));
}

        Arrays.asList(new Object());

4-2 集合转对象

/**
 * 取出集合中第一个元素
 *
 * @param collection 集合实例
 * @param <E>        集合中元素类型
 * @return 泛型类型
 */
public static <E> E toObject(Collection<E> collection) {
    // 处理集合空指针异常
    Collection<E> coll = Optional.ofNullable(collection).orElseGet(ArrayList::new);
    // 此处可以对流进行排序，然后取出第一个元素
    return coll.stream().findFirst().orElse(null);
}

4-3 Java Steam中的并发操作实例 parallelStream

List<Integer> list = new ArrayList<Integer>();
for(int i = 1; i< 10; i++){
    list.add(i);
}
Stream<Integer> stream = list.parallelStream();    // 创建并发流

Integer[] evenNumbersArr = stream.filter(i -> i%2 == 0).toArray(Integer[]::new);

System.out.print(evenNumbersArr);   // 打印出的偶数为无规则排序的