java8新特性

1.HashMap和HashSet

如果说当某一个链表的大小大于8，总容量大于64，那么就会把链表转换成红黑树结构（二叉树的一种），除了添加以外其他的效率都比链表快，所以现在的结构是数组加链表加红黑树

2.ConcurrentHashMap<K,V>

使用大量的cas算法，且取消原来的16段机制，采用了链表和红黑树

3.方法区

原来称为非堆（但是占用jvm空间），现在直接分离出来了叫做元空间，直接占用物理内存。

4.lambda表达式

函数式接口：只包含一个抽象方法的接口，称为函数式接口，使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口。

适用前提条件：必须是一个函数式接口

定义：lambda表达式表示的是一个匿名的函数，Lambda 操作符“->”左侧：指定了Lambda 表达式需要的所有参数，右侧：指定了Lambda 体（匿名函数方法的方法体），即Lambda 表达式要执行的功能。

左侧：在无参的条件下（），有参只有一个参数的前提下可以写成（x），当然也可以去掉（）写成x，多个参数的情况下都需要带（）

右侧：无返回值只用一条语句可以不带{}，多条语句需要带{}，有返回值只有一条语句无{}情况下无需写return，多条或者有{}时需要写rreturn

原因：在加载编译的时候会自判断后编译成class字节码文件，在效率上在以前的基础上并没有提升，只是书写较为方便

public class LambdaTest1 {
	 public  static  void testA(LambdaTest1A la){
		 la.testA();
	 }
     public static void main(String[] args) {
    	 testA(()->System.out.println("hello testA"));
    	 ArrayList<Integer> list = new  ArrayList<>();
    	 list.add(321);
    	 list.add(123);
    	 list.add(342);
    	 list.add(112);
    	 //Collections.sort(list,(x,y)->x-y);从小到大
    	 Collections.sort(list,(x,y)->y-x);//从大到小
    	 System.out.println(list);
	}
}
interface   LambdaTest1A{
	   void  testA();
}

//策略设计模式
public class LambdaTest2 {
	public static List<LambdaTest2Person> test(List<LambdaTest2Person> list, Predicate<LambdaTest2Person> t) {
		ArrayList<LambdaTest2Person> list2 = new ArrayList<>();
		for (LambdaTest2Person lambdaTest2Person : list) {
			if (t.test(lambdaTest2Person)) {
				list2.add(lambdaTest2Person);
			}
		}
		return list2;
	}

	public static void main(String[] args) {
		ArrayList<LambdaTest2Person> list = new ArrayList<>();
		list.add(new LambdaTest2Person("张三", 24, 3333));
		list.add(new LambdaTest2Person("李四", 34, 8888));
		list.add(new LambdaTest2Person("王五", 15, 5555));
		list.add(new LambdaTest2Person("赵六", 34, 6666));
		//List<LambdaTest2Person> test = test(list, (x) -> x.getAge() > 30);
		//System.out.println(test);// 年龄大于35岁的
		Collections.sort(list, (x, y) -> {
			if (x.getAge() == y.getAge()) {
				return x.getSalary() - y.getSalary();
			}
			return x.getAge() - y.getAge();
		});// 先按年龄从小到大排列，年龄相同那么按工资从小到大排列
		for (LambdaTest2Person lambdaTest2Person : list) {
			System.out.println(lambdaTest2Person);
		}

	}
}

class LambdaTest2Person {
	private String name;
	private int age;
	private int salary;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getSalary() {
		return salary;
	}

	public void setSalary(int salary) {
		this.salary = salary;
	}

	public LambdaTest2Person(String name, int age, int salary) {
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	public LambdaTest2Person() {
	}

	@Override
	public String toString() {
		return "LambdaTest2Person [name=" + name + ", age=" + age + ", salary=" + salary + "]";
	}

}

