枚举类，Lambda表达式，JDK1.8新增日期API_java1.8枚举类api

1.JDK5新特性（枚举类）

JDK1.5的新特性

自动拆装箱 , 泛型 , 增强for , 可变参数 , 枚举
1

（1）枚举概述

就是一个类只能存在几个固定的对象,那么这个就是枚举.我们就可以使用这些对象可以表示一些固定的值。
举例：一周只有7天，一年只有12个月等。

（2）枚举的注意事项

• 定义枚举类要用关键字enum
• 所有枚举类都是Enum的子类，但是不要显式的写出来
• 枚举类的第一行上必须是枚举项，最后一个枚举项后的分号 是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略
• 枚举类可以有构造器，但必须是private的，它默认的也是private的。枚举项的用法比较特殊：枚举(“”);
• 枚举类也可以有抽象方法，但是枚举项必须重写该方法
• 枚举在switch语句中的使用

（3）枚举类的常用方法

int ordinal()  返回枚举项的序号
int compareTo(E o) 比较两个枚举项的 返回的是两个枚举项序号的 差值
String name() 获取枚举项的名称
String toString()获取枚举项的名称
<T> T valueOf(Class<T> type,String name) 用来获取指定的枚举项  参数1:枚举类对应的字节码对象 参数2 枚举项的名称
values()  获取所有的枚举项
1
2
3
4
5
6

（4）案例演示

package com.练习.枚举类;
public class Demo1 {
    public static void main(String[] args) {
        demo behind = demo.BEHIND;
        demo front = demo.FRONT;
        demo left = demo.LEFT;
        demo right = demo.RIGHT;
        System.out.println(behind.ordinal());//返回枚举项的序号
        System.out.println(front.compareTo(left));//比较两个枚举项的 返回两个枚举项的序号差值
        System.out.println(left.name());//返回枚举项的名称
        //获取指定的枚举项
        demo right1 = demo.valueOf(demo.class, "RIGHT");
        System.out.println(right1);
        //获取所有的枚举项
        demo[] values = demo.values();
        for (demo value : values) {
            System.out.println(value);
        }
    }
}
enum demo{
FRONT,BEHIND,LEFT,RIGHT;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2.Lambda表达式

（1）概述

• Lambda 是一个匿名函数，可以把 Lambda表达式 理解为是一段可以传递的代码 (将代码像数据一样进行传递)。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
• 基础语法： Java8 中引入了一个新的操作符 “->” 该操作符称为箭头操作符或 Lambda 操作符，箭头操作符将 Lambda 表达式拆分成两部分 :
  左侧 : Lambda 表达式的参数列表
  右侧 : Lambda 表达式中所需执行的功能， 即 Lambda 体

（2）应用

package com.westmo3.demo2;
import java.util.Arrays;
import java.util.Comparator;
public class MyDemo8 {
    public static void main(String[] args) {
        Integer arr[]={12,9,23,11,34,10};
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        Integer arr1[]={12,9,23,11,34,10};
        //上面的代码有Lambda表达式一行就完成了
        Arrays.sort(arr1,(o1,o2)->o1-o2);
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

（3）.对接口的要求

• 虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambda 表达式来实现。Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法。
• @FunctionalInterface
  修饰函数式接口的，要求接口中的抽象方法只有一个。 这个注解往往会和 lambda 表达式一起出现。

package com.westmo3.demo2;

public class MyDemo9 {
    public static void main(String[] args) {
        new Myinterface() {
            @Override
            public void test() {
                System.out.println("123");
            }
        }.test();
        //lambda表达式实现
        Myinterface myinterface=()-> System.out.println("123");
        myinterface.test();
    }
}
@FunctionalInterface //修饰函数式接口的，要求接口中的抽象方法只有一个
interface Myinterface{
    void test();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.JDK1.8新增时间日期API

JDK1.8之前，关于时间日期的API线程是不安全的，1.8之后，新的时间日期API是线程安全的。针对日期提供了三个类。

• LocalDate，表示年月日
• LocalTime，表示时分秒
• LocalDateTime，表示年月日时分秒
  常用方法

1.与获取相关的方法:get系类的方法
		ldt.getYear();获取年
		ldt.getMinute();获取分钟
		ldt.getHour();获取小时
		getDayOfMonth 获得月份天数(1-31)
		getDayOfYear 获得年份天数(1-366)
		getDayOfWeek 获得星期几(返回一个 DayOfWeek枚举值)
		getMonth 获得月份, 返回一个 Month 枚举值
		getMonthValue 获得月份(1-12)
		getYear 获得年份
2.格式化日期日期字符串的方法 format()
3.转换的方法 toLocalDate();toLocalTime();
4.判断的方法
		isAfter()判断一个日期是否在指定日期之后
		isBefore()判断一个日期是否在指定日期之前
		isEqual(); 判断两个日期是否相同
		isLeapYear()判断是否是闰年注意是LocalDate类中的方法
5.解析的静态方法parse()
6.添加年月日时分秒的方法 plus系列的方法 都会返回一个新的LocalDateTime的对象
		LocalDateTime localDateTime = ldt.plusYears(1);
		LocalDateTime localDateTime1 = ldt.plusMonths(3);
		LocalDateTime localDateTime2=ldt.plusHours(10);
7.减去年月日时分秒的方法 minus 系列的方法 注意都会返回一个新的LocalDateTime的对象
8.指定年月日时分秒的方法 with系列的方法 注意都会返回一个新的LocalDateTime的对象
		例如 LocalDateTime localDateTime3 = ldt.withYear(1998);
		  //获取这个月的第几个星期几是几号,比如 TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.FRIDAY) 代表的意思是这个月的第二个星期五是几号
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

案例演示

package com.westmo3.demo3;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
public class MyDemo6 {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();//获取当前时间 年月是分秒
        System.out.println(now);
        LocalDateTime of = LocalDateTime.of(2020, 3, 9, 21, 37, 2);//指定日期
        System.out.println(now.getYear());//获取当前年份
        //日期格式化
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-DD HH:mm:ss");
        System.out.println(now.format(dateTimeFormatter));
        //判断两个日期的前后关系
        LocalDate now1 = LocalDate.now();
        LocalDate of1 = LocalDate.of(2020, 3, 2);
        System.out.println(of1.isBefore(now1));//判断一个日期是否在另一个日期之前
        System.out.println(of1.isAfter(now1));//判断一个日期是否在另一个日期之后
        //解析日期
        String data="2020年03月03日";
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
        System.out.println(LocalDate.parse(data, dateTimeFormatter1));
        System.out.println(now1.plusMonths(3));//给当前日期增加时间量
        //TemporalAdjusters工具类，提供了一些获取特殊日期的方法
        LocalDate with1 = now1.with(TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.FRIDAY));//这个月的第二个星期五是几号
        System.out.println(with1);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

4.时间戳类Instant

1获取对象的方法 now()
	注意默认获取出来的是当前的美国时间和我们相差八个小时
		我们在东八区 所以可以加8个小时 就是我们的北京时间
2. Instant中设置偏移量的方法:atOffset() 设置偏移量
3.获取系统默认时区时间的方法atZone()，方法的参数是要一个时区的编号可以通过时区编号类获取出来，ZoneId.systemDefault()获取本地的默认时区ID
4.get系列的方法
	getEpochSecond() 获取从1970-01-01 00:00:00到当前时间的秒值
	toEpochMilli();获取从1970-01-01 00:00:00到当前时间的毫秒值
	getNano()方法是把获取到的当前时间的秒数 换算成纳秒
	long epochSecond = ins.getEpochSecond();//获取从1970-01-01 00:00:00到当前时间的秒值
	getNano()方法是把获取到的当前时间的豪秒数 换算成纳秒 比如当前时间是2018-01-01 14:00:20:30
	那就把30豪秒换算成纳秒 int nano = ins.getNano();
5. ofEpochSecond()方法 给计算机元年增加秒数
	ofEpochMilli() 给计算机元年增加毫秒数
		单位换算
		 0.1 毫秒 = 10 的5次方纳秒 = 100000 纳秒
   			 1 毫秒 = 1000 微妙 = 1000000 纳秒
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

案例演示

package com.westmo3.demo3;
import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
public class MyDemo7 {
    public static void main(String[] args) {
        //获取从1970-01-01 00:00:00到当前时间的秒值
        Instant now = Instant.now();
        System.out.println(now);//获取的是默认时区
        OffsetDateTime offsetDateTime = now.atOffset(ZoneOffset.ofHours(8));//增加偏移量 获取到的就是当前时区
        System.out.println(offsetDateTime);
        System.out.println(now.getEpochSecond());获取从1970 -01 - 01 00:00:00 截止到当前时间间隔的秒值
        //给计算机元年增加毫秒数
        Instant instant = Instant.ofEpochMilli(1000 * 60 * 60 * 24);
        System.out.println(instant);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

5.Duration和 Period 类

• 用于计算两个“时间”间隔的类
• 用于计算两个“日期”间隔的类
  案例演示

package com.westmo3.demo3;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.Period;
public class MyDemo8 {
    public static void main(String[] args) {
        Instant now = Instant.now();
        for (int i = 0; i < 1000; i++) {
            System.out.println(i);
        }
        Instant now1 = Instant.now();
        Duration between = Duration.between(now, now1);//计算两个时间之间的间隔
        System.out.println(between.toMillis());//将结果转换为毫秒值
        LocalDate now2 = LocalDate.now();
        LocalDate of = LocalDate.of(1998, 01, 05);
        Period between1 = Period.between(of,now2);//计算两个日期之间的间隔
        System.out.println(between1.getYears());//计算间隔了多少年
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20