个人中心
退出
JavaSE：第十六章：java8新特性
##java8内容
1.Lambda表达式 ★
2.函数式接口 ★
3.方法引用 ★
4.构造器引用|数组引用 ★
5.StreamAPI ★
6.接口中可以定义默认方法和静态方法 ★
7.Optional类的引入：为了减少空指针异常【了解】
8.新日期API【了解】
9.重复注解【了解】
10.Nashone引擎的使用：在jvm上运行js【后面课程】
##Java8引进
1995年推出jdk1.0
04年推出 jdk5 ，改革非常大
06年推出 jdk6 ,企业中使用的最长久版本
--------被Oralce公司收购-----------
11年 推出 jdk7
14年 推出 jdk8 LTS版本：受商业公司支持的长期版本
17年 9月份推出 jdk9， “六个月版本升级计划” 小版本
18年 3月份 推出jdk10 小版本
18年 9月份 推出jdk11 LTS版本：
##Lambda表达式
###理解
理解成一段可以传递的代码，作为函数式接口的实例出现
###应用场景
示例1：
接口 a = Lambda表达式;
示例2：【居多】
method(Lambda表达式);
public void method(接口 a){
}
###好处
1、语句更加简洁
2、更加紧凑，使java语言的表达能力得到了提升！
###语法 ★
(参数类型 参数名,参数类型 参数名)->{方法体的实现/Lambda体}
示例：
(String o1, String o2)->{return o1.compareTo(o2);}
特点：
①左侧参数列表中的参数类型可以省略！
②如果左侧参数列表中，只有一个参数，则小括号也可以省略
③右侧的Lambda体中如果仅有一句话，则大括号可以省略
④右侧的Lambda体中仅有的一句话为return语句，则return要求省略
##函数式接口
理解：
只有一个抽象方法的接口，称为函数式接口
Consumer消费型接口
Supplier供给型接口
Function<T,R>函数型接口
Predicate 断定型接口
##方法引用
###理解
* 方法引用实质上就是Lambda表达式的简化，同样可以作为函数式接口的实例出现
* 能用方法引用 的肯定能用Lambda表达式
* 能用Lambda表达式的不一定能用方法应用，除非满足以下要求：
###要求：
①Lambda体中仅仅只有一句话
②仅有的一句话为 方法调用！
③调用方法的参数列表和Lambda体实现的抽象方法的参数列表一致！
调用方法的返回类型和Lambda体实现的抽象方法的返回类型一致！
特例：类名::普通方法
调用方法的调用者正好是 抽象方法的第一个参数，并且其他参数一致
调用方法的返回类型和抽象方法的返回类型一致！
###语法：
类名或对象::方法名
###情况：
* 1、对象::普通方法
* 2、类名::静态方法
* 3、类名::普通方法
##关于方法引用、数组引用、构造器引用的总结
1.能使用方法引用|数组引用|构造器引用的地方，肯定能用Lambda表达式！
2.能用Lambda表达式的地方，不一定能用方法引用|数组引用|构造器引用，必须满足以下条件
3.能使用Lambda表达式的地方，肯定能用匿名内部类
能用匿名内部类的，不一定能用Lambda表达式，必须满足：
实现的接口为 函数式接口（里面只有一个抽象方法的接口）！
方法引用：
①Lambda体只有一句话
②仅有的一句话为调用方法
③方法的参数列表、返回类型正好与抽象方法的参数列表、返回类型一致！
特殊：如果是类名::普通方法，则要求方法的调用者为抽象的方法的第一个参数，其他一致
此类用于演示方法引用
* 举例：
* 匿名内部类：
* UnaryOperator<Double> up = new UnaryOperator<Double>(){
* public Double apply(Double t){
* return Math.sqrt(t);
* }
* };
* Lambda：
* UnaryOperator<Double> up =d->Math.sqrt(d);
* 方法引用：
UnaryOperator<Double> up = Math::sqrt;
*/
public class TestMethodRef {
//1、对象::普通方法
@Test
public void test1_1() {
//匿名内部类
// Runnable r = new Runnable() {
// @Override
// public void run() {
// System.out.println();
// }
// };
//方法引用
Runnable r2 = System.out::println;
r2.run();
}
//对象::普通方法
@Test
public void test1_2() {
//匿名内部类
// Consumer<String> con = new Consumer<String>() {
// @Override
// public void accept(String t) {
// System.out.println(t);
//
// }
// };
//方法引用
Consumer<String> con2 = System.out::println;
con2.accept("赵丽颖和冯绍峰已经结婚了");
}
//2、类名::静态方法
@Test
public void test2() {
//匿名内部类
Comparator<Double> com = new Comparator<Double>() {
@Override
public int compare(Double o1, Double o2) {
return Double.compare(o1, o2);
}
};
//Lambda
Comparator<Double> com1 = (o1,o2)->Double.compare(o1, o2);
//方法引用
Comparator<Double> com2 =Double::compare;
}
//3、类名::普通方法
@Test
public void test3() {
//匿名内部类
// Function<Employee,String> fun = new Function<Employee,String>(){
// @Override
// public String apply(Employee t) {
// return t.getName();
// }
// };
//方法引用
Function<Employee,String> fun2 = Employee::getName;
System.out.println(fun2.apply(new Employee("张无忌", 12, 1000, '男')));
}
//3、类名::普通方法
@Test
public void test3_2() {
//匿名内部类
// BiFunction<String, String, Boolean> bf = new BiFunction<String, String, Boolean>() {
// @Override
// public Boolean apply(String t, String u) {
// return t.equals(u);
// }
// };
//方法引用
BiFunction<String, String, Boolean> bf2 = String::equals;
System.out.println(bf2.apply("hello", "Hello"));
}
}
构造器引用
理解：构造器引用本质上就是Lambda表达式，只是语句更加简洁。作为函数式接口的实例，一般作为参数传递给方法！
能用构造器引用的地方，肯定能用Lambda表达式
但能用Lambda表达式的地方，不一定能用构造器引用
要求：
①Lambda体中仅仅只有一句话
②仅有的一句话为调用构造器 new ClassName(实参列表);
③抽象方法的参数列表和构造器的参数列表完全一致
抽象方法的返回类型为构造器所属的类型。
语法：
类名::new
此类用于演示构造器引用
public class TestConstructorRef {
//案例1：返回new String();
@Test
public void test1() {
//匿名内部类
// Supplier<String> sup = new Supplier<String>() {
// @Override
// public String get() {
// return new String();
// }
// };
//构造器引用
Supplier<String> sup2 = String::new;
int length = sup2.get().length();
System.out.println(length);
}
//案例2：返回new StringBuffer(int capacity);
@Test
public void test2() {
Function<Integer,StringBuffer> fun = new Function<Integer,StringBuffer>(){
@Override
public StringBuffer apply(Integer t) {
return new StringBuffer(t);
}
};
Function<Integer,StringBuffer> fun2 = StringBuffer::new;
}
//案例3：返回new Employee("段誉", 22, 10000, '男')
@Test
public void test3() {
A<String,Integer,Double,Character,Employee> a1 = (s,i,d,c)->new Employee(s,i,d,c);
A<String,Integer,Double,Character,Employee> a = Employee::new;
}
}
interface A<T,R,U,M,N>{
N test(T t,R r,U u,M m);
}
数组引用
理解：数组引用本质上就是Lambda表达式，只是语句更加简洁。作为函数式接口的实例，一般作为参数传递给方法！
能用数组引用的地方，肯定能用Lambda表达式
但能用Lambda表达式的地方，不一定能用数组引用
要求:
①Lambda体仅仅有一句话
②仅有的一句话为返回一个新数组 new 数组类型[长度];
③抽象方法的参数只有一个，就是数组的长度；抽象方法的返回为创建的新数组类型
语法：
数组类型[]::new
此类用于演示数组引用
public class TestArrayRef {
//案例1：返回一个String[] s = new String[5]
@Test
public void test1() {
//匿名内部类
// Function<Integer,String[]> fun = new Function<Integer,String[]>(){
// @Override
// public String[] apply(Integer t) {
// return new String[t];
// }
// };
//数组引用
Function<Integer,String[]> fun2 = String[]::new;
String[] arr = fun2.apply(5);
for (String string : arr) {
System.out.println(string);
}
}
//案例2：返回一个Employee[]
@Test
public void test2() {
Function<Integer,Employee[]> fun = Employee[]::new;
Employee[] apply = fun.apply(3);
for (Employee employee : apply) {
System.out.println(employee);
}
}
}
综述：匿名内部类》Lambda表达式》方法引用|数组引用|构造器引用
##StreamAPI
###好处
1、更高效
2、易于使用，提供了丰富强大的方法。
###使用步骤
1.开始操作（√）
说明：创建Stream对象，指向一个具体的数据源（集合、数组、一系列值、无线流）
2.中间操作（可选 0——n）
说明：对数据源数据的计算、处理
3.终止操作（√）
说明：想要一个结果（打印、计数、去最值等）
###使用特点
1、Stream讲究的是“计算”，可以处理数据，但不能更新源数据
2、Stream 属于“惰性操作”，必须等待终止操作执行后，前面的中间操作或开始操作才会处理
3、Stream只能消费一次，一旦消费，就不能再次使用，除非重新创建Stream对象
4、Stream的中间操作可以有0个或多个，每个操作都会返回一个新的Stream
5、Stream相当于一个 更强大的Iterator，可以处理更加复杂的数据，并且实现并行化，效率更高！
###开始操作的相关API
一、通过集合来获取Stream对象 ★
Stream stream = list.stream();
二、通过数组来获取Stream对象
Stream stream = Arrays.stream(数组);
三、通过一组指定的值来获取Stream对象
Stream stream = Stream.of(T…ts)
四、生成无限流
Stream stream= Stream.generate(Supplier sup);
/**
* 此类用于演示Stream的使用步骤一：创建Stream对象
* 引申：
* Stream的使用步骤
* 1、创建Stream对象，指向数据源
* 2、中间操作，处理数据，返回一个新的Stream
* 3、终止操作，执行
* 创建Stream对象的方式
* 1、通过集合对象创建Stream
* 2、通过数组对象创建Stream
* 3、通过一系列值创建Stream
* 4、生成无限流
*/
public class TestStreamStart {
// 1、通过集合对象创建Stream ★
@Test
public void test1() {
List<Employee> list = EmployeeData.getData();//集合
//获取串行流对象stream
Stream<Employee> stream = list.stream();
//获取并行流对象parallelStream
// Stream<Employee> parallelStream = list.parallelStream();
//补充：终止操作
stream.forEach(System.out::println);
}
// 2、通过数组对象创建Stream
@Test
public void test2() {
Stream<String> stream = Arrays.stream(new String[] {"白眉鹰王","青易斧王","紫衫龙王","金毛狮王"});
stream.forEach(System.out::println);
}
// 3、通过一系列值创建Stream
@Test
public void test3() {
Stream<String> of = Stream.of("周芷若","小昭","殷离","赵敏");
of.forEach(System.out::println);
}
// 4、生成无限流
@Test
public void test4() {
Stream<Double> stream = Stream.generate(Math::random);
stream.forEach(System.out::println);
}
//案例：演示链式调用（流式编程）
@Test
public void exec1() {
//测试1
// EmployeeData.getData().stream().forEach(System.out::println);
//测试2
Person p = new Person();
// p.eat();
// p.sleep();
// p.play();
// p.study();
p.eat().sleep().play().study();
}
}
class Person{
public Person eat() {
System.out.println("吃");
return this;
}
public Person sleep() {
System.out.println("睡");
return this;
}
public Person play() {
System.out.println("玩");
return this;
}
public Person study() {
System.out.println("学");
return this;
}
}
###中间操作的相关API
* filter(Predicate):根据条件过滤
* limit(long max):截取size<=max的元素
* skip(long s):跳过前s个
* distinct():返回去重后的元素集合，根据hashCode和equals方法判断重复项
* map(Function):映射成新元素
* flatMap(Function):映射成Stream类型的新元素
* sorted():自然排序
* sorted(Comparator):定制排序
*
/**
* 此类用于演示Stream的使用步骤二：中间操作
* 特点：
* ①每个中间操作方法，都会返回一个持有结果的新的Stream对象
* ②中间操作是“惰性求值”，必须等待终止操作后，才会有处理结果
* ③Stream是一次性消费，每次消费后，则不能再次消费，除非重新创建新的Stream
* ④中间操作可以实现链式调用！
* 常见方法：
* filter(Predicate)：过滤
* skip(n):去掉前几项
* limit(n):获取前n项
* distinct():去重
* map(Function):映射
* flatMap(Function):映射,返回Stream
* sorted():自然排序，要求元素本身实现Comparable接口
* sorted(Comparator):定制排序
*/
public class TestStreamMiddle {
List<Employee> list;
@Before
public void before() {
list = EmployeeData.getData();
}
/*
* 筛选与切片
* filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。
limit(n)——截断流，使其元素不超过给定数量。
skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
*/
@Test
public void test1() {
//1.创建Stream对象
Stream<Employee> stream = list.stream();
//2.中间操作
//方式一：filter过滤
// Stream<Employee> filter = stream.filter(t->t.getGender()=='男');
//方式二：limit限制，返回不超过指定条目数的数据
// Stream<Employee> limit = stream.limit(5);
//方法三：skip(n)，跳过指定的n条数据
// Stream<Employee> skip = stream.skip(3);
//方法四：distinct()去重:两个元素通过equals判断，如果返回true，则为重复项，一般往往需要重写元素的equals和hashCode方法
Stream<Employee> distinct = stream.distinct();
//3.终止操作
distinct.forEach(System.out::println);
}
/**
* 映射
* map:映射(将元素映射成任意类型)
* flatMap:映射（将元素映射成Stream类型）
*/
@Test
public void test2() {
//1.创建Stream对象
Stream<Employee> stream = list.stream();
//2.中间操作
//方法5：map
// Stream<String> map = stream.map(Employee::getName);
// Stream<String> filter = map.filter(s->s.contains("段"));
Stream<Stream<Object>> map = stream.map(TestStreamMiddle::fromEmployeeToStream);
//方法6：flatMap
// Stream<Object> flatMap = stream.flatMap(TestStreamMiddle::fromEmployeeToStream);
//3.终止操作
// filter.forEach(System.out::println);
map.forEach(System.out::println);
}
/*
* 排序
* sorted()——自然排序
sorted(Comparator com)——定制排序
*/
@Test
public void test3() {
//1.开始操作
Stream<Employee> stream = list.stream();
//2.中间操作
//方法7：sorted自然排序
// Stream<Employee> sorted = stream.sorted();
//方法8：sorted(Comparator) 定制排序
Stream<Employee> sorted = stream.sorted((o1,o2)->Double.compare(o2.getSalary(), o1.getSalary()));
//3.终止操作
sorted.forEach(System.out::println);
}
//将Employee转换成Stream
public static Stream<Object> fromEmployeeToStream(Employee e){
return Stream.of(e.getName(),e.getAge(),e.getGender(),e.getSalary());
}
//案例：获取工资>6000的，第2条——第8条数据，并且去掉重复项，最后打印
@Test
public void exec1() {
EmployeeData.
getData().
stream().
filter(t->t.getSalary()>6000).
skip(1).
limit(7).
distinct().
forEach(System.out::println);
}
//练习1：获取员工姓名长度大于2的员工的姓名。
@Test
public void exec2() {
list.stream().map(Employee::getName).filter(s->s.length()>2).forEach(System.out::println);
}
//练习2：获取员工工资>5000并且年龄<30的员工的工资
@Test
public void exec3() {
list.stream().filter(e->e.getAge()<30&&e.getSalary()>5000).map(Employee::getSalary).forEach(System.out::println);
}
//练习3：最老的三个员工的工资
@Test
public void exec4() {
list.stream().sorted((e1,e2)->Integer.compare(e2.getAge(),e1.getAge())).limit(3).map(Employee::getSalary).forEach(System.out::println);
}
}
###终止操作的相关API
* allMatch：测试是否全部匹配
* anyMatch:测试是否至少有一个匹配
* noneMatch:测试是否所有的都不匹配
* findFirst：返回第一个
* findAny:返回并行流中的任意一个
* count:统计个数
* max(comparator):返回最大值
* min(comparator):返回最小值
* forEach(Consumer):内部迭代（遍历）
* reduce(BinaryOperator):归约，往往和map搭配使用
/**
* 此类用于演示Stream的使用步骤三：终止操作
* 常见方法：
* reduce：归约 ★
* forEach:内部迭代 ★
* max:求最大值
* min:求最小值
* count:统计个数 ★
* allMatch:检测是否所有元素都匹配指定条件
* anyMatch:检测是否至少有一个元素匹配指定条件
* noneMatch:检测是否所有元素都不匹配指定条件
* findFirst:返回第一个元素
* findAny:返回任意一个元素
* collect:将Stream转换成集合对象
*/
public class TestStreamEnd {
List<Employee> list;
@Before
public void before() {
list = EmployeeData.getData();
}
/**
* 匹配与查找
* allMatch(Predicate p)——检查是否匹配所有元素
anyMatch(Predicate p)——检查是否至少匹配一个元素
noneMatch(Predicate p)——检查是否没有匹配的元素
findFirst——返回第一个元素
findAny——返回当前流中的任意元素
*/
@Test
public void test1() {
//1.开始操作：创建Stream对象
Stream<Employee> stream = list.stream();
//2.中间操作（支持0——n步）
//3.终止操作
boolean allMatch = stream.anyMatch(e->e.getSalary()>10000);
System.out.println(allMatch);
}
/*
* 统计和迭代
* count
* max
* min
* forEach
*/
@Test
public void test2() {
//1.开始操作：创建Stream对象
Stream<Employee> stream = list.stream();
//2.中间操作（支持0——n步）
//3.终止操作
//方法1：count统计
// long count = stream.count();
// System.out.println(count);
//方法2：max求最大值
Optional<Employee> max = stream.max((o1,o2)->o1.getAge()-o2.getAge());
System.out.println(max);
}
/*
* 归约
* reduce:反复结合流中的元素
*/
@Test
public void test3() {
//1.开始操作：创建Stream对象
Stream<Employee> stream = list.stream();
//2.中间操作（支持0——n步）
//3.终止操作
Optional<Double> sum = stream.map(Employee::getSalary).reduce((t,u)->t+u);
System.out.println(sum);
}
/*
*收集
* collect:收集
*/
@Test
public void test4() {
//1.开始操作：创建Stream对象
Stream<Employee> stream = list.stream();
//2.中间操作（支持0——n步）
//3.终止操作
List<Employee> collect = stream.collect(Collectors.toList());
System.out.println(collect);
}
//练习2：员工姓名中包含“马”的员工个数
@Test
public void exec2() {
Optional<Integer> reduce = list.stream().filter(t->t.getName().contains("马")).map(t->1).reduce((t,u)->t+u);
System.out.println(reduce);
}
//练习：返回最高的工资：
@Test
public void exec1() {
Optional<Double> max = list.stream().map(Employee::getSalary).max(Double::compare);
System.out.println(max);
}
}
JDK8对接口的改进
JDK8：
说明：接口中允许出现静态方法和默认方法
语法：
静态方法：
public static 返回类型 方法名（参数列表）{
}
默认方法：
public default 返回类型 方法名（参数列表）{
}
使用特点：
1、静态方法不能被实现类或子接口继承，只能通过所在的接口名调用！
2、默认方法具备继承性。可以被实现类或子接口继承过去
解决同名冲突的问题：
1、类优先原则
当父类或实现的接口中出现了同名并且已经实现好的方法时，如果子类中没有重写，则默认使用的是父类的方法
2、当实现的多个接口中出现了同名并且已经实现好的方法时，子类必须重写该方法，否则报错！
JDK9：
说明：接口中允许私有方法
语法：
private 返回类型 方法名(参数列表){
//代码
}
Optional的特性
理解：
Optional实质上是一个容器，里面包装了具体类型的对象。可以避免对象出现空指针异常的现象
方法：
of
ofNullable
orElse
重复注解
说明：jdk8支持重复注解
语法：
在被修饰的数据上方：
@注解类名
@注解类名
…
示例：
public class TestJava8Ann {
@MyAnn
@MyAnn
// @AnnArray({@MyAnn,@MyAnn})
String name;
}
@Repeatable(AnnArray.class)
@interface MyAnn{
//语法：类型 value() [default 值];
}
@interface AnnArray{
MyAnn[] value();
}
##日期API
第一代日期：
Date类
SimpleDateFormat类
Date date = new Date();//当前时间
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh::mm::ss");
String dateString = sdf.format(date);
/**
* 此类用于演示第一代日期类
* Date
* new Date();
* getTime()
* SimpleDateFormat
* format
* parse
*/
public class TestDate1 {
//创建Date对象，表示一个时间，精确到毫秒
@Test
public void test1() {
//代表当前系统时间
Date d1 = new Date();
System.out.println(d1);
//获取距离1970-1-1的毫秒数
System.out.println(d1.getTime());
}
//测试SimpleDateFormat，格式化或解析日期
@Test
public void test2() throws ParseException {
Date d=new Date();
//1.创建SimpleDateFormat对象
//①使用默认的格式 18-8-8 下午4:25
// SimpleDateFormat sdf = new SimpleDateFormat();
//②使用指定的格式【建议】
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh小时mm分钟ss秒 S毫秒");
//-------------格式化日期（将日期转换成字符串）------------
String format = sdf.format(d);
System.out.println(format);
//------------解析字符串为日期（将字符串转换成日期）--------
String s = "2018年12月12日 12小时12分钟12秒 12毫秒";
Date date = sdf.parse(s);
System.out.println(date);
}
}
第二代日期：
Calendar抽象类：更侧重于获取和设置日历字段
Calendar date = Calendar.getInstance();
System.out.println(date);
int year = date.get(Calendar.YEAR);
int month = date.get(Calendar.MONTH);
int day = date.get(Calendar.DAY_OF_MONTH);
System.out.println(year+"年"+(month+1)+"月"+day+"日");
/**
* 此类用于演示第二代日期类
* Calendar
*/
public class TestDate2 {
@Test
public void test1() {
//1.获取一个Calendar对象
Calendar c = Calendar.getInstance();
// System.out.println(c);
//2.获取日历字段
System.out.println("年："+c.get(Calendar.YEAR));
System.out.println("月："+(c.get(Calendar.MONTH)+1));
System.out.println("日："+c.get(Calendar.DAY_OF_MONTH));
System.out.println("小时："+c.get(Calendar.HOUR));
System.out.println("分钟："+c.get(Calendar.MINUTE));
System.out.println("秒："+c.get(Calendar.SECOND));
System.out.println("------------------------------------------");
//3.设置具体的时间
c.set(2000, 1, 1);
System.out.println("年："+c.get(Calendar.YEAR));
System.out.println("月："+(c.get(Calendar.MONTH)+1));
System.out.println("日："+c.get(Calendar.DAY_OF_MONTH));
System.out.println("小时："+c.get(Calendar.HOUR));
System.out.println("分钟："+c.get(Calendar.MINUTE));
System.out.println("秒："+c.get(Calendar.SECOND));
}
}
第三代日期：
//1.LocalDate/LocalTime/LocalDateTime————>Calendar
@Test
public void test1() {
//①创建日期对象
LocalDateTime ldt = LocalDateTime.now();
//System.out.println(ldt);
//②获取日历字段
int year = ldt.getYear();
int month = ldt.getMonthValue();
int day = ldt.getDayOfMonth();
int hour = ldt.getHour();
int minute = ldt.getMinute();
int second = ldt.getSecond();
System.out.println(year+"年"+month+"月"+day+"日 "+hour+"小时"+minute+"分钟"+second+"秒");
}
//2.Instant————————>Date
@Test
public void test2() {
//①创建Instant对象
Instant now = Instant.now();
//②实现Instant和Date之间的转换
//Instant——————>Date
Date date = Date.from(now);
System.out.println(date);
//Date——————>Instant
Instant instant = date.toInstant();
System.out.println(instant);
}
//3.DateTimeFormatter——————>SimpleDateFormat
/*
* 可以格式化LocalDateTime，也可以格式化Instant
*/
@Test
public void test3() {
LocalDateTime ldt = LocalDateTime.now();
//①创建DateTimeFormatter对象
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd kk::mm::ss");
//②格式化日期（日期——————>字符串）
String format = dtf.format(ldt);
System.out.println(format);
//③解析日期(字符串——>日期)
LocalDateTime parse = LocalDateTime.parse("2018-08-08 16::32::21", dtf);
System.out.println(parse);
}
分类导航