Java基础篇--Stream流

1.体验Stream流：

1.需求：按照下面的要求完成集合的创建和遍历

①创建一个集合，存储多个字符串元素

②把集合中所有以“张”开头的元素存储到一个新的集合

③把“张”开头的集合中的长度为3的元素存储到一个新的集合

④遍历上一步得到的集合

ArrayList<String> list = new ArrayList<String>();
        ArrayList<String> list1 = new ArrayList<String>();
            ArrayList<String> list2 = new ArrayList<String>();
            list.add("张三丰");
            list.add("张无忌");
            list.add("张三");
            list.add("张斯特");
            list.add("张敏");
            for(String s : list){
                if(s.startsWith("张")){//这个就是提前字符串的第一个字，进行对比
                    list1.add(s);
                }
            }
            System.out.println(list1);
            for(String s : list1){
                if(s.length() == 3){
                    list2.add(s);
                }
            }
            System.out.println(list2);
            for(String s : list2){
            System.out.println(s);
        }

 二、使用Stream流的方式完成过滤操作：

1.list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);

2.直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：生成流、过滤姓张、过滤长度为3、逐一打印

3.Stream流把真正的函数式编程风格引入到java中

ArrayList<String> list = new ArrayList<String>();
        ArrayList<String> list1 = new ArrayList<String>();
            ArrayList<String> list2 = new ArrayList<String>();
            list.add("张三丰");
            list.add("张无忌");
            list.add("张三");
            list.add("张斯特");
            list.add("张敏");
list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));

 三、Stream流的使用：

1.生成流

         通过数据源(集合，数组等)生成流

                 list.stream()

2.中间操作

         一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用

                 filter()

3.终结操作

         一个流只能有一个总结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作

                 forEach()

四、Stream流的常见生成方式：

 1.Collection体系的集合可以使用默认方法stream()生成流

         default Stream<E> stream()

List<String> li = new ArrayList<String>();
Stream<String> stream1 = li.stream();
Set<String> set = new HashSet<String>();
Stream<String> stream2 = set.stream();

 2.Map体系集合间接的生成流

Map<String,Integer> map = new HashMap<String,Integer>();
Stream<String> stream3 = map.keySet().stream();
Stream<Integer> stream4 = map.values().stream();
Stream<Map.Entry<String,Integer>> stream5 = map.entrySet().stream();

 3.数组可以通过Stream接口的静态方法of(T...values)生成流

String[] strArray = {"hello","world","java"};
Stream<String> stream6 = Stream.of(strArray);
Stream<String> stream7 = Stream.of("hello","world","java");
Stream<Integer> stream8 = Stream.of(2,34,53,243);

 五、Stream流的常见中间操作方法：

1.Stream<T> filter(Predicate predicate):用于对流中的数据进行过滤

        Predicate接口中的方法

        boolean test(T t):对给定的参数进行判断，返回一个布尔值

//        需求1：把list集合中一张开头的元素在控制台输出
list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);

 2.Stream<T> limit (long maxSize):返回此流中的元素组成的流，截取前指定参数个数的数据

//        需求1：取前3个数据在控制台输出
list.stream().limit(3).forEach(System.out::println);

 3.Stream<T> skip (long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流

//        需求2：跳过3个元素，把剩下的元素在控制台输出
list.stream().skip(3).forEach(System.out::println);

 4.static <T> Stream<T> concat(Stream a,Stream b):合并a和b两个流为一个流

Stream<String> sm = list.stream().limit(4);
Stream<String> sm1 = list.stream().skip(2);
//需求3：合并需求1和需求2得到的流，并把结果输出在控制台
Stream.concat(sm,sm1).forEach(System.out::println);

 5.Stream<T> distinct()：返回由该流的不同元素（根据Object.equals(Object)）组成的流

​Stream<String> sm = list.stream().limit(4);
Stream<String> sm1 = list.stream().skip(2);
//需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
Stream.concat(sm,sm1).distinct().forEach(System.out::println);

6.Stream<T> sorted():返回有此流的元素组成的流，根据自然顺序排序

//        需求1：按照字母顺序把数据在控制台输出
list3.stream().sorted().forEach(System.out::println);

 7.Stream<T> sorted(Comparator comparator):返回由该流的元素组成的流，根据提供的Comparator进行排序

         Comparator接口中的方法

         int compare(t o1,To2)

list3.stream().sorted((s1,s2) -> {
            int sum = s1.length() - s2.length();
            int sum2 = sum == 0?s1.compareTo(s2):sum;
            return sum2;
        }).forEach(System.out::println);

 8.<R> Stream<R> map (Function mapper):返回由给定函数应用于此流的元素的结果组成的流

         Function接口中的方法

         R apply(T t)

//        需求1：将集合中的字符串数据转换为整数之后在控制台输出
list4.stream().map(Integer::parseInt).forEach(System.out::println);

 9.IntStream mapToInt(ToIntFunction mapper):返回一个IntStream其中包括将给定函数应用于此流的元素结果

        IntStream：表示原始的int流

        ToIntFunction接口中方法int applyAsInt(T value)

//        需求2：将集合中的字符串数据转换为整数型，并求出他们的和在控制台输出
list4.stream().mapToInt(Integer::parseInt).forEach(System.out::println);

 六、Stream流的常见终结操作方法：

1.void forEach(Consumer action)：对此流的每个元素执行操作

         Consumer接口中的方法

         void accept(T t)：对给定的参数执行此操作

//        需求1：把集合中的元素在控制台输出
list.stream().forEach(System.out::println);

 2.long count()：返回此流中的元素数

//需求2：统计集合中有几个以张开头的元素，并把统计结果在控制台输出
long sum = list.stream().filter(s -> s.startsWith("张")).count();