Stream流

Collection体系的集合，使用Collection接口的默认方法，stream方法生成流

//        Collection 体系的集合使用 接口的默认方法 stream() 生成流
        List list = new ArrayList<>();
        Stream listStream = list.stream();

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

//        Map 体系的集合间接生成流
        Map map = new HashMap<>();
        Stream keySetStream = map.keySet().stream();
        Stream valuesStream = map.values().stream();
        Stream> entryStream = map.entrySet().stream();

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

        System.out.println(list.stream().getClass());
        System.out.println(new HashSet<>().stream().getClass());
//        class java.util.stream.ReferencePipeline$Head
//        class java.util.stream.ReferencePipeline$Head
        System.out.println(list.getClass());
//        class java.util.ArrayList
        System.out.println(new HashSet<>().getClass());
//        class java.util.HashSet

// 该方法在 ReferencePipeline 类中进行了实现, 我们需要做的就是, 提供 Predicate接口中test抽象方法的实现逻辑。
// 其余的事情, 源码中已经帮我们做好了。
Stream filter(Predicate predicate);

        ArrayList list = new ArrayList<>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

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

// 这两个方法也是在 ReferencePipeline 类中进行了实现
Stream limit(long maxSize);
Stream skip(long n);

        // 取前两个数据
        list.stream().limit(2).forEach(System.out::println);
        System.out.println("------------");
        // 跳过前两个数据
        list.stream().skip(2).forEach(System.out::println);
        System.out.println("------------");
        // 跳过前两个数据, 取剩下元素的前两个
        list.stream().skip(2).limit(2).forEach(System.out::println);

// Stream接口中的静态方法, 需要使用接口进行调用
static  Stream concat(Stream a, Stream b)
// 在 ReferencePipeline 类中进行了实现
Stream distinct()		

        Stream s1 = list.stream().limit(4);
        Stream s2 = list.stream().skip(2);
// 			合并两个流
		Stream.concat(s1,s2).forEach(System.out::println);
//          返回由该流的不同元素组成的流
        Stream.concat(s1,s2).distinct().forEach(System.out::println);

// 这两个方法也是在 ReferencePipeline 类中进行了实现
Stream sorted()		// 自然顺序排序
Stream sorted(Comparator comparator)		// 根据指定比较器进行排序

        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);

// 这两个方法同样是在 ReferencePipeline 类中进行了实现。
// 参数: 实现 Function接口中 apply方法的 lambda表达式
 Stream map(Function mapper);		// 将给定函数 apply 应用于此流元素

// IntStream表示原始 int 流, ToIntFunction接口中的抽象方法：`int applyAsInt(T value);`
IntStream mapToInt(ToIntFunction mapper);			// 将给定函数 applyAsInt 应用于此流元素

        ArrayList list = new ArrayList<>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");

        list.stream().map(Integer::parseInt).forEach(System.out::println);
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);

void forEach(Consumer action);			// 对此流的每个元素执行操作
long count();										// 返回此流中的元素个数

        ArrayList list = new ArrayList<>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");

        list.stream().forEach(System.out::print);
        long count = list.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(count);

// 在ReferencePipeline中进行实现
 R collect(Collector collector);

Collectors类中有一个静态内部类CollectorImpl实现了Collector接口

static class CollectorImpl implements Collector

以下都是Collectors类的静态方法，返回一个CollectorImpl对象。

Collector> toList()
Collector> toSet()
Collector> toMap(Function keyMapper, Function valueMapper)

        List newList = list.stream().filter(s -> s.startsWith("张")).collect(Collectors.toList());
        System.out.println(newList);

原来你是这样的 Stream
内部类和静态内部类的区别
Java Stream 源码深入解析