 4.java8内置的函数式接口

Consumer<T>   void accept(T t)

Supplier<T>    T get()

Function<T, R>  R apply(T t)

Predicate<T>  boolean test(T t);

BiFunction<T,U,R>  R apply(T t,U u)

UnaryOperator<T>  T apply(T t)

BinaryOperator<T>  T apply(T t1,T t2)

BiConsumer<T,U>   void accept(T t,U u)

ToIntFunction<T>   参数T  返回值 int

IntFunction<R>  参数int  返回R

public class LambdaTest3 {
     public static void main(String[] args) {
    	 Consumer<String>   cm=(x)->System.out.println(x);
    	 cm.accept("consumer");
    	 Supplier<String>   sp=()->"Supplier";
    	 System.out.println(sp.get());
    	 Function<String, Integer>  fu= x-> Integer.valueOf(x);
    	 System.out.println(fu.apply("12"));
    	 Predicate<Integer> pr=(x)-> x>0;
    	 System.out.println(pr.test(5));
    	 BiFunction<Integer,Integer, Integer>  bi=(x,y)->x+y;
    	 System.out.println(bi.apply(2, 3));
	}
}

 5.方法引用与构造器引用及数组引用

方法引用

对象::实例方法    ；     类::静态方法       ；类::实例方法      ；    构造器引用    ；    类名 :: new   ；    数组引用     ；    类型[] :: new

public class LambdaTest4 {
     public static void main(String[] args) {
    	 //自我推测是建立在编译的前提下的，编译时一行一行的，例如如下
    	 String [] str={"a","b"};//成立
    	 //str={"a","b"};//编译不通过
    	 //编译时能自我推测  对象::实例方法
    	 Consumer<String>   cm=System.out::println;
    	 cm.accept("Consumer");
    	 //类::静态方法,编译时一行一行的
    	 BiFunction<Integer,Integer, Integer>  bi=Integer::compare;
    	 System.out.println(bi.apply(1, 2));
    	 //类名实例方法
    	 Function<LambdaTest2Person, Integer> fu=LambdaTest2Person::getAge;
    	 System.out.println(fu.apply(new LambdaTest2Person("张三", 23, 3333)));
    	 //类名::new   
    	 Supplier<LambdaTest2Person>  person=LambdaTest2Person::new;
    	 //无参构造
    	 LambdaTest2Person lambdaTest2Person = person.get();
    	 System.out.println(lambdaTest2Person);
    	 //类型[] :: new 
    	 Function<Integer, LambdaTest2Person[]> fun2 = LambdaTest2Person[] :: new;
    	 LambdaTest2Person[] emps = fun2.apply(20);
 		 System.out.println(emps.length);
	}
}

 6.stream流

定义：数据渠道，用于操作数据源（集合、数组等）所生成的元素序列

特点：Stream 自己不会存储元素。

Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

也就是说需要结束以后才有结果

public class StreamTest2 {
  public static void main(String[] args) {
	//获取流的方式1
	 ArrayList<String> list = new ArrayList<>();
	 Stream<String> stream = list.stream();
		// 获取流的方式2
		String[] strs = new String[10];
		Stream<String> stream2 = Arrays.stream(strs);
		// 获取流的方式3
		Stream<String> of = Stream.of("a", "b");
		// 创建无线流
		// 迭代   static <T> UnaryOperator<T> identity() {return t -> t;}，0表示起始值
		Stream<Integer> iterate = Stream.iterate(0, (x) -> x - 2);
		iterate.limit(10).forEach(System.out::println);
		System.out.println("-----------------");
		// 创建无限流
		// 生成  
		//T get();
		Stream<Double> generate = Stream.generate(() -> Math.random());
		generate.limit(10).forEach(System.out::println);
	}
}

public class StreamTest1 {
  public static void main(String[] args) {
	  ArrayList<LambdaTest2Person> list = new ArrayList<>();
		list.add(new LambdaTest2Person("张三", 24, 3333));
		list.add(new LambdaTest2Person("李四", 34, 8888));
		list.add(new LambdaTest2Person("王五", 15, 5555));
		list.add(new LambdaTest2Person("赵六", 34, 6666));
		Stream<LambdaTest2Person> stream = list.stream();
		Stream<LambdaTest2Person> stream1 = list.stream();
		Stream<LambdaTest2Person> stream2 = list.stream();
		Stream<LambdaTest2Person> stream3 = list.stream();
		// filter--  boolean test(T t);
		stream.filter((x)->x.getAge()>25).forEach(System.out::println);
		System.out.println("-----------------------");
		/*
		 * LambdaTest2Person [name=李四, age=34, salary=8888]
		 * LambdaTest2Person [name=赵六, age=34, salary=6666]
		 */
		//limit 显示的个数
		stream1.filter((x)->x.getAge()>25).limit(1).forEach(System.out::println);
		//LambdaTest2Person [name=李四, age=34, salary=8888]
		System.out.println("-----------------------");
		//skip跳过几个
		stream2.filter((x)->x.getAge()>25).skip(1).forEach(System.out::println);
		//LambdaTest2Person [name=赵六, age=34, salary=6666]
		System.out.println("-----------------------");
		//distinct()根据hashcode去重,需要重写hashcode，这里就根据相同年龄去重
		stream3.filter((x)->x.getAge()>25).distinct().forEach(System.out::println);
		//LambdaTest2Person [name=李四, age=34, salary=8888]
  }
}

class LambdaTest2Person {
	private String name;
	private int age;
	private int salary;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getSalary() {
		return salary;
	}

