jdk1.8 java.util.stream

java 新增了 java.util.stream 包，它和之前的流大同小异。之前接触最多的是资源流，比如java.io.FileInputStream，通过流把文件从一个地方输入到另一个地方，它只是内容搬运工，对文件内容不做任何CRUD。

Stream依然不存储数据，不同的是它可以检索(Retrieve)和逻辑处理集合数据、包括筛选、排序、统计、计数等。可以想象成是 Sql 语句。

它的源数据可以是 Collection、Array 等。由于它的方法参数都是函数式接口类型，所以一般和 Lambda 配合使用。

# 流类型

1. stream 串行流
2. parallelStream 并行流，可多线程执行

# 实战 

public void test1() {
        List strings = Arrays.asList("abc", "def", "gkh", "abc");
        // 返回符合条件的stream
        Stream stringStream = strings.stream().filter(s -> "abc".equals(s));
        // 计算流符合条件的流的数量
        long count = stringStream.count();

        // forEach遍历->打印元素
        strings.stream().forEach(System.out::println);// 如果只进行打印，可以使用方法的引用。
        strings.stream().forEach(x -> System.out.println(x)); // 拿到每个元素打印

      Map map = new HashMap<>();

      map.forEach((k,v)->System.out.println(v));

 

        // limit 获取到1个元素的stream
        Stream limit = strings.stream().limit(1);
        // toArray 比如我们想看这个limitStream里面是什么，比如转换成String[],比如循环
        String[] array1 = limit.toArray(String[]::new);

        // map 对每个元素进行操作返回新流
        Stream map = strings.stream().map(s -> s + "22");

        // sorted 排序并打印
        strings.stream().sorted().forEach(System.out::println);
    
        // 需要特别注意的是：你对user进行排序，那么user类必须实现了Comparable接口，并重写compareTo方法，来定义比较方法才可以，否则会报无法转换为Compare错误！
        // 需要注意的是：这里排序之后只是流中进行了排序，如果想要得到排序之后的集合，需要对流进行toArray操作，然后重新转换成集合。
        List userlist = new ArrayList();
        User uservo = new User();
        uservo.setAge(12);
        userlist.add(uservo);

        User uservo3 = new User();
        uservo3.setAge(23);
        userlist.add(uservo3);

        User uservo2 = new User();
        uservo2.setAge(13);
        userlist.add(uservo2);

        userlist.stream().filter((user) -> String.valueOf(user.getAge()).startsWith("1")).sorted().forEach(x -> System.out.println(x.getAge())); // 13 12
        Object[] array = userlist.stream().filter((user) -> String.valueOf(user.getAge()).startsWith("1")).sorted().toArray();
        System.out.println();

        userlist.stream().filter((user) -> String.valueOf(user.getAge()).startsWith("1")).sorted().forEach(user -> {
            user.setAge(user.getAge() + 1);
            System.out.println("年龄加一：" + user.getAge());
        });

      
        List> backList = new ArrayList>();
        Map map1 = new HashMap();
        map1.put("money", 23.2);
        Map map2 = new HashMap();
        map2.put("money", 23.1);
        Map map3 = new HashMap();
        map3.put("money", 24);
        backList.add(map1);
        backList.add(map2);
        backList.add(map3);

        List> collect = backList.stream().filter(item -> item.containsKey("money") && item.get("money") != null && Double.valueOf(item.get("money").toString()) >= 0)
                .sorted((o1, o2) -> {
                    return new BigDecimal(o1.get("money").toString()).compareTo(new BigDecimal(o2.get("money").toString()));
                }).limit(10).collect(Collectors.toList());
        collect.forEach(x -> System.out.println(x.get("money")));

        // Collectors collect 把abc放入容器中
        List collect1 = strings.stream().filter(string -> "abc".equals(string)).collect(Collectors.toList());
        // 把list转为string，各元素用，号隔开
        String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(","));

        // 对数组的统计，比如用
        List number = Arrays.asList(1, 2, 5, 4);

        IntSummaryStatistics statistics = number.stream().mapToInt((x) -> x).summaryStatistics();
        System.out.println("列表中最大的数 : " + statistics.getMax());
        System.out.println("列表中最小的数 : " + statistics.getMin());
        System.out.println("平均数 : " + statistics.getAverage());
        System.out.println("所有数之和 : " + statistics.getSum());

        // concat 合并流
        List strings2 = Arrays.asList("xyz", "jqx");
        Stream.concat(strings2.stream(), strings.stream()).count();

        // 注意 一个Stream只能操作一次，不能断开，否则会报错。
        Stream stream = strings.stream();
        // 第一次使用
        stream.limit(2);
        // 第二次使用
        stream.forEach(System.out::println);
        // 报错 java.lang.IllegalStateException: stream has already been operated upon or
        // closed

        // 但是可以这样, 连续使用
        stream.limit(2).forEach(System.out::println);
    }

package nccloud.api.testcase.base;

import java.io.Serializable;

public class User implements Comparable, Serializable {
    
    private static final long serialVersionUID = 1L;
    private Integer age;
    
    
    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public int compareTo(User user) {
        return user.getAge() - this.getAge() ;
    }
}