JAVA小知识14：浅谈Stream流

在阅读本文章之前请了解什么叫  Lambda表达式  以及  如何使用 

一、Stream流

Stream流的使用步骤：

1. 获得一条Stream流，并且将数据放上去
   1. 单列集合获取Stream流

      // 1. 单列集合获取Stream
      ArrayList<String> list = new ArrayList<String>();
      list.add("a");
      list.add("b");
      // 2. 获取Stream流
      list.stream().forEach(e-> System.out.println(e));

   2. 双列集合获取Stream需要转化为单列集合

      // 1. 双列集合获取Stream
      HashMap<String,Integer> hm = new HashMap<String,Integer>();
      hm.put("a",1);
      hm.put("b",2);
      // 2. 双列集合获取Stream需要转化为单列集合
      //    使用keyset/entryset
      hm.keySet().stream().forEach(key -> System.out.println(key));

   3. 数组获取Steam需要通过Arrays

      // 1. 数组获取Stream流
      int[] arr = {1,2,3,4,5,6,7,8};
      // 2. 数组通过Arrays获取Stream流
      Arrays.stream(arr).forEach(e-> System.out.println(e));

   4. 零散数据通过Stream中的of获取，但是需要零散数据为同种数据类型。如果of传递的是数组，则必须传递引用数据类型的数组，不能是基本数据类型的（八大基本数据类型）

      // 1. 零散数据获取Stream流
      Stream.of(1234).forEach(e-> System.out.println(e));
      // 2. 零散数据获取stream通过of
      //    但是切记零散数据需要这些数据为同种数据类型
      Stream.of("A","B").forEach(e-> System.out.println(e));

2. 利用Stream流的API操作数据
   •  中间方法：方法调用完成后还可以调用其他中间方法，一般例如：过滤、装换
   •  终结方法：最后一步，不能在调用其他方法，一般例如：统计、 打印     

二、Stream流的中间方法

 2.1 过滤filter

ArrayList<Integer> arr = new ArrayList<Integer>();
Collections.addAll(arr,1,10,16,27,29,29,30,40,50);
// 1. 获取stream流,使用filter过滤大于等于30的数字
arr.stream().filter(e->e<30).forEach(e-> System.out.println(e));

2.2 获取前几个元素limit

ArrayList<Integer> arr = new ArrayList<Integer>();
Collections.addAll(arr,1,10,16,27,29,29,30,40,50);
// 1. 获取stream流,获取前5个元素
arr.stream().limit(5).forEach(e-> System.out.println(e));

 
2.3 跳过前几个元素skip 

ArrayList<Integer> arr = new ArrayList<Integer>();
Collections.addAll(arr,1,10,16,27,29,29,30,40,50);
// 1. 获取stream流,跳过5个元素
arr.stream().skip(5).forEach(e-> System.out.println(e));

2.4 去重distinct

ArrayList<Integer> arr = new ArrayList<Integer>();
Collections.addAll(arr,1,10,16,27,29,29,30,40,50);
// 1. 获取stream流，去重
arr.stream().distinct().forEach(e-> System.out.println(e));

2.5 合并两个流concat

ArrayList<Integer> arr1 = new ArrayList<Integer>();
ArrayList<Integer> arr2 = new ArrayList<Integer>();
Collections.addAll(arr1,1,10,16);
Collections.addAll(arr2,2,10,26);
// 1. 获取stream流,合并去重
Stream.concat(arr1.stream(),arr2.stream())
        .distinct()
        .forEach(e-> System.out.println(e));

2.6 转化流中数据类型map 

ArrayList<String> arr1 = new ArrayList<String>();
Collections.addAll(arr1,"a-1","b-2","c-3","d-4");
// 1. 获取stream流，并且只打印数字 使用map进行类型转化
arr1.stream()
        .map(e->Integer.parseInt(e.split("-")[1]))
        .forEach(e-> System.out.println(e));

 

三、Stream流的终结方法

3.1 遍历forEach

这个没啥好说的，上面中间方法的所有例子的终结方法都是foreach

3.2 统计count

ArrayList<Integer> arr1 = new ArrayList<Integer>();
Collections.addAll(arr1, 1,2,3,4,5,6,7,8,9,10,11);
long count = arr1.stream().count();
System.out.println(count);

3.3 收集到数组中 toArray

ArrayList<String> arr1 = new ArrayList<String>();
Collections.addAll(arr1,"a-1","b-2","c-3","d-4");
// 1. 获取stream流，并且存储到数组中 toArray
// 2. 如果toArry为空参则对象为Object
Object[] objects = arr1.stream().toArray();
System.out.println(Arrays.toString(objects));
// 3. 如果需要转为指定类型的数组则需要传参 参数传递为 个数->需要数组类型【个数】
String[] strings = arr1.stream().toArray(e -> new String[e]);
System.out.println(Arrays.toString(strings));

3.4 收集到集合中collect

ArrayList<String> arr1 = new ArrayList<String>();
Collections.addAll(arr1,"a-1","b-2","c-3","d-4","d-4");
// 1. 获取stream流，并且存储到List集合当中
// .collect(Collectors.toList()) 底层会自动为我们创建list集合
List<String> collect = arr1.stream().collect(Collectors.toList());
// 2. 获取stream流，并且存储到Set集合当中
Set<String> collect1 = arr1.stream().collect(Collectors.toSet());
System.out.println("list:"+collect);
System.out.println("set:"+collect1);

 通过输出我们可以看到，存储在list与set集合中的区别，set会去重

 注意转化list到map的时候 不能有相同的key出现哦！！！！

ArrayList<String> arr1 = new ArrayList<String>();
Collections.addAll(arr1,"a-1","b-2","c-3","d-4");
// 3. 获取stream流，并且存储到map集合当中 a为键 1为值
/*
 tomap:参数1：键的生成规则
       参数2：值的生成规则
 */
Map<String, String> collect2 = arr1.stream()
        .collect(Collectors.toMap(
                e -> e.split("-")[0], //参数1
                e -> e.split("-")[1]  //参数2
        ));
System.out.println("map:"+collect2);