jdk1.8的新特性

准备工作：

1.新建maven项目，编写pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.immo</groupId>
	<artifactId>jdk1.8</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

2.新建Converter.java,DefaultInterface.java,DefaultInterfaceImpl.java

3.编写Converter.java:

package com.immo.test;
/**
 * 函数式接口
 * @author Linhai.Tan
 *
 * @param <F>
 * @param <T>
 */
@FunctionalInterface
public interface Converter<F, T> {
    T convert(F from);
}

4.编写DefaultInterface.java:

package com.immo.test;

public interface DefaultInterface {
	default void OutputString(String string) {
		System.out.println(string);
	}
}

5.编写测试类DefaultInterfaceImpl.java:

package com.immo.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;

import org.junit.Test;

public class DefaultInterfaceImpl implements DefaultInterface {

	/**
	 * 接口定义的默认方法
	 */
	@Test
	public void OutputString() {
		OutputString("这是输出的方法"); // 直接可以调用接口定义的default修饰的方法
	}

	/**
	 * Lambda 表达式
	 */
	// 以前集合排序方式
	@Test
	public void oldAsList() {
		List<String> list = Arrays.asList("1", "0", "3", "2");
		Collections.sort(list, new Comparator<String>() {
			@Override
			public int compare(String a, String b) {
				return a.compareTo(b);
			}
		});
		System.out.println(list); // 输出 [0, 1, 2, 3]
	}

	// 使用 Lambda 表达式
	@Test
	public void newAsList() {
		List<String> list = Arrays.asList("1", "0", "3", "2");
		Collections.sort(list, (String a, String b) -> {
			return a.compareTo(b);
		});
		System.out.println(list); // 输出 [0, 1, 2, 3]
	}

	// 使用 Lambda 表达式2 对于函数体只有一行代码的，可以去掉大括号{}以及return关键字
	@Test
	public void newAsList2() {
		List<String> list = Arrays.asList("1", "0", "3", "2");
		Collections.sort(list, (String a, String b) -> a.compareTo(b));
		System.out.println(list); // 输出 [0, 1, 2, 3]
	}

	// 使用 Lambda 表达式3 对于函数体只有一行代码的，可以去掉大括号{}以及return关键字 Java编译器可以自动推导出参数类型
	@Test
	public void newAsList3() {
		List<String> list = Arrays.asList("1", "0", "3", "2");
		Collections.sort(list, (a, b) -> a.compareTo(b));
		System.out.println(list); // 输出 [0, 1, 2, 3]
	}

	/**
	 * 函数式接口
	 */
	// Lambda表达式实现
	@Test
	public void converterLambda() {
		Converter<String, Integer> converter = (from) -> Integer.valueOf(from); // 相当于创建了一个匿名对象，实现了 convert
																				// 方法，传入一个字符串，返回这个字符串调用Integer.valueOf后的值
		Integer converted = converter.convert("123");
		System.out.println(converted); // 123
	}

	// 静态方法引用 表示:
	@Test
	public void converterStatic() {
		Converter<String, Integer> converter = Integer::valueOf;
		Integer converted = converter.convert("123");
		System.out.println(converted); // 123
	}

	// 对象方法引用 表示:
	@Test
	public void converterObject() {
		Converter<String, Integer> converter = Object::hashCode; // 调用object的hashCode方法获得哈希码值
		Integer converted = converter.convert("123");
		System.out.println(converted);
	}

