1.lambda 了解:

package com.atguigu.java8;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;
import org.junit.Test;
public class TestLambda1 {
	//原来的匿名内部类
	@Test
	public void test1(){
		Comparator<String> com = new Comparator<String>(){
			@Override
			public int compare(String o1, String o2) {
				return Integer.compare(o1.length(), o2.length());
			}
		};
		TreeSet<String> ts = new TreeSet<>(com);
		TreeSet<String> ts2 = new TreeSet<>(new Comparator<String>(){
			@Override
			public int compare(String o1, String o2) {
				return Integer.compare(o1.length(), o2.length());
			}
		});
	}
	//现在的 Lambda 表达式
	@Test
	public void test2(){
		Comparator<String> com = (x, y) -> Integer.compare(x.length(), y.length());
		TreeSet<String> ts = new TreeSet<>(com);
	}
	List<Employee> emps = Arrays.asList(
			new Employee(101, "张三", 18, 9999.99),
			new Employee(102, "李四", 59, 6666.66),
			new Employee(103, "王五", 28, 3333.33),
			new Employee(104, "赵六", 8, 7777.77),
			new Employee(105, "田七", 38, 5555.55)
	);
	//需求：获取公司中年龄小于 35 的员工信息
	public List<Employee> filterEmployeeAge(List<Employee> emps){
		List<Employee> list = new ArrayList<>();
		for (Employee emp : emps) {
			if(emp.getAge() <= 35){
				list.add(emp);
			}
		}
		return list;
	}
	@Test
	public void test3(){
		List<Employee> list = filterEmployeeAge(emps);
		for (Employee employee : list) {
			System.out.println(employee);
		}
	}
	//需求：获取公司中工资大于 5000 的员工信息
	public List<Employee> filterEmployeeSalary(List<Employee> emps){
		List<Employee> list = new ArrayList<>();
		for (Employee emp : emps) {
			if(emp.getSalary() >= 5000){
				list.add(emp);
			}
		}
		return list;
	}
	//优化方式一：策略设计模式
	public List<Employee> filterEmployee(List<Employee> emps, MyPredicate<Employee> mp){
		List<Employee> list = new ArrayList<>();
		for (Employee employee : emps) {
			if(mp.test(employee)){
				list.add(employee);
			}
		}
		return list;
	}
	@Test
	public void test4(){
		List<Employee> list = filterEmployee(emps, new FilterEmployeeForAge());
		for (Employee employee : list) {
			System.out.println(employee);
		}
		System.out.println("------------------------------------------");
		List<Employee> list2 = filterEmployee(emps, new FilterEmployeeForSalary());
		for (Employee employee : list2) {
			System.out.println(employee);
		}
	}
	//优化方式二：匿名内部类
	@Test
	public void test5(){
		List<Employee> list = filterEmployee(emps, new MyPredicate<Employee>() {
			@Override
			public boolean test(Employee t) {
				return t.getId() <= 103;
			}
		});
		for (Employee employee : list) {
			System.out.println(employee);
		}
	}
	//优化方式三：Lambda 表达式
	@Test
	public void test6(){
		List<Employee> list = filterEmployee(emps, (e) -> e.getAge() <= 35);
		list.forEach(System.out::println);
		System.out.println("------------------------------------------");
		List<Employee> list2 = filterEmployee(emps, (e) -> e.getSalary() >= 5000);
		list2.forEach(System.out::println);
	}
	//优化方式四：Stream API
	@Test
	public void test7(){
		emps.stream()
			.filter((e) -> e.getAge() <= 35)
			.forEach(System.out::println);
		System.out.println("----------------------------------------------");
		emps.stream()
			.map(Employee::getName)
			.limit(3)
			.sorted()
			.forEach(System.out::println);
	}
}
----------------------------------MyPredicate接口------------------------------------------------
package com.atguigu.java8;
@FunctionalInterface
public interface MyPredicate<T> {
	public boolean test(T t);
}
----------------------------------MyPredicate实现类------------------------------------------------
package com.atguigu.java8;
public class FilterEmployeeForAge implements MyPredicate<Employee>{
	@Override
	public boolean test(Employee t) {
		return t.getAge() <= 35;
	}
}
----------------------------------MyPredicate实现类------------------------------------------------
package com.atguigu.java8;
public class FilterEmployeeForSalary implements MyPredicate<Employee> {
	@Override
	public boolean test(Employee t) {
		return t.getSalary() >= 5000;
	}
}

2.lambda基础语法:

package com.atguigu.java8;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import org.junit.Test;
/*
 * 一、Lambda 表达式的基础语法：Java8中引入了一个新的操作符 "->" 该操作符称为箭头操作符或 Lambda 操作符
 * 						    箭头操作符将 Lambda 表达式拆分成两部分：
 * 
 * 左侧：Lambda 表达式的参数列表
 * 右侧：Lambda 表达式中所需执行的功能， 即 Lambda 体
 * 
 * 语法格式一：无参数，无返回值
 * 		() -> System.out.println("Hello Lambda!");
 * 
 * 语法格式二：有一个参数，并且无返回值
 * 		(x) -> System.out.println(x)
 * 
 * 语法格式三：若只有一个参数，小括号可以省略不写
 * 		x -> System.out.println(x)
 * 
 * 语法格式四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句
 *		Comparator<Integer> com = (x, y) -> {
 *			System.out.println("函数式接口");
 *			return Integer.compare(x, y);
 *		};
 *
 * 语法格式五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写
 * 		Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
 * 
 * 语法格式六：Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”
 * 		(Integer x, Integer y) -> Integer.compare(x, y);
 * 
 * 上联：左右遇一括号省
 * 下联：左侧推断类型省
 * 横批：能省则省
 * 
 * 二、Lambda 表达式需要“函数式接口”的支持
 * 函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。 可以使用注解 @FunctionalInterface 修饰
 * 			 可以检查是否是函数式接口
 */