	public void setSalary(int salary) {
		this.salary = salary;
	}

	public LambdaTest2Person(String name, int age, int salary) {
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	public LambdaTest2Person() {
	}

	@Override
	public String toString() {
		return "LambdaTest2Person [name=" + name + ", age=" + age + ", salary=" + salary + "]";
	}
　　　　　//hashcode根据年龄去重
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		LambdaTest2Person other = (LambdaTest2Person) obj;
		if (age != other.age)
			return false;
		return true;
	}
}

public class StreamTest2 {
	public static   Stream<Character> toUpper(String str){
		ArrayList<Character> list = new  ArrayList<>();
		for (Character character : str.toUpperCase().toCharArray()) {
			list.add(character);
		}
		return  list.stream();
	}
	public static void main(String[] args) {
		System.out.println("----------");
		ArrayList<LambdaTest2Person> list = new ArrayList<>();
		list.add(new LambdaTest2Person("张三", 24, 3333));
		list.add(new LambdaTest2Person("李四", 34, 8888));
		list.add(new LambdaTest2Person("王五", 15, 5555));
		list.add(new LambdaTest2Person("赵六", 34, 6666));
		// map逐个遍历映射 获取名字 张三 李四 王五 赵六
		List<String> collect2 = list.stream().map((x) -> x.getName()).collect(Collectors.toList());
		collect2.stream().forEach(System.out::println);
		System.out.println("----------");
		//flatMap与map的区别
		//首先是map 返回的是     Stream<Stream<Character>>        
		Stream<Stream<Character>> map = Stream.of("aa","bb").map(StreamTest2::toUpper);
		//然后是flatMap Stream<Character>
		Stream<Character> flatMap = Stream.of("aa","bb").flatMap(StreamTest2::toUpper);
		// sort排序  按年龄排序  王五 张三 李四 赵六
		System.out.println("----------");
		list.stream().sorted((x, y) -> x.getAge() - y.getAge()).map((x) -> x.getName()).collect(Collectors.toList())
				.forEach(System.out::println);
		//count  统计 2 2 
		Long collect =  Stream.of(1, 2, 3, 4, 5).filter((x) -> x > 3).map((x) -> 1).collect(Collectors.counting());
		long count = Stream.of(1, 2, 3, 4, 5).filter((x) -> x > 3).map((x) -> 1).count();
		System.out.println(collect);
		System.out.println(count);
		System.out.println("----------");
		//allMatch  是否所有的都匹配  false  
		boolean allMatch = list.stream().allMatch((x)-> "张三".equals (x.getName()));
		System.out.println(allMatch);
		//anyMatch  是否一个匹配 true
		boolean anyMatch = list.stream().anyMatch((x)-> "张三".equals (x.getName()));
		System.out.println(anyMatch);
		//noneMatch  没有匹配  false
		boolean noneMatch = list.stream().noneMatch((x)-> "张三".equals (x.getName()));
		System.out.println(noneMatch);
		System.out.println("----------");
		//findFirst()  返回第一个元素  张三
		String string = list.stream().map((x)->x.getName()).findFirst().get();
		System.out.println(string);
		//findAny()  返回年龄为34的其中的任何一个人 
		LambdaTest2Person lambdaTest2Person = list.stream().filter((x)->x.getAge()==34).findAny().get();
		System.out.println(lambdaTest2Person);
		//返回最大值（也有可能是最小值） 这个是根据排序来的
		Integer integer = Stream.of(1,3,2,4,10,3,2).max((x,y)->x-y).get();
		System.out.println(integer);
		//返回最小值（也有可能是最大值） 这个是根据排序来的
		Integer integer1 = Stream.of(1,3,2,4,10,3,2).max(Integer::compare).get();
		System.out.println(integer1);
		System.out.println("----------");
		//reduce   根据所写的逐个计算，下面是求和  21  31
		Integer integer2 = Stream.of(1,2,3,4,5,6).reduce((x,y)->x+y).get();
		System.out.println(integer2);
		//10表示起始值
		Integer integer3 = Stream.of(1,2,3,4,5,6).reduce(10,(x,y)->x+y);
		System.out.println(integer3);
	}
}

public class StreamTest4 {
	public static void main(String[] args) {
		// collect(Collector c) 这个可以求和，平均值，求最大值，分组，保存到集合等
		// 求平均值
		Double collect = Stream.of(1, 3, 2, 4, 6).filter((x) -> x > 3).collect(Collectors.averagingInt((x) -> x));
		System.out.println(collect);
		System.out.println("----------");
		// 去重1 2 3 4 6
		Stream.of(1, 3, 2, 4, 6, 6, 6, 4).collect(Collectors.toSet()).forEach(System.out::println);
		;
		System.out.println("----------");
		// 先去重后分组 {大于3=[4, 6], 小于3=[1, 2, 3]}
		Map<String, List<Integer>> collect2 = Stream.of(1, 3, 2, 4, 6, 6, 6, 4).collect(Collectors.toSet()).stream()
				.collect(Collectors.groupingBy((x) -> {
					if (x > 3) {
						return "大于3";
					} else {
						return "小于3";
					}
				}));
		System.out.println(collect2);
		// 多级分组
		ArrayList<LambdaTest2Person> list = new ArrayList<>();
		list.add(new LambdaTest2Person("张三", 24, 3333));
		list.add(new LambdaTest2Person("李四", 34, 8888));
		list.add(new LambdaTest2Person("王五", 15, 5555));
		list.add(new LambdaTest2Person("赵六", 34, 6666));
		Map<String, Map<String, List<LambdaTest2Person>>> collect3 = list.stream().collect(Collectors.groupingBy((x) -> {
			if (x.getAge() > 25) {
				return "大于25";
			} else {
				return "小于25";
			}
		}, Collectors.groupingBy((x) -> {
			if (x.getSalary() > 4000) {
				return "大于4000";
			}else {
				return "小于4000";
			}
		})));
		//{大于25={大于4000=[LambdaTest2Person [name=李四, age=34, salary=8888], LambdaTest2Person [name=赵六, age=34, salary=6666]]}, 
　　　　　　　　　　//小于25={大于4000=[LambdaTest2Person [name=王五, age=15, salary=5555]], 小于4000=[LambdaTest2Person [name=张三, age=24, salary=3333]]}}
		System.out.println(collect3);
	}
}

7.java8的局部内部类的变更

