【Stream流的使用】

获取stream流的两种方式

1.通过Collection接口获取Stream流

//1.通过collection接口获取stream流
//Collection接口中的方法default Stream<E> stream()
//Collection接口下面的集合：list、Set、queue、Map
    ArrayList<String> list=new ArrayList<>();
    list.stream();
    LinkedList<String> linkedList=new LinkedList<>();
    linkedList.stream();
    Set<String> set=new HashSet<>();
    set.stream();
    Map<String,String> map=new HashMap<>();
    map.keySet().stream();
    map.values().stream();

2.stream中的静态方法of获取流

//2.通过Stream静态方法of获取stream流
//static<T> Stream<T> of(T... values)
    Stream<String> stream = Stream.of("aa", "bb", "cc");
    stream.forEach(System.out::println);
    String[] str={"aa","bb","cc"};
    Stream<String> stream1 = Stream.of(str);
//基本数据类型的数组不能使用静态方法获取stream流，因为是把int[]看为一个整体h
    int[] arr={1,2,3,4,5};
    Stream<int[]> stream2 = Stream.of(arr);

Stream流中的常用方法和注意事项

常用方法

方法名	方法作用	返回值类型	方法种类
count	统计个数	long	终结
forEach	逐一处理	void	终结
filter	过滤	Stream	函数拼接
limit	取前几个	Stream	函数拼接
skip	跳过前几个	Stream	函数拼接
map	映射	Stream	函数拼接
concat	组合	Stream	函数拼接

注意事项

        //1.Stream流只能使用一次
        Stream<String> stream = Stream.of("aa", "bb", "cc");
        stream.forEach(System.out::println);
        //如果多次使用，stream has already been operated upon or closed
        stream.count();
        //2.stream返回的是一个新的流
        //------java.util.stream.ReferencePipeline$Head@511d50c0
        //------java.util.stream.SliceOps$1@60e53b93
        Stream<String> limit = stream.limit(1);
        System.out.println("------"+stream);
        System.out.println("------"+limit);
        //3.stream想要执行必须要执行终止操作
        stream.filter((s -> s.contains("a"))).forEach(System.out::println);

Stream流中的常用方法

forEach方法

forEach方法用来遍历数据

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"a","b","c","d","e");
//输出打印结果
//使用匿名函数
list.stream().forEach(new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
});
//使用lambda表达式
list.stream().forEach(str-> System.out.println(str));
//使用方法引用
list.stream().forEach(System.out::println);

count方法

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"a","b","c","d","e");
 long count = list.stream().count();
 System.out.println(count);

filter方法

统计流中的元素个数

ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"迪丽热巴","古力娜扎","马尔扎哈","赵丽颖","杨幂","刘诗诗","高圆圆");
        //filter里需要实现predicate接口，接口中的抽象方法为boolean test(T t);
        //使用lambda表达式
        list.stream().filter((String s)->{
            return s.length()==3;
        });
        //简化后的
        list.stream().filter(s->s.length()==3);

limit方法

获取前几个数据

ArrayList<String> list=new ArrayList<>();
Collections.addAll(list,"迪丽热巴","古力娜扎","马尔扎哈","赵丽颖","杨幂","刘诗诗","高圆圆");
 list.stream()
         .limit(3)
         .forEach(System.out::println);

skip方法

跳过几个数据几个数据

ArrayList<String> list=new ArrayList<>();
Collections.addAll(list,"迪丽热巴","古力娜扎","马尔扎哈","赵丽颖","杨幂","刘诗诗","高圆圆");
list.stream()
        .skip(2)
        .forEach(System.out::println);

map方法

将一种数据类型的流转换为另一种数据类型

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"1","2","3","4","5");
list.stream()
		.map(s->Integer.parseInt(s))
		.forEach(System.out::println);
//使用方法引用
list.stream()
		.map(Integer::parseInt)
		.forEach(System.out::println);

sorted方法

实现排序操作

Stream<Integer> stream = Stream.of(11, 22, 33, 15, 43);
//使用无参构造方法：默认升序
 stream.sorted().forEach(System.out::print);
 //使用有参构造,int compare(T o1, T o2);
 //实现降序
 stream.sorted((Integer i1,Integer i2)->{return i2 - i1;
 }).forEach(System.out::println);
 //简化后
 stream.sorted((i1,i2)->i2-i1).forEach(System.out::println);

distinct方法

实现去重操作

Stream<String> stream = Stream.of("a", "b", "c", "d", "a");
stream.distinct().forEach(System.out::println);
Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 1, 2, 6);
stream1.distinct().forEach(System.out::println);

match方法

判断数据是否匹配指定的条件

Stream<Integer> stream = Stream.of(1, 3, 5, 7, 2);
boolean b = stream.allMatch(i -> i > 2);//allMatch:判断是否是所有的条件都满足
boolean b1 = stream.anyMatch(i -> i > 2);//anyMatch:判断是否有一个条件满足
boolean b2 = stream.noneMatch(i -> i > 2);//noneMatch:判断是否没有一个条件满足
System.out.println(b2);

find方法

找到特定的值

Stream<String> stream = Stream.of("a", "b", "c", "d", "e");
Optional<String> first = stream.findFirst();//findFirst()返回的是一个Optional对象
System.out.println(first.get());
Stream<String> stream1 = Stream.of("a", "b", "c", "d", "e");
Optional<String> any = stream1.findAny();//findAny()返回的是一个Optional对象
System.out.println(any.get());

max和min方法

找到最大值和最小值

Optional<Integer> max = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).max(((o1, o2) -> 01 - 02));//01-02，升序
System.out.println(max.get());
Optional<Integer> min = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).min(((o1, o2) -> o1 - o2));
System.out.println(min.get());

reduce方法

将所有数据归纳得到一个数据

Stream<Integer> stream = Stream.of(1, 3, 2, 5, 7);
//T reduce(T identity, BinaryOperator<T> accumulator);
//R apply(T t, U u);
//第一次：x=0,y=集合中的第一个数据
//第二次：x=返回的值,y=集合中的第二个数据
//。。。。。。。。。
Integer reduce = stream.reduce(0, (x, y) -> x + y);
System.out.println(reduce);

mapToInt方法

将包装类转换为基本数据类型

Stream<Integer> stream = Stream.of(1, 2, 3, 4);
//初始的
 Stream.of(1, 2, 3, 4).mapToInt(new ToIntFunction<Integer>() {
     @Override
     public int applyAsInt(Integer value) {
         return value.intValue();
     }
 }).forEach(System.out::println);
 //经过优化的
 Stream.of(1, 2, 3, 4).mapToInt(Integer::intValue).forEach(System.out::println);

concat方法

将两个流合并为一个流，使stream的静态方法

Stream<String> stream = Stream.of("张三");
Stream<String> stream1 = Stream.of("李四");
//只支持两个流合成
Stream<String> concat = Stream.concat(stream, stream1);
concat.forEach(System.out::println);
//操作后的刘不能再进行操作
stream.forEach(System.out::println);