public class TestLambda2 {
	@Test
	public void test1(){
		int num = 0;//jdk 1.7 前，必须是 final
		Runnable r = new Runnable() {
			@Override
			public void run() {
				System.out.println("Hello World!" + num);
			}
		};
		r.run();
		System.out.println("-------------------------------");
		Runnable r1 = () -> System.out.println("Hello Lambda!");
		r1.run();
	}
	@Test
	public void test2(){
		Consumer<String> con = x -> System.out.println(x);
		con.accept("我大尚硅谷威武！");
	}
	@Test
	public void test3(){
		Comparator<Integer> com = (x, y) -> {
			System.out.println("函数式接口");
			return Integer.compare(x, y);
		};
	}
	@Test
	public void test4(){
		Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
	}
	@Test
	public void test5(){
//		String[] strs;
//		strs = {"aaa", "bbb", "ccc"};
		List<String> list = new ArrayList<>();
		show(new HashMap<>());
	}
	public void show(Map<String, Integer> map){
	}
	//需求：对一个数进行运算
	@Test
	public void test6(){
		Integer num = operation(100, (x) -> x * x);
		System.out.println(num);
		System.out.println(operation(200, (y) -> y + 200));
	}
	public Integer operation(Integer num, MyFun mf){
		return mf.getValue(num);
	}
}

3.lambda练习:

package com.atguigu.exer;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
import com.atguigu.java8.Employee;
public class TestLambda {
	List<Employee> emps = Arrays.asList(
			new Employee(101, "张三", 18, 9999.99),
			new Employee(102, "李四", 59, 6666.66),
			new Employee(103, "王五", 28, 3333.33),
			new Employee(104, "赵六", 8, 7777.77),
			new Employee(105, "田七", 38, 5555.55)
	);
	@Test
	public void test1(){
		Collections.sort(emps, (e1, e2) -> {
			if(e1.getAge() == e2.getAge()){
					return e1.getName().compareTo(e2.getName());
			}else{
				return -Integer.compare(e1.getAge(), e2.getAge());
			}
		});
		for (Employee emp : emps) {
			System.out.println(emp);
		}
	}
	@Test
	public void test2(){
		String trimStr = strHandler("\t\t\t 我大尚硅谷威武   ", (str) -> str.trim());
		System.out.println(trimStr);
		String upper = strHandler("abcdef", (str) -> str.toUpperCase());
		System.out.println(upper);
		String newStr = strHandler("我大尚硅谷威武", (str) -> str.substring(2, 5));
		System.out.println(newStr);
	}
	//需求：用于处理字符串
	public String strHandler(String str, MyFunction mf){
		return mf.getValue(str);
	}
	@Test
	public void test3(){
		op(100L, 200L, (x, y) -> x + y);
		op(100L, 200L, (x, y) -> x * y);
	}
	//需求：对于两个 Long 型数据进行处理
	public void op(Long l1, Long l2, MyFunction2<Long, Long> mf){
		System.out.println(mf.getValue(l1, l2));
	}
}
----------------------------------------------------------------------------------
package com.atguigu.exer;
@FunctionalInterface
public interface MyFunction {	
	public String getValue(String str);
}
----------------------------------------------------------------------------------
package com.atguigu.exer;
public interface MyFunction2<T, R> {
	public R getValue(T t1, T t2);
}

4.内置的四大核心函数式接口:

package com.atguigu.java8;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import org.junit.Test;
/*
 * Java8 内置的四大核心函数式接口
 * 
 * Consumer<T> : 消费型接口
 * 		void accept(T t);
 * 
 * Supplier<T> : 供给型接口
 * 		T get(); 
 * 
 * Function<T, R> : 函数型接口
 * 		R apply(T t);
 * 
 * Predicate<T> : 断言型接口
 * 		boolean test(T t);
 * 
 */
public class TestLambda3 {
	//Predicate<T> 断言型接口：
	@Test
	public void test4(){
		List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");
		List<String> strList = filterStr(list, (s) -> s.length() > 3);
		for (String str : strList) {
			System.out.println(str);
		}
	}
	//需求：将满足条件的字符串，放入集合中
	public List<String> filterStr(List<String> list, Predicate<String> pre){
		List<String> strList = new ArrayList<>();
		for (String str : list) {
			if(pre.test(str)){
				strList.add(str);
			}
		}
		return strList;
	}
	//Function<T, R> 函数型接口：
	@Test
	public void test3(){
		String newStr = strHandler("\t\t\t 我大尚硅谷威武   ", (str) -> str.trim());
		System.out.println(newStr);
		String subStr = strHandler("我大尚硅谷威武", (str) -> str.substring(2, 5));
		System.out.println(subStr);
	}
	//需求：用于处理字符串
	public String strHandler(String str, Function<String, String> fun){
		return fun.apply(str);
	}
	//Supplier<T> 供给型接口 :
	@Test
	public void test2(){
		List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
		for (Integer num : numList) {
			System.out.println(num);
		}
	}
	//需求：产生指定个数的整数，并放入集合中
	public List<Integer> getNumList(int num, Supplier<Integer> sup){
		List<Integer> list = new ArrayList<>();
		for (int i = 0; i < num; i++) {
			Integer n = sup.get();
			list.add(n);
		}
		return list;
	}
	//Consumer<T> 消费型接口 :
	@Test
	public void test1(){
		happy(10000, (m) -> System.out.println("你们刚哥喜欢大宝剑，每次消费：" + m + "元"));
	} 
	public void happy(double money, Consumer<Double> con){
		con.accept(money);
	}
}

5.lambda方法引用:

package com.atguigu.java8;
import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import org.junit.Test;
/*
 * 一、方法引用：若 Lambda 体中的功能，已经有方法提供了实现，可以使用方法引用
 * 			  （可以将方法引用理解为 Lambda 表达式的另外一种表现形式）
 * 
 * 1. 对象的引用 :: 实例方法名
 * 
 * 2. 类名 :: 静态方法名
 * 
 * 3. 类名 :: 实例方法名
 * 
 * 注意：
 * 	 ①方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致！
 * 	 ②若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式： ClassName::MethodName
 * 
 * 二、构造器引用 :构造器的参数列表，需要与函数式接口中参数列表保持一致！
 * 
 * 1. 类名 :: new
 * 
 * 三、数组引用
 * 
 * 	类型[] :: new;
 * 
 * 
 */
