java之Stream

Stream：

//对于模型进行操作，本身不变
//终结性型方法：不支持链式调用->count和forEach
//延迟型方法：支持链式调用->filter，map，limit，skip，contact
//limit(long i)超过i个元素截取前i个
//skip(long n)跳过前n个
//contact（Stream s1， Stream s2）
//Stream流属于管道流，第一个流使用后流转到下一个Stream,一个Stream只能使用一次，使用后就会关闭
//每次操作都会返回新的一个流

package cn.xmz.pr2001.pr11;

import org.omg.PortableInterceptor.INACTIVE;

import java.util.*;
import java.util.stream.Stream;

public class StreamFilter {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三丰");list.add("张无忌");list.add("周芷若");list.add("张强");list.add("赵铭");

        List<String> l = new ArrayList<>();
        list.stream().filter(name->name.startsWith("张"))//对于模型进行操作，本身不变
                .filter(name->name.length()==3)//Predicate
                .forEach(name-> {l.add(name);System.out.print(name+ " ");});//Consumer
        System.out.println();

        l.forEach(name-> System.out.print(name+ " "));//都是Lambda表达式
        System.out.println();
        list.forEach(name-> System.out.print(name+ " "));
        System.out.println();

        demo01();
    }

    private static void demo01() {
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

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

        Map<String, String> map = new HashMap<>();
        Set<String> keySet = map.keySet();
        Stream<String> stream3 = keySet.stream();

        Collection<String> valueSet = map.values();
        Stream<String> stream4 = valueSet.stream();
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<Map.Entry<String, String>> stream5 = entries.stream();

        Stream<Integer> stream6 = Stream.of(1,2,3,4,5);
        Integer[] arr = {1,2,3,4,5};
        Stream<Integer> stream7 = Stream.of(arr);
        String[] s = {"a","bb","ccc"};
        Stream<String> s1 = Stream.of(s);

        stream1.map(in->Integer.parseInt(in));
//        System.out.println(stream1.count());会报错，只能使用一次
        System.out.println(stream6.count());

        //终结性型方法：不支持链式调用->count和forEach
        //延迟型方法：支持链式调用->filter，map，limit，skip，contact
        //limit(long i)超过i个元素截取前i个
        //skip(long n)跳过前n个
        //contact（Stream s1， Stream s2）
        //Stream流属于管道流，第一个流使用后流转到下一个Stream,一个Stream只能使用一次，使用后就会关闭
        //每次操作都会返回新的一个流
    }
}