Java之Stream流

获取Stream流

单列集合	default Stream<E> stream()	Collection中的默认方法
双列集合	无	无法直接使用stream流
数组	public static <T> Stream<T> stream(T[] array)	Arrays工具类中的静态方法
一堆零散数据	public static<T> Stream<T> of(T...values)	Stream接口中的静态方法

代码演示：

单列集合

default Stream<E> stream() Collection中的默认方法

public static void main(String[] args) {  
    //1.单列集合获取Stream流  
    ArrayList<String> list = new ArrayList<>();  
    Collections.addAll(list,"a","b","c","d","e","f","d","e");  
    //获取一个Stream流，把数据放到Stream流上  
    Stream<String> stream1 = list.stream();  
    //使用终结方法打印一下所有数据  
    stream1.forEach(new Consumer<String>() {  
        @Override  
        public void accept(String s) {  
            //s表示stream流里每一个数据  
        }  
    });  
    //用lambda表达式简化  
    list.stream().forEach(s-> System.out.println(s));  
}

双列集合

无 无法直接使用stream流

public static void main(String[] args) {  
    //双列集合  
    //1.创建双列集合  
    HashMap<String,Integer> hm = new HashMap<>();  
    //2.添加数据  
    hm.put("aaa",111);  
    hm.put("bbb",222);  
    hm.put("ccc",333);  
    hm.put("ddd",444);  
    hm.put("eee",555);  
    //3.第一种获取Stream流  
    hm.keySet().stream().forEach(s-> System.out.println(s));  
    //4.第二种获取Stream流  
    hm.entrySet().stream().forEach(s-> System.out.println(s));  
}

数组

public static <T> Stream<T> stream（T[] array) Arrays工具类中的静态方法

public static void main(String[] args) {  
    //1.创建数据  
    int[] arr1 = {1,2,3,4,5,6,7,8,9};  
    String[] arr2 = {"a","b","c"};  
    //2.获取stream流  
    Arrays.stream(arr1).forEach(s-> System.out.println(s));  
    System.out.println("================");  
    Arrays.stream(arr2).forEach(s-> System.out.println(s));  
}

一堆零散数据

public static<T> Stream<T> of(T...values) Stream接口中的静态方法

public static void main(String[] args) {  
    Stream.of(1,2,3,4,5,6).forEach(s-> System.out.println(s));  
    Stream.of("a","b","c").forEach(s-> System.out.println(s));  
}

注意：
Stream接口中静态方法of的细节
方法的形参是一个可变参数，可以传递一堆零散的数据，也可以传递参数
但是数组必须是引用数据类型的，如果传递基本数据类型，是会把整个数组当作一个元素，放到Stream当中。

int[] arr = {1,2,3,4};  
Stream.of(arr).forEach(s-> System.out.println(s));  

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两个流为一个流
Stream<R> map(Function<T,R> mapper)	转换流中的数据类型\

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

代码演示：

过滤

Stream\ filter(Predicate\<? super T>predicate) 过滤

ArrayList<String> list = new ArrayList<>();  
Collections.addAll(list,"123","123","246","1263","572");  
//Stream<T> filter(Predicate<? super T>predicate)       过滤  
list.stream().filter(new Predicate<String>() {  
    @Override  
    public boolean test(String s) {  
        //如果返回值为true,表示当前数据留下  
        //如果返回值为false,表示当前数据舍弃不要  
        return s.startsWith("1");  
    }  
}).forEach(s-> System.out.println(s));  
  
//lambda简化  
list.stream().filter(s -> s.startsWith("1")).forEach(s -> System.out.println(s));

去头去尾

Stream\ limit(long maxSize) 获取前几个元素
Stream\ skip(long n) 跳过前几个元素

list.stream().limit(2).forEach(s-> System.out.println(s));  
list.stream().skip(2).forEach(s-> System.out.println(s));

去重和合并

