Stream流

Stream流

Stream流的生成方式

Stream流的使用

• 生成流：通过数据源（集合，数组等）生成流 list.stream()
• 中间操作：一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流， 交给下一个操作使用 filter（）
• 终结操作：一个流只能有一个终结操作，当这个操作执行后，流就被使用光了，无法再被操作，所以这必定是流的最后一个操作 forEach（）

Collection体系的集合可以使用默认方法stream（）生成流

• default Stream < E > stream()
• Map体系的集合可以间接生成流
• 数组可以通过Stream接口的静态方法of（T…values）生成流

Stream流的常见中间操作方法

filter()的使用

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

  Predicate接口中的方法 boolean test（T t）：对给定的参数进行判断，返回一个布尔值

public class StreamDemo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("周星驰");
        list.add("周董");
        list.add("周杰伦");
        list.add("林俊杰");
        list.add("华晨宇");
        list.add("毛不易");
        //输出集合中姓名为周的
        list.stream().filter(s -> s.startsWith("周")).forEach(System.out::println);
        //输出集合中姓名为周的,长度为3的
        list.stream().filter(s -> s.startsWith("周")).filter(s -> s.length() == 3).forEach(System.out::println);
    }
}

• Stream < T > limit(long maxSize): 返回此流中的元素组成的流，组成的流，截取前指定参数的数据
• Stream < T > skip (long n) 跳过指定参数个数的数据，返回由该流剩余元素组成的流

public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("周星驰");
        list.add("周董");
        list.add("周杰伦");
        list.add("林俊杰");
        list.add("华晨宇");
        list.add("毛不易");
        //取前三个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("*".repeat(10));

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

        //跳过两个元素，把剩下前3个元素的元素在控制台输出
        list.stream().skip(2).limit(3).forEach(System.out::println);
        System.out.println("*".repeat(10));
}

• static < T > stream < T > concat (Stream a, Stream b), 合并a和b两个流为一个流
• Stream < T > distinct (),返回由该流的不同元素，根据Object.equals(Object) 组成的流

public class StreamDemo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("周星驰");
        list.add("周董");
        list.add("周杰伦");
        list.add("林俊杰");
        list.add("华晨宇");
        list.add("毛不易");
        //取前四个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);
        //跳过2个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);
        //合并s1和s2得到的流，并在控制台输出
        //Stream.concat(s1, s2).forEach(System.out::println);
        //a合并s1和s2得到的流，去除重复的元素并输出
        Stream.concat(s1, s2).distinct().forEach(System.out::println);

    }
}

• Stream < T > sorted():返回由此元素组成的流，根据自然元素排序
• Stream < T > sorted(Comparator comparator): 返回该流组成元素的流，根据Comparator进行排序

public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("周星驰");
        list.add("林俊杰");
        list.add("周董");
        list.add("周杰伦");
        list.add("华晨宇");
        list.add("毛不易");
     
        //按照字母排序在控制台输出
        list.stream().sorted().forEach(System.out::println);
        //按照字符串长度排序输出
        list.stream().sorted((a, b) -> a.length() - b.length()).forEach(System.out::println);
    

    }

 list1.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        list1.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        //求和
        int i = list1.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(i);

收集流

 Stream<String> s1 = list.stream().limit(4);
        List<String> name =s1.collect(Collectors.toList());

 Map<String, String> map = new HashMap<String, String>();
        map.put("3432", "第三个");
        map.put("3dfs", "第三个");
        map.put("3sdf2", "第三个");
        Map map1 = map.entrySet().stream().collect((Collectors.toMap(s -> s.getKey(), s -> s.getKey())));

        map.entrySet().stream().sorted(Comparator.comparing(s -> s.getValue())).forEach(s -> System.out.println(s.getValue()));   //通过值进行排序
List<Student> student = studentList.stream().sorted(Comparator.comparing(Student::getScore).reserved()).collet(Collectors.toList());
//学生成绩