public class TestMethodRef {
	//数组引用
	@Test
	public void test8(){
		Function<Integer, String[]> fun = (args) -> new String[args];
		String[] strs = fun.apply(10);
		System.out.println(strs.length);
		System.out.println("--------------------------");
		Function<Integer, Employee[]> fun2 = Employee[] :: new;
		Employee[] emps = fun2.apply(20);
		System.out.println(emps.length);
	}
	//构造器引用
	@Test
	public void test7(){
		Function<String, Employee> fun = Employee::new;
		BiFunction<String, Integer, Employee> fun2 = Employee::new;
	}
	@Test
	public void test6(){
		Supplier<Employee> sup = () -> new Employee();
		System.out.println(sup.get());
		System.out.println("------------------------------------");
		Supplier<Employee> sup2 = Employee::new;
		System.out.println(sup2.get());
	}
	//类名 :: 实例方法名
	@Test
	public void test5(){
		BiPredicate<String, String> bp = (x, y) -> x.equals(y);
		System.out.println(bp.test("abcde", "abcde"));
		System.out.println("-----------------------------------------");
		BiPredicate<String, String> bp2 = String::equals;
		System.out.println(bp2.test("abc", "abc"));
		System.out.println("-----------------------------------------");
		Function<Employee, String> fun = (e) -> e.show();
		System.out.println(fun.apply(new Employee()));
		System.out.println("-----------------------------------------");
		Function<Employee, String> fun2 = Employee::show;
		System.out.println(fun2.apply(new Employee()));
	}
	//类名 :: 静态方法名
	@Test
	public void test4(){
		Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
		System.out.println("-------------------------------------");
		Comparator<Integer> com2 = Integer::compare;
	}
	@Test
	public void test3(){
		BiFunction<Double, Double, Double> fun = (x, y) -> Math.max(x, y);
		System.out.println(fun.apply(1.5, 22.2));
		System.out.println("--------------------------------------------------");
		BiFunction<Double, Double, Double> fun2 = Math::max;
		System.out.println(fun2.apply(1.2, 1.5));
	}
	//对象的引用 :: 实例方法名
	@Test
	public void test2(){
		Employee emp = new Employee(101, "张三", 18, 9999.99);
		Supplier<String> sup = () -> emp.getName();
		System.out.println(sup.get());
		System.out.println("----------------------------------");
		Supplier<String> sup2 = emp::getName;
		System.out.println(sup2.get());
	}
	@Test
	public void test1(){
		PrintStream ps = System.out;
		Consumer<String> con = (str) -> ps.println(str);
		con.accept("Hello World！");
		System.out.println("--------------------------------");
		Consumer<String> con2 = ps::println;
		con2.accept("Hello Java8！");
		Consumer<String> con3 = System.out::println;
	}
}

6.Stream API(创建 Stream ):

package com.atguigu.java8;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;
import org.junit.Test;
/*
 * 一、Stream API 的操作步骤：
 * 
 * 1. 创建 Stream
 * 
 * 2. 中间操作
 * 
 * 3. 终止操作(终端操作)
 */
public class TestStreamaAPI {
	//1. 创建 Stream
	@Test
	public void test1(){
		//1. Collection 提供了两个方法  stream() 与 parallelStream()
		List<String> list = new ArrayList<>();
		Stream<String> stream = list.stream(); //获取一个顺序流
		Stream<String> parallelStream = list.parallelStream(); //获取一个并行流
		//2. 通过 Arrays 中的 stream() 获取一个数组流
		Integer[] nums = new Integer[10];
		Stream<Integer> stream1 = Arrays.stream(nums);
		//3. 通过 Stream 类中静态方法 of()
		Stream<Integer> stream2 = Stream.of(1,2,3,4,5,6);
		//4. 创建无限流
		//迭代
		Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2).limit(10);
		stream3.forEach(System.out::println);
		//生成
		Stream<Double> stream4 = Stream.generate(Math::random).limit(2);
		stream4.forEach(System.out::println);
	}
	//2. 中间操作
	List<Employee> emps = Arrays.asList(
			new Employee(102, "李四", 59, 6666.66),
			new Employee(101, "张三", 18, 9999.99),
			new Employee(103, "王五", 28, 3333.33),
			new Employee(104, "赵六", 8, 7777.77),
			new Employee(104, "赵六", 8, 7777.77),
			new Employee(104, "赵六", 8, 7777.77),
			new Employee(105, "田七", 38, 5555.55)
	);
	/*
	  筛选与切片
		filter——接收 Lambda ， 从流中排除某些元素。
		limit——截断流，使其元素不超过给定数量。
		skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
		distinct——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
	 */
	//内部迭代：迭代操作 Stream API 内部完成
	@Test
	public void test2(){
		//所有的中间操作不会做任何的处理
		Stream<Employee> stream = emps.stream()
			.filter((e) -> {
				System.out.println("测试中间操作");
				return e.getAge() <= 35;
			});
		//只有当做终止操作时，所有的中间操作会一次性的全部执行，称为“惰性求值”
		stream.forEach(System.out::println);
	}
	//外部迭代
	@Test
	public void test3(){
		Iterator<Employee> it = emps.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}
	@Test
	public void test4(){
		emps.stream()
			.filter((e) -> {
				System.out.println("短路！"); // &&  ||
				return e.getSalary() >= 5000;
			}).limit(3)
			.forEach(System.out::println);
	}
	@Test
	public void test5(){
		emps.parallelStream()
			.filter((e) -> e.getSalary() >= 5000)
			.skip(2)
			.forEach(System.out::println);
	}
	@Test
	public void test6(){
		emps.stream()
			.distinct()
			.forEach(System.out::println);
	}
}

7.Stream API(中间操作):

package com.atguigu.java8;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
import org.junit.Test;
/*
 * 一、 Stream 的操作步骤
 * 
 * 1. 创建 Stream
 * 
 * 2. 中间操作
 * 
 * 3. 终止操作
 */