Stream\ distinct() 元素去重，依赖(hashCode和equals方法)
static\ Stream\ concat(Stream a,Stream b) 合并a和b两个流为一个流

ArrayList<String> list1 = new ArrayList<>();  
Collections.addAll(list1,"1","1","2","2","2","3","4");  
list1.stream().distinct().forEach(s-> System.out.println(s));  
  
ArrayList<String> list2 = new ArrayList<>();  
Collections.addAll(list2,"a","b");  
Stream.concat(list1.stream(),list2.stream()).forEach(s-> System.out.println(s));

转换类型

Stream\ map(Function\ mapper) 转换流中的数据类型

//需求：只获取里面的年龄并进行打印
//String->int

//第一个类型：流中原本的数据类型
//第二个类型：要转成之后的类型

//apply的形参s:依次表示流里面的每一个数据
//返回值：表示转换之后的数据

//当map方法执行完毕之后，流上的数据就变成了整数
//所以在下面forEach当中，s依次表示流里面的每一个数据，这个数据现在就是整数了

ArrayList<String> list = new ArrayList<>();  
Collections.addAll(list,"张三-23","李四-35","王五-18","赵六-19");   
list.stream().map(new Function<String, Integer>() {  
    @Override  
    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));  
  
System.out.println("=================");  
list.stream().map(s-> Integer.parseInt(s.split("-")[1])).forEach(s-> System.out.println());

Stream流的终结方法

常用方法（总览）

方法	说明
void forEach(Consumer action)	遍历
long count()	统计
toArray()	收集流中的数据，放到数组中
collect(Collector collector)	收集流中的数据，放到集合中（List Set Map）

代码演示：

前提集合：

ArrayList<String> list = new ArrayList<>();  
Collections.addAll(list, "张三", "李四", "王五", "赵六", "老七", "老八", "牢九");

遍历

Consumer的泛型：表示流中的数据类型
accept方法的形参s:依次表示流里面的每一个元素
方法体：对每一个数据的处理操作（打印）

list.forEach(new Consumer<String>() {  
    @Override  
    public void accept(String s) {  
        System.out.println(s);  
    }  
});  
list.stream().forEach(s -> System.out.println(s));

统计

long count = list.stream().count();  
System.out.println(count);

存入数组

不指定类型(object[]）

Object[] array = list.stream().toArray();  
System.out.println(Arrays.toString(array));

指定类型：

IntFunction的泛型：具体类型的数组
apply的形参：流中数据的个数，要跟数组的长度保持一致
apply的返回值：具体类型的数组
方法体：就是创建数组

toArray方法的参数的作用：负责创建一个指定类型的数组
toArray方法的底层，会依次得到流里面的每一个数据，并把数据放到数组当中
toArray方法的返回值：是一个装着流里面所有数据的数组

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

Collect

collect(Collector collector) 收集流中的数据，放到集合中（List Set Map）

前提：获取集合

ArrayList<String> list = new ArrayList<>();  
Collections.addAll(list, "张三-男-18", "李四-女-18", "王五-男-19", "赵六-女-18", "老七-男-18", "老八-女-18");

收集List集合当中

需求：
我要把所有的男性收集起来

List<String> newList = list.stream().  
        filter(s -> "男".equals(s.split("-")[1])).  
        collect(Collectors.toList());  
System.out.println(newList);

收集Set集合当中

需求：
要把所有的男性收集起来

Set<String> newList2 = list.stream()  
        .filter(s -> "男".equals(s.split("-")[1]))  
        .collect(Collectors.toSet());  
System.out.println(newList2);

收集Map集合当中

谁作为键，谁作为值
我要把所有的男性收集起来
键：姓名。 值：年龄

注意点： 如果我们要收集到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> map2 = list.stream().  
        filter(s -> "男".equals(s.split("-")[1])).  
        collect(Collectors.  
                toMap(  
                        s->s.split("-")[0],  
                        s->Integer.parseInt(s.split("-")[2])));  
System.out.println(map2);