简单了解JAVA8的新特性

JAVA8新特性会颠覆整个JAVA程序员的编程习惯

甚至如果您坚守JAVA7之前的编程习惯，今后你看比较年轻的程序员写的JAVA代码都会无法理解

所以为了保证不脱钩，我觉得有必要学习JAVA8的新特性，况且，这会极大得提高CPU效率和编码效率

我们来简单了解一下JAVA8的新特性

我觉得主要有两个比较重要的，一是Lambda表达式，二是集合类的stream操作

关于这两点，我写了几个小DEMO，附上注释，应该能够迅速掌握

如果大家好奇更多的JAVA8新特性，请自行阅读更加专业的知识，敏捷开发不求甚解是我的编程态度。

顺便说一句，JAVA8目前只有最新版eclipse MARs支持编译

即使您下载了JAVA8的JDK和JRE，myeclipse目前还不支持对JAVA8的编译

也就是说下面的代码会在myeclipse下面报错的。

package com.newflypig.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class TestJava {
    public static void main(String[] args) {
        // java8 的新特性，lambda表达式，类似于匿名内部类
        Thread testThread = new Thread(() -> {
            List<String> list = new ArrayList<String>();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("aa");
            list.add("bb");
            list.add("cc");
            list.forEach(s -> {
                System.out.println(s);
                ;
            });

            list.stream().filter(s -> s.length() == 2).forEach(s -> {
                System.out.println(s);
            });
        });

        System.out.println("======================================");

        distinct("2", "3", "4", "5", "6", "7", "8", "9", "2", "3", "4", "5", "6", "7", "8", "9");

        testThread.run();
    }

    // 新特性，不定参数
    private static void distinct(String... numbers) {
        List<String> list = Arrays.asList(numbers);
        List<Integer> listInt = list.stream()
            .map(s -> Integer.parseInt(s))         // 将集合流中的元素一一映射为一个新的元素，并生成到新的输出流中
            .filter(a -> isPrime(a))             // 过滤，lambda表达式
            .distinct()                         // stream的高级方法，去除重复
            .collect(Collectors.toList());        // 将整理好的输出流收集到新的listInt集合中
        /**
         * 你可能会觉得在这个例子里，List list被迭代了好多次，
         * map，filter，distinct都分别是一次循环，效率会不好。
         * 实际并非如此。这些返回另一个Stream的方法都是“lazy”的，而最后返回最终结果的collect方法则是“eager”的。
         * 在遇到eager方法之前，lazy的方法不会执行。
         *
         * 当遇到eager方法时，前面的lazy方法才会被依次执行。
         * 而且是管道贯通式执行。这意味着每一个元素依次通过这些管道。
         * 例如有个元素“3”，首先它被map成整数型3；
         * 然后通过filter，发现是素数，被保留下来；又通过distinct，
         * 如果已经有一个3了，那么就直接丢弃，如果还没有则保留。这样，3个操作其实只经过了一次循环。
         *
         * 除collect外其它的eager操作还有forEach，toArray，reduce等
         */

        listInt
            .stream()
            .forEach(i -> {                         // stream的forEach，类似于Collections.forEach
                System.out.println(i);
            });

        int sum=listInt
            .stream()
            .reduce((isum,item)->isum+item)
            .get();
        int min=listInt
            .stream()
            .reduce((a,b)->a<b?a:b)
            .get();
        int max=listInt
            .stream()
            .reduce((a,b)->a>b?a:b)
            .get();
        /**
         * reduce方法接受一个函数，这个函数有两个参数，
         * 第一个参数是上次函数执行的返回值（也称为中间结果），
         * 第二个参数是stream中的元素，这个函数把这两个值相加，
         * 得到的和会被赋值给下次执行这个函数的第一个参数。
         * 要注意的是：第一次执行的时候第一个参数的值是Stream的第一个元素， 第二个参数是Stream的第二个元素。
         * 这个方法返回值类型是Optional，这是Java8防止出现NPE(NULL POINT ELEMENT)的一种可行方法，
         * 这里就简单的认为是一个容器，其中可能会包含0个或者1个对象。
         */
        System.out.println(sum+"\t"+min+"\t"+max);
    }

    private static boolean isPrime(int a) {
        boolean flag = true;
        for (int i = 2; i <= a / 2; i++) {
            if (a % i == 0) {
                flag = false;
                break;
            }
        }
        return flag;
    }
}

对于JAVA8的新特性的学习，可以浅尝辄止，因为大部分现有的框架，目前而且以后相当长时间不会迁移到JAVA8上。

不过新特性Lambda表达式的引入，我感觉会爆发出另一批更为优秀的框架出来

从形式上看，λ表达式只是为你节省了几行代码。

但将λ表达式引入Java的动机并不仅仅为此。

Java8有一个短期目标和一个长期目标。

短期目标是：配合“集合类批处理操作”的内部迭代（脱离于客户代码）和并行处理（更高效地利用现代CPU）；

长期目标是将Java向函数式编程语言这个方向引导

并不是要完全变成一门函数式编程语言，只是让它有更多的函数式编程语言的特性，

也正是由于这个原因，Oracle并没有简单地使用内部类去实现λ表达式，而是使用了一种更动态、更灵活、易于将来扩展和改变的策略。