public class TestStreamAPI1 {
	List<Employee> emps = Arrays.asList(
			new Employee(102, "李四", 59, 6666.66),
			new Employee(101, "张三", 18, 9999.99),
			new Employee(103, "王五", 28, 3333.33),
			new Employee(104, "赵六", 8, 7777.77),
			new Employee(104, "赵六", 8, 7777.77),
			new Employee(104, "赵六", 8, 7777.77),
			new Employee(105, "田七", 38, 5555.55)
	);
	//2. 中间操作
	/*
		映射
		map——接收 Lambda ， 将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
		flatMap——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
	 */
	@Test
	public void test6(){
		Stream<String> str = emps.stream()
			.map((e) -> e.getName());
		System.out.println("-------------------------------------------");
		List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
		Stream<String> stream = strList.stream()
			   .map(String::toUpperCase);
		stream.forEach(System.out::println);
		Stream<Stream<Character>> stream2 = strList.stream()
			   .map(TestStreamAPI1::filterCharacter);
		stream2.forEach((sm) -> {
			sm.forEach(System.out::println);
		});
		System.out.println("---------------------------------------------");
		Stream<Character> stream3 = strList.stream()
			   .flatMap(TestStreamAPI1::filterCharacter);
		stream3.forEach(System.out::println);
	}
	public static Stream<Character> filterCharacter(String str){
		List<Character> list = new ArrayList<>();
		for (Character ch : str.toCharArray()) {
			list.add(ch);
		}
		return list.stream();
	}
	/*
		sorted()——自然排序(Comparable)
		sorted(Comparator com)——定制排序(Comparator)
	 */
	@Test
	public void test7(){
		emps.stream()
			.map(Employee::getName)
			.sorted()
			.forEach(System.out::println);
		System.out.println("------------------------------------");
		emps.stream()
			.sorted((x, y) -> {
				if(x.getAge() == y.getAge()){
					return x.getName().compareTo(y.getName());
				}else{
					return Integer.compare(x.getAge(), y.getAge());
				}
			}).forEach(System.out::println);
	}
}

8.Stream API(终止操作1):

package com.atguigu.java8;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
import org.junit.Test;
import com.atguigu.java8.Employee.Status;
/*
 * 一、 Stream 的操作步骤
 * 
 * 1. 创建 Stream
 * 
 * 2. 中间操作
 * 
 * 3. 终止操作
 */
public class TestStreamAPI2 {
	List<Employee> emps = Arrays.asList(
			new Employee(102, "李四", 59, 6666.66, Status.BUSY),
			new Employee(101, "张三", 18, 9999.99, Status.FREE),
			new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
			new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
			new Employee(104, "赵六", 8, 7777.77, Status.FREE),
			new Employee(104, "赵六", 8, 7777.77, Status.FREE),
			new Employee(105, "田七", 38, 5555.55, Status.BUSY)
	);
	//3. 终止操作
	/*  //查找与匹配
		allMatch——检查是否匹配所有元素
		anyMatch——检查是否至少匹配一个元素
		noneMatch——检查是否没有匹配的元素
		findFirst——返回第一个元素
		findAny——返回当前流中的任意元素
		count——返回流中元素的总个数
		max——返回流中最大值
		min——返回流中最小值
	 */
	@Test
	public void test1(){
			boolean bl = emps.stream()
				.allMatch((e) -> e.getStatus().equals(Status.BUSY));
			System.out.println(bl);
			boolean bl1 = emps.stream()
				.anyMatch((e) -> e.getStatus().equals(Status.BUSY));
			System.out.println(bl1);
			boolean bl2 = emps.stream()
				.noneMatch((e) -> e.getStatus().equals(Status.BUSY));
			System.out.println(bl2);
	}
	@Test
	public void test2(){
		//findFirst——返回第一个元素
		//findAny——返回当前流中的任意元素
		Optional<Employee> op = emps.stream()
			.sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
			.findFirst();
		System.out.println(op.get());
		System.out.println("--------------------------------");
		Optional<Employee> op2 = emps.parallelStream()
			.filter((e) -> e.getStatus().equals(Status.FREE))
			.findAny();
		System.out.println(op2.get());
	}
	@Test
	public void test3(){
/*		count——返回流中元素的总个数
		max——返回流中最大值
		min——返回流中最小值*/
		long count = emps.stream()
						 .filter((e) -> e.getStatus().equals(Status.FREE))
						 .count();
		System.out.println(count);
		Optional<Double> op = emps.stream()
			.map(Employee::getSalary)
			.max(Double::compare);
		System.out.println(op.get());
		Optional<Employee> op2 = emps.stream()
			.min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
		System.out.println(op2.get());
	}
	//注意：流进行了终止操作后，不能再次使用
	@Test
	public void test4(){
		Stream<Employee> stream = emps.stream()
		 .filter((e) -> e.getStatus().equals(Status.FREE));
		long count = stream.count();
		stream.map(Employee::getSalary)
			.max(Double::compare);
	}
}

9.Stream API(终止操作2):

