Java8解决了什么？

内容简介：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 ）

以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，也希望大家多多支持 码农网

查看所有标签

猜你喜欢:

• Hadoop小文件解决方案-基于文件整合的解决方案
• scala – 由SBT解决的本地依赖关系,但不是Play解决的！骨架
• Hadoop小文件解决方案-基于NameNode内存和MapReduce性能解决方案
• 【已解决】使用vue-electron脚手架进行vuex赋值时，失败的解决办法。
• Go 自定义日期时间格式解析解决方案 - 解决 `parsing time xx as xx` 错误
• 如何解决人智商不够？

本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。