面向面试编程：Java8新特性——Optional类和新时间日期API

Bertha 。 2023-09-26 16:01 43阅读 0赞

## Optional类 ##

这个Optional类主要是解决空指针的问题。

### 以前对null的处理 ###

@Test
        public void test01(){
            String userName = null;
            if(userName != null){
                System.out.println("字符串的长度：" + userName.length());
            }else{
                System.out.println("字符串为空");
            }
    
        }
    复制代码

### Optional类介绍 ###

Optional是一个没有子类的工具类，Optional是一个可以为null的容器对象，它的主要作用就是为了避免Null检查，防止NullpointerException。

### Optional的基本使用 ###

Optional对象的创建方式：

/**
         * Optional对象的创建方式
         */
        @Test
        public void test02(){
            // 第一种方式 通过of方法  of方法是不支持null的
            Optional<String> op1 = Optional.of("zhangsan");
            //Optional<Object> op2 = Optional.of(null);
    
            // 第二种方式通过 ofNullable方法 支持null
            Optional<String> op3 = Optional.ofNullable("lisi");
            Optional<Object> op4 = Optional.ofNullable(null);
    
            // 第三种方式 通过empty方法直接创建一个空的Optional对象
            Optional<Object> op5 = Optional.empty();
    
        }
    复制代码

### Optional的常用方法 ###

*  get(): 如果Optional有值则返回，否则抛出NoSuchElementException异常。get()通常和isPresent方法一块使用
 *  isPresent():判断是否包含值，包含值返回true，不包含值返回false
 *  orElse(T t):如果调用对象包含值，就返回该值，否则返回t
 *  orElseGet(Supplier s):如果调用对象包含值，就返回该值，否则返回 Lambda表达式的返回值

@Test
        public void test03(){
            Optional<String> op1 = Optional.of("zhangsan");
            Optional<String> op2 = Optional.empty();
    
            // 获取Optional中的值
            if(op1.isPresent()){
                String s1 = op1.get();
                System.out.println("用户名称:" +s1);
            }
    
            if(op2.isPresent()){
                System.out.println(op2.get());
            }else{
                System.out.println("op2是一个空Optional对象");
            }
    
            String s3 = op1.orElse("李四");
            System.out.println(s3);
            String s4 = op2.orElse("王五");
            System.out.println(s4);
    
            String s5 = op2.orElseGet(()->{
                return "Hello";
            });
            System.out.println(s5);
        }
        
        @Test
        public void test04(){
            Optional<String> op1 = Optional.of("zhangsan");
            Optional<String> op2 = Optional.empty();
            // 如果存在值 就做什么
            op1.ifPresent(s-> System.out.println("有值:" +s));
            op1.ifPresent(System.out::println);
        }
    
        /**
         * 自定义一个方法，将Person对象中的 name 转换为大写 并返回
         */
        @Test
        public void test05(){
            Person p = new Person("zhangsan",18);
            Optional<Person> op = Optional.of(p);
            String name = getNameForOptional(op);
            System.out.println("name="+name);
    
        }
    
        /**
         * 根据Person对象 将name转换为大写并返回
         *    通过Optional方式实现
         * @param op
         * @return
         */
        public String getNameForOptional(Optional<Person> op){
           if(op.isPresent()){
               String msg = //op.map(p -> p.getName())
                       op.map(Person::getName)
                       //.map(p -> p.toUpperCase())
                       .map(String::toUpperCase)
                       .orElse("空值");
               return msg;
           }
           return null;
        }
    
        /**
         * 根据Person对象 将name转换为大写并返回
         * @param person
         * @return
         */
        public String getName(Person person){
            if(person != null){
                String name = person.getName();
                if(name != null){
                    return name.toUpperCase();
                }else{
                    return null;
                }
            }else{
                return null;
            }
        }
    复制代码

## 新时间日期API ##

面试官：说说Java8新的时间日期API
    复制代码

### 旧版日期时间的问题 ###

在旧版本中JDK对于日期和时间这块的时间是非常差的。

*  设计不合理，在java.util和java.sql的包中都有日期类，java.util.Date同时包含日期和时间的，而java.sql.Date仅仅包含日期，此外用于格式化和解析的类在java.text包下。
 *  非线程安全，java.util.Date是非线程安全的，所有的日期类都是可变的，这是java日期类最大的问题之一。
 *  时区处理麻烦，日期类并不提供国际化，没有时区支持。

### 新日期时间API介绍 ###

JDK 8中增加了一套全新的日期时间API，这套API设计合理，是线程安全的。新的日期及时间API位于 java.time 包 中，下面是一些关键类。

*  LocalDate ：表示日期，包含年月日，格式为 2019-10-16
 *  LocalTime ：表示时间，包含时分秒，格式为 16:38:54.158549300
 *  LocalDateTime ：表示日期时间，包含年月日，时分秒，格式为 2018-09-06T15:33:56.750
 *  DateTimeFormatter ：日期时间格式化类。
 *  Instant：时间戳，表示一个特定的时间瞬间。
 *  Duration：用于计算2个时间(LocalTime，时分秒)的距离
 *  Period：用于计算2个日期(LocalDate，年月日)的距离
 *  ZonedDateTime ：包含时区的时间

