jdk新特性
1.1 lambda表达式
一、处理匿名内部类
1、Runnable接口
1 new Thread(new Runnable() {
2 public void run() {
3 System.out.println("hello world!!!");
4 }
5 }).start();
6
7 // lambda
8 new Thread(()->System.out.println("hello lambda!!!")).start();
说明：
- 上边的方式是原本匿名内部类方式
- 下边的方法是lambda表达式方式
lambda基本语法：(形参列表)->{方法体}
注意：
- 形参列表：(String x, String y)这样的基本形式
- 如果没有形参，使用"()"，如上
- 如果参数类型可以被推断出来，使用(x,y)
- 如果是单个参数且类型可以被推断出来，直接使用x
- 方法体：如果只有一句话，可以去掉"{}"，如上
2、Comparator接口
1 List<String> strList = Arrays.asList("zhaojigang","nana","tianya");
2 //原来的方式
3 Collections.sort(strList, new Comparator<String>() {
4 @Override
5 public int compare(String s1, String s2) {
6 return s1.compareTo(s2);
7 }
8 });
9
10 //lambda
11 Collections.sort(strList, (s1, s2)->s1.compareTo(s2));
说明：这里的s1和s2就被根据comparator的泛型和strList的泛型推断出了类型为String，可以省略参数类型。
二、方法引用
1 //lambda 2 Collections.sort(strList, (s1, s2)->s1.compareTo(s2)); 3 //方法引用 4 Collections.sort(strList, String::compareTo); 5 //lambda 6 strList.forEach(x->System.out.println(x)); 7 //方法引用 8 strList.forEach(System.out::println);
说明：
- 前两个语句效果一样，后两个效果一样，自己比对方法引用与lambda的哪些部分等价
- 集合类的foreach方法就是增强型for循环的再增强。
注意：
- 方法引用的语法
- 对象::实例方法=>等价于"提供方法参数的lambda表达式"
- 类::静态方法=>等价于"提供方法参数的lambda表达式"
- eg. System.out::println等价于x->System.out.println(x)
- 类::实例方法=>第一个参数是执行方法的对象
- eg. String::compareTo等价于(s1, s2)->s1.compareTo(s2)
三、局部变量
lambda操作的局部变量必须是final型的，即：在lambda表达式所使用到的局部变量（方法体内的变量或形参）只能被读取，不能被改变。
注意：列出这条约束的原因是防止线程不安全，可能会有疑问，局部变量是方法私有的，怎么会有线程安全问题？
解释：假设我在该方法体内，启动了一个线程并使用lambda表达式去操作一个局部变量count（注意该变量并没有在lambda中进行声明，但是lambda却可以用，这就是"闭包"），而在该线程外且在该方法体内，该方法也操作了count，这时可能就会有线程安全问题了。
四、接口的改变
java的接口也可以写实现default级别的实例方法和静态方法了。
1 public interface LambdaInterface {
2 //default方法
3 default void defaultMethod(){
4 System.out.println("xxxx");
5 }
6 //static方法
7 static void staticMethod(){
8 System.out.println("xxxx");
9 }
10 }
1 public class TestInterface implements LambdaInterface{
2 public static void main(String[] args) {
3 LambdaInterface test = new TestInterface();
4 test.defaultMethod();//default方法测试
5
6 LambdaInterface.staticMethod();//static方法测试
7 }
8 }
用途：当改造老的项目时，想在旧的接口中添加一些方法，但是又不想让该接口的旧的实现类去实现这些方法时，可以使用这个技巧。
1.2 Stream API
引例：
1 List<String> strList = Arrays.asList("zhaojigang","nana","tianya","nana");
2 Stream<String> streamList = strList.stream();//集合转为stream
3 strList = streamList.distinct().filter(str->!str.equals("tianya")).sorted(String::compareTo).collect(Collectors.toList());
4 strList.forEach(System.out::println);
说明：
- 第一行：创建数组并转为List
- 第二行：根据List创建stream
- 第三行：对该stream进行去重-->选择-->排序-->stream转为List
- 第四行：遍历该List
以上代码显示了stream API的方便。当然，上边的代码可以更为简洁，如下改为一行：
Arrays.asList("zhaojigang","nana","tianya","nana").stream().distinct().filter(str->!str.equals("tianya")).sorted(String::compareTo).collect(Collectors.toList()).forEach(System.out::println);
以上代码有一个易错点：filter是选择而不是过滤，即filter是选择满足条件的元素。
一、创建Stream
三种常用API：
- 集合-->Stream：stream()
- 数组-->Stream：Stream.of(T t)或者Arrays.stream(T[] t)
- 任意元素-->Stream：Stream.of(T... values)
1 List<String> strList = Arrays.asList("zhaojigang","nana","tianya","nana");
2 Stream<String> streamList = strList.stream();//集合转为stream
3
4 String[] strArray = {"java","c++","c"};
5 Stream<String> streamArray = Stream.of(strArray);//数组转为Stream
6 Stream<String> streamArray2 = Arrays.stream(strArray);//数组转为Stream
7
8 Stream<String> streamPartArray = Arrays.stream(strArray, 0, 2);//转换部分数组，范围：[0,2)
9
10 Stream<String> streamSelf = Stream.of("python","basic","php");//任意元素
还有一种：用于产生无限流的，Stream.generate(Supplier<T> s)。
二、Stream 2 array/collection/String/map
1、stream2array
1 Stream<String> strStream = Stream.of("java","c++","c","python");
2 Object[] objectArray = strStream.toArray();//只能返回Object[]
3 String[] strArray = strStream.toArray(String[]::new);//构造器引用（类似于方法引用）,可以返回String[]
说明：
通过构造器引用（类似于方法引用），可以构造出具体类型的数组。
2、stream2collection
1 List<String> strList = strStream.collect(Collectors.toList());//返回List 2 Set<String> strSet = strStream.collect(Collectors.toSet());//返回set 3 ArrayList<String> strArrayList = strStream.collect(Collectors.toCollection(ArrayList::new));//收集到指定的List集合，例如收集到ArrayList
说明：
通过构造器引用，可以构造出具体类型的集合。
3、将stream中的元素拼接起来（joining()、joining(",")）
1 Stream<String> strStream = Stream.of("java","c++","c","python");
2 String str = strStream.collect(Collectors.joining());//将所有字符串拼接起来，结果：javac++cpython
3 System.out.println(str);
4
5 String str2 = strStream.collect(Collectors.joining(","));//将所有字符串拼接起来，中间用","隔开，结果：java,c++,c,python
6 System.out.println(str2);
4、stream2map(toMap、toConcurrentMap)
1 Stream<String> strStream = Stream.of("java","c++","c","python");
2 Map<String, Integer> map1 = strStream.collect(Collectors.toMap(Function.identity(), (x)->0));
3 //Function.identity()-->返回strStream中的元素，toMap方法的我两个参数都是Function接口型的，所以第二个参数即使只放0，也不能直接写作0，可以使用如上的方式进行操作
4
5 for(String key : map1.keySet()){
6 System.out.println("key:"+key+"->"+"value:"+map1.get(key));
7 }
8 //结果
9 /*
10 key:python->value:0
11 key:c++->value:0
12 key:c->value:0
13 key:java->value:0
14 */
说明：
- toMap-->stream转为map
- Function.identity()-->返回stream中的元素
如果key重复的话，这时就会出现问题"duplicate key"，采用如下方式解决（增加第三个参数）：
1 Stream<String> strStream = Stream.of("java","c++","c","python","java");
2 Map<String, Integer> map1 = strStream.collect(Collectors.toMap(Function.identity(), //key
3 (x)->0, //value
4 (existingValue, newValue) -> existingValue));//如果key重复，取旧值
需要指定返回map的具体类型（增加第四个参数）。
1 Map<String, Integer> map1 = strStream.collect(Collectors.toMap(Function.identity(), //key 2 (x)->0, //value 3 (existingValue, newValue) -> existingValue,//如果key重复，取旧值 4 TreeMap::new));//返回TreeMap
注意：每一个toMap就会对应一个相应的toConcurrentMap
5、groupingBy partitioningBy
1 /***************************groupingBy partitioningBy**************************/
2 Stream<Locale> localeStream = Stream.of(Locale.getAvailableLocales());
3 Map<String, List<Locale>> country2localeList = localeStream.collect(Collectors.groupingBy(Locale::getCountry));//根据国家分组，groupBy的参数是分类器
4 List<Locale> locales = country2localeList.get("CH");
5
6 Map<String, Set<Locale>> country2localeSet = localeStream.collect(Collectors.groupingBy(Locale::getCountry, Collectors.toSet()));//根据国家分组，groupBy的参数是分类器，返回set
7 Set<Locale> localeSet = country2localeSet.get("CH");
8
9 Map<Boolean, List<Locale>> country2locales = localeStream.collect(Collectors.partitioningBy(locale->locale.getLanguage().equals("en")));//分成两组，一组为true（即语言是en的），一组为false（即语言不是en的）
10 List<Locale> trueLocale = country2locales.get(true);
三、filter(Predicate p)
注意：是选择而非过滤。
1 Stream<String> streamSelf = Stream.of("python","basic","php");
2 streamSelf.filter(str->str.startsWith("p")).forEach(System.out::println);
注意：
- stream也是可以foreach的，没必要一定要转化成集合再foreach
更好的写法可能是下边这种：
1 Predicate<String> startCondition = str->str.startsWith("p");
2 streamSelf.filter(startCondition).forEach(System.out::println);
说明：将条件（通常是lambda表达式）抽取出来。这种方式在多个条件的情况下比较清晰。
注意：函数式接口 = lambda表达式 （即lambda表达式只能返回为函数式接口）
1 Stream<String> s = Stream.of("java1","java3","java","php12");
2 Predicate<String> condition1 = str->str.length()==5;//条件1
3 Predicate<String> condition2 = str->str.startsWith("j");//条件2
4 s.filter(condition1.and(condition2)).forEach(System.out::println);//and条件
说明：
多条件运算：and or
四、map(Function mapper)
作用：对流中的每一个元素进行操作。
1 Stream<String> streamSelf = Stream.of("python","basic","php");
2 streamSelf.map(String::toUpperCase).forEach(System.out::println);
说明：将流内的每一个String全部转换为了大写。
五、reduce
作用：对stream中的每一个元素做聚合操作。
1 Stream<Integer> reduceStream = Stream.of(1,2,3,4,5); 2 Optional<Integer> sumOption = reduceStream.reduce((x,y)->x+y);//计算1+2+3+4+5，即对元素中的元素进行聚合计算，而map是对元素中的每一个元素分别计算（注意：如果stream为null的话，就会产生无效的结果，需要使用Optional接收） 3 //Optional<Integer> sumOption = reduceStream.reduce(Integer::sum);//计算1+2+3+4+5，即对元素中的元素进行聚合计算，而map是对元素中的每一个元素分别计算 4 5 Integer result = reduceStream.reduce(0, Integer::sum);//0为标识值，即计算：0+1+2+。。+5，如果整个stream为null，就返回标识值。 6 System.out.println(result);
注意：以上是reduce的简单形式，即内联函数是(T,T)->T，即返回值和参数类型是一样的，返回值和参数类型不同的场景需要自己编写函数（用的较少）
六、Optional
两种用法：
- ifPresent(xxx)：存在的就执行xxx，不存在就什么都不执行
- orElse(xxx)：存在就返回存在的值，不存在就返回xxx（可以理解为是默认值）
1 Stream<String> optionalStream = Stream.of("java","python","basic");
2 Optional<String> optionValue = optionalStream.filter(str->str.startsWith("p")).findFirst();
3 optionValue.ifPresent(str->System.out.println(str));//if optionalValue为true，即str存在，则输出str，当然也可以使用如下
4 String str = optionValue.orElse("xxx");//如果optionValue为false，即不存在以p开头的字符串时，使用"xxx"来替代
5 System.out.println(str);
七、limit skip contact
1、limit(long size)
作用：截取stream的前size个元素。
1 Stream<String> streamSelf = Stream.of("python","basic","php");
2 streamSelf.limit(2).forEach(System.out::println);//截取前两个
2、skip(long size)
作用：跳过stream的钱size个元素
1 Stream<String> streamSelf = Stream.of("python","basic","php");
2 streamSelf.skip(2).forEach(System.out::println);//跳过前两个
3、contact(Stream<T>,Stream<T>)
作用：拼接两个stream
1 Stream<String> streamSelf = Stream.of("python","basic","php");
2 Stream<String> streamSelf2 = Stream.of("python2","basic2","php2");
3 Stream.concat(streamSelf, streamSelf2).forEach(System.out::println);
八、聚合函数 count max min findFirst findAny anyMatch allMatch noneMatch
1 Stream<String> streamSelf = Stream.of("python","basic","php","b");
2 System.out.println(streamSelf.count());//计算流中的元素个数
3 Optional<String> largest = streamSelf.max(String::compareToIgnoreCase);//寻找最大值
4 if(largest.isPresent()){
5 System.out.println(largest.get());
6 }
说明：min函数也一样。
注意：Optional的使用，上边的是最差的一种形式，见"六"。
1 Optional<String> firstMatch = streamSelf.filter(str->str.startsWith("b")).findFirst();//寻找第一个符合条件的元素
2 firstMatch.ifPresent(System.out::println);//这是Optional的第一种用法
3
4 Optional<String> anyMatch = streamSelf.parallel().filter(str->str.startsWith("b")).findAny();//返回集合中符合条件的任意一个元素，对于并行处理非常好（因为多个线程只要有一个线程找到了，整个计算就会结束）
5 if(anyMatch.isPresent()){
6 System.out.println(anyMatch.get());//这里的结果可能是b,有可能是basic
7 }
8
9 boolean isAnyMatch = streamSelf.parallel().anyMatch(str->str.startsWith("c"));//集合中是否有一个满足条件
10 System.out.println(isAnyMatch);
11
12 Stream<String> streamSelf3 = Stream.of("basic","b");
13 boolean isAllMatch = streamSelf3.parallel().allMatch(str->str.startsWith("b"));//集合中是否所有元素都满足条件
14 System.out.println(isAllMatch);
15
16 boolean isAllNotMatch = streamSelf.parallel().noneMatch(str->str.startsWith("p"));//集合中是否没有一个元素满足条件
17 System.out.println(isAllNotMatch);
注意：
- optional的最佳用法：ifPresent()-->如果有就输出，如果没有，什么都不做
- parallel()：将stream转为并行流，并行流的使用一定要注意线程安全
九、原始类型流
- IntStream：int、short、char、byte、boolean
- LongStream：long
- DoubleStream：double、float
1.3 java8新特性总结
java8中重要的4个新特性：
- Lambda
- Stream
- Optional
- 日期时间API
- 接口方法（default和static方法，jdk9可定义private方法）
一、Lambda
1 import java.util.Comparator;
2 import java.util.function.Consumer;
3
4 /**
5 * @author zhaojigang
6 * @date 2018/5/19
7 */
8 public class LambdaTest {
9 /**
10 * Lambda 是一个匿名函数。
11 * 1、语法
12 * Lambda表达式引入了操作符为"->"，该操作符将Lambda分为两个部分：
13 * 左侧:指定了Lambda表达式需要的所有参数
14 * 右侧:指定了Lambda体，即Lambda表达式要执行的功能。
15 *
16 * 2、示例
17 */
18 public void testLambda() {
19 /**
20 * 语法格式一：无参，无返回值
21 */
22 Runnable task = () -> System.out.println("hello lambda");
23 /**
24 * 语法格式二：一个参数，无返回值
25 * 注意：参数类型可以通过
26 */
27 Consumer<String> consumer = str -> System.out.println(str);
28 /**
29 * 语法格式三：一个参数，有返回值
30 * 注意：当Lambda体只有一条语句时，省略大括号和return
31 */
32 Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);
33 }
34
35 /**
36 * 函数式接口：只包含一个抽象方法的接口。
37 * 1、可以通过Lambda表达式来创建该接口的对象
38 * 2、可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口
39 *
40 * Java内置了四大核心函数式接口：
41 * 1、Consumer<T>：void accept(T t)，消费型接口
42 * 2、Supplier<T>：T get()，供给型接口
43 * 3、Function<T, R>：R apply(T t)，函数型接口
44 * 4、Predicate<T>：boolean test(T t)，断言型接口
45 * 还有部分子接口。
46 */
47 public void testFunctionalInterface() {
48 Consumer<String> consumer = str -> System.out.println(str);
49 }
50 }
二、Stream
1 import java.util.ArrayList;
2 import java.util.HashMap;
3 import java.util.List;
4 import java.util.Map;
5 import java.util.Optional;
6 import java.util.OptionalLong;
7 import java.util.stream.LongStream;
8
9 /**
10 * @author zhaojigang
11 * @date 2018/5/19
12 */
13 public class StreamTest {
14
15 static List<Integer> integerList = new ArrayList<Integer>() {{
16 add(1);
17 add(2);
18 add(3);
19 add(4);
20 add(5);
21 add(5);
22 add(5);
23 }};
24
25 static List<Integer> integerList2 = new ArrayList<Integer>() {{
26 add(10);
27 add(20);
28 add(30);
29 }};
30
31 static Map<String, List<Integer>> map1 = new HashMap<>();
32
33 static {
34 map1.put("list1", integerList);
35 map1.put("list2", integerList2);
36 }
37
38 /**
39 * 分片与筛选
40 */
41 public static void test1() {
42 integerList.stream()
43 .filter(x -> x > 2) // 3,4,5,5,5
44 .skip(2) //5,5,5
45 .limit(2) //5,5 短路:一旦获取到2个元素后不再向后迭代
46 .distinct() //5
47 .forEach(System.out::println);
48 }
49
50 /**
51 * 映射
52 * map(Function f)：接收一个函数作为参数，该函数会被应用到每个元 素上，并将其映射成一个新的元素
53 * flatMap(Function f)：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
54 */
55 public static void test2() {
56 integerList.stream()
57 .map(x -> x + 10)
58 .forEach(System.out::println);
59
60 map1.values().stream()
61 .flatMap(x -> x.stream()) // x是每一个List，flatMap将每一个List的Stream合并起来
62 .forEach(System.out::println);
63
64 }
65
66 /**
67 * 排序
68 * sorted()：产生一个新流，其中按自然顺序排序（按照元素的Comparable接口）
69 * sorted(Comparator comp)：产生一个新流，其中按比较器顺序排序（按照自定义的Comparator）
70 */
71 public static void test3() {
72 integerList.stream()
73 .sorted()
74 .forEach(System.out::println);
75
76 integerList.stream()
77 .sorted((x, y) -> {
78 if (x < y) {
79 return 1;
80 } else {
81 return -1;
82 }
83 })
84 .forEach(System.out::println);
85
86 }
87
88 /**
89 * 查找与匹配
90 * allMatch(Predicate p)：检查是否匹配所有元素
91 * anyMatch(Predicate p)：检查是否至少匹配一个元素
92 * noneMatch(Predicate p)：检查是否没有匹配所有元素
93 * findFirst()：返回第一个元素
94 * findAny()：返回当前流中的任意元素
95 * count()：返回流中元素总数
96 * max(Comparator c)：返回流中最大值
97 * min(Comparator c)：返回流中最小值
98 */
99 public static void test4() {
100 final boolean allMatch = integerList.stream().allMatch(x -> x > 4);
101 final boolean anyMatch = integerList.stream().anyMatch(x -> x > 4);
102 final boolean noneMatch = integerList.stream().noneMatch(x -> x > 4);
103 final Optional<Integer> first = integerList.stream().filter(x -> x > 3).findFirst();
104 final Optional<Integer> any = integerList.stream().filter(x -> x > 3).findAny();
105 final long count = integerList.stream().filter(x -> x > 4).count();
106 final Optional<Integer> max = integerList.stream()
107 .max((x, y) -> {
108 if (x < y) {
109 return 1;
110 } else {
111 return -1;
112 }
113 });
114
115 }
116
117 /**
118 * 规约
119 * <p>
120 * reduce(T iden, BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回T，其中iden是初始值
121 * reduce(BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回Optional<T>
122 */
123 public static void test5() {
124 // 计算：100+1+2+3+4+5+5+5
125 final Integer sum = integerList.stream().reduce(100, (x, y) -> x + y);
126 final Optional<Integer> sumOptional = integerList.stream().reduce((x, y) -> x + y);
127 }
128
129 /**
130 * 收集
131 * 常用：
132 * 1、将流元素收集到List：List<Employee> emps= list.stream().collect(Collectors.toList());
133 * 2、将流元素收集到Set：List<Employee> emps= list.stream().collect(Collectors.toSet());
134 * 3、连接流中每个字符串：String str= list.stream().map(Employee::getName).collect(Collectors.joining());
135 * 4、分组： Map<Emp.Status, List<Emp>> map= list.stream().collect(Collectors.groupingBy(Employee::getStatus));
136 *
137 * 不常用：
138 * 1、根据true或false进行分区：Map<Boolean,List<Emp>>vd= list.stream().collect(Collectors.partitioningBy(Employee::getManage));
139 * 2、根据比较器选择最大值：Optional<Emp>max= list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary)));
140 * 3、根据比较器选择最小值：Optional<Emp> min = list.stream().collect(Collectors.minBy(comparingInt(Employee::getSalary)));
141 * 4、将流元素收集到任意指定集合：Collection<Employee> emps=list.stream().collect(Collectors.toCollection(ArrayList::new));
142 * 5、计算流中元素的个数：long count = list.stream().collect(Collectors.counting());
143 * 6、对流中元素的属性求和：int total=list.stream().collect(Collectors.summingInt(Employee::getSalary));
144 * 7、计算流中元素Integer属性的平均值：double avg= list.stream().collect(Collectors.averagingInt(Employee::getSalary));
145 */
146 public static void test6() {
147 }
148
149 /**
150 * 并行流与串行流
151 * 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。
152 * 底层：fork/join
153 * Stream API可以声明性地通过parallel()与sequential()在并行流与顺序流之间进行切换
154 */
155 public static void test7(){
156 long start = System.currentTimeMillis();
157
158 final OptionalLong sum = LongStream.rangeClosed(0, 100000000000L)
159 .parallel()
160 .reduce(Long::sum);
161
162 System.out.println(sum + "-" + (System.currentTimeMillis() - start));
163 }
164
165 public static void main(String[] args) {
166 test7();
167 }
168 }
三、Optional
1 import java.util.Optional;
2
3 /**
4 * @author zhaojigang
5 * @date 2018/5/19
6 */
7 public class OptionalTest {
8
9 public static void main(String[] args) {
10 // String godName = "shijia";
11 String godName = null;
12 // 常用方式
13 final String god = Optional.ofNullable(godName).orElse("yesu");
14 System.out.println(god);
15 }
16 }
四、日期时间API
1 import java.time.Duration;
2 import java.time.Instant;
3 import java.time.LocalDateTime;
4 import java.time.format.DateTimeFormatter;
5
6 /**
7 * @author zhaojigang
8 * @date 2018/5/19
9 */
10 public class TimeTest {
11
12 /**
13 * 一、日期创建：
14 * LocalDate localDate = LocalDate.now();
15 * LocalTime localTime = LocalTime.now();
16 * LocalDateTime localDateTime = LocalDateTime.now();
17 *
18 * LocalDate localDate = LocalDate.of(2016, 10, 26);
19 * LocalTime localTime = LocalTime.of(02, 22, 56);
20 * LocalDateTime localDateTime = LocalDateTime.of(2016, 10, 26, 12, 10, 55);
21 *
22 * 二、日期加减运算
23 * plusDays, plusWeeks, plusMonths, plusYears
24 * minusDays, minusWeeks, minusMonths, minusYears
25 * plus, minus
26 *
27 * 三、日期比较计算
28 * isBefore, isAfter
29 *
30 * 四、是否闰年
31 * isLeapYear
32 *
33 * 五、时间戳与时间间隔运算
34 * Instant 时间戳：以Unix元年(传统的设定为UTC时区1970年1月1日午夜时分)开始所经历的描述进行运算
35 * Duration:用于计算两个“时间”间隔
36 * Period:用于计算两个“日期”间隔
37 *
38 * 六、时间校正器
39 * TemporalAdjuster/TemporalAdjusters 调整时间：例如获取下一个周日等
40 *
41 * 七、日期解析和格式化
42 * java.time.format.DateTimeFormatter类
43 */
44 public static void main(String[] args) {
45 /**
46 * 计算时间间隔
47 */
48 Instant in1 = Instant.now();
49 Instant in2 = Instant.now();
50 System.out.println(Duration.between(in1, in2).toMillis());
51
52 /**
53 * 日期格式化
54 */
55 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
56 LocalDateTime time1 = LocalDateTime.now();
57 String formatDateTime = time1.format(formatter);
58
59 /**
60 * 日期解析
61 */
62 LocalDateTime dateTime = LocalDateTime.parse(formatDateTime, formatter);
63 }
64 }
日期操作我们通常会使用Apache commons包，但是这样就会引入一个包，能够使用java本身的就是用java本身的。
五、接口方法
1 /**
2 * @author zhaojigang
3 * @date 2018/5/19
4 */
5 public class InterfaceTest {
6 public static void main(String[] args) {
7 MyImpl myClass = new MyImpl();
8 System.out.println(myClass.getName());
9 System.out.println(MyInterface.getAge());
10 }
11 }
12
13 interface MyInterface {
14 default String getName(){
15 return "nana";
16 }
17
18 static Integer getAge(){
19 return 18;
20 }
21 }
22
23 /**
24 * 若一个接口中定义了一个默认方法，而另外一个父类中又定义了一个同名的方法时，取父类
25 * 若一个接口中定义了一个默认方法，而另外一个实现接口中又定义了一个同名的方法时，实现类需要执行重写其中一个
26 */
27 class MyImpl implements MyInterface {
28 }
