简单了解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并无简单地使用内部类去实现λ表达式，而是使用了一种更动态、更灵活、易于未来扩展和改变的策略。