package com.atguigu.java8;
import java.util.Arrays;
import java.util.DoubleSummaryStatistics;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import org.junit.Test;
import com.atguigu.java8.Employee.Status;
public class TestStreamAPI3 {
	List<Employee> emps = Arrays.asList(
			new Employee(102, "李四", 79, 6666.66, Status.BUSY),
			new Employee(101, "张三", 18, 9999.99, Status.FREE),
			new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
			new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
			new Employee(104, "赵六", 8, 7777.77, Status.FREE),
			new Employee(104, "赵六", 8, 7777.77, Status.FREE),
			new Employee(105, "田七", 38, 5555.55, Status.BUSY)
	);
	//3. 终止操作
	/*
		归约
		reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。
	 */
	@Test
	public void test1(){
		List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
		Integer sum = list.stream()
			.reduce(0, (x, y) -> x + y);
		System.out.println(sum);
		System.out.println("----------------------------------------");
		Optional<Double> op = emps.stream()
			.map(Employee::getSalary)
			.reduce(Double::sum);
		System.out.println(op.get());
	}
	//需求：搜索名字中 “六” 出现的次数
	@Test
	public void test2(){
		Optional<Integer> sum = emps.stream()
			.map(Employee::getName)
			.flatMap(TestStreamAPI1::filterCharacter)
			.map((ch) -> {
				if(ch.equals('六'))
					return 1;
				else 
					return 0;
			}).reduce(Integer::sum);
		System.out.println(sum.get());
	}
	//collect——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
	@Test
	public void test3(){
		System.out.println("---------------list-------------------");
		List<String> list = emps.stream()
			.map(Employee::getName)
			.collect(Collectors.toList());
		list.forEach(System.out::println);
		System.out.println("---------------set-------------------");
		Set<String> set = emps.stream()
			.map(Employee::getName)
			.collect(Collectors.toSet());
		set.forEach(System.out::println);
		System.out.println("---------------hashset-------------------");
		HashSet<String> hs = emps.stream()
			.map(Employee::getName)
			.collect(Collectors.toCollection(HashSet::new));
		hs.forEach(System.out::println);
	}
	@Test
	public void test4(){
		Optional<Double> max = emps.stream()
			.map(Employee::getSalary)
			.collect(Collectors.maxBy(Double::compare));  // 最大值
		System.out.println(max.get());
		Optional<Employee> op = emps.stream()
			.collect(Collectors.minBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))); //最小值
		System.out.println(op.get());
		Double sum = emps.stream()
			.collect(Collectors.summingDouble(Employee::getSalary));  // 工资总和
		System.out.println(sum);
		Double avg = emps.stream()
			.collect(Collectors.averagingDouble(Employee::getSalary));  // 平局工资
		System.out.println(avg);
		Long count = emps.stream()
			.collect(Collectors.counting());  //总数
		System.out.println(count);
		System.out.println("--------------------------------------------");
		DoubleSummaryStatistics dss = emps.stream()
			.collect(Collectors.summarizingDouble(Employee::getSalary)); //统计函数
		System.out.println(dss.getMax());
		System.out.println(dss.getAverage());
		System.out.println(dss.getSum());
	}
	//分组
	@Test
	public void test5(){
		Map<Status, List<Employee>> map = emps.stream()
			.collect(Collectors.groupingBy(Employee::getStatus));
		System.out.println(map);
	}
	//多级分组
	@Test
	public void test6(){
		Map<Status, Map<String, List<Employee>>> map = emps.stream()
			.collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
				if(e.getAge() >= 60)
					return "老年";
				else if(e.getAge() >= 35)
					return "中年";
				else
					return "成年";
			})));
		System.out.println(map);
	}
	//分区
	@Test
	public void test7(){
		Map<Boolean, List<Employee>> map = emps.stream()
			.collect(Collectors.partitioningBy((e) -> e.getSalary() >= 5000));
		System.out.println(map);
	}
	//连接
	@Test
	public void test8(){
		String str = emps.stream()
			.map(Employee::getName)
			.collect(Collectors.joining("," , "----", "----")); //以逗号连接,前后使用
		System.out.println(str);
	}
	@Test
	public void test9(){
		Optional<Double> sum = emps.stream()
			.map(Employee::getSalary)
			.collect(Collectors.reducing(Double::sum));
		System.out.println(sum.get());
	}
}

10.练习1:

package com.atguigu.exer;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import org.junit.Test;
import com.atguigu.java8.Employee;
import com.atguigu.java8.Employee.Status;
public class TestStreamAPI {
	/*
	  	1.	给定一个数字列表，如何返回一个由每个数的平方构成的列表呢？
		，给定【1，2，3，4，5】， 应该返回【1，4，9，16，25】。
	 */
	@Test
	public void test1(){
		Integer[] nums = new Integer[]{1,2,3,4,5};
		Arrays.stream(nums)
			  .map((x) -> x * x)
			  .forEach(System.out::println);
	}
	/*
	 2.	怎样用 map 和 reduce 方法数一数流中有多少个Employee呢？
	 */
	List<Employee> emps = Arrays.asList(
			new Employee(102, "李四", 59, 6666.66, Status.BUSY),
			new Employee(101, "张三", 18, 9999.99, Status.FREE),
			new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
			new Employee(104, "赵六", 8, 7777.77, Status.BUSY),
			new Employee(104, "赵六", 8, 7777.77, Status.FREE),
			new Employee(104, "赵六", 8, 7777.77, Status.FREE),
			new Employee(105, "田七", 38, 5555.55, Status.BUSY)
	);
	@Test
	public void test2(){
		Optional<Integer> count = emps.stream()
			.map((e) -> 1)
			.reduce(Integer::sum);
		System.out.println(count.get());
	}
}

11.练习2:

package com.atguigu.exer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
import org.junit.Before;
import org.junit.Test;
public class TestTransaction {
	List<Transaction> transactions = null;
	@Before
	public void before(){
		Trader raoul = new Trader("Raoul", "Cambridge");
		Trader mario = new Trader("Mario", "Milan");
		Trader alan = new Trader("Alan", "Cambridge");
		Trader brian = new Trader("Brian", "Cambridge");
		transactions = Arrays.asList(
				new Transaction(brian, 2011, 300),
				new Transaction(raoul, 2012, 1000),
				new Transaction(raoul, 2011, 400),
				new Transaction(mario, 2012, 710),
				new Transaction(mario, 2012, 700),
				new Transaction(alan, 2012, 950)
		);
	}
	//1. 找出2011年发生的所有交易， 并按交易额排序（从低到高）
	@Test
	public void test1(){
		transactions.stream()
					.filter((t) -> t.getYear() == 2011)
					.sorted((t1, t2) -> Integer.compare(t1.getValue(), t2.getValue()))
					.forEach(System.out::println);
	}
	//2. 交易员都在哪些不同的城市工作过？
	@Test
	public void test2(){
		transactions.stream()
					.map((t) -> t.getTrader().getCity())
					.distinct()
					.forEach(System.out::println);
	}
	//3. 查找所有来自剑桥的交易员，并按姓名排序
	@Test
	public void test3(){
		transactions.stream()
					.filter((t) -> t.getTrader().getCity().equals("Cambridge"))
					.map(Transaction::getTrader)
					.sorted((t1, t2) -> t1.getName().compareTo(t2.getName()))
					.distinct()
					.forEach(System.out::println);
	}
	//4. 返回所有交易员的姓名字符串，按字母顺序排序
	@Test
	public void test4(){
		transactions.stream()
					.map((t) -> t.getTrader().getName())
					.sorted()
					.forEach(System.out::println);
		System.out.println("-----------------------------------");
		String str = transactions.stream()
					.map((t) -> t.getTrader().getName())
					.sorted()
					.reduce("", String::concat);
		System.out.println(str);
		System.out.println("------------------------------------");
		transactions.stream()
					.map((t) -> t.getTrader().getName())
					.flatMap(TestTransaction::filterCharacter)
					.sorted((s1, s2) -> s1.compareToIgnoreCase(s2))
					.forEach(System.out::print);
	}
	public static Stream<String> filterCharacter(String str){
		List<String> list = new ArrayList<>();
		for (Character ch : str.toCharArray()) {
			list.add(ch.toString());
		}
		return list.stream();
	}
	//5. 有没有交易员是在米兰工作的？
	@Test
	public void test5(){
		boolean bl = transactions.stream()
					.anyMatch((t) -> t.getTrader().getCity().equals("Milan"));
		System.out.println(bl);
	}
	//6. 打印生活在剑桥的交易员的所有交易额
	@Test
	public void test6(){
		Optional<Integer> sum = transactions.stream()
					.filter((e) -> e.getTrader().getCity().equals("Cambridge"))
					.map(Transaction::getValue)
					.reduce(Integer::sum);
		System.out.println(sum.get());
	}
	//7. 所有交易中，最高的交易额是多少
	@Test
	public void test7(){
		Optional<Integer> max = transactions.stream()
					.map((t) -> t.getValue())
					.max(Integer::compare);
		System.out.println(max.get());
	}
	//8. 找到交易额最小的交易
	@Test
	public void test8(){
		Optional<Transaction> op = transactions.stream()
					.min((t1, t2) -> Integer.compare(t1.getValue(), t2.getValue()));
		System.out.println(op.get());
	}
}
----------------------------------------------------------------------------------
package com.atguigu.exer;
//交易类
public class Transaction {
	private Trader trader;
	private int year;
	private int value;
	public Transaction() {
	}
	public Transaction(Trader trader, int year, int value) {
		this.trader = trader;
		this.year = year;
		this.value = value;
	}
	public Trader getTrader() {
		return trader;
	}
	public void setTrader(Trader trader) {
		this.trader = trader;
	}
	public int getYear() {
		return year;
	}
	public void setYear(int year) {
		this.year = year;
	}
	public int getValue() {
		return value;
	}
	public void setValue(int value) {
		this.value = value;
	}
	@Override
	public String toString() {
		return "Transaction [trader=" + trader + ", year=" + year + ", value="
				+ value + "]";
	}
}
----------------------------------------------------------------------------------
package com.atguigu.exer;
//交易员类
public class Trader {
	private String name;
	private String city;
	public Trader() {
	}
	public Trader(String name, String city) {
		this.name = name;
		this.city = city;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	@Override
	public String toString() {
		return "Trader [name=" + name + ", city=" + city + "]";
	}
}

12.并行流与串行流(fork/join):

package com.atguigu.java8;
import java.util.concurrent.RecursiveTask;  //有返回值
import java.util.concurrent.RecursiveAction;  //无返回值
public class ForkJoinCalculate extends RecursiveTask<Long>{
	/**
	 * 
	 */
	private static final long serialVersionUID = 13475679780L;
	private long start;
	private long end;
	private static final long THRESHOLD = 10000L; //临界值,拆成多大的(比如从1加到1亿,拆成1亿/10000个任务)
	public ForkJoinCalculate(long start, long end) {
		this.start = start;
		this.end = end;
	}
	@Override
	protected Long compute() {
		long length = end - start;
		if(length <= THRESHOLD){
			long sum = 0;
			for (long i = start; i <= end; i++) {
				sum += i;
			}
			return sum;
		}else{
			long middle = (start + end) / 2;
			ForkJoinCalculate left = new ForkJoinCalculate(start, middle);
			left.fork(); //拆分，并将该子任务压入线程队列
			ForkJoinCalculate right = new ForkJoinCalculate(middle+1, end);
			right.fork();
			return left.join() + right.join();
		}
	}
}
-----------------------------------------------------------------------------------
package com.atguigu.java8;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;
import org.junit.Test;
public class TestForkJoin {
//	fork/join
	@Test
	public void test1(){
		long start = System.currentTimeMillis();
		ForkJoinPool pool = new ForkJoinPool();
		ForkJoinTask<Long> task = new ForkJoinCalculate(0L, 10000000000L);
		long sum = pool.invoke(task);
		System.out.println(sum);
		long end = System.currentTimeMillis();
		System.out.println("耗费的时间为: " + (end - start)); //112-1953-1988-2654-2647-20663-113808
	}
//	for循环
	@Test
	public void test2(){
		long start = System.currentTimeMillis();
		long sum = 0L;
		for (long i = 0L; i <= 10000000000L; i++) {
			sum += i;
		}
		System.out.println(sum);
		long end = System.currentTimeMillis();
		System.out.println("耗费的时间为: " + (end - start)); //34-3174-3132-4227-4223-31583
	}
//	java8 并行流
	@Test
	public void test3(){
		long start = System.currentTimeMillis();
		Long sum = LongStream.rangeClosed(0L, 10000000000L)
							 .parallel()  //加上这个方法就变成了并行
							 .sum();
		System.out.println(sum);
		long end = System.currentTimeMillis();
		System.out.println("耗费的时间为: " + (end - start)); //2061-2053-2086-18926
	}
}

13.Optional 类:

package com.atguigu.java8;
public class Man {
	private Godness god;
	public Man() {
	}
	public Man(Godness god) {
		this.god = god;
	}
	public Godness getGod() {
		return god;
	}
	public void setGod(Godness god) {
		this.god = god;
	}
	@Override
	public String toString() {
		return "Man [god=" + god + "]";
	}
}
------------------------------------------------------------------------------
package com.atguigu.java8;
public class Godness {
	private String name;
	public Godness() {
	}
	public Godness(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Godness [name=" + name + "]";
	}
}
---------------------------------------------------------------------------------
package com.atguigu.java8;
import java.util.Optional;
//注意：Optional 不能被序列化
public class NewMan {
	private Optional<Godness> godness = Optional.empty();
	private Godness god;
	public Optional<Godness> getGod(){
		return Optional.of(god);
	}
	public NewMan() {
	}
	public NewMan(Optional<Godness> godness) {
		this.godness = godness;
	}
	public Optional<Godness> getGodness() {
		return godness;
	}
	public void setGodness(Optional<Godness> godness) {
		this.godness = godness;
	}
	@Override
	public String toString() {
		return "NewMan [godness=" + godness + "]";
	}
}
-----------------------------------------------------------------------------------
package com.atguigu.java8;
import java.util.Optional;
import org.junit.Test;
/*
 * 一、Optional 容器类：用于尽量避免空指针异常
 * 	Optional.of(T t) : 创建一个 Optional 实例
 * 	Optional.empty() : 创建一个空的 Optional 实例
 * 	Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
 * 	isPresent() : 判断是否包含值
 * 	orElse(T t) :  如果调用对象包含值，返回该值，否则返回t
 * 	orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
 * 	map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
 * 	flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
 */
public class TestOptional {
	@Test
	public void test4(){
		Optional<Employee> op = Optional.of(new Employee(101, "张三", 18, 9999.99));
		Optional<String> op2 = op.map(Employee::getName); //获取到的名字
		System.out.println(op2.get());
		Optional<String> op3 = op.flatMap((e) -> Optional.of(e.getName())); //获取到的名字,但是必须返回Optional类型
		System.out.println(op3.get());
	}
	@Test
	public void test3(){
		Optional<Employee> op = Optional.ofNullable(new Employee());
		if(op.isPresent()){  //是否有值
			System.out.println(op.get());
		}
		Employee emp = op.orElse(new Employee("张三"));  //如果有值就取出来,没值输出你给的默认值
		System.out.println(emp);
		Employee emp2 = op.orElseGet(() -> new Employee()); //如果有值取出来,没有值通过供给型接口创建一个返回
		System.out.println(emp2);
	}
	@Test
	public void test2(){
		/*Optional<Employee> op = Optional.ofNullable(null); //可以传入NULL值
		System.out.println(op.get());*/
//		Optional<Employee> op = Optional.empty();  //构建空的optional
//		System.out.println(op.get());
	}
	@Test
	public void test1(){
		Optional<Employee> op = Optional.of(new Employee());  //不可以传入null,否则报错
		Employee emp = op.get();
		System.out.println(emp);
	}
	@Test
	public void test5(){
		Man man = new Man();
		String name = getGodnessName(man);
		System.out.println(name);
	}
	//需求：获取一个男人心中女神的名字
	public String getGodnessName(Man man){
		if(man != null){
			Godness g = man.getGod();
			if(g != null){
				return g.getName();
			}
		}
		return "苍老师";
	}
	//运用 Optional 的实体类
	@Test
	public void test6(){
		Optional<Godness> godness = Optional.ofNullable(new Godness("林志玲"));
		Optional<NewMan> op = Optional.ofNullable(new NewMan(godness));
		String name = getGodnessName2(op);
		System.out.println(name);
	}
	public String getGodnessName2(Optional<NewMan> man){
		return man.orElse(new NewMan())
				  .getGodness()  //获取一个Optional类型的女神,有可能为空
				  .orElse(new Godness("苍老师")) //所以这里给以默认值
				  .getName();
	}
}

14.接口中的默认方法与静态方法:

package com.atguigu.java8;
public interface MyFun {
	default String getName(){
		return "哈哈哈";
	}
}
-----------------------------------------------------------------------------------
package com.atguigu.java8;
public class MyClass {
	public String getName(){
		return "嘿嘿嘿";
	}
}
-----------------------------------------------------------------------------------
package com.atguigu.java8;
public class SubClass /*extends MyClass*/ implements MyFun, MyInterface{
	@Override
	public String getName() {
        //当继承多个接口,调用同名方法时,需要指明调用的是哪个接口
		return MyInterface.super.getName();  
	}
}
-----------------------------------------------------------------------------------
package com.atguigu.java8;
public interface MyInterface {
    //java接口中可以定义默认方法和静态方法
	default String getName(){
		return "呵呵呵";
	}
	public static void show(){
		System.out.println("接口中的静态方法");
	}
}
-----------------------------------------------------------------------------------
package com.atguigu.java8;
public class TestDefaultInterface {
	public static void main(String[] args) {
		SubClass sc = new SubClass();
         //当调用父类和接口中的相同的方法的时候,父类优先
		System.out.println(sc.getName());
		MyInterface.show();
	}
}

15.新时间日期 API 1:

----------------------------------------------------------------------------------
package com.atguigu.java8;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TestSimpleDateFormat {
	public static void main(String[] args) throws Exception {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		Callable<Date> task = new Callable<Date>() {
			@Override
			public Date call() throws Exception {
				return sdf.parse("20161121");
			}
		};
		ExecutorService pool = Executors.newFixedThreadPool(10);
		List<Future<Date>> results = new ArrayList<>();
		for (int i = 0; i < 10; i++) {
			results.add(pool.submit(task));
		}
		for (Future<Date> future : results) {
			System.out.println(future.get());
		}
		pool.shutdown();
		//解决多线程安全问题,使用线程锁方式
//		Callable<Date> task = new Callable<Date>() {
//
//			@Override
//			public Date call() throws Exception {
//				return DateFormatThreadLocal.convert("20161121");
//			}
//			
//		};
//
//		ExecutorService pool = Executors.newFixedThreadPool(10);
//		
//		List<Future<Date>> results = new ArrayList<>();
//		
//		for (int i = 0; i < 10; i++) {
//			results.add(pool.submit(task));
//		}
//		
//		for (Future<Date> future : results) {
//			System.out.println(future.get());
//		}
//		
//		pool.shutdown();
		//权限的时间api是线程安全的
		DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyyMMdd");
		Callable<LocalDate> task = new Callable<LocalDate>() {
			@Override
			public LocalDate call() throws Exception {
				LocalDate ld = LocalDate.parse("20161121", dtf);
				return ld;
			}
		};
		ExecutorService pool = Executors.newFixedThreadPool(10);
		List<Future<LocalDate>> results = new ArrayList<>();
		for (int i = 0; i < 10; i++) {
			results.add(pool.submit(task));
		}
		for (Future<LocalDate> future : results) {
			System.out.println(future.get());
		}
		pool.shutdown();
	}
}
-------------------------------------------线程锁方式----------------------------------------
package com.atguigu.java8;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormatThreadLocal {
	private static final ThreadLocal<DateFormat> df = new ThreadLocal<DateFormat>(){
		protected DateFormat initialValue(){
			return new SimpleDateFormat("yyyyMMdd");
		}
	};
	public static final Date convert(String source) throws ParseException{
		return df.get().parse(source);
	}
}

16.新时间日期 API 2:

package com.atguigu.com;
import java.time.DayOfWeek;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.Period;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.Set;
import org.junit.Test;
public class NewDateApi {
	//6.ZonedDate、ZonedTime、ZonedDateTime ： 带时区的时间或日期
	@Test
	public void test8(){
		LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Asia/Shanghai")); //指定时区的当前时间,并不显示时区
		System.out.println(ldt);
		LocalDateTime ldt1 = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
		ZonedDateTime zdt = ldt1.atZone(ZoneId.of("Asia/Shanghai")); //指定时区,并显示时区
		System.out.println(zdt);
	}
	@Test
	public void test7(){
		Set<String> set = ZoneId.getAvailableZoneIds(); // 查看支持的时区
		set.forEach(System.out::println);
	}
	//5. DateTimeFormatter : 解析和格式化日期或时间
	@Test
	public void test6(){
//		DateTimeFormatter dtf = DateTimeFormatter.ISO_LOCAL_DATE;
		DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss E");  //创建格式化对象
		LocalDateTime ldt = LocalDateTime.now();
		String strDate = ldt.format(dtf); // 从LocalDateTime转换成时间字符串
		System.out.println(strDate);
		LocalDateTime newLdt = ldt.parse(strDate, dtf); // 从字符串转换到LocalDateTime
		System.out.println(newLdt);
	}
	// 4. TemporalAdjuster : 时间校正器
	@Test
	public void test5() {
		LocalDateTime ldt = LocalDateTime.now();
		System.out.println(ldt);
		LocalDateTime ldt2 = ldt.withDayOfMonth(10); // 指定为某月的第几天
		System.out.println(ldt2);
		LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.SUNDAY)); // 通过时间矫正器,指定周的某日
		System.out.println(ldt3);
		// 自定义：下一个工作日
		LocalDateTime ldt5 = ldt.with((l) -> {
			LocalDateTime ldt4 = (LocalDateTime) l;
			DayOfWeek dow = ldt4.getDayOfWeek(); //获取周几
			if (dow.equals(DayOfWeek.FRIDAY)) {
				return ldt4.plusDays(3);  // 加上三天
			} else if (dow.equals(DayOfWeek.SATURDAY)) {
				return ldt4.plusDays(2); // 加上两天
			} else {
				return ldt4.plusDays(1);
			}
		});
		System.out.println(ldt5);
	}
	// 3.
	// Duration : 用于计算两个“时间”间隔
	// Period : 用于计算两个“日期”间隔
	@Test
	public void test4() {
		LocalDate ld1 = LocalDate.of(2015, 1, 1);
		LocalDate ld2 = LocalDate.now();
		Period pre = Period.between(ld1, ld2);
		System.out.println(pre.getYears());
		System.out.println(pre.getMonths());
		System.out.println(pre.getDays());
	}
	@Test
	public void test3() {
		Instant ins1 = Instant.now();
		System.out.println("--------------------");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
		}
		Instant ins2 = Instant.now();
		Duration duration = Duration.between(ins1, ins2);
		System.out.println("所耗费时间为：" + duration); // 获取时间间隔
		System.out.println(duration.toMillis()); // 获取毫秒
		System.out.println("----------------------------------");
		LocalTime ld1 = LocalTime.now();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		LocalTime ld2 = LocalTime.now();
		Duration dur = Duration.between(ins1, ins2); // 两个时间之间间隔
		System.out.println("所耗费时间为：" + dur);
		System.out.println(dur.toMillis());
	}
	// 2. Instant : 时间戳。 （使用 Unix 元年 1970年1月1日 00:00:00 所经历的毫秒值）
	@Test
	public void test2() {
		Instant ins = Instant.now(); // 默认使用 UTC 时区
		System.out.println(ins);
		System.out.println(ins.toEpochMilli()); // 转化为毫秒时间
		OffsetDateTime odt = ins.atOffset(ZoneOffset.ofHours(8)); // 获取标准的时间(北京时间)
		System.out.println(odt);
		System.out.println(ins.getNano());
		Instant ins2 = Instant.ofEpochSecond(60); // 相较于unix元年加上一分钟的时间
		System.out.println(ins2);
	}
	// 1. LocalDate 日期、LocalTime 时间、LocalDateTime 时间日期
	@Test
	public void test1() {
		LocalDateTime ldt = LocalDateTime.now(); // 获取当期时间
		System.out.println(ldt);
		LocalDateTime ld2 = LocalDateTime.of(2016, 11, 21, 10, 10, 10); // 获取指定时间
		System.out.println(ld2);
		LocalDateTime ldt3 = ld2.plusYears(20); // 加20年
		System.out.println(ldt3);
		LocalDateTime ldt4 = ld2.minusMonths(2); // 减20分钟
		System.out.println(ldt4);
		System.out.println(ldt.getYear());
		System.out.println(ldt.getMonthValue());
		System.out.println(ldt.getDayOfMonth());
		System.out.println(ldt.getHour());
		System.out.println(ldt.getMinute());
		System.out.println(ldt.getSecond());
	}
}

17.重复注解与类型注解:

package com.atguigu.com;

import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.ElementType.TYPE_PARAMETER;

import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//加上@Repeatable(MyAnnotations.class)之后可以使用重复注解
@Repeatable(MyAnnotations.class)
//加上LOCAL_VARIABLE之后可以public void show1(@MyAnnotation("abc") String str),定义类型注解
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, TYPE_PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
	String value() default "atguigu";
}
----------------------------------------------------------------------------------
package com.atguigu.com;

import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotations {
	MyAnnotation[] value();
}
----------------------------------------------------------------------------------
package com.atguigu.com;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import org.junit.Test;
public class TestAnnotation {
	//checker framework
//	private @NotNull Object Object = null;  //@NotNull java8现在不支持
	@Test
	public void test1() throws Exception{
		Class<TestAnnotation> clazz = TestAnnotation.class;
		Method show = clazz.getMethod("show");
		MyAnnotation[] mas = show.getAnnotationsByType(MyAnnotation.class); //通过反射获取注解
		for(MyAnnotation declaredAnnotations1: mas){
			System.out.println(declaredAnnotations1.value());
		}
	}
	@MyAnnotation("hello")
	@MyAnnotation("world")
	public void show(){
	}
	public void show1(@MyAnnotation("abc") String str){
	}
}