注解
概念
解释代码的代码,称为注解,也被称为元代码
常用的注解
@Override: 重写
@Deprecated: 过时
@SuppressWarnings("deprecation"): 忽略警告
自定义注解
语法:
访问权限修饰符 @interface 注解名{
公共静态常量
注解的属性
}
注意:
1.注解的属性语法格式:
数据类型 属性名();
数据类型 属性名() default 默认值;
2.如果注解的属性没有默认值,使用注解时,必须给属性赋值
3.如果注解的属性有默认值,使用注解时,可以给该属性赋值,也可以赋值
4.注解的属性的数据类型不能是集合
注解的使用
@注解名(属性名1 = 属性值1, 属性名2 = 属性值2, 属性名3 = {});
注意:
1.可以不按照顺序赋值
2.有默认值的属性可以不赋值
3.如果注解中所有属性都有默认值或没有属性,此时可以省略()不写
4.如果注解中有且只有一个value属性,在使用注解时,可以忽略属性名不写
如:
@注解名(值);
元注解
概念: 解释注解的注解
常用的元注解:
@Target:
作用: 限定注解的使用范围
值:
TYPE: 在类上用
FIELD: 在属性上用
METHOD: 在方法上用
PARAMETER: 在形参上用
CONSTRUCTOR: 在构造函数上用
注意: 自定义一个注解不使用上述注解时,自定义的注解可以在任何一处使用
@Retention
作用: 限定其使用范围(在什么情况下使用)
值:
SOURCE: 在java文件时可用
CLASS: 编译为class文件时可用
RUNTIME: 程序运行时可用
注意:
自定义的注解默认是java文件时可用
@Documented
作用: 可以生成api文件
@Inherited
作用: 允许被继承
注意: 不加是不被继承的
注解 + 反射
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.CONSTRUCTOR)
public @interface DogAnnotation {
String name() default "狗";
int age() default 1;
String color() default "黑";
String[] likeFoods() default {"骨头", "肉"};
}
import java.lang.reflect.Constructor;
import java.util.Arrays;
public class Dog {
private String name;
private int age;
private String color;
private String[] likeFoods;
@DogAnnotation(name = "小狗", color = "白")
public Dog() throws Exception {
Class c = Dog.class;
Constructor<Dog> constructor = c.getDeclaredConstructor();
DogAnnotation annotation = constructor.getAnnotation(DogAnnotation.class);
this.name = annotation.name();
this.age = annotation.age();
this.color = annotation.color();
this.likeFoods = annotation.likeFoods();
}
public Dog(String name, int age, String color, String[] likeFoods) {
this.name = name;
this.age = age;
this.color = color;
this.likeFoods = likeFoods;
}
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 String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String[] getLikeFoods() {
return likeFoods;
}
public void setLikeFoods(String[] likeFoods) {
this.likeFoods = likeFoods;
}
@Override
public String toString() {
return "Dog [name=" + name + ", age=" + age + ", color=" + color + ", likeFoods=" + Arrays.toString(likeFoods)
+ "]";
}
}
public class Test {
public static void main(String[] args) throws Exception {
Dog dog = new Dog();
System.out.println(dog);
}
}
运行结果
JDK1.8新特性
简介
在Java 8版本添加的新内容
如: Java5的时候添加反射,Java2集合...
函数式接口
简介
一个接口中只有一个抽象方法,这种接口称为函数式接口
相关注解
@FunctionalInterface
作用: 验证接口是否为函数式接口
系统提供的常见的函数式接口
接口名 返回值类型 抽象方法 分类
Consumer<T> void accept(T t) 消费型接口
Supplier<T> T get() 供给型接口
Function<T,R> R apply(T t) 函数型接口
Predicate<T> boolean test(T t) 断言型接口
Lambda
简介
一种特殊的匿名内部类
优点
语法简洁
节省内存,不会生成class文件
语法
() -> {}
注意:
1.创建的匿名内部类中只有一个方法,此时才能使用Lambda表达式
2.在Lambda表达式中,可以省略形参的数据类型
3.在Lambda表达式中,当只有一个形参时可以忽略小括号不写
4.当代码块只有一行代码时,可以省略大括号不写
5.当代码块中只有一行代码,该代码是返回值,此时如果要省略大括号,也需将return去掉
package demo01;
import java.util.function.Function;
public class Test {
public static void main(String[] args) {
/**
* 定义一个方法传入字符串,返回字符串长度
*/
// Function<String, Integer> function = new Function<String, Integer>() {
// @Override
// public Integer apply(String t) {
// return t.length();
// }
// };
// Function<String, Integer> function = (String t) -> {
// return t.length();
// };
Function<String, Integer> function = t -> t.length();
Integer len = function.apply("Hello Java!");
System.out.println(len);
}
}
运行结果
方法引用
简介
在Lambda表达式前提下的一些特殊情况可以继续简化
常见形式
对象::实例方法
类::静态方法
类::实例方法
类::new
package demo02;
public class Person {
private String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
public void getName() {
System.out.println(name);
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person [name=" + name + "]";
}
}
package demo02;
import java.util.function.Consumer;
//方法引用
//对象::实例方法
public class Test {
public static void main(String[] args) {
A a = new A();
// Consumer<Integer> consumer = new Consumer<Integer>() {
//
// @Override
// public void accept(Integer t) {
// a.out(t);
// }
// };
//Lambda表达式简写
// Consumer<Integer> consumer = (Integer t) -> {
// a.out(t);
// };
//继续简写
// Consumer<Integer> consumer = t -> a.out(t);
//当传入的形参与方法中代码的实参一致,可以使用方法引用
Consumer<Integer> consumer = a::out;
consumer.accept(10);
}
}
class A {
public void out(Integer t) {
System.out.println(t);
}
}
运行结果
package demo02;
import java.util.function.Consumer;
//方法引用
//类::静态方法
public class Test02 {
public static void main(String[] args) {
// Consumer<Integer> consumer = new Consumer<Integer>() {
//
// @Override
// public void accept(Integer t) {
// B.out(t);
// }
// };
//Lambda表达式简写
// Consumer<Integer> consumer = (Integer t) -> {
// B.out(t);
// };
//继续简写
// Consumer<Integer> consumer = t -> B.out(t);
//当传入的形参与方法中代码的实参一致,可以使用方法引用
Consumer<Integer> consumer = B::out;
consumer.accept(10);
}
}
class B {
public static void out(Integer t) {
System.out.println(t);
}
}
运行结果
package demo02;
import java.util.function.Consumer;
//方法引用
//类::实例方法
public class Test03 {
public static void main(String[] args) {
// Consumer<Person> consumer = new Consumer<Person>() {
//
// @Override
// public void accept(Person t) {
// t.getName();
// }
// };
//Lambda表达式简写
// Consumer<Person> consumer = (Person t) -> {
// t.getName();
// };
//继续简写
// Consumer<Person> consumer = t -> t.getName();
//形参传入的内容就是方法体中调用方法的对象
//此时可以使用方法引用再次简化
Consumer<Person> consumer = Person::getName;
Person person = new Person("张三");
consumer.accept(person);
}
}
运行结果
package demo02;
import java.util.function.Function;
import java.util.function.Supplier;
//方法引用
//类::new
public class Test04 {
public static void main(String[] args) {
// Supplier<Person> supplier = new Supplier<Person>() {
//
// @Override
// public Person get() {
// return new Person();
// }
// };
//Lambda表达式简写
// Supplier<Person> supplier = () -> new Person();
//此方法体中只有一行代码,而且该代码用于创建对象
//此时可以使用方法引用简写
Supplier<Person> supplier = Person::new;
Person person = supplier.get();
System.out.println(person);
System.out.println("-------------------------");
// Function<String, Person> function = new Function<String, Person>() {
//
// @Override
// public Person apply(String t) {
// return new Person(t);
// }
// };
//Lambda表达式简写
// Function<String, Person> function = (String t) -> {
// return new Person(t);
// };
//继续简写
// Function<String, Person> function = t -> new Person(t);
//使用方法引用简写
Function<String, Person> function = Person::new;
Person p = function.apply("张三");
System.out.println(p);
}
}
运行结果
流
简介
Stream: 工作流
类似于集合,区别是集合中存储的是数据,而流中存储的是过程
特点
自己不会存储数据
不会改变源对象
使用步骤
1.创建
2.中间操作
注意: 中间操作可以有多个
3.终止操作
注意: 一旦进行终止操作,该流就不能再使用了
创建
方式1:
通过Collection对象的stream方法获取
通过Collection对象的parallelStream方法获取
方式2:
通过Arrays提供的stream方法
方式3:
通过Stream接口提供的of,iterate,generate
方式4:
通过Stream接口子类或子接口对象调用of,iterate,generate
中间操作
filter: 过滤
limit: 限制
skip: 跳过
distinct: 去掉重复
sorted: 排序
map: 映射操作
parallel: 并行流
注意: 一个流可以有多个中间操作,也可以没有
1.filter过滤
代码:
ArrayList<Employee> list=new ArrayList<>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
//获取薪资大于15000,forEach终止操作,遍历结果
list.stream()
.filter(e->e.getMoney()>15000)
.forEach(System.out::println);
2.limit限制
代码:
ArrayList<Employee> list=new ArrayList<>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
//获取集合中前两个输出
list.stream()
.limit(2)
.forEach(System.out::println);
3.skip跳过
代码:
ArrayList<Employee> list=new ArrayList<>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
//跳过集合中前两个输出
list.stream()
.skip(2)
.forEach(System.out::println);
4.distinct去掉重复
注意:存储对象必须实现hashCode()和equals()方法,用这两个方法判断是否重复,先调用hashCode()方法,如果该方法的返回值与存储的其他数据一致,再调用equals()比较
代码:
ArrayList<Employee> list=new ArrayList<>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
list.stream()
.distinct()
.forEach(System.out::println);
5.sorted排序
代码:
ArrayList<Employee> list=new ArrayList<>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
list.stream()
.sorted((e1,e2)->Double.compare(e1.getMoney(), e2.getMoney()))
.forEach(System.out::println);
6.map映射操作
简介:将当前Stream中的每个元素都映射转换为另一个元素,从而得到一个新的Stream
代码:
ArrayList<Employee> list=new ArrayList<>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
list.stream()
.map(e->e.getName())
.forEach(System.out::println);
7.parallel并行流
简介:采用多线程, 效率高
代码:
ArrayList<Employee> list=new ArrayList<>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
list.stream().parallel()
.forEach(System.out::println);
package demo03;
public class Employee {
private String name;
private int money;
public Employee() {
}
public Employee(String name, int money) {
this.name = name;
this.money = money;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
@Override
public String toString() {
return "Employee [name=" + name + ", money=" + money + "]";
}
}
package demo03;
import java.util.ArrayList;
import java.util.function.Consumer;
import java.util.function.Predicate;
public class Test01 {
public static void main(String[] args) {
ArrayList<Employee> list=new ArrayList<Employee>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
//获取薪资大于15000,forEach终止操作,遍历结果
// list.stream().filter(new Predicate<Employee>() {
//
// @Override
// public boolean test(Employee e) {
// return e.getMoney() > 15000;
// }
// })
// .forEach(new Consumer<Employee>() {
//
// @Override
// public void accept(Employee e) {
// System.out.println(e);
// }
// });
//简化写法
list.stream()
.filter(e->e.getMoney()>15000)
.forEach(System.out::println);
}
}
运行结果
package demo03;
import java.util.ArrayList;
import java.util.function.Consumer;
public class Test02 {
public static void main(String[] args) {
ArrayList<Employee> list=new ArrayList<Employee>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
//获取集合中前两个输出
// list.stream().limit(2)
// .forEach(new Consumer<Employee>() {
//
// @Override
// public void accept(Employee e) {
// System.out.println(e);
// }
// });
//简化写法
list.stream()
.limit(2)
.forEach(System.out::println);
}
}
运行结果
package demo03;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;
public class Test05 {
public static void main(String[] args) {
ArrayList<Employee> list=new ArrayList<Employee>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
//按工资排序
// list.stream().sorted(new Comparator<Employee>() {
//
// @Override
// public int compare(Employee e1, Employee e2) {
// return Double.compare(e1.getMoney(), e2.getMoney());
// }
// }).forEach(new Consumer<Employee>() {
//
// @Override
// public void accept(Employee e) {
// System.out.println(e);
// }
// });
//简化写法
list.stream()
.sorted((e1,e2)->Double.compare(e1.getMoney(), e2.getMoney()))
.forEach(System.out::println);
}
}
运行结果
package demo03;
import java.util.ArrayList;
import java.util.function.Consumer;
import java.util.function.Function;
public class Test06 {
public static void main(String[] args) {
ArrayList<Employee> list=new ArrayList<Employee>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
//获取所有名字并打印
// list.stream().map(new Function<Employee, String>() {
//
// @Override
// public String apply(Employee e) {
// return e.getName();
// }
// }).forEach(new Consumer<String>() {
//
// @Override
// public void accept(String s) {
// System.out.println(s);
// }
// });
//简化写法
list.stream()
.map(e->e.getName())
.forEach(System.out::println);
}
}
运行结果
结束操作
forEach: 遍历
min: 最小值
max: 最大值
count: 数量
reduce: 规约
collect: 收集
注意: 一个流有且只有一个结束操作
1.forEach遍历
代码:
ArrayList<Employee> list=new ArrayList<>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
list.stream().forEach(System.out::println);
2.min最小值
代码:
ArrayList<Employee> list=new ArrayList<>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
Optional<Employee> min = list.stream().min((o1,o2)->Integer.compare(o1.getMoney(), o2.getMoney()));
System.out.println(min.get());
3.max最大值
代码:
ArrayList<Employee> list=new ArrayList<>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
Optional<Employee> max = list.stream().max((e1,e2)->Integer.compare(e1.getMoney(), e2.getMoney()));
System.out.println(max.get());
4.count数量
代码:
//薪资大于20000的人数
ArrayList<Employee> list=new ArrayList<>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
long count = list.stream().filter(o -> o.getMoney()>20000).count();
System.out.println(count);
5.reduce规约
代码:
//所有员工薪资和
ArrayList<Employee> list=new ArrayList<>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
Optional<Integer> sum = list.stream()
.map(e->e.getMoney())
.reduce((x,y)->x+y);
System.out.println(sum.get());
6.collect收集
代码:
//获取所有的员工姓名,封装成一个list集合
ArrayList<Employee> list=new ArrayList<>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
List<String> names = list.stream()
.map(e->e.getName())
.collect(Collectors.toList());
for (String string : names) {
System.out.println(string);
}
package demo04;
public class Employee {
private String name;
private int money;
public Employee() {
}
public Employee(String name, int money) {
this.name = name;
this.money = money;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
@Override
public String toString() {
return "Employee [name=" + name + ", money=" + money + "]";
}
}
package demo04;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Optional;
public class Test03 {
public static void main(String[] args) {
ArrayList<Employee> list=new ArrayList<Employee>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
//求工资最大值
// Optional<Employee> max = list.stream().max(new Comparator<Employee>() {
//
// @Override
// public int compare(Employee e1, Employee e2) {
// return Integer.compare(e1.getMoney(), e2.getMoney());
// }
// });
// System.out.println(max.get());
//简化写法
Optional<Employee> max = list.stream().max((e1,e2)->Integer.compare(e1.getMoney(), e2.getMoney()));
System.out.println(max.get());
}
}
运行结果
package demo04;
import java.util.ArrayList;
import java.util.function.Predicate;
public class Test04 {
public static void main(String[] args) {
ArrayList<Employee> list=new ArrayList<Employee>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
//薪资大于20000的人数
// long count = list.stream().filter(new Predicate<Employee>() {
//
// @Override
// public boolean test(Employee e) {
// return e.getMoney() > 20000;
// }
// }).count();
//简化写法
long count = list.stream().filter(o -> o.getMoney()>20000).count();
System.out.println(count);
}
}
运行结果
package demo04;
import java.util.ArrayList;
import java.util.Optional;
import java.util.function.BinaryOperator;
import java.util.function.Function;
public class Test05 {
public static void main(String[] args) {
ArrayList<Employee> list=new ArrayList<Employee>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
//所有员工薪资和
// Optional<Integer> sum = list.stream().map(new Function<Employee, Integer>() {
//
// @Override
// public Integer apply(Employee e) {
// return e.getMoney();
// }
// }).reduce(new BinaryOperator<Integer>() {
//
// @Override
// public Integer apply(Integer x, Integer y) {
// return x + y;
// }
// });
//简化写法
Optional<Integer> sum = list.stream()
.map(e->e.getMoney())
.reduce((x,y)->x+y);
System.out.println(sum.get());
}
}
运行结果
package demo04;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
public class Test06 {
public static void main(String[] args) {
ArrayList<Employee> list=new ArrayList<Employee>();
list.add(new Employee("小王", 15000));
list.add(new Employee("小张", 12000));
list.add(new Employee("小李", 18000));
list.add(new Employee("小孙", 20000));
list.add(new Employee("小刘", 25000));
list.add(new Employee("小刘", 25000));
//获取所有的员工姓名,封装成一个list集合
// List<String> names = list.stream().map(new Function<Employee, String>() {
//
// @Override
// public String apply(Employee e) {
// return e.getName();
// }
// }).collect(Collectors.toList());
//简化写法
List<String> names = list.stream()
.map(e->e.getName())
.collect(Collectors.toList());
for (String string : names) {
System.out.println(string);
}
}
}
运行结果
新时间API
简介
以前的时间相关API,是线程不安全的,而且在设计时就是混乱的
所以在JDK1.8时候提供新的时间API的类
提供的类有:
LocalDate
LocalTime
LocalDateTime
替换Date
DateTimeFormatter
替换:SimpleDateFormat
Instant
瞬时
ZoneId
时区
LocalDate
作用: 本地日期
提供的方法:
static LocalDate now(): 获取当前日期
static LocalDate of(): 获取指定日期
LocalTime
作用: 本地时间
提供的方法:
static LocalTime now(): 获取当前时间
static LocalTime of(): 获取指定时间
LocalDateTime
作用: 本地日期时间
提供的方法:
static LocalTime now(): 获取当前日期时间
static LocalTime of(): 获取指定日期时间
getXXX(): 获取时间
withXXX(): 设置时间
plusXXX(): 在原时间基础上增加
minusXXX(): 在原时间基础上减小
DateTimeFormatter
package demo05;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class Test01 {
public static void main(String[] args) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
LocalDateTime dateTime01 = LocalDateTime.now();
//将时间转换为固定格式的字符串
String str = formatter.format(dateTime01);
System.out.println(str);
//将固定格式的字符串转换为对象
LocalDateTime dateTime02 = LocalDateTime.parse("2022年12月10日 13:14:52", formatter);
System.out.println(dateTime02);
}
}
运行结果
Instant
作用: 瞬时
package demo05;
import java.time.Instant;
public class Test02 {
public static void main(String[] args) {
Instant instant = Instant.now();
System.out.println(instant);
}
}
运行结果
转换
package demo05;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
public class Test03 {
public static void main(String[] args) {
//将Date对象的时间转换为LocalDatetime对象
Date date = new Date();
Instant instant = date.toInstant();
LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
System.out.println(dateTime);
//将LocalDatetime对象转换为Date对象
LocalDateTime dateTime2 = LocalDateTime.of(2000, 1, 1, 12, 0, 1);
Instant instant2 = dateTime2.atZone(ZoneId.systemDefault()).toInstant();
Date date2 = Date.from(instant2);
System.out.println(date2);
}
}
运行结果