Stream流的操作方法

Stream 流的生成方法
    1.生成流：通过数据源（集合和数组等）生成流：list.stream()
    2.中间操作：一个流后面可以跟随零个或者多个中间操作，其目的就是打开流，做出某种程度的数据过滤
        然后生成一个新的流，交给下一个操作处理：filter
    3.终结操作：一个流只有一个终结操作，当这个操作执行后，流就无法再进行操作：forEach();

  Stream流的生成方式：
    1.Collection体系的集合可以使用默认方法stream（）生成流：default Stream<E> stream()
    2.Map体系的集合间接生成流
    3.数组可以通过Stream接口的静态方法of(T...values)生成流

    Stream流的具体收集方式：
        1. public static <T> Collector toList() :把元素收集到List集合中
        2. public static <T> Collector toSet(): 把元素收集到Set集合中
        3. public static Collector toMap (Function keyMapper,Function valueMapper):把元素收集到Map结合中

Stream流的基本方法：
      1.  返回此流中的元素组成的流，截取前指定参数个数的数据：Stream<T> limit(long size)
      2.  跳过指定参数个数的数据，返回由该流的剩余元素组成的流：Stream<T> skip(long n)
      3.  合并a和b俩个流为一个流：static<T> Stream<T> concat(Stream a,Stream b)
      4.  返回由该流的不同元素（根据Object.equals(Object)）组成的流：Stream<T> distanct();
      5.  Stream<T>filter(Predicate predicate):用于对流中的数据进行过滤
      6.  Stream<T>sorted(): 返回由此流的元素组成的流，根据自然顺序排序
      7.  Stream<T>sorted(Comparator comparator): 返回由该流的元素组成的流，根据提供的Comparator进行排序
      8.  Stream<R>map(Function mapper): 返回由给定函数应用于此流的元素的结果组成的流
      9.  InStream mapTolnt(TolntFunction mapper): 返回一个IntStream其中包含给定函数应用此流的元素的结果
      10.  Stream流的常见终结操作方法：
                void forEach(Consumer action):对此流中的每个元素执行操作，Consumer接口中的方法，void accept（T t）：对给定的参数执行此操作
                loong count(): 返回此流中的元素数

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamDemo {
    public static void main(String[] args) {
        //Collection体系的集合可以使用默认方法stream（）生成流
        List<String> list = new ArrayList<String>();
        Stream<String> listStream = list.stream();
  //取前三个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);

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

        //跳过2个元素，把剩下元素当中的前2个在控制台输出
        list.stream().skip(2).limit(2).forEach(System.out::println);

        //需求1：取前4个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);

        //需求2：跳过2个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);

        //合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
        Stream.concat(s1,s2).distinct().forEach(System.out::println);

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

        //按照字符串的长度把数据在控制台输出
//        list.stream().sorted((s1,s2)->s1.length()-s2.length()).forEach(System.out::println);
        list.stream().sorted((s1,s2) ->{
            int num = s1.length()-s2.length();
            int num2 = num ==0?s1.compareTo(s2):num;
            return num2;
        }).forEach(System.out::println);

        //需求：将集合中字符串数据转换为整数之后在控制台输出的三种不同的改进方式
        list.stream().map(s-> Integer.parseInt(s)).forEach(System.out::println);
        list.stream().map(Integer :: parseInt).forEach(System.out::println);
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);

        //int sun():返回此流中的元素的总和
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);

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

        //把使用的Stream流操作完毕的数据收集到Lits集合中并遍历
        List<String> names = listStream.collect(Collectors.toList());
        for(String name : names){
            System.out.println(name);
        }




        Set<String> set = new HashSet<String>();
        Stream<String> setStream = set.stream();

        //Map体系的集合间接的生成流
        Map<String,Integer> map = new HashMap<String,Integer>();
        //键对应的流
        Stream<String> keyStream = map.keySet().stream();
        //键值对应的流
        Stream<Integer> valueStream = map.values().stream();
        Stream<Map.Entry<String,Integer>> entryStream = map.entrySet().stream();

        //数组可以通过Stream接口的静态方法of（T...values）生成流
        String[] strArray = {"hello","world","java"};
        Stream<String> strArrayStream = Stream.of(strArray);
        Stream<String> strArrayStream2 = Stream.of("hello","world","java");
        Stream<Integer> intStream = Stream.of(10,20,30);



    }
}

黑马程序员的学习笔记，来自于B站，只作为学习笔记使用

黑马程序员全套Java教程_Java基础入门视频教程，零基础小白自学Java必备教程_哔哩哔哩_bilibili