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