美文网首页
java-jdk8-stream与js-es6+语法对比/语法处

java-jdk8-stream与js-es6+语法对比/语法处

作者: Raral | 来源:发表于2021-04-16 11:54 被阅读0次

    stream

    lambda表达式是stream的基础,初学者建议先学习lambda表达式,http://www.cnblogs.com/andywithu/p/7357069.html

    1. 作用

    就是为了处理一些 集合数据(List, Map)和数组 Array更方便, 就像js中 forEach, filter filterIndex, map, sort, reduce...等

    2. 流的特性

    1. 不改变数据
    2. 不改变原数据
    3. 延迟执行, 目的中间可以写异步逻辑,比如连接一次数据库

    3. 初始体验

    public static void main(String[] args) {
            Person zhangsan = new Person(1, "zhangsan", 12, 0);
            Person lisi = new Person(2, "lisi", 22, 1);
            Person wangwu = new Person(3, "wangwu", 42, 0);
            List<Person> list = new ArrayList<>();
            list.add(zhangsan);
            list.add(lisi);
            list.add(wangwu);
    
    
            //1. 遍历list每一个person
            for (Person person : list) {
    //            System.out.println(person);
            }
            //1.1 jdk新语法--------------与js中forEach类似
            //创建集合流
            Stream<Person> stream = list.stream();
            stream.forEach(item -> {
                System.out.println(item);
            });
    
            //eg:打印出 status < 1的学生,并且按照年龄降序输出名字
            //1. 创建一个集合流,每个元素是一个字符串
            List<String> sList =  list.stream()
                    .filter(item -> item.getStatus() < 1)// 先过滤
                    .sorted(Comparator.comparing(Person::getAge).reversed())//排序, 加了 reversed是降序
                    .map(Person::getName)// 遍历获取name字符串
                    .collect(Collectors.toList());//转成List集合
    
            System.out.println(sList);// [wangwu, zhangsan]
    
    
        }
    
    //咋样实现 遍历同时需要Long类型转换成String类型;前端显示Long类型精度缺失
            HkgCookbook db = this.baseMapper.selectById(id);
    //        List<Long> collect = hkgCookbookStms.stream().map(HkgCookbookStm::getStmId).collect(Collectors.toList());
            ArrayList<String> stmIds =(ArrayList<String>) hkgCookbookStms.stream().map( item -> item.getStmId().toString()).collect(Collectors.toList());
            db.setCookbookStmIds(stmIds);
    
    

    js实现

    let arr = [
        {
            name:"zhangsan",
            age:12,
            status:0
        },{
            name:"lisi",
            age:32,
            status:1
        },{
            name:"wangwu",
            age:42,
            status:0
        }
    ]
    //eg:打印出 status < 1的学生,并且按照年龄降序输出名字
    let temp = arr.filter(item => item.status < 1)
                    .sort((a, b) => b.age - a.age)
                    .map(item => item.name);
    console.log(temp)//["wangwu", "zhangsan"]
    
    
    //扁平化
    let arr2 = [ [1,2], [4,5], [9, 10] ];
    console.log(arr2.flat())
    
    

    是不是一模一样,我也不知道是谁模仿谁呢,应该js模仿java; 但是js没有延迟特性,需要闭包,promise解决。

    4. 接下来深入了解 stream

    4.1 创建流

    • 创建数组流
    //1.通过Arrays.stream
        //1.1基本类型
        int[] arr = new int[]{1,2,34,5};
        IntStream intStream = Arrays.stream(arr);
        //1.2引用类型
        Student[] studentArr = new Student[]{new Student("s1",29),new Student("s2",27)};
        Stream<Student> studentStream = Arrays.stream(studentArr);
        //2.通过Stream.of
        Stream<Integer> stream1 = Stream.of(1,2,34,5,65);
        //注意生成的是int[]的流
        Stream<int[]> stream2 = Stream.of(arr,arr);
        stream2.forEach(System.out::println);
    
    • 创建集合流
    List<String> strs = Arrays.asList("11212","dfd","2323","dfhgf");
        //创建普通流
        Stream<String> stream  = strs.stream();
        //创建并行流
        Stream<String> stream1 = strs.parallelStream();
    
    • 创建空的流
    //创建一个空的stream
        Stream<Integer> stream  = Stream.empty();
    
    • 创建无限流
    //创建无限流,通过limit提取指定大小
        Stream.generate(()->"number"+new Random().nextInt()).limit(100).forEach(System.out::println);
        Stream.generate(()->new Student("name",10)).limit(20).forEach(System.out::println);
    
    • 创建规律的无限流
    Stream.iterate(0,x->x+1).limit(10).forEach(System.out::println);
        Stream.iterate(0,x->x).limit(10).forEach(System.out::println);
        //Stream.iterate(0,x->x).limit(10).forEach(System.out::println);与如下代码意思是一样的
        Stream.iterate(0, UnaryOperator.identity()).limit(10).forEach(System.out::println);
    

    4.2 对stream操作

    1. 最常使用
    • map,filter 和 js一样不用过多介绍
    • sorted: 排序
    String[] arr1 = {"abc","a","bc","abcd"};
    /**
     * Comparator.comparing是一个键提取的功能
     * 以下两个语句表示相同意义
     */
    @Test
    public void testSorted1_(){
        /**
         * 按照字符长度排序
         */
        Arrays.stream(arr1).sorted((x,y)->{
            if (x.length()>y.length())
                return 1;
            else if (x.length()<y.length())
                return -1;
            else
                return 0;
        }).forEach(System.out::println);
        Arrays.stream(arr1).sorted(Comparator.comparing(String::length)).forEach(System.out::println);
    }
     
    /**
     * 倒序
     * reversed(),java8泛型推导的问题,所以如果comparing里面是非方法引用的lambda表达式就没办法直接使用reversed()
     * Comparator.reverseOrder():也是用于翻转顺序,用于比较对象(Stream里面的类型必须是可比较的)
     * Comparator. naturalOrder():返回一个自然排序比较器,用于比较对象(Stream里面的类型必须是可比较的)
     */
    @Test
    public void testSorted2_(){
        Arrays.stream(arr1).sorted(Comparator.comparing(String::length).reversed()).forEach(System.out::println);
        Arrays.stream(arr1).sorted(Comparator.reverseOrder()).forEach(System.out::println);
        Arrays.stream(arr1).sorted(Comparator.naturalOrder()).forEach(System.out::println);
    }
     
    /**
     * thenComparing
     * 先按照首字母排序
     * 之后按照String的长度排序
     */
    @Test
    public void testSorted3_(){
        Arrays.stream(arr1).sorted(Comparator.comparing(this::com1).thenComparing(String::length)).forEach(System.out::println);
    }
    public char com1(String x){
        return x.charAt(0);
    }
    
    • flatMap: 拆解流: 和 flat相似
    /**
     * flapMap:拆解流
     */
    @Test
    public void testFlapMap1() {
        String[] arr1 = {"a", "b", "c", "d"};
        String[] arr2 = {"e", "f", "c", "d"};
        String[] arr3 = {"h", "j", "c", "d"};
       // Stream.of(arr1, arr2, arr3).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);
        Stream.of(arr1, arr2, arr3).flatMap(Arrays::stream).forEach(System.out::println);
    }
    
    1. 提取流和组合流,和js contact相似
    @Before
        public void init(){
            arr1 = new String[]{"a","b","c","d"};
            arr2 = new String[]{"d","e","f","g"};
            arr3 = new String[]{"i","j","k","l"};
        }
        /**
         * limit,限制从流中获得前n个数据
         */
        @Test
        public void testLimit(){
            Stream.iterate(1,x->x+2).limit(10).forEach(System.out::println);
        }
     
        /**
         * skip,跳过前n个数据
         */
        @Test
        public void testSkip(){
    //        Stream.of(arr1).skip(2).limit(2).forEach(System.out::println);
            Stream.iterate(1,x->x+2).skip(1).limit(5).forEach(System.out::println);
        }
     
        /**
         * 可以把两个stream合并成一个stream(合并的stream类型必须相同)
         * 只能两两合并
         */
        @Test
        public void testConcat(){
            Stream<String> stream1 = Stream.of(arr1);
            Stream<String> stream2 = Stream.of(arr2);
            Stream.concat(stream1,stream2).distinct().forEach(System.out::println);
         }
    
    1. 聚合操作, 和 js的 find findeIndex findLastIndex indexof reduce
    @Before
    public void init(){
        arr = new String[]{"b","ab","abc","abcd","abcde"};
    }
     
    /**
     * max、min
     * 最大最小值
     */
    @Test
    public void testMaxAndMin(){
        Stream.of(arr).max(Comparator.comparing(String::length)).ifPresent(System.out::println);
        Stream.of(arr).min(Comparator.comparing(String::length)).ifPresent(System.out::println);
    }
     
    /**
     * count
     * 计算数量
     */
    @Test
    public void testCount(){
        long count = Stream.of(arr).count();
        System.out.println(count);
    }
     
    /**
     * findFirst
     * 查找第一个
     */
    @Test
    public void testFindFirst(){
        String str =  Stream.of(arr).parallel().filter(x->x.length()>3).findFirst().orElse("noghing");
        System.out.println(str);
    }
     
    /**
     * findAny
     * 找到所有匹配的元素
     * 对并行流十分有效
     * 只要在任何片段发现了第一个匹配元素就会结束整个运算
     */
    @Test
    public void testFindAny(){
        Optional<String> optional = Stream.of(arr).parallel().filter(x->x.length()>3).findAny();
        optional.ifPresent(System.out::println);
    }
     
    /**
     * anyMatch
     * 是否含有匹配元素
     */
    @Test
    public void testAnyMatch(){
        Boolean aBoolean = Stream.of(arr).anyMatch(x->x.startsWith("a"));
        System.out.println(aBoolean);
    }
     
     
    @Test
    public void testStream1() {
        Optional<Integer> optional = Stream.of(1,2,3).filter(x->x>1).reduce((x,y)->x+y);
        System.out.println(optional.get());
    }
    
    1. Optional类型
      通常聚合操作会返回一个Optional类型,Optional表示一个安全的指定结果类型,所谓的安全指的是避免直接调用返回类型的null值而造成空指针异常,调用optional.ifPresent()可以判断返回值是否为空,或者直接调用ifPresent(Consumer<? super T> consumer)在结果部位空时进行消费操作;调用optional.get()获取返回值。通常的使用方式如下:
    @Test
        public void testOptional() {
            List<String> list = new ArrayList<String>() {
                {
                    add("user1");
                    add("user2");
                }
            };
            Optional<String> opt = Optional.of("andy with u");
            opt.ifPresent(list::add);
            list.forEach(System.out::println);
        }
    

    使用Optional可以在没有值时指定一个返回值,例如

    @Test
    public void testOptional2() {
        Integer[] arr = new Integer[]{4,5,6,7,8,9};
        Integer result = Stream.of(arr).filter(x->x>9).max(Comparator.naturalOrder()).orElse(-1);
        System.out.println(result);
        Integer result1 = Stream.of(arr).filter(x->x>9).max(Comparator.naturalOrder()).orElseGet(()->-1);
        System.out.println(result1);
        Integer result2 = Stream.of(arr).filter(x->x>9).max(Comparator.naturalOrder()).orElseThrow(RuntimeException::new);
        System.out.println(result2);
    }
    
    1. 收集结果, 可以把stream 收集成自己想要的数据结构,收集结果目的就是统计
    /**
         * 生成List
         */
        List<Student> list = Arrays.stream(students).collect(toList());
        list.forEach((x)-> System.out.println(x));
         /**
         * 生成Set
         */
        Set<Student> set = Arrays.stream(students).collect(toSet());
        set.forEach((x)-> System.out.println(x));
         /**
         * 如果包含相同的key,则需要提供第三个参数,否则报错
         */
        Map<String,Integer> map = Arrays.stream(students).collect(toMap(Student::getName,Student::getScore,(s,a)->s+a));
        map.forEach((x,y)-> System.out.println(x+"->"+y));
    
    
        /**
     * 生成数组
     */
        Student[] s = Arrays.stream(students).toArray(Student[]::new);
    
    
        /**
     * 指定生成的类型
     */
    @Test
    public void testCollect3(){
        HashSet<Student> s = Arrays.stream(students).collect(toCollection(HashSet::new));
        s.forEach(System.out::println);
    }
    
    //收集结果目的就是统计
    /**
     * 统计
     */
    @Test
    public void testCollect4(){
        IntSummaryStatistics summaryStatistics = Arrays.stream(students).collect(Collectors.summarizingInt(Student::getScore));
        System.out.println("getAverage->"+summaryStatistics.getAverage());
        System.out.println("getMax->"+summaryStatistics.getMax());
        System.out.println("getMin->"+summaryStatistics.getMin());
        System.out.println("getCount->"+summaryStatistics.getCount());
        System.out.println("getSum->"+summaryStatistics.getSum());
    }
    
    1. 分组和分片,要想达到自己想要的结果,必须先提前想好自己的收集结果的数据结构;
      前端一般喜欢数据是树形的,方便前端做分组渲染,但是如果后台不处理数据分组,前端也可以进行数据分组渲染,这个看前后端之间的默契
      分组和分片的意义是,将collect的结果集展示位Map<key,val>的形式,通常的用法如下:
    //分组和分片
        public static void test3() {
            Person zhangsan = new Person(1, "zhangsan", 12, 0);
            Person lisi = new Person(2, "lisi", 22, 1);
            Person wangwu = new Person(3, "wangwu", 42, 0);
            Person zhaosi = new Person(4, "zhaosi", 60, 2);
            List<Person> list = new ArrayList<>();
            list.add(zhangsan);
            list.add(lisi);
            list.add(wangwu);
            list.add(zhaosi);
            //eg: status:0-男生,1-女生,2-保密 进行分组
            //分组后,是以status为key, 对应的list为value
            Map<Integer, List<Person>> contentMap = list.stream().collect(groupingBy(Person::getStatus));
            contentMap.forEach((k,v) -> System.out.println(k + "->" + v));
            //分组后,可以指定value的类型
            Map<Integer, Set<Person>> contentMap2 = list.stream().collect(groupingBy(Person::getStatus, toSet()));
            contentMap2.forEach((k,v) -> System.out.println(k + "->" + v));
            // 聚合操作,就是统计一些 个数,对象属性累加,最大的对象,
            //counting: 个数
            Map<String, Long> contentMap3 = list.stream().collect(groupingBy(Person::getName, counting()));
            contentMap3.forEach((k,v) -> System.out.println(k + "->" + v));
            //summingInt: 累加
            Map<Integer, Integer> contentMap4 = list.stream().collect(groupingBy(Person::getStatus, summingInt(Person::getAge)));
            contentMap4.forEach((k,v) -> System.out.println(k + "->" + v));
            //maxBy: 最大值
            Map<Integer, Optional<Person>> contentMap5 = list.stream().collect(groupingBy(Person::getStatus, maxBy(Comparator.comparing(Person::getAge))));
            contentMap5.forEach((k,v) -> System.out.println(k + "->" + v));
            //mapping:统计出性别对应的年龄
            Map<Integer, Set<Integer>> contentMap6 = list.stream().collect(groupingBy(Person::getStatus, mapping(Person::getAge, toSet())));
            contentMap6.forEach((k,v) -> System.out.println(k + "->" + v));
    
    
    
        }
    
    
    

    js实现分组

    let arr = [
        {
            name:"zhangsan",
            age:12,
            status:0
        },{
            name:"lisi",
            age:32,
            status:1
        },{
            name:"wangwu",
            age:42,
            status:0
        }
    ]
    //分组,自己可以定制化 map的value结构,比较简单
    //方式一
    let map = new Map();
    arr.forEach(item => {
        if(map.get(item.status)){
            let arr = map.get(item.status);
            arr.push(item);
            map.set(item.status,arr);
        }else {
            map.set(item.status, [item]) //java put
        }
    })
    // console.log(map);
    console.log("--------------------------------")
    //方式二
    let obj = arr.reduce((pre,cur) => {
        if(pre[cur.status]) {
            let arr = pre[cur.status].concat([cur]);
            pre[cur.status] = arr;
    
        }else {
            console.log('err',  pre[cur.status])
            pre[cur.status] = [cur]
            console.log('err2',  pre[cur.status])
        }
        return pre;
    
    }, {})
    console.log(obj);
    

    5.原始流

    在数据量比较大的情况下,将基本数据类型(int,double...)包装成相应对象流的做法是低效的,因此,我们也可以直接将数据初始化为原始类型流,在原始类型流上的操作与对象流类似,我们只需要记住两点
    1.原始类型流的初始化
    2.原始类型流与流对象的转换

    DoubleStream doubleStream;
        IntStream intStream;
     
        /**
         * 原始类型流的初始化
         */
        @Before
        public void testStream1(){
     
            doubleStream = DoubleStream.of(0.1,0.2,0.3,0.8);
            intStream = IntStream.of(1,3,5,7,9);
            IntStream stream1 = IntStream.rangeClosed(0,100);
            IntStream stream2 = IntStream.range(0,100);
        }
     
        /**
         * 流与原始类型流的转换
         */
        @Test
        public void testStream2(){
            Stream<Double> stream = doubleStream.boxed();
            doubleStream = stream.mapToDouble(Double::new);
        }
    

    6. 并行流

    可以将普通顺序执行的流转变为并行流,只需要调用顺序流的parallel() 方法即可,如Stream.iterate(1, x -> x + 1).limit(10).parallel()。
    1) 并行流的执行顺序
    我们调用peek方法来瞧瞧并行流和串行流的执行顺序,peek方法顾名思义,就是偷窥流内的数据,peek方法声明为Stream<T> peek(Consumer<? super T> action);加入打印程序可以观察到通过流内数据,见如下代码:

    public void peek1(int x) {
            System.out.println(Thread.currentThread().getName() + ":->peek1->" + x);
        }
     
        public void peek2(int x) {
            System.out.println(Thread.currentThread().getName() + ":->peek2->" + x);
        }
     
        public void peek3(int x) {
            System.out.println(Thread.currentThread().getName() + ":->final result->" + x);
        }
     
        /**
         * peek,监控方法
         * 串行流和并行流的执行顺序
         */
        @org.junit.Test
        public void testPeek() {
            Stream<Integer> stream = Stream.iterate(1, x -> x + 1).limit(10);
            stream.peek(this::peek1).filter(x -> x > 5)
                    .peek(this::peek2).filter(x -> x < 8)
                    .peek(this::peek3)
                    .forEach(System.out::println);
        }
     
        @Test
        public void testPeekPal() {
            Stream<Integer> stream = Stream.iterate(1, x -> x + 1).limit(10).parallel();
            stream.peek(this::peek1).filter(x -> x > 5)
                    .peek(this::peek2).filter(x -> x < 8)
                    .peek(this::peek3)
                    .forEach(System.out::println);
        }
    

    相关文章

      网友评论

          本文标题:java-jdk8-stream与js-es6+语法对比/语法处

          本文链接:https://www.haomeiwen.com/subject/oaqelltx.html