Java - Stream流

Stream流

1. 获取Stream流对象，将数据放到流中

   1. 集合获取Stream流对象（使用Collection接口中的默认方法）

      • default Stream stream()
      • Map集合获取Stream流对象，需要间接获取，可以通过.values()和.keySet()去实现Map的流操作，但是将键值拆分是不推荐的。以后要使用entrySet()先将Map改为Set集合然后再用流对象
      • map.entrySet().stream()

          private static void method1() {
              // 单列集合
              List<String> list = new ArrayList<>();
              list.add("one");
              list.add("two");
              list.add("three");
              list.add("four");
              list.add("five");
              list.add("five");
              list.add("six");
              list.stream().forEach(s -> System.out.println(s));
              System.out.println("list print finished");
      
              Set<String> set = list.stream().collect(Collectors.toSet());
              set.stream().forEach(s -> System.out.println(s));
              System.out.println("set print finished");
      
              // 双列集合
              Map<String, Integer> map = new HashMap<>();
              map.put("one", 1);
              map.put("two", 2);
              map.put("three", 3);
              map.put("four", 4);
              map.put("five", 5);
              map.entrySet().stream().forEach(stringIntegerEntry -> System.out.println(stringIntegerEntry));
              System.out.println("map print finished");
          }
      

   2. 数组获取Stream流对象（使用Arrays数据工具类中的静态方法）

      • static <T> Stream<T> stream (T[] array)

          private static void method2() {
              int[] ints = {11, 22, 33};
              double[] doubles = {11.1, 22.1, 33.1};
      
              IntStream intStream = Arrays.stream(ints);
              intStream.forEach(s -> System.out.println(s));
      
              DoubleStream doubleStream = Arrays.stream(doubles);
              doubleStream.forEach(s -> System.out.println(s));
      
              Stream stream = Stream.of(1, 2, 3, 4, 5);
              stream.forEach(s -> System.out.println(s));
          }
      

   3. 零散的数据获取Stream流对象（使用Stream类中的静态方法）

      • static <T> Stream<T> of(T… values)

          private static void method2() {
              Stream stream = Stream.of(1, 2, 3, 4, 5);
              stream.forEach(s -> System.out.println(s));
          }
      

2. 中间方法（Stream流被终止过后就不能再调用使用了，只能重新创建），返回对象

   • Stream流的中间操作方法：操作后返回Stream对象，可以继续操作
   • Stream<T> filter(Predicate<? super T> predicate)用于对流中的数据进行过滤
   • Stream<T> limit(long maxSize) 获取前几个元素
   • Stream<T> skip(long n) 跳过前几个元素
   • Stream<T> distinct() 去除流中重复的元素，依赖hashCode和equals方法
   • Static<T> Stream<T> concat(Stream a, Stream b) 合并a和b两个流为一个流

3. 终结方法

   • void forEach(Consumer action) - 对此流的每个元素执行遍历操作
   • long count() - 返回此流中的元素数量

public static void main(String[] args) {
        Stream.of(1, 2, 3, 4, 5, 6).filter(s -> s % 2 == 0).forEach(s -> System.out.println(s));
        long count = Stream.of(1, 2, 3, 4, 5, 6).filter(s -> s % 2 == 0).count();
        System.out.println(count);
    }

4. Stream 收集操作

• 把 Stream 流操作后的结果数据转回到集合
  • R collect(Collector collector) - 开始收集 Stream 流，指定收集器
• Collectors 工具类提供了具体的收集方式
  • public static Collector toList() - 把元素收集到List集合中
  • public static Collector toSet() - 把元素收集到Set集合中
  • public static Collector toMap() - 把元素收集到Map集合中

File类