java8-stream 1 初见

学习java如同学习武功，代码规范就是武功招式，设计模式如同内功心法。如果你会几个好用的开源工具，就如同学了几本武学秘籍。秘籍虽然好，但是如果没有用对，分分钟反伤自己。

化骨绵掌外柔内刚，以爆发劲为主。手法以掌为主，运转舒展，动作连绵不断，掌法运行成环；劲力内蓄刚劲，外现绵柔，爆发迅猛。
stream就是java中的化骨绵掌。一套连续不断地输出，帮我们攻击拉满。

让我们通过一个具体的小任务来看看，stream和普通招式对比。
我现在需要将integerList中的所有数字都取平方，并且输出到resultList

普通招式1 ⭐️⭐️⭐️

public class Test20181129 {

    List integerList = Arrays.asList(1, 2, 3, 4, 5);

    @Test
    public void test1() {

        //用于存放结果
        List resultList = new LinkedList<>();

        //循环调用函数
        for (int i = 0; i < integerList.size(); i++) {
            resultList.add(fun(integerList.get(i)));
        }

        //输出结果
        System.out.println(resultList);

    }

    private Integer fun(Integer i) {
        return i * i;
    }


}

[1, 4, 9, 16, 25]

普通招式2 ⭐️⭐️⭐️

public class Test20181129 {

    List integerList = Arrays.asList(1, 2, 3, 4, 5);

    @Test
    public void test2() {

        //用于存放结果
        List resultList = new LinkedList<>();

        //循环调用函数
        for (Integer integer :integerList) {
            resultList.add(fun(integer));
        }

        //输出结果
        System.out.println(resultList);

    }

    private Integer fun(Integer i) {
        return i * i;
    }

}

[1, 4, 9, 16, 25]

stream ⭐️⭐️⭐️⭐️⭐️

public class Test20181129 {

    List integerList = Arrays.asList(1, 2, 3, 4, 5);

    @Test
    public void test3() {

        List result = integerList.parallelStream().
                map(integer -> integer * integer).
                collect(Collectors.toList());
        System.out.println(result);

    }

}

[1, 4, 9, 16, 25]

好像没有很厉害嘛，仅仅只是省了几行代码而已。

那我们现在让fun函数需要消耗点时间，然后看看不同的方法都要用多少时间？

普通招式1 节省时间 ⭐️

public class Test20181129 {

    List integerList = Arrays.asList(1, 2, 3, 4, 5);

    @Test
    public void test1() {

        long begin = System.currentTimeMillis();

        //用于存放结果
        List resultList = new LinkedList<>();

        //循环调用函数
        for (int i = 0; i < integerList.size(); i++) {
            resultList.add(fun(integerList.get(i)));
        }

        long end = System.currentTimeMillis();

        System.out.println("useTime: "+(end-begin));
        //输出结果
        System.out.println(resultList);

    }

    private Integer fun(Integer i) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return i * i;
    }
}

useTime: 5015
[1, 4, 9, 16, 25]

普通招式2 节省时间 ⭐️

public class Test20181129 {

    List integerList = Arrays.asList(1, 2, 3, 4, 5);

    @Test
    public void test1() {

        long begin = System.currentTimeMillis();

        //用于存放结果
        List resultList = new LinkedList<>();

        //循环调用函数
        for (Integer integer :integerList) {
            resultList.add(fun(integer));
        }

        long end = System.currentTimeMillis();

        System.out.println("useTime: "+(end-begin));
        //输出结果
        System.out.println(resultList);

    }

    private Integer fun(Integer i) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return i * i;
    }
}

useTime: 5009
[1, 4, 9, 16, 25]

stream 节省时间 ⭐️⭐️⭐️⭐️⭐️

public class Test20181129 {

    List integerList = Arrays.asList(1, 2, 3, 4, 5);

    @Test
    public void test3() {

        long begin = System.currentTimeMillis();

        List result = integerList.parallelStream().
                map(integer -> fun(integer)).
                collect(Collectors.toList());

        long end = System.currentTimeMillis();
        System.out.println(result);
        System.out.println("useTime : "+(end-begin));
    }

    public Integer fun(Integer integer)  {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return integer * integer;
    }
}

useTime : 1087
[1, 4, 9, 16, 25]

在造成相同伤害的基础上（结果一致），stream的执行时间只用了 普通招式1和2 的1/5
我们并没有显式的去开多线程，但是通过stream这一切就精巧的做完了。
这就是stream的魅力，接下来我会带着大家一起看看stream都能帮我们做什么？以及如何避免反伤我们自己。