首页 » Java » Java8学习笔记:2.Stream流

Java8学习笔记:2.Stream流

原文 http://blog.csdn.net/u013898617/article/details/79053638

2018-01-14 02:00:28阅读(350)

今天学习总结了Stream(),在此备注:

惰性求值方法:类似sql查询的where条件,过滤stream的条件。如:filter()

及早求值函数:类似sql查询的seletct条件,直返结果。如:count(),max()

方法总结:

count():及早求值函数,求总数。

collect():由Stream里的值生成一个列表,是一个及早求值操作(.of()方法时惰性求值的方法)。list、set初始化既是。

map():如果有一个函数可以将一种类型的值转换成另外一种类型,map操作就可以使用该函数,将一个流中的值转换成一个新的流。

filter():保留stream中的一些元素,过滤其他的。

flatMap():flatMap方法可用Stream替换值,然后将多个Stream连接成一个Stream

max()和min():注意这两个方法都是及早值操作,后面需要接一个get()方法获取结果对象(get可以取出Optional对象中的值)

reduce():

       1.reduce简约方法,reduce可以实现从一组值中生成一个值,其实count、max、min都是reduce操作。

       2.实际是reduce函数在stream中遍历一遍,最后函数结果即为最终值

       3.T reduce(T identity, BinaryOperator<T> accumulator);identity累计结果值,accumulator是累加器

剩下有时间可以补充的方法:

mapToInt(mapToLong、mapToDouble)、flatMapToInt(flatMapToLong、flatMapToDouble)、distinct、sorted、peek、limit、skip、forEach、forEachOrdered、anyMatch(allMatch、noneMatch)、findFirst、findAny、builder、empty、iterate、generate、concat

public class Java8StreamTest {
    private static List<String> list = Stream.of("1","2","3","4","5","6","7","8","9","10").collect(Collectors.toList());
    private static Set<String> set = Stream.of("1","2","3","4","5","6","7","8","9","10").collect(Collectors.toSet());
    private static Map<String, String> map1 = list.stream().collect(Collectors.toMap(str -> str, str -> str + "_value1"));
    private static Map<String, String> map2 = set.stream().collect(Collectors.toMap(str -> str, str -> str + "_value2"));
    public static void main(String[] args) {
        /**
         * 及早求值函数,求总数
         */
        count();
        /**
         * collect方法:由Stream里的值生成一个列表,是一个及早求值操作(.of()方法时惰性求值的方法)。list、set初始化既是
         */
        collect();
        /**
         * 如果有一个函数可以将一种类型的值转换成另外一种类型,map操作就可以使用该函数,将一个流中的值转换成一个新的流
         */
        map();
        /**
         * 保留stream中的一些元素,过滤其他的
         */
        filter();
        /**
         * flatMap方法可用Stream替换值,然后将多个Stream连接成一个Stream
         */
        flatMap();
        /**
         * max和min,注意这两个方法都是及早值操作,后面需要接一个get()方法获取结果对象(get可以取出Optional对象中的值)
         */
        max();
        min();
        /**
         * reduce简约方法,reduce可以实现从一组值中生成一个值,其实count、max、min都是reduce操作。
         * 实际是reduce函数在stream中遍历一遍,最后函数结果即为最终值
         * T reduce(T identity, BinaryOperator<T> accumulator);identity累计结果值,accumulator是累加器
         */
        reduce();
    }
    private static void count() {
        System.out.println("count_" + list.stream().filter(str -> Integer.valueOf(str) > 5).count());
        System.out.println("count_" + set.stream().filter(str -> str.contains("1")).count());
    }
    private static void collect() {
        System.out.println("collect_" + list.stream().count());
        System.out.println("collect_" + set.stream().count());
        System.out.println("collect_" + map1.size());
        System.out.println("collect_" + map2.size());
        List<String> list2 = Stream.of("1", "2", "3", "4", "5", "6", "7", "8", "9", "10").filter(str -> Integer.valueOf(str) > 5).collect(Collectors.toList());
        Set<String> set2 = Stream.of("1", "2", "3", "4", "5", "6", "7", "8", "9", "10").filter(str -> Integer.valueOf(str) > 4).collect(Collectors.toSet());
        System.out.println("collect_" + list2.stream().count());
        System.out.println("collect_" + set2.stream().count());
    }
    private static void map() {
        List<String> list = Stream.of("a", "b", "c").map(str -> str.toUpperCase()).collect(Collectors.toList());
        System.out.println("map_" + list.get(0) + " " + list.get(1) + " " + list.get(2));
    }
    private static void filter() {
        Stream stream = list.stream().filter(str -> Integer.valueOf(str) > 5);
        System.out.println(stream.filter(str-> {System.out.println("filter_"+str);return true;}).count());
    }
    private static void flatMap() {
        List<Integer> together = Stream.of(Arrays.asList(1, 2), Arrays.asList(3, 4))
                                       .flatMap(num -> num.stream())
                                       .collect(Collectors.toList());
        System.out.println(together.stream().count());
    }
    public static class UserTest{
        private String name;
        private Integer age;
        public UserTest(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
        public UserTest() {
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public Integer getAge() {
            return age;
        }
        public void setAge(Integer age) {
            this.age = age;
        }
        @Override
        public String toString(){
            return "name:" + name + ",age:" + age;
        }
    }
    private static void max() {
        UserTest userTest = Stream
                .of(new UserTest("A", 1), new UserTest("B", 2))
                .max(Comparator.comparing(user -> user.getAge()))
                .get();
        System.out.println(userTest.toString());
    }
    private static void min() {
        UserTest userTest = Stream
                .of(new UserTest("A", 1), new UserTest("B", 2))
                .min(Comparator.comparing(user -> user.getAge()))
                .get();
        System.out.println(userTest.toString());
    }
    private static void reduce() {
        int sum = Stream.of(1, 2, 3).reduce(0, (a, b) -> a + b);
        System.out.println(sum);
        int subtraction = Stream.of(10, 5, 3).reduce(100, (a, b) -> a - b);
        System.out.println(subtraction);
        int multiplication = Stream.of(1, 2, 3).reduce(1, (a, b) -> a * b);
        System.out.println(multiplication);
        int division  = Stream.of(8, 4, 2).reduce(256, (a, b) -> a / b);
        System.out.println(division );
        BinaryOperator<Integer> accumlator = (a, b) -> a + b;
        int count = accumlator
                .apply(accumlator
                        .apply(accumlator
                                .apply(accumlator
                                        .apply(-1, 0)
                                        , 1)
                                , 2)
                        , 3);
        System.out.println(count);
        count = 0;
        for (Integer a : Arrays.asList(-1, 0, 1, 2, 3)) {
            count = count + a;
        }
        System.out.println(count);
    }
}


最新发布

CentOS专题

关于本站

5ibc.net旗下博客站精品博文小部分原创、大部分从互联网收集整理。尊重作者版权、传播精品博文,让更多编程爱好者知晓!

小提示

按 Ctrl+D 键,
把本文加入收藏夹