   public static void main(String[] args) {
	   //当局部内部类使用外部的变量是会自动的添加final，在jdk1.7之前需要手动的添加
	   	  int  i=3;//在jdk1.7之前 这个前面需要添加 final ，但在jdk1.8后会自己添加
//	   	  i=5//编译错误
		  class LocalInnerTest{
			  public void test(){
				  System.out.println(i);
			  }
		  }
  }

 8.fork/join框架

 fork/join，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行join 汇总.

 工作窃取模式，充分利用多核线程；

 工作窃取：当一个线程执行完了，别的没有执行完，那么该线程会随机的去别的线程的末尾进行窃取工作任务，前提是多核cpu

//jdk1.7之前的算法   传统的算法
public class ForkJoinCalculate extends RecursiveTask<Long> {
	public static void main(String[] args) {
		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));
	}

	private static final long serialVersionUID = 13475679780L;

	private long start;
	private long end;

	private static final long THRESHOLD = 100000L; // 临界值

	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();
		}

	}

}

public class NewForkJoin {
	@Test
	//顺序流，单线程的
	//parallel() 与sequential() 在并行流与顺序流之间进行切换。
    public  void  serialStream(){
    	long asLong = LongStream.rangeClosed(0, 10000000L).reduce(Long::sum).getAsLong();
    	long sum = LongStream.rangeClosed(0, 10000000L).sum();
    	System.out.println(asLong);
    	System.out.println(sum);
    }
	@Test
	//并行流  多线程的
	public  void  parallelStream1(){
		long sum = LongStream.rangeClosed(0, 10000000L).parallel().sum();
    	System.out.println(sum);
    }
}

 9.optional

