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

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

2. 提取流和组合流，和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);
     }

3. 聚合操作, 和 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());
}

4. 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);
}

5. 收集结果， 可以把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());
}

6. 分组和分片，要想达到自己想要的结果，必须先提前想好自己的收集结果的数据结构;
   前端一般喜欢数据是树形的，方便前端做分组渲染，但是如果后台不处理数据分组，前端也可以进行数据分组渲染，这个看前后端之间的默契
   分组和分片的意义是，将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);
    }