	/**
	 * 访问局部变量，默认加上了 final 修饰
	 */
	@Test
	public void partVariable() {
		int num = 1;
		Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num);
		System.out.println(stringConverter.convert(2));
	}

	/**
	 * stream
	 * 
	 * 无存储。stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。
	 * 为函数式编程而生。对stream的任何修改都不会修改背后的数据源，比如对stream执行过滤操作并不会删除被过滤的元素，而是会产生一个不包含被过滤元素的新stream。
	 * 惰式执行。stream上的操作并不会立即执行，只有等到用户真正需要结果的时候才会执行。
	 * 可消费性。stream只能被“消费”一次，一旦遍历过就会失效，就像容器的迭代器那样，想要再次遍历必须重新生成。
	 *
	 */
	@Test
	public void streamforEach() {// 遍历所有长度为5的字符串
		List<String> stringCollection = new ArrayList<>();
		stringCollection.add("dd");
		stringCollection.add("aaa2s");
		stringCollection.add("bbb1");
		Stream<String> stream = stringCollection.stream();
		stream.filter(str -> str.length() == 5).forEach(str -> System.out.println(str));
	}

	@Test
	public void streamSorted() {// 按照字符串长度排序,sorted方法里面不写排序方式则默认是自然排序
		List<String> stringCollection = new ArrayList<>();
		stringCollection.add("dd");
		stringCollection.add("aaa2s");
		stringCollection.add("bbb1");
		Stream<String> stream = stringCollection.stream();
		stream.sorted((str1, str2) -> str1.length() - str2.length()).forEach(str -> System.out.println(str));
	}

	@Test // map映射
	public void streamMap() {// 中间操作map会将元素根据指定的Function接口来依次将元素转成另外的对象
		List<String> stringCollection = new ArrayList<>();
		stringCollection.add("dd");
		stringCollection.add("aaa2s");
		stringCollection.add("bbb1");
		Stream<String> stream = stringCollection.stream();
		stream.map(String::toUpperCase).sorted((a, b) -> b.compareTo(a)).forEach(System.out::println);
	}

	@Test // Match 匹配
	public void streamMatch() {// Stream提供了多种匹配操作，允许检测指定的Predicate是否匹配整个Stream。所有的匹配操作都是最终操作，并返回一个boolean类型的值。
		List<String> stringCollection = new ArrayList<>();
		stringCollection.add("dd");
		stringCollection.add("aaa2s");
		stringCollection.add("bbb1");
		Stream<String> stream = stringCollection.stream();
		boolean anyStartsWithA = stringCollection.stream().anyMatch((s) -> s.startsWith("a"));// 是否最少有一个元素是a开头
		System.out.println(anyStartsWithA); // true
		boolean allStartsWithA = stringCollection.stream().allMatch((s) -> s.startsWith("a"));// 是否全部元素是a开头
		System.out.println(allStartsWithA); // false
		boolean noneStartsWithZ = stringCollection.stream().noneMatch((s) -> s.startsWith("z"));// 是否全部元素都不是z开头
		System.out.println(noneStartsWithZ); // true
	}

	@Test
	public void streamCount() {// 返回所有是b开头的元素的个数
		Stream<String> stream = Stream.of("dd", "aaa2s", "bbb1");
		long count = stream.filter((s) -> s.startsWith("b")).count();
		System.out.println(count);
	}

	@Test // Reduce 规约
	public void streamReduce() {// 允许通过指定的函数来讲stream中的多个元素规约为一个元素，规越后的结果是通过Optional接口表示的
		Stream<String> stream = Stream.of("dd", "aaa2s", "bbb1");
		Optional<String> reduce = stream.sorted().reduce((s1, s2) -> s1 + "#" + s2);
		reduce.ifPresent(System.out::printf);
	}

	@Test
	public void streamSerial() {// 串行--单线程
		int max = 1000000;
		List<String> values = new ArrayList<>(max);
		for (int i = 0; i < max; i++) {
			UUID uuid = UUID.randomUUID();
			values.add(uuid.toString());
		}
		long t0 = System.nanoTime();
		long count = values.stream().sorted().count();
		System.out.println(count);
		long t1 = System.nanoTime();
		long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
		System.out.println(String.format("串行：%d ms", millis));
	}

	@Test
	public void streamParallel() {// 并行Streams--多线程
		int max = 1000000;
		List<String> values = new ArrayList<>(max);
		for (int i = 0; i < max; i++) {
			UUID uuid = UUID.randomUUID();
			values.add(uuid.toString());
		}
		long t0 = System.nanoTime();
		long count = values.parallelStream().sorted().count();
		System.out.println(count);
		long t1 = System.nanoTime();
		long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
		System.out.println(String.format("并行：%d ms", millis));
	}

}