目的：尽量的减少空指针异常，属于一个容器类，表示一个值存在或者不存在

public class OptionalTest {
	
    public static void main(String[] args) {    	
		//Optional<String> of = Optional.of(null);// 创建一个 Optional 实例,也会报异常，指定在这一行
		Optional<Object> empty = Optional.empty();//创建一个空的 Optional 实例
		System.out.println(empty.toString());//Optional.empty
		Optional<Object> ofNullable = Optional.ofNullable(null);//若 t 不为 null,创建 Optional 实例,否则创建空实例
		Object orElse = Optional.ofNullable(null).orElse("大帅哥");//如果调用对象包含值，返回该值，否则返回t
		System.out.println(orElse);//大帅哥
		boolean present = Optional.ofNullable(null).isPresent();// 判断是否包含值
		System.out.println(present);//false
		Object orElseGet = Optional.ofNullable(null).orElseGet(()->"大帅哥");//orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
		System.out.println(orElseGet);//大帅哥
		//map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
		//flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
	}
}

10.接口中的新定义

类优先，接口中都实现，那么就按需加载（需要时指定），在Java 8中，在接口中添加静态方法带来了一个限制 ：这些方法不能由实现它的类继承。

public class InterfaceTest extends InterfaceTestC implements InterfaceTestA,InterfaceTestB{
	public static void main(String[] args) {
            InterfaceTest interfaceTest = new InterfaceTest();
            interfaceTest.testA();//InterfaceTestC:testA优先使用类中的方法
            interfaceTest.testB();//InterfaceTestB---Override--testB,优先使用类中的方法
            
	}

	@Override
	public void testB() {
		System.out.println("InterfaceTestB---Override--testB");
	}

	@Override
	public void testC() {
		InterfaceTestA.super.testC();//多个需要重写一个使用的方法，静态方法需要用接口名调用
	}

}

interface InterfaceTestA {
	static void testA() {// 没有默认会添加public，只能是public的
		System.out.println("InterfaceTestA:testA");
	}

	default void testB() {/// 没有默认会添加public，只能是public的
		System.out.println("InterfaceTestA:testB");
	}
	default void testC() {// 没有默认会添加public，只能是public的
		System.out.println("InterfaceTestA:testC");
	}
}

interface InterfaceTestB {
	void testB();// 默认添加public abstract
	default void testC() {// 没有默认会添加public，只能是public的
		System.out.println("InterfaceTestB:testC");
	}
}

class InterfaceTestC {
	void testA() {// 没有默认会添加public，只能是public的
		System.out.println("InterfaceTestC:testA");
	}
}

11.重复注解

java8后可以重复注解@Repeatable

public class AnnotationTest {

	@MyAnnotation("a") // @Repeatable没有这个之前，不能按如下这么写
	@MyAnnotation("b")
	public void test() {

	}

	public static void main(String[] args) throws NoSuchMethodException, SecurityException {// 获取方法上的注解
		Class<? extends AnnotationTest> class1 = new AnnotationTest().getClass();
		Method method = class1.getMethod("test");
		// MyAnnotation annotation =
		// method.getAnnotation(MyAnnotation.class);//只有一次注解的时候能这么做，重复注解的则不行null
		MyAnnotation[] annotationsByType = method.getAnnotationsByType(MyAnnotation.class);// 重复注解可以这样
		for (MyAnnotation myAnnotation : annotationsByType) {
			System.out.println(myAnnotation.value());
		}
	}
}

