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