Stream流

使用传统方式遍历集合

public class p01List {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("宋朋薇");
        list.add("陈卓");
        list.add("张顽强");
        list.add("上官婉儿");
        list.add("张无忌");

        //对list集合中的元素进行过滤，只要以张开头的元素，存储到一个新的集合中
        List<String> listA = new ArrayList<>();
        for (String s : list){
            if (s.startsWith("张")){
                listA.add(s);
            }
        }
        //对listA进行过滤，只要姓张的长度为3的人，存储到一个新的集合中
        List<String> listB = new ArrayList<>();
        for (String s : listA) {
            if (s.length()==3){
                listB.add(s);
            }
        }
        //遍历listB集合
        for (String s : listB) {
            System.out.println(s);
        }
    }
}

使用Stream流遍历集合

public class p02Stream {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("宋朋薇");
        list.add("陈卓");
        list.add("张顽强");
        list.add("上官婉儿");
        list.add("张无忌");

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

两种获取Stream流的方式

public class p01GetStream {
    public static void main(String[] args) {
        //把集合转换为Stream流
        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集合中
        Set<String> ketSet = map.keySet();
        Stream<String> stream3 = ketSet.stream();

        //获取值，存储到一个collection集合中
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();

        //获取键值对（键与值的映射关系 entrySet）
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<Map.Entry<String, String>> stream5 = entries.stream();

        //把数组转换为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[] arr2 = {"a","b","c"};
        Stream<String> stream8 = Stream.of(arr2);

    }
}

Stream流中的方法forEach

public class p01Stream_forEach {
    public static void main(String[] args) {
        //获取一个Stream流
        Stream<String> stream = Stream.of("张三","李志","王五");
        /*//使用Stream流中的方法forEach对Stream流中的数据进行遍历
        stream.forEach((String name)->{
            System.out.println(name);
        })*/;
        stream.forEach(name-> System.out.println(name));
    }
}

Stream流中的方法filter

public class p01Stream_Filter {
    public static void main(String[] args) {
        //创建一个stream流
        Stream<String> stream = Stream.of("张三丰", "张翠山", "张炎露", "张无忌", "赵高", "王致和");
        //对Stream流中的元素进行过滤，只要姓张的
        Stream<String> stream2 = stream.filter((String name)->{return name.startsWith("张");});
        //遍历
        stream2.forEach(name-> System.out.println(name));
    }
}

Stream流中的方法map

public class p01Stream_map {
    public static void main(String[] args) {
        //获取一个String类型的Stream流
        Stream<String> stream = Stream.of("1", "2", "3", "4");
        //使用map方法，把字符串类型的整数转换（映射）为integer类型的整数
        Stream<Integer> stream2= stream.map((String s)->{
           return Integer.parseInt(s);
        });
        //遍历
        stream2.forEach(i-> System.out.println(i));
    }
}

Stream流中的方法count

public class p01Stream_count {
    public static void main(String[] args) {
        //获取一个Stream流
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        Stream<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);
    }
}

Stream流中的方法limit

public class Stream_limit {
    public static void main(String[] args) {
        //获取Stream流
        String[] arr = {"喜羊羊","美羊羊","沸羊羊","红太狼","灰太狼"};
        Stream<String> stream = Stream.of(arr);
        //使用limit方法对stream流中的元素进行截取，只要前三个元素
        Stream<String> stream2 = stream.limit(3);
        //遍历
        stream2.forEach(name-> System.out.println(name));
    }
}

Stream流中的方法skip

public class p01Stream_skip {
    public static void main(String[] args) {
        //获取一个Stream流
        String[] arr = {"喜羊羊","美羊羊","沸羊羊","红太狼","灰太狼"};
        Stream<String> stream = Stream.of(arr);
        //使用skip跳过前三个元素
        Stream<String> stream2 = stream.skip(3);
        //遍历
        stream2.forEach(name-> System.out.println(name));
    }
}

Stream流中的方法concat

public class p01Stream_concat {
    public static void main(String[] args) {
        //创建一个stream流
        Stream<String> stream1 = Stream.of("张三丰", "张翠山", "张炎露", "张无忌", "赵高", "王致和");
        //获取一个Stream流
        String[] arr = {"喜羊羊","美羊羊","沸羊羊","红太狼","灰太狼"};
        Stream<String> stream2 = Stream.of(arr);
        //把以上两个流合并为一个流
        Stream<String> concat = Stream.concat(stream1, stream2);
        //遍历
        concat.forEach(name-> System.out.println(name));
    }
}