java8新特性
java8新特性简介
- 速度更快
- 代码更少(增加了新的语法：Lambda表达式 )
- 强大的Stream Api
- 便于并行
- 最大化减少空指针异常：Optional
- Nashorn引擎，允许JVM上运行JS应用
为什么使用Lambda表达式
Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
import org.junit.Test;
/*
* Lambda表达式的使用举例
*/
public class LambdaTest {
@Test
public void test1(){
Runnable r1 = new Runnable(){
public void run(){
System.out.println( "I LOVE CHINA!")
}
};
r1.run();
System.out.println( "**************")
Runnable r2 = () -> {System.out.println( "I LOVE CHINA!")}
r2.run();
}
}
pubilc void test2(){
Comparator<Integer> com1 = new Comparator<Integer>(){
pubilc int compare(Integer o1, Integer o2){
return Integer.compare(o1, o2);
}
};
int compare1 = com1.compare(12, 21);
System.out.println(compare1);
System.out.println("****************");
//Lambda表达式的写法
Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
int compare2 = com2.compare(12, 21);
System.out.println(compare2);
System.out.println("****************");
//方法引用
Comparator<Integer> com2 = Integer :: compare;
int compare3 = com2.compare(12, 21);
System.out.println(compare3);
}
Lambda表达式的使用
-
举例：(o1, o2) -> Integer.compare(o1,o2);
-
格式：
-> : Lambda操作符 或 箭头操作符
->左边 : Lambda形参列表 (其实就是接口中的抽象方法的形参列表)
->右边 : Lambda体 (其实就是重写的抽象方法的方法体)
-
Lambda表达式的使用：(分为6种情况介绍)
//语法格式1 //无参，无返回值 public class LambdaTest { @Test public void test1(){ Runnable r1 = new Runnable(){ public void run(){ System.out.println( "I LOVE CHINA!") } }; r1.run(); System.out.println( "**************") Runnable r2 = () -> System.out.println( "I LOVE CHINA!") r2.run(); } }//语法格式2 //Lambda 需要一个参数，但是没有返回值 Consumer<String> con = new Consumer<String>(){ public void accept(String s){ System.out.println(s); } }; con.accept("I LOVE CHINA!"); System.out.println("****************"); Consumer<String> con1 = (String s) -> { System.out.println(s); }; con1.accept("I LOVE CHINA!");//语法格式3 //数据类型可以省略，因为可由编译器推断得出，称为“数据推断” Consumer<String> con1 = (String s) -> { System.out.println(s); }; con1.accept("I LOVE CHINA!"); System.out.println("****************"); Consumer<String> con2 = (s) -> { System.out.println(s); }; con2.accept("I LOVE CHINA!");//数据推断 ArrayList<String> list = new ArrayList<>(); int[] arr = {1,2,3};//语法格式4 //Lambda若只需要一个参数是，参数的小括号可以省略 Consumer<String> con2 = (s) -> { System.out.println(s); }; con2.accept("I LOVE CHINA!"); System.out.println("****************"); Consumer<String> con2 = s -> { System.out.println(s); }; con2.accept("I LOVE CHINA!");//语法格式5 //Lambda需要两个或以上的参数，多条执行语句，并且可以由返回值 Comparator<Integer> com1 = new Comparator<Integer>(){ public int compare(Integer o1, Integer o2){ System.out.println(o1); System.out.println(o2); return o1.compareTo(o2); } }; System.out.println(com1.compare(12,21)); System.out.println("****************"); Comparator<Integer> com2 = (o1,o2) -> { System.out.println(o1); System.out.println(o2); return o1.compareTo(o2); }; System.out.println(com2.compare(12,21));//语法格式5 //当Lambda体只有一条语句时，return与大括号若由，都可以省略 Comparator<Integer> com1 = (o1,o2) -> { return o1.compareTo(o2); }; System.out.println(com1.compare(12,21)); System.out.println("****************"); Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2); System.out.println(com2.compare(12,21));总结：
->左边 : Lambda形参列表可以省略(类型推断) ; 如果Lambda形参列表只有一个参数，其一对()也可以省略
->右边 : Lambda体应该使用一对{}包裹 ; 如果Lambda体只有一条执行语句(可能是return语句)，可以省略一对{}和return关键字
-
Lambda表达式的本质：作为函数式接口的实例
-
如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口
@FunctionalInterface public interface MyInterface{ void method(); }函数式接口
- 在Java8中，Lambda表达式和函数式接口的关系是Lambda表达式就是一个函数式接口的实例。也就是说，只要一个对象时函数式接口的实例，那么该对象就可以用Lambda表达式来表示
- 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写
- 我们可以使用在一个接口上使用@FunctionalInterface注解，这样作可以检查它是否是一个函数式接口
Java内置四大核心函数式接口
函数式接口 参数类型 返回类型 用途 消费者接口 T void 对类型为T的对象应用操作，包含方法，void accept(T t) Supplier供给型接口 无 T 返回类型为T的对象，包含方法：T get() Function<T,R>函数型接口 T R 对类型为T的对象应用操作，并返回结果。结果式R类型的对象。包含方法：R apply(T t) Predicate断定型接口 T boolean 确定类型为T的对象是否满足某约束，并返回boolean值。包含方法：boolean test(T t) pubic class LambdaTest2{ publiv void test1(){ happyTime(500, new Consumwe<Double>(){ public void accept(Double aDoule){ System.out.println("矿泉收价格为：" + aDouble); } }); System.out.println("****************"); happyTime(500, money -> System.out.println("矿泉水价格为：" + money);) } pubic void happyTime(double money, Consumer<Double> con){ con.accept(); } }public void test2(){ List<String> list = Arrays.asList("北京"，"南京"，"东京")； List<String> filterStrs = filterString(list, new Predicate<String>(){ public boolean test(String s){ return s.contains("京"); } }); System.out.println(filterStrs); List<String> filterStrs1 = filterString(list, s -> s.contains("京")); System.out.println(filterStrs); } //根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定 public void fileterString(List<String> list, Predicate<String> pre){ ArrayList<String> filterList = new ArrayList<>(); for(String s : list){ if(pre.test(s)){ filterList.add(s); } } return filterList; }方法引用和构造器引用
方法引用
当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用!
方法引用可以看作是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为式Lambda表达式的一个语法
使用格式： 类(或对象) :: 方法名
具体分为如下三种情况：
对象 :: 非静态方法
类 :: 静态方法
类 :: 非静态方法
方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同[针对情况一和情况二]
//情况一：对象 :: 实例方法 //Consumer中的void accept(T t) //PrintStream中的void println(T t) public void test1(){ Consumer<String> con1 = str -> System.out.print(str); con1.accept("北京"); System.out.println("****************"); PrintStream ps = System.out; Consumer<String> con2 = ps::println; con2.accept("北京") }//情况二：类 :: 静态方法 //Comparator中的int compare(T t1, T t2) //Integer 中的int compare(T t1, T t2) public void test(){ Compare<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2); System.out.println(com1.compare(12,21)); System.out.println("****************"); Compare<Integer> com2 = Integer::compare; System.out.println(com2.compare(12,21)); }//情况三：类 :: 实例方法 //Comparator中的int compare(T t1, T t2) //String 中的int t1.compareTo(t2) public void test5(){ Comparetor<String> com1 = (s1,s2) -> s1.compareTo(s2); System.out.println(com1.compare("abc","abd")); System.out.println("****************"); Comparetor<String> com2 = String::compareTo; System.out.println(com1.compare("abc","abd")); }构造器引用
和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类型
pubic void test1(){ Supplier<Employee> sup = new Supplier<Employee>(){ public Employee get(){ return new Employee(); } }; System.out.println(sup.get()); System.out.println("****************"); Supplier<Employee> sup1 = () -> new; System.out.println(sup1.get()); }数组引用
可以把数组看作是一个特殊的类，则写法与构造器引用一致
//数组引用 //Function中的R apply(T t) public void test4(){ Fuction<Integer,String[]> func1 = length -> new String[length]; String[] arr1 = func1.apply(5); System.out.println(Arrays.toString(arr1)); System.out.println("****************"); Fuction<Integer,String[]> func2 = String[]::new; String[] arr2 = func2.apply(5); System.out.println(Arrays.toString(arr2) }Stream API
- Stream API(java.util.stream)
- Stream是java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找，过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用使用Stream API来并行执行操作。简言之，Stream API提供了一种高效且易于只用的处理数据的方式
为什么要使用Stream API
- 实际开发中，项目中多数据源都来自于Mysql,Oracle等。但现在数据源可以更多了，有MongDB,Radis等，而这些NoSQL的数据就需要处理
- Stream 和Collection集合的区别：Collection是一种静态的内存数据结构，而Stream是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向CPU，通过CPU实现计算。
Stream到底是什么
-
是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。
-
集合讲的是数据，Stream将的是计算。
-
Stream自己不会存储元素
-
Stream不会改变源对象。相反，他们返回一个持有结果的新Stream
-
STream操作时延迟执行的，这意味着他们会等到需要结果的时候才执行
Stream的操作三个步骤
-
创建Stream
一个数据源(如：集合、数组)，获取一个流
-
中间操作
一个中间操作链，对数据源的数据进行处理
-
终止操作(终端操作)
一旦执行终止操作，就执行中间操作盘，并产生结果。之后，不会再被使用
-
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nOKdHdRC-1654006884777)(C:\Users\123\AppData\Roaming\Typora\typora-user-images\image-20220527230920251.png)]
创建Stream方式一：通过集合
Java8中的Collection接口被扩展：提供了两个获取流的方法：
- default Stram Stream():返回一个顺序流
- default Stram parallelStream():返回一个并行流
public void test1(){ List<Employee> employees = EmployeeData.getEmployees(); //default Stram<E> Stream():返回一个顺序流 Stream<Employee> stream = employees.stram(); //default Stram<E> parallelStream():返回一个并行流 Stream<Employee> parallelStream = employees.parallelStream(); }创建Stream方式二：通过数组
Java8中的Arrays的静态方法stram()可以获取数组流：
- static Stream Stream(T[] array):返回一个流
重载形式，能够处理对应基本类型的数组
- public static IntStream stream(int[] array)
- public static LongStream stream(long[] array)
- public static DoubleStream stream(double[] array)
public void test2(){ int[] arr = new int[]{1,2,3,4,5,6}; IntStream stream = Arrays.stream(arr); Employee e1 = new Employee(1001,"Tom"); Employee e2 = new Employee(1002,"Jerry"); Employee[] arr1 = new Employee[]{e1,e2}; Stream<Employee> stream1 = Arrays.stream(arr1) }创建Stream方式三：通过Stream的of()
可以调用Stream类静态方法of()，通过显示值创建一个流。它可以接收任意数量的参数
- public static Stream of(T… value):返回一个流
public void test3(){ Stream<Integer> stream = Stream.of(1,2,3,4,5,6); }创建Stream方式四：创建无限流
可以使用静态方法Stream.iterate()和Stream.generate(),创建无限流
- 迭代
public static Stream iterate(final T seed, final UnaryOperator f)
- 生成
public static Stream generate(Supplier s)
//迭代 //public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) //遍历前10个偶数 Stream.interate(0, t -> t + 2).limit(10).forEach(System.out::println); //生成 //public static<T> Stream<T> generate(Supplier<T> s) Stream.generate(Math::random).limit(10).forEach(System.out::println);Stream的中间操作
多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为"惰性求值"
1-筛选与切片
方法 描述 filter(Predicate p) 接收Lambda，从流中排除某些元素 distinct() 筛选，通过流所生成元素的hashCode()和equals()去除重复元素 limit(long maxSize) 截断流，使其元素不超过给定数量 skip(long n) 跳过元素，返回一个扔掉了前n个元素1的流。若流中元素不足n个，则返回个空流。与limit(n)互补 public void test1(){ List<Employee> list = EmployeeData.getEmployees(); //filter(Predicate p)——接收Lambda，从流中排除某些元素 Stream<Employee> stream = list.stream(); //查询员工表中薪资大于7000的员工信息 stream.filter(e -> e.getSalary() > 7000).forEach(System.out::ptintln); System.put.println(); //limit(long maxSize)——截断流，使其元素不超过给定数量 list.Stream().limit(3).forEach(System.out::println); System.put.println(); //skip(long n)--跳过元素，返回一个扔掉了前n个元素1的流。若流中元素不足n个，则返回个空流。与limit(n)互补 list.Stream().skip(3).forEach(System.out::println); System.put.println(); //distinct()--筛选，通过流所生成元素的hashCode()和equals()去除重复元素 list.Stream().distinct().forEach(System.out.println); }2-映射
方法 描述 map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素 mapToDouble(toDoubleFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream mapToInt(ToIntFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream mapToLang(ToIntFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流 public void test2(){ //map(Function f)--接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素 List<String> list = Arrays.asList("aa","bb","cc","dd"); list.stream().map(str -> str.toUpperCase()).forEach(System.out::println); System.out.println(); //flatMap(Function f)--接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流 Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStrToStream); characterStream.forEach(System.out::println); }3-排序
方法 描述 sorted() 产生一个新流，其中按自然顺序排序 sorted(Comparator com) 产生一个新流，其中按比较器顺序排序 public void test1(){ //sorted()--产生一个新流，其中按自然顺序排序 List<Integer> list = Arrays.asList(1,2,3,4,5); list.stream().sorted().forEach(System.out::prrintln); //sorted(Comparator com)--定制排序 List<Employee> employees = EmployeeData.getEmployees(); employees.stream().sorted((e1,e2) -> Integer.compare(e1.getAge(),e2.getAge())).forEach(System.out::println); }Stream的终止操作
- 终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是void。
- 流进行了终止操作后，不能再次使用
1-匹配与查找
方法 描述 allMatch(Predicate p) 检查是否匹配所有元素 anyMatch(Predicate p) 检查是否至少匹配一个元素 noneMatch(Predicate p) 检查是否没有匹配所有元素 findFirst() 返回第一个元素 findAny() 返回当前流中的任意元素 public void test(){ List<Employee> employees = EmployeeData.getEmployees(); //allMatch(Predicate p)--检查是否匹配所有元素。 //是否所有员工年龄都大于18岁 boolean allMatch = employee.stream().allMatch(e -> e.getAge() > 18); System.out.println(allMatch); //anyMatch(Predicate p)--检查是否至少匹配一个元素 //是否存在员工工资大于10000 boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000); System.out.println(anyMatch); //noneMatch(Predicate p)--检查是否没有匹配所有元素 //是否存在员工姓“雷” boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startWith("雷")); System.out.println(noneMatch); //findFirst()--返回第一个元素 Optional<Employee> employee = employees.stream().findFirst(); System.out.println(employe); //findAny()--返回当前流中的任意元素 Optional<Employee> employee1 = employees.stream().findAny(); System.out.println(employe1); }方法 描述 count 返回流中元素的总个数 max(Comparator c) 返回流中最大值 min(Comparator c) 返回流中最小值 forEach(Consumer c) 内部迭代 public void test2(){ List<Employee> employees = EmployeeData.getEmployees(); //count--返回流中元素的总个数 long count = employees.stream().filter(e -> e.getSalary() > 5000).count(); System.out.println(count); //max(Comparator c)--返回流中最大值 //返回最高的工资 Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary()); Optional<Double> maxSalary = salaryStream.max(Double::compare); System.out.println(maxSalary); //min(Comparator c)--返回流中最小值 //返回最小工资的员工 Optional<Employee> employee = employees.stream().min((e1,e2) -> Double.compare(e1.getSalary(),e2.getSalary())); //forEach(Consumer c)--内部迭代 employees.stream().forEach(System.out::println); }2-归约
方法 描述 reduce(T iden,BinaryOperator b) 可以将流中元素反复结合起来，得到一个值，返回T reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值，返回Optional map和reduce的连接通常称为map-reduce模式
public void test3(){ //reduce(T iden,BinaryOperator b)--可以将流中元素反复结合起来，得到一个值，返回T //计算1-10的自然数的和 List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10); list.stream().reduce(0,Integer::sum); //reduce(BinaryOperator b)--可以将流中元素反复结合起来，得到一个值，返回Optional<T> //计算公司所有员工工资的总和 List<Employee> employees = EmployeeData.getEmployees(); Stream<Double> salaryStream = employees.stream().map(Employee::getSalary); Optional<Double> sumMoney = salaryStream.reduce(Double::sum); System.out.println(sumMoney); }3-收集
方法 描述 collect(Collector c) 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法 Collector接口中方法的实现决定了如何对流执行操作(如收集到List、Set、Map)
另外，Collectors实用类提供了很多静态方法，可以方便创建常见收集器实例，具体方法和实例如下
方法 返回类型 作用 toList List 把流中元素收集到List toSet Set 把流中元素收集到Set toCollection Collection 把流中元素收集到创建的集合 counting Long 计算流中元素的个数 summingInt Integer 对流中元素的整数属性求和 averagingInt Double 计算流中元素Integer属性的平均值 summarizingInt IntSummaryStatics 收集流中Integer属性的统计值。如：平均值 public void test4(){ //collect(Collector c)--将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法 //查找工资大于6000的员工，结果返回一个List或Set List<Employee> employees = EmployeeData.getEmployees(); List<Employee> employeeList = employees.stream(),filter(e -> e.getSalary() > 6000).collect(Collectors.toList()); employeeList.forEach(System.out::println); System.oue.println(); Set<Employee> employeeSet = employees.stream(),filter(e -> e.getSalary() > 6000).collect(Collectors.toSet()); employeeSet.forEach(System.out::println); }
OPtional类
- Optional类(java.util.optional)是一个容器类，它可以保存类型T的值，代表这个值存在，或者仅仅保存null，表示这个值不存在。原来用null表示表示一个值不存在，现在Optional可以更好的表达这个概念。并且可以避免空指针异常
- 创建Optional类对象的方法：
- Optional.of(T t)：创建一个Optional实例，t必须非空
- Optional.empty()：创建一个空的Optional实例
- Optional.ofNullable(T t)：t可以为null
- 判断Optional容器中是否包含对象：
- boolean isPresent()：判断是否包含对象
- void isPresent(Consumer<? super T> consumer)：如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传递给它
- 获取Optional容器的对象
- T get()：如果调用对象包含值，返回该值，否则抛出异常
- T orElse(T other)：如果有值则将其返回，否则返回指定的other对象
- T orElseGet(Suppler<? extends T> other)：如果有值则将其返回，否则返回由Supplier接口实现提供的对象
- T orElseThrow(Supplier<Supplier<? extends X> exceptionSupplier)：如果有值则将其返回，否则抛出由Supplier接口实现提供的异常
public class Girl{
private String name;
public Girl(){
}
public Girl(String name){
this.name = name;
}
public String toString(){
return name;
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
}
public class Boy{
private Girl girl;
public Boy(){
}
public Boy(Girl girl){
this.girl = girl;
}
public Girl getGirl(){
return girl;
}
public void setGirl(){
this.girl = girl;
}
public String toString(){
return girl;
}
}
/*Optional.of(T t)：创建一个Optional实例，t必须非空
Optional.empty()：创建一个空的Optional实例
Optional.ofNullable(T t)：t可以为null
*/
public void test1(){
Girl girl = new Girl();
Optional<Girl> optionalGirl = Optional.of(girl);
}
public void test2(){
Girl girl = new Girl();
Optional<Girl> optionalGirl = Optional.ofNullable(girl);
Girl girl1 = optionalGirl.orElse(new Girl("苍井空"));
System.out.println(optionalGirl);
System.out.println(girl1);
}
public String getGirlName(Boy boy){
if(boy != null){
Girl girl = boy.getGirl();
if(girl != null){
return girl.getName();
}
}
return null;
}
public void test3(){
Boy boy = new Boy();
String girlName = getGirlName(boy);
System.out.println(girlName);
}
//使用Optional类的getGirlName():
public String getGirlName1(Boy boy){
Optional<Boy> boyOptional = Optional.ofNullable(boy);
Boy boy1 = boyOptional.orElse(new Boy(new Girl("波多野结衣")))；
Girl girl = boy1.getGirl();
Optional<Girl> girlOptional = Optional.ofNullable(girl);
Girl girl1 = girlOptional.orElse(new Girl("三上悠亚"));
return girl1.getName();
}
public void test4(){
Boy boy = null;
String girlName = getGirlName1(boy);
System.out.println(girlName);
}
Java8默认接口方法
- 默认方法就是接口可以由实现方法，而且不需要实现类去实现其方法
语法
public interface Orange{
default void print(){
System.out.println("橘子");
}
}
静态默认方法
Java8的另一个特性是接口可以声明(并且可以提供实现)静态方法。
public interface Orange{
default void print(){
System.out.println("橘子");
}
static void eat(){
System.out.println("吃橘子");
}
}
新日期时间API
旧版Java中，日期时间存在问题
- 非线程安全
- 设计性差
- 时区处理麻烦
Java8在java.time包下提供了很多新API,以下面两个比较重要
- Local(本地)–简化了日期时间的处理，没有时区的问题
- Zoned(时区)–通过指定的时区处理日期问题
本地化日期时间API
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.Month;
public class TestTimer(){
public static void main(String args[]){
Test testTimer = new Test();
testTimer.testLocalDateTime();
}
public void testLocalDateTime(){
//获取当前的日期时间
LocalDateTime currentTime = LocalDateTime();
System.out.println("当前时间: " + currentTime);
LocalDate date1 = currentTime.toLocalDate();
System.out.println("date1: " + date1);
Month month = currentTime.getMonth();
int day = currentTime.getDayOfMonth();
int seconds = currentTime.getSecond();
System.out.println("月: " + month +", 日: " + day +", 秒: " + seconds);
LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
System.out.println("date2: " + date2);
//12 december 2014
LocalDate date3 = LocalDate.of(2014,Month.DECEMBER,12);
System.out.println("date3: " + date3);
//22小时15分钟
LocalTime date4 = LocalTime.of(22,15);
System.out.println("date4: " + date4);
//解析字符串
LocalTime date5 = LocalTime.parse(20:13:30);
System.out.println("date5: " + date5);
}
}
使用时区的日期时间API
import java.time.ZonedDateTime;
import java.time.ZoneId;
public class Java8Tester {
public static void main(String args[]){
Java8Tester java8tester = new Java8Tester();
java8tester.testZonedDateTime();
}
public void testZonedDateTime(){
//获取当前时间日期
ZonedDateTime date1 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");
ZineId id = ZoneId.of("Europe/Paris");
System.out.println("ZoneId: " + id);
ZoenId currentZone = ZoneId.systemDefault();
System.out.println("当期时区: " + currentZone);
}
}
```java
LocalTime date4 = LocalTime.of(22,15);
System.out.println("date4: " + date4);
//解析字符串
LocalTime date5 = LocalTime.parse(20:13:30);
System.out.println("date5: " + date5);
}
}
使用时区的日期时间API
import java.time.ZonedDateTime;
import java.time.ZoneId;
public class Java8Tester {
public static void main(String args[]){
Java8Tester java8tester = new Java8Tester();
java8tester.testZonedDateTime();
}
public void testZonedDateTime(){
//获取当前时间日期
ZonedDateTime date1 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");
ZineId id = ZoneId.of("Europe/Paris");
System.out.println("ZoneId: " + id);
ZoenId currentZone = ZoneId.systemDefault();
System.out.println("当期时区: " + currentZone);
}
}
704
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
