Java8解决了什么？

在学习面向对象时，许多人都会用Java来举例子，但是其实Java并非纯正的面向对象语言，最明显的就是:int,double等基本类型不是对象。
自从java8出来过后，引入了流，函数式编程，就更不是在向着面向对象发展了。有人可能会感到诧异，为啥越来越偏离我们遵循了这么久的面向对象设计模式？

其实很简单，我们对工具的改造的最终目的都是为了解决问题，以前有面向过程解决不了的问题，那么面向对象出来解决了；现在面向对象有许多问题，那么就可以用函数式编程来解决，所以这些变化是很自然的，Java要在不同时代的保持自己的活力，就必须与时俱进，所以Java8的出现就是自然而然的。

下面我就来探索一下，Java8到底解决了一些什么问题。

消除冗余类代码

假设有个类：

class People{
    private String name;
    private int age;

    public  People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

现在有个list

  List<People> workers = new LinkedList<>();
  workers.add( new People("aa",23));
  workers.add( new People("abc",21));
  workers.add( new People("cdf",18));

如果要对这个list按照People的年龄排序，并打印出来，那么在Java8之前会这样写：

workers.sort(new Comparator<People>() {
    @Override
    public int compare(People o1, People o2) {
        return o1.getAge()>o2.getAge()?1:-1;
    }
});
for (People p:workers  ) {
    System.out.println(p.getName()+":"+p.getAge());
}

Java8引入了函数式编程的lambda表达式，就可以这样写了：

workers.sort((o1, o2) -> o1.getAge()>o2.getAge()?1:-1);
for (People p:workers  ) {
    System.out.println(p.getName()+":"+p.getAge());
}  

进一步，使用方法引用就可以这样写：

workers.sort(Comparator.comparing(People::getAge));
for (People p:workers  ) {
    System.out.println(p.getName()+":"+p.getAge());
}

这样就更简洁了，而且意图也和清晰，可以不写注释就能让别人明白，是按照年龄排序。

函数式的lambda表达式通过将函数提升为“一等公民”，使得直接传递函数成为可能，而不必再为了传递实现某个功能的函数而强行传递一个冗余的外包类。

内部迭代替代外部迭代

stream允许你以声明性方式处理数据集合，类似于SQL语句。我们直接看例子吧，上面那一段代码已经很简洁了，但是使用了流还可以更简洁

 
  workers.sort(Comparator.comparing(People::getAge));
  workers.stream().map(p-> p.getName()+":"+p.getAge()).forEach(System.out::println);

这一段代码根本就没有循环了，Stream API 替你搞定了循环，这就是内部迭代 替代 外部迭代 ，
亦即API的设计者 替 使用者完成了迭代，代码相当简洁。
而且由于是内部迭代，所以Stream库可以选择最适合本机硬件的实现，达到性能优化的目的，如果是外部迭代，就需要调用者自己来优化了（你得承认许多API调用者没有这种优化能力）。

安全简洁地并行

如果我们有大量数据要处理，通常会使用多线程，在Java8之前，使用多线程是一件比较麻烦的事：

• 我们得自己合理的划分数据

• 手动为每一部分数据单独分配一个线程，还有可能会产生竞态条件需要进行同步

• 完成每个线程的结果的合并，得到最终结果。

这个过程是比较麻烦的，易错的。使用流能够安全简洁的使用多核，甚至于你都不需要关心多线程的具体实现。

传统的循环：

List<String> intList = new LinkedList();
for (int i=0;i<20_000_000;i++){
    intList.add(i+"");
}
   
long count = 0;
long start = System.nanoTime();

for (String in:intList ) {
    if (Integer.parseInt(in)>1_123_345) count++;
}

long duration = (System.nanoTime() - start) / 1_000_000;
System.out.println(duration);

结果：781，747，770

Java8的并行流：

List<String> intList = new LinkedList();
for (int i=0;i<20_000_000;i++){
    intList.add(i+"");
}

long count = 0;
long start = System.nanoTime();

count = intList.parallelStream().filter(p->Integer.parseInt(p)>1_123_345).count();

long duration = (System.nanoTime() - start) / 1_000_000;
System.out.println(duration);

结果：665，683，662

可见我们并不需要显式的进行多线程编程就能取得比单线程更好的结果，也就是Stream库帮我们实现了多线程，更安全（不得不承认许多人写的多线程代码都是有问题的），更简洁（我们不用写多线程代码了）。

稍微需要注意的是，多线程本身会带来一定开销，所以如果问题规模不够大的话（具体数值取决于你的硬件），单线程反而优于多线程，所以使用之前要先考虑和测试，多线程到底能否带来好处。一个简单的原则是：要处理的问题规模很庞大，或处理单个问题特别耗时就可以考虑多线程了。

---

总之，Java8还有好多新特性，会帮我们解决许多以前无法解决的问题，所以我们要与时俱进，好好学习啊（~_~）。

欢迎反问我的主页，Mageek（http://mageek.cn）