Java中使用的历法是ISO 8601日历系统，它是世界民用历法，也就是我们所说的公历。平年有365天，闰年是366 天。此外Java 8还提供了4套其他历法，分别是：

*  ThaiBuddhistDate：泰国佛教历
 *  MinguoDate：中华民国历
 *  JapaneseDate：日本历
 *  HijrahDate：伊斯兰历

#### 日期时间的常见操作 ####

LocalDate，LocalTime以及LocalDateTime的操作。

/**
         * JDK8 日期时间操作
         */
        @Test
        public void test01(){
            // 1.创建指定的日期
            LocalDate date1 = LocalDate.of(2021, 05, 06);
            System.out.println("date1 = "+date1);
    
            // 2.得到当前的日期
            LocalDate now = LocalDate.now();
            System.out.println("now = "+now);
    
            // 3.根据LocalDate对象获取对应的日期信息
            System.out.println("年：" + now.getYear());
            System.out.println("月：" + now.getMonth().getValue());
            System.out.println("日：" + now.getDayOfMonth());
            System.out.println("星期：" + now.getDayOfWeek().getValue());
        }
    
        /**
         * 时间操作
         */
        @Test
        public void test02(){
            // 1.得到指定的时间
            LocalTime time = LocalTime.of(5,26,33,23145);
            System.out.println(time);
            // 2.获取当前的时间
            LocalTime now = LocalTime.now();
            System.out.println(now);
            // 3.获取时间信息
            System.out.println(now.getHour());
            System.out.println(now.getMinute());
            System.out.println(now.getSecond());
            System.out.println(now.getNano());
        }
    
        /**
         * 日期时间类型  LocalDateTime
         */
        @Test
        public void test03(){
            // 获取指定的日期时间
            LocalDateTime dateTime =
                    LocalDateTime.of(2020
                            , 06
                            , 01
                            , 12
                            , 12
                            , 33
                            , 213);
            System.out.println(dateTime);
            // 获取当前的日期时间
            LocalDateTime now = LocalDateTime.now();
            System.out.println(now);
            // 获取日期时间信息
            System.out.println(now.getYear());
            System.out.println(now.getMonth().getValue());
            System.out.println(now.getDayOfMonth());
            System.out.println(now.getDayOfWeek().getValue());
            System.out.println(now.getHour());
            System.out.println(now.getMinute());
            System.out.println(now.getSecond());
            System.out.println(now.getNano());
        }
    复制代码

#### 日期时间的修改和比较 ####

/**
         * 日期时间的修改
         */
        @Test
        public void test01(){
            LocalDateTime now = LocalDateTime.now();
            System.out.println("now = "+now);
            // 修改日期时间  对日期时间的修改，对已存在的LocalDate对象，创建了它模板
            // 并不会修改原来的信息
            LocalDateTime localDateTime = now.withYear(1998);
            System.out.println("now :"+now);
            System.out.println("修改后的：" + localDateTime);
    
            System.out.println("月份：" + now.withMonth(10));
            System.out.println("天：" + now.withDayOfMonth(6));
            System.out.println("小时：" + now.withHour(8));
            System.out.println("分钟:" + now.withMinute(15));
    
            // 在当前日期时间的基础上 加上或者减去指定的时间
            System.out.println("两天后:" + now.plusDays(2));
            System.out.println("10年后:"+now.plusYears(10));
            System.out.println("6个月后 = " + now.plusMonths(6));
    
            System.out.println("10年前 = " + now.minusYears(10));
            System.out.println("半年前 = " + now.minusMonths(6));
            System.out.println("一周前 = " + now.minusDays(7));
        }
    
        /**
         * 日期时间的比较
         */
        @Test
        public void test02(){
            LocalDate now = LocalDate.now();
            LocalDate date = LocalDate.of(2020, 1, 3);
            // 在JDK8中要实现 日期的比较 isAfter  isBefore isEqual 通过这几个方法来直接比较
            System.out.println(now.isAfter(date)); // true
            System.out.println(now.isBefore(date)); // false
            System.out.println(now.isEqual(date)); // false
        }
    复制代码

注意：在进行日期时间修改的时候，原来的LocalDate对象是不会被修改，每次操作都是返回了一个新的LocalDate对象，所以在多线程场景下是数据安全的。

#### 格式化和解析操作 ####

在JDK8中我们可以通过`java.time.format.DateTimeFormatter`类可以进行日期的解析和格式化操作。

@Test
        public void test01(){
            LocalDateTime now = LocalDateTime.now();
            // 指定格式  使用系统默认的格式 2021-05-27T16:16:38.139
            DateTimeFormatter isoLocalDateTime = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
            // 将日期时间转换为字符串
            String format = now.format(isoLocalDateTime);
            System.out.println("format = " + format);
    
            // 通过 ofPattern 方法来指定特定的格式
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            String format1 = now.format(dateTimeFormatter);
            // 2021-05-27 16:16:38
            System.out.println("format1 = " + format1);
    
            // 将字符串解析为一个 日期时间类型
            LocalDateTime parse = LocalDateTime.parse("1997-05-06 22:45:16", dateTimeFormatter);
            // parse = 1997-05-06T22:45:16
            System.out.println("parse = " + parse);
        }
    复制代码

#### Instant类 ####

在JDK8中给我们新增一个Instant类(时间戳/时间线)，内部保存了从1970年1月1日 00:00:00以来的秒和纳秒。

@Test
        public void test01() throws Exception{
            Instant now = Instant.now();
            System.out.println("now = " + now);
    
            // 获取从1970年一月一日 00:00:00 到现在的 纳秒
            System.out.println(now.getNano());
            Thread.sleep(5);
            Instant now1 = Instant.now();
            System.out.println("耗时：" + (now1.getNano() - now.getNano()));
    
        }
    复制代码

#### 计算日期时间差 ####

JDK8中提供了两个工具类Duration/Period：计算日期时间差。

*  Duration：用来计算两个时间差(LocalTime)
 *  Period:用来计算两个日期差(LocalDate)

@Test
        public void test01(){
            // 计算时间差
            LocalTime now = LocalTime.now();
            LocalTime time = LocalTime.of(22, 48, 59);
            System.out.println("now = " + now);
            // 通过Duration来计算时间差
            Duration duration = Duration.between(now, time);
            System.out.println(duration.toDays()); // 0
            System.out.println(duration.toHours()); // 6
            System.out.println(duration.toMinutes()); // 368
            System.out.println(duration.toMillis()); // 22124240
    
            // 计算日期差
            LocalDate nowDate = LocalDate.now();
            LocalDate date = LocalDate.of(1997, 12, 5);
            Period period = Period.between(date, nowDate);
            System.out.println(period.getYears()); // 23
            System.out.println(period.getMonths()); // 5
            System.out.println(period.getDays()); // 22
        }
    复制代码

#### 时间校正器 ####

有时候我们可以需要如下调整：将日期调整到"下个月的第一天"等操作。这时我们通过时间校正器效果可能会更好。

*  TemporalAdjuster:时间校正器
 *  TemporalAdjusters:通过该类静态方法提供了大量的常用TemporalAdjuster的实现。

@Test
        public void test02(){
            LocalDateTime now = LocalDateTime.now();
            // 将当前的日期调整到下个月的一号
            TemporalAdjuster adJuster = (temporal)->{
                LocalDateTime dateTime = (LocalDateTime) temporal;
                LocalDateTime nextMonth = dateTime.plusMonths(1).withDayOfMonth(1);
                System.out.println("nextMonth = " + nextMonth);
                return nextMonth;
            };
            // 我们可以通过TemporalAdjusters 来实现
            // LocalDateTime nextMonth = now.with(adJuster);
            LocalDateTime nextMonth = now.with(TemporalAdjusters.firstDayOfNextMonth());
            System.out.println("nextMonth = " + nextMonth);
        }
    复制代码

#### 日期时间的时区 ####

Java8 中加入了对时区的支持，LocalDate、LocalTime、LocalDateTime是不带时区的，带时区的日期时间类分别为：ZonedDate、ZonedTime、ZonedDateTime。其中每个时区都对应着 ID，ID的格式为 “区域/城市” 。例如 ：Asia/Shanghai 等。

ZoneId：该类中包含了所有的时区信息。

@Test
        public void test01(){
            // 获取所有的时区id
            // ZoneId.getAvailableZoneIds().forEach(System.out::println);
    
            // 获取当前时间 中国使用的 东八区的时区，比标准时间早8个小时
            LocalDateTime now = LocalDateTime.now();
            System.out.println("now = " + now); // 2021-05-27T17:17:06.951
            // 获取标准时间
            ZonedDateTime bz = ZonedDateTime.now(Clock.systemUTC());
            System.out.println("bz = " + bz); // 2021-05-27T09:17:06.952Z
    
            // 使用计算机默认的时区，创建日期时间
            ZonedDateTime now1 = ZonedDateTime.now();
            System.out.println("now1 = " + now1); //2021-05-27T17:17:06.952+08:00[Asia/Shanghai]
    
            // 使用指定的时区创建日期时间
            ZonedDateTime now2 = ZonedDateTime.now(ZoneId.of("America/Marigot"));
            System.out.println("now2 = " + now2);
    
        }
    复制代码

#### JDK新的日期和时间API的优势 ####

*  新版日期时间API中，日期和时间对象是不可变，操作日期不会影响原来的值，而是生成一个新的实例
 *  提供不同的两种方式，有效的区分了人和机器的操作
 *  TemporalAdjuster可以更精确的操作日期，还可以自定义日期调整期
 *  线程安全