jdk1.8 java.util.stream

文章列表

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

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

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

# 流类型

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

# 实战

public void test1() {
       List<String> strings = Arrays.asList("abc", "def", "gkh", "abc");
       // 返回符合条件的stream
       Stream<String> 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<Integer, String> map = new HashMap<>();

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

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

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

       // sorted 排序并打印
       strings.stream().sorted().forEach(System.out::println);

       // 需要特别注意的是：你对user进行排序，那么user类必须实现了Comparable<User>接口，并重写compareTo方法，来定义比较方法才可以，否则会报无法转换为Compare错误！
       // 需要注意的是：这里排序之后只是流中进行了排序，如果想要得到排序之后的集合，需要对流进行toArray操作，然后重新转换成集合。
       List<User> userlist = new ArrayList<User>();
       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<Map<String, Object>> backList = new ArrayList<Map<String, Object>>();
       Map<String, Object> map1 = new HashMap<String, Object>();
       map1.put("money", 23.2);
       Map<String, Object> map2 = new HashMap<String, Object>();
       map2.put("money", 23.1);
       Map<String, Object> map3 = new HashMap<String, Object>();
       map3.put("money", 24);
       backList.add(map1);
       backList.add(map2);
       backList.add(map3);

       List<Map<String, Object>> 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<String> 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<Integer> 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<String> 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<User>, 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() ;
   }
}

jdk1.8 java.util.stream

# 流类型

相关问题

公告