@Repeatable(MyAnnotations.class)//添加该注解，需要一个该注解的容器，例如@interface MyAnnotations  MyAnnotation[] value();
@Target({ ElementType.METHOD, ElementType.TYPE, ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
	String value() default "adu";
}

@Target({ ElementType.METHOD, ElementType.TYPE, ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotations {
	MyAnnotation[] value();
}

 12.新时间api

java8的时间api先线程安全的，而以前的是线程不安全的

//存在线程安全问题，java.util.concurrent.ExecutionException异常偶尔会出现；
public class OldTimeTest {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		SimpleDateFormat sdf = new SimpleDateFormat();
		sdf.applyPattern("yyyy-MM-dd");
		FutureTask<Date> futureTask = new FutureTask<>(() -> {
			return sdf.parse("2018-5-5");
		});
		ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(10);
		Future<?> submit2 = newFixedThreadPool.submit(futureTask);
		System.out.println(submit2.get());// null

		Callable<Date> task = new Callable<Date>() {
			@Override
			public Date call() throws Exception {
				return sdf.parse("2018-5-5");
			}
		};
		List<Future<Date>> list = new ArrayList<>();
		for (int i = 0; i < 9; i++) {
			list.add(newFixedThreadPool.submit(task));
		}
		newFixedThreadPool.shutdown();
		for (Future<Date> future : list) {
			System.out.println(future.get());// callable的不为空
		}
	}
}

 old的解决方法

public class ThreadLocalTest {
	private static  ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>() {
		@Override
		protected DateFormat initialValue() {
			return new SimpleDateFormat("yyyy-MM-dd");//每次都产生一个新的DateFormat解决线程安全问题
		}

	};
	/**
	 * format：yyyy-MM-dd
	 * 
	 * @param str
	 * @throws ParseException
	 * @return
	 */
	public  static Date  getDate(String str) throws ParseException{
		return threadLocal.get().parse(str);
	}
}

public class OldTimeTest {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(10);
		Callable<Date> task = new Callable<Date>() {
			@Override
			public Date call() throws Exception {
				return ThreadLocalTest.getDate("2018-5-5");
			}
		};
		List<Future<Date>> list = new ArrayList<>();
		for (int i = 0; i < 10; i++) {
			list.add(newFixedThreadPool.submit(task));
		}
		newFixedThreadPool.shutdown();
		for (Future<Date> future : list) {
			System.out.println(future.get());
		}
	}
}

 新的时间api  使用ISO-8601标准

//DateTimeFormatter    LocalDate
public class NewLocalDateTime {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
    	DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    	ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(10);
		Callable<LocalDate> task = new Callable<LocalDate>() {
			@Override
			public LocalDate call() throws Exception {
				return LocalDate.parse("2018-05-05", df);//格式需要完全一致"2018-5-5"就不行
			}
		};
		List<Future<LocalDate>> list = new ArrayList<>();
		for (int i = 0; i < 10; i++) {
			list.add(newFixedThreadPool.submit(task)) ;
		}
		for (Future<LocalDate> future : list) {
			System.out.println(future.get());
		}
		newFixedThreadPool.shutdown();
	}
}

//DateTimeFormatter    LocalDate
        public void main(String[] args) throws InterruptedException, ExecutionException {
            Instant now = Instant.now();//默认使用 UTC 时区  +8h
            System.out.println(now);//2018-08-05T07:23:22.110Z
            OffsetDateTime atOffset = now.atOffset(ZoneOffset.ofHours(8));
            long l = atOffset.toInstant().toEpochMilli();
            System.out.println(atOffset);//2018-08-05T15:23:22.110+08:00
            long epochMilli = now.toEpochMilli();
            System.out.println(epochMilli);// System.currentTimeMillis()  new Date().getTime()
            System.out.println("----------------");
            LocalDateTime localDateTime=LocalDateTime.now();//获取本地时间
            DateTimeFormatter df=DateTimeFormatter.ofPattern("yyyy年MM月dd天hh时mm分ss秒");
            String format = localDateTime.format(df);//
            System.out.println(format);
            System.out.println("----------------");
            LocalDateTime parse = LocalDateTime.parse("2006年5月6日", df);
            Instant oldTime = Instant.now();
            Thread.sleep(1000);
            Instant newTime = Instant.now();
            Duration between = Duration.between(oldTime, newTime);
            System.out.println(between.getSeconds());//1s
            //Period.between(ld2, ld1);  年月天 时间差
            //ZonedDate、ZonedTime、ZonedDateTime ： 带时区的时间或日期
            //LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
    }