Java之Stream流大白话简介说明

下文笔者讲述Stream的简介说明,如下所示

Stream流简介

Stream是一种处理集合(Collection)数据的方式
   Stream使用一种更简洁的方式对集合进行过滤、映射、排序等操作

Stream是Java 8 API添加的一个新的抽象
    称为流Stream
    以一种声明性方式处理数据集合(侧重对于源数据计算能力的封装
       并且支持序列与并行两种操作方式) 

Stream流是
     从支持数据处理操作的源生成的元素序列
       源可以是数组、文件、集合、函数
         流不是集合元素
          它不是数据结构并不保存数据
           它的主要目的在于计算 

Stream流是
    对集合(Collection)对象功能的增强
    与Lambda表达式结合
    可提高编程效率、间接性和程序可读性 

Stream流特性

结构化处理:
    Stream提供了一种结构化的方式来处理集合数据
     可以使用一系列的操作来处理数据
       而不是通过循环遍历集合。
链式操作:
    Stream的操作可以进行链式调用
      形成一个操作流水线
       每个操作都会作用于前一个操作的结果上。
惰性求值:
    Stream的操作是惰性求值的
     只有在终止操作时才会触发执行
       这样可以避免不必要的计算。
并行执行:
    Stream可以以并行的方式执行操作
      可以充分利用多核处理器的优势提高程序的性能

例

//单列集合
Arraylist<String> list = new ArrayList<>();
Collections.addAll(list, "a", "b", "c", "d", "e", "f");
 
Stream<String> stream = list.stream();
stream.forEach(s -> System.out.println(s));

// 双列集合
HashMap<String,Integer> hm = new HashMap<>();
hm.put("aaa", 111);
hm.put("bbb", 222);
hm.put("ccc", 333);
hm.put("ddd", 444);
 
// 第一种
hm.keySet().stream().forEach(s -> System.out.println(s));
 
// 第二种
hm.entrySet().stream().forEach(s -> System.out.println(s));

// 数组
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
 
Arrays.stream(arr).forEach(s-> System.out.println(s));

// 一堆零散数据
// 必须是同一种数据
Stream.of(1,2,3,4,5,6,7).forEach(s-> System.out.println(s));
 
Stream.of("a","b","c","d","e").forEach(s-> System.out.println(s));

Stream流其他操作

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", 
"张翠山", "张良", "王二麻子", "谢广坤");
 
// filter   过滤
list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
 
// limit    获取前几个元素
list.stream().limit(2).forEach(s -> System.out.println(s));
 
// skip    跳过前几个元素
list.stream().skip(2).forEach(s -> System.out.println(s));

ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1, "张无忌", "张无忌", "张无忌",  "张强", 
"张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
 
ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2, "周芷若", "赵敏");
 
// distinct     元素去重（依赖hashcode和equals方法）
list1.stream().distinct().forEach(s -> System.out.println(s));
 
// concat       合并a和b两个流为一个流
Stream.concat(list1.stream(),list2.stream()).forEach(s -> System.out.println(s));

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-20", "周芷若-18", "赵敏-19", "张强-30", "张三丰-69", 
"张翠山-25", "张良-29", "王二麻子-54", "谢广坤-58");
 
// Stream<R> map(Function<T,R> mapper)	      转换流中的数据类型
// 第一个类型：流中原本的数据类型
// 第二个类型：要转成之后的类型
// apply的形参s：依次表示流里面的每一个数据
// 返回值：表示转换之后的数据
 
//当map方法执行完毕后，流上的数据就变成了整数
//随意在下面forEach当中，s依次表示流里面的每一个数据，这个数据现在是整数
list.stream().map(new Function<String, Integer>() {
    @Override
    public Integer apply(String s) {
        String[] arr = s.split("-");
        return Integer.parseInt(arr[1]);
    }
}).forEach(s -> System.out.println(s));
 
System.out.println("========");
 
// lambda表达式的形式
list.stream().map(s -> Integer.parseInt(s.split("-")[1])).forEach(s -> System.out.println(s));

Stream流的终结方法

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", 
  "张强", "张三丰", "张翠山", "张良", 
   "王二麻子", "谢广坤");
 
// void forEach(Consumer action)	    遍历
list.stream().forEach(s -> System.out.println(s));
 
// long count()	                    统计
long count = list.stream().count();
System.out.println(count);
 
// toArray()	                        收集流中的数据，放到数组中
Object[] obj = list.stream().toArray();
System.out.println(Arrays.toString(obj));
 
// IntFunction的泛型：具体类型的数组
// apply的形参：流中数据的个数，要跟数组的长度保持一致
// apply的返回值：具体类型的数组
// 方法体：就是创建数组
String[] arr = list.stream().toArray(new IntFunction<String[]>() {
    @Override
    public String[] apply(int value) {
        return new String[value];
    }
});
System.out.println(Arrays.toString(arr));
 
// lambda表达式的形式
String[] arr = list.stream().toArray(value -> new String[value]);
System.out.println(Arrays.toString(arr));

 
// collect(Collector collector)	    收集流中的数据，放到集合中
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-男-32", "周芷若-女-18", "赵敏-女-19", 
 "张强-男-26", "张三丰-男-45", "张翠山-男-24",
  "张良-男-23", "王二麻子-男-48",
   "谢广坤-男-56");
 
 
// 收集到List集合
// 收集男性
List<String> collect = list.stream()
  .filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toList());
System.out.println(collect);
 
 
// 收集到Set集合中
// 收集男性
// 会去重
Set<String> collect1 = list.stream()
   .filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toSet());
System.out.println(collect1);

// 收集到Map集合 // 收集男性,键：姓名，值：年龄 // 键不能重复 /* toMap:参数一表示键的生成规则 参数二表示值的生成规则 参数一： Function泛型一：表示流中每一个数据的类型 泛型二：表示map集合中键的数据类型 apply形参：依次表示流里面的每一个数据 方法体：生成键的代码 返回值：已经生成的键 参数二： Function泛型一：表示流中每一个数据的类型 泛型二：表示map集合中值的数据类型 apply形参：依次表示流里面的每一个数据 方法体：生成键的代码 返回值：已经生成的键 */ Map<String, Integer> map = list.stream() .filter(s -> "男".equals(s.split("-")[1])) .collect(Collectors.toMap(new Function<String, String>() { @Override public String apply(String s) { return s.split("-")[0]; } }, new Function<String, Integer>() { @Override public Integer apply(String s) { return Integer.parseInt(s.split("-")[2]); } })); System.out.println(map); // lambda表达式的形式 Map<String, Integer> map1 = list.stream() .filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toMap( s -> s.split("-")[0], s -> Integer.parseInt(s.split("-")[2]) )); System.out.println(map1);