Stream流---结合了Lambda表达式，简化集合、数组的操作

Stream流

介绍

1. ​ 结合了Lambda表达式，简化集合、数组的操作
2. ​ 先得到一条Stream流，并把数据放上去
3. ​ 利用Stream流中的API进行各种功能操作

使用步骤

单列集合获取Stream流

//遍历输出
ArrayList<String> list = new ArrayList<>();
Collections.addALL(list,"a","b","c","d");
Stream<String> stream1 = list.stream();
stream1.forEach(new Consumer<String>(){
    public void accept(String s){
        System.out.println(s);
    }
});
//简化后
list.stream().forEach(s->System.out.println(s));

双列集合获取Stream流（间接）

HashMap<String,Integer> hm = new HashMap<>();
hm.put("aaa",111);
hm.put("bbb",222);
hm.entrySet().stream().forEach(s->System.out.println(s));

数组获取Steam流

int arr1 = {1,2,3,4};
String[] arr2 = {"a","b","c"};
Arrays.stream(arr1).forEach(s->System.out.printl(s));
Arrays.Stream(arr2),forEach(s->System.out.printl(s));

零散数据

Stream.of(arr1).forEach(s->System.out.println(s));

注意：

• 此方法形参是一个可变参数，可以传递一堆零散数据，也可以传递数组。
• 数组必须是引用数据类型，如果是基本数据类型，会把整个数组当成一个元素放到Stream 中（基本类型使用此方法会返回该数组地址）

Steam流中间方法

过滤操作

ArrayList<String> list = new ArrayList<>();
Collections.addALL(list,"aaa","bbb","ccc");
//把a开头的留下
list.stream().filter(new Predicate<String>(){
    public boolean test(String s){
        return s.startsWith("a");//如果符合返回true
    }
}).forEach(s->System.out.println(s));
//lambda表达式
list.stream().filter(s->s.startsWith("a")).forEach(s->System.out.println(s));

合并流操作

ArrayList<String> list1 = new ArrayList<>();
Collections.addALL(list1,"张无忌","张无忌","张无忌"，"张强"，"张三丰"，"张翠山"，"张良"，"王二麻子"，"谢广坤");
ArrayList<String> list2 = new ArrayList<>();
Collections.addALL(list2,"周芷若"，"赵敏");
Steam.concat(list1.stream(),list2.stream()).forEach(s->System.out.println(s));

转换流中的数据类型

ArrayList<String> list = new ArrayList<>();
Collections.addALL(list,"张无忌-11"，"张强-4"，"张三丰-6"，"张翠山-4"，"张良-6"，"王二麻子-5"，"谢广坤-7");
list.stream().map(new Function<String,Integer>(){
    public Integer apply(String s){
        String[] arr = s.split("-");
        String ageString = arr[1];
        int age = Integer.parseInt(ageString);
        return age;
    }
}).forEach(s->System.out.println(s));
//lambda
list.stream().map(s->Integer.parseInt(s.split("-")[1]).forEach(s->System.out.println(s));

注意：

• 中间方法，返回新的Stream流，原来的Steam流只能使用一次，建议使用链式编程
• 修改Steam流中的数据，不会影响原来集合或者数组中的数据

Steam流终结方法

收集数据到数组

String[] arr = list.stream().toArray(new IntFunction<String[]>(){
    public String[] apply(int value){
        return new String[Value];
    }
});
//lambda
String[] arr = list.stream().toArray(value -> new String[Value]);
System.out.println(Arrays.toString(arr));

收集数据到集合

ArrayList<String> list = new ArrayList<>();
Collections.addALL（list,"张无忌-男-15"，"周芷若-女-14"，"赵敏-女-13"，"张强-男-20","张三丰-男-100"，"张翠山-男-40"，"张良-男-35"，"王二麻子-男-37","谢广坤-男-41"）;
//list集合
List<String> newList = list.stream()
    .filter(s ->"男".equals(s.split(regex:"-")[1]))
    .collect(Collectors.toList());
//set集合(可自动去重)
Set<String> newList = list.stream()
    .filter(s ->"男".equals(s.split(regex:"-")[1]))
    .collect(Collectors.toSet());
//map集合
Set<String> newList = list.stream()
    .filter(s ->"男".equals(s.split(regex:"-")[1]))
    .collect(Collectors.toMap(new Function<String,String>(){
						public String apply(String s）{
						//张无忌-男-15
						return s.split( regex: "-")[0];
                        }
                      },
						new Function<Strihg, Integer>(){
						public Integer apply(String s){
						return Integer.parseInt(s.split( regex: "-")[2]);
                        }
                      }
	}));
//lambda
Map<String, Integer> map2 = list.stream()
    .filter(s -> "男".equals(s.split(regex:"-")[1]))
    .collect(Collectors.toMap(
        s -> s.split("-")[0],
        S -> Integer.parseInt(s.split(regex:"-")[2])));
System.out.println(map2);

Function

• 泛型一：表示流中每一个数据的类型
• 泛型二：表示Map集合中值的数据类型

方法apply

• 形参：依次表示流里面的每一个数据

• 方法体：生成值的代码

• 返回值：已经生成的值