Java学习高级五

南风number

已于 2024-09-02 13:23:08 修改

阅读量260

点赞数 1

分类专栏： Java 文章标签：学习 java

于 2024-08-19 14:04:35 首次发布

本文链接：https://blog.csdn.net/weixin_45730243/article/details/141323854

版权

Java 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

API

在这里插入图片描述

常用API

在这里插入图片描述

Object类

在这里插入图片描述

Object类的常见方法

在这里插入图片描述

Object类提供的对象克隆方法

在这里插入图片描述

@Override // 浅拷贝
    protected Object clone() throws CloneNotSupportedException {
        // super去调用父类Object中的clone方法
        return super.clone();
    }

@Override // 深拷贝
    protected Object clone() throws CloneNotSupportedException {
        // super去调用父类Object中的clone方法
        User u2 = (User) super.clone();
        u2.scores = u2.scores.clone();
        return u2;
    }

在这里插入图片描述

Objects常见方法

在这里插入图片描述

import java.util.Objects;

public class Test {
    public static void main(String[] args) {
        // OBjects 类常用方法
        /*String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1.equals(s2));
        System.out.println(Objects.equals(s1, s2));*/
        String s1 = null;
        String s2 = "abc";
        //System.out.println(s1.equals(s2)); //报错 空指针异常
        System.out.println(Objects.equals(s1, s2));//更安全 更好

        System.out.println(Objects.isNull(s1));//true
        System.out.println(s1 == null);//true
        System.out.println(Objects.isNull(s2));//false
        System.out.println(s2 == null);//false


        System.out.println(Objects.nonNull(s2));//true
    }
}

在这里插入图片描述

包装类

在这里插入图片描述

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        // 包装类的使用
        //Integer a1= new Integer(10); //过时

        Integer a1 = Integer.valueOf(10);
        System.out.println(a1);

        //自动装箱：可以自动将基本数据类型转换为包装类
        Integer a2 = 10;
        System.out.println(a2);

        //自动拆箱：可以自动将包装类转换为基本数据类型
        int a3 = a2;
        System.out.println(a3);


        // 泛型和集合不支持基本数据类型，只能支持引用数据类型
        //ArrayList<int> list = new ArrayList<>();
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);//自动装箱
        System.out.println(list);
        int a4 = list.get(0);//自动拆箱

        System.out.println("----------------------");

        //1、把基本数据类型转换为字符串
        Integer a = 23;
        String rs1 = Integer.toString(a);//"23"
        System.out.println(rs1 + 1);//"231"

        String s2 = a.toString();//"23"
        System.out.println(s2 + 1);//"231"

        String s3 = a + "";
        System.out.println(s3 + 1);

        // 2、把字符串类型的数值转换为对应的基本类型
        String ageStr = "23";
        //int age = Integer.parseInt(ageStr);
        int age = Integer.valueOf(ageStr);
        System.out.println(age + 1);

        String scoreStr = "98.5";
        //double score = Double.parseDouble(scoreStr);
        double score = Double.valueOf(scoreStr);
        System.out.println(score + 1);

    }
}

在这里插入图片描述

StringBuilder

在这里插入图片描述

public class Test {
    public static void main(String[] args) {
        // StringBuilder的用法和作用
        //StringBuilder s= new StringBuilder();//""
        StringBuilder s = new StringBuilder("hello");//"hello"
        // 1.append 拼接内容
        s.append(12);
        s.append("你好");
        s.append(true);

        // 支持链式编程
        s.append(12).append("你好").append(true);
        System.out.println(s);
        // 2.reverce 反转
        s.reverse();
        System.out.println(s);

        // 3.length 长度
        int b = s.length();
        System.out.println(b);

        // 4.tostring 转字符串  把StringBuilder转成String
        String c = s.toString();
        System.out.println(c);
    }
}

在这里插入图片描述

StringBuffer

在这里插入图片描述

StringJoiner

在这里插入图片描述

import java.util.StringJoiner;

public class Test3 {
    public static void main(String[] args) {
        // 完成遍历数组内容，并拼接成指定格式
        int[] arr = {1, 2, 3};
        String a = getArrayData(arr);
        System.out.println(a);
    }

    /* public static String getArrayData(int[] arr) {
         //1、判断arr是否为null
         if (arr == null) {
             return null;
         }
         // 2、判断arr长度是否为0
         if (arr.length == 0) {
             return "";
         }
         // 3、遍历数组，拼接字符串
         StringBuilder sb = new StringBuilder();
         sb.append(("["));
         for (int i = 0; i < arr.length; i++) {
             if (i == arr.length - 1) {
                 sb.append(arr[i]);
                 continue;
             }
             sb.append(arr[i]).append(",");
         }
         sb.append("]");
         return sb.toString();
     }*/
    public static String getArrayData(int[] arr) {
        //1、判断arr是否为null
        if (arr == null) {
            return null;
        }
        // 2、判断arr长度是否为0
        if (arr.length == 0) {
            return "";
        }
        // 3、遍历数组，拼接字符串
        StringJoiner sb = new StringJoiner(",", "[", "]");
        for (int i = 0; i < arr.length; i++) {
            sb.add(arr[i] + "");
        }
        return sb.toString();
    }
}

Math

在这里插入图片描述

public class MathTset {
    public static void main(String[] args) {
        // Math类提供的常见方法
        // 1.绝对值
        System.out.println(Math.abs(-10));
        // 2.最大值
        System.out.println(Math.max(10, 20));
        // 3.最小值
        System.out.println(Math.min(10, 20));
        // 4.向上取整
        System.out.println(Math.ceil(10.5));
        // 5.向下取整
        System.out.println(Math.floor(10.5));
        // 6.四舍五入
        System.out.println(Math.round(10.5));
        // 7.随机数
        System.out.println(Math.random());
        // 8.向上取整
        System.out.println(Math.ceil(10.5));
        // 9.向下取整
        System.out.println(Math.floor(10.5));
        // 10.四舍五入
        System.out.println(Math.round(10.5));
        // 12.平方根
        System.out.println(Math.sqrt(10));
        // 13.幂运算
        System.out.println(Math.pow(2, 3));
        // 14.取整
        System.out.println(Math.rint(10.5));
    }
}

System

在这里插入图片描述


public class SystemTest {
    public static void main(String[] args) {
        // System类的常见方法
        //1、终止当前运行的java虚拟机
        // 非0表示异常终止 0表示人为终止
        //System.exit(0);
        //2、在标准输出流中，将指定的系统时间显示出来 1970年1月1日 00:00:00 开始到此刻的 毫秒值
        System.out.println(System.currentTimeMillis());

        long time = System.currentTimeMillis();
        System.out.println(time);
        for (int i = 0; i < 1000000; i++) {
            System.out.println(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println((endTime - time) / 1000 + "s");
    }
}

Runtime

在这里插入图片描述

import java.io.IOException;

public class RuntimeTest {
    public static void main(String[] args) throws IOException, InterruptedException {
        Runtime runtime = Runtime.getRuntime();
        System.out.println(runtime);
        // runtime.exec(0); // 非0表示异常终止 0表示人为终止
        int a = runtime.availableProcessors(); // 获取CPU核数
        System.out.println(a);
        long b = runtime.freeMemory(); // 获取JVM空闲内存
        System.out.println(b);
        long c = runtime.totalMemory(); // 获取JVM总内存  1024=1kb 1024*1024=1mb 1024*1024*1024=1gb
        System.out.println(c / (1024 * 1024) + "MB");
        long d = runtime.maxMemory(); // 获取JVM最大内存
        System.out.println(d);
        //runtime.exec("notepad"); // 启动记事本 因为全局环境变量配置了notepad，所以直接启动
        Process p = runtime.exec("D:\\HBuilderX.4.15.2024050802\\HBuilderX\\HBuilderX.exe");// 启动某个程序
        Thread.sleep(5000); // 让程序暂停5秒，
        p.destroy(); // 关闭HBuilderX
    }
}

时间毫秒值 1970

在这里插入图片描述

BigDecimal

在这里插入图片描述

import java.math.BigDecimal;
import java.math.RoundingMode;

public class BigdecimalDemo1 {
    public static void main(String[] args) {
        // BigDecimal使用 解决小数运算失真问题
        double a = 0.1;
        double b = 0.2;
        System.out.println(a + b); // 0.30000000000000004
        System.out.println("-----------");
        // 1、把double类型转换为字符串 封装为BigDecimal对象来运算
        /*BigDecimal a1= new BigDecimal(Double.toString(a));
        BigDecimal b1= new BigDecimal(Double.toString(b));*/
        // 推荐以下方式:把小数转换成字符串再得到BigDecimal对象来使用（更简洁）
        BigDecimal a1 = BigDecimal.valueOf(a);
        BigDecimal b1 = BigDecimal.valueOf(b);
        //System.out.println(a1.add(b1)); // 0.3 //加法
        //System.out.println(a1.subtract(b1)); //-0.1 //减法
        System.out.println(a1.multiply(b1)); //0.02 //乘法
        //System.out.println(a1.divide(b1)); //0.5 //除法
        System.out.println("-----------");

        BigDecimal i = BigDecimal.valueOf(0.1);
        BigDecimal j = BigDecimal.valueOf(0.3);
        BigDecimal result = i.divide(j,2, RoundingMode.HALF_UP);
        System.out.println(result);

        // 把BigDecimal类型转换为double
        double rs = result.doubleValue();
        System.out.println(rs);
    }
}

JDK8之前传统的日期、时间

在这里插入图片描述

Date

在这里插入图片描述

import java.util.Date;

public class Test1Date {
    public static void main(String[] args) {
        // Date日期类的使用
        // 1.创建Date对象
        Date date = new Date();
        System.out.println(date);

        // 2.获取时间戳
        long time = date.getTime();
        System.out.println(time);

        // 3.把时间毫秒值转化成日期对象 ：2秒后的时间是多少
        long time2 = time + 1000 * 2;
        Date date2 = new Date(time2);
        System.out.println(date2);

        // 4.直接把日期对象的时间通过setTime设置给Date对象
        Date date3 = new Date();
        date3.setTime(time2);
        System.out.println(date3);
    }
}

SimpleDateFormat

在这里插入图片描述

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test2SimpleDateFormat {
    public static void main(String[] args) throws ParseException {
        // SimpleDateFormat应用
        Date date = new Date();
        System.out.println(date);

        long time = date.getTime();
        System.out.println(time);

        // 格式化时间
        SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE a");
        String a = sdf.format(date);
        String b = sdf.format(time);
        System.out.println(a);
        System.out.println(b);
        System.out.println("----------------------------");

        // 解析字符串时间 成为日期对象
        String str = "2019-08-31 15:46:07";
        // 创建简单日期格式化对象 要求参数必须和被解析的字符串格式一致
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date2 = sdf2.parse(str);
        System.out.println(date2);

    }
}

在这里插入图片描述

秒杀案例

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test3 {
    public static void main(String[] args) throws ParseException {
        // 秒杀案例
        String start = "2024-12-12 0:0:0";
        String end = "2024-12-12 0:10:0";
        // 张三下单时间
        String zhangsanTime = "2024-12-12 0:1:18";
        String lisiTime = "2024-12-12 0:10:38";


        // 把时间字符串转换成时间对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date startDate = sdf.parse(start);
        Date endDate = sdf.parse(end);
        Date zhangsanDate = sdf.parse(zhangsanTime);
        Date lisiDate = sdf.parse(lisiTime);

        // 把日期对象转化为时间毫秒值
        long startMillis = startDate.getTime();
        long endMillis = endDate.getTime();
        long zhangsanMillis = zhangsanDate.getTime();
        long lisiMillis = lisiDate.getTime();

        // 判断时间是否在秒杀时间内
        if (zhangsanMillis >= startMillis && zhangsanMillis <= endMillis) {
            System.out.println("张三秒杀成功");
        } else {
            System.out.println("张三秒杀失败");
        }
        if (lisiMillis >= startMillis && lisiMillis <= endMillis) {
            System.out.println("李四秒杀成功");
        } else {
            System.out.println("李四秒杀失败");
        }


    }
}

Calendar

在这里插入图片描述

import java.util.Calendar;
import java.util.Date;

public class Test4Calendar {
    public static void main(String[] args) {
        // Calendar的使用和特点
        // 1.Calendar是一个抽象类，不能直接new对象 得到系统此刻时间对应的日历对象
        Calendar now = Calendar.getInstance();
        System.out.println(now);

        // 2.获取日历中的某个信息
        int year = now.get(Calendar.YEAR);
        int month = now.get(Calendar.MONTH) + 1;
        int day = now.get(Calendar.DAY_OF_MONTH);
        int hour = now.get(Calendar.HOUR_OF_DAY);
        int minute = now.get(Calendar.MINUTE);
        int second = now.get(Calendar.SECOND);
        System.out.println(year + "-" + month + "-" + day + " " + hour + ":" + minute + ":" + second);


        // 3.拿到日历中记录的日期对象
        Date date = now.getTime();
        System.out.println(date);

        // 4.拿到时间毫秒值
        long time = now.getTimeInMillis();
        System.out.println(time);

        // 5.修改日历中的某个信息
        now.set(Calendar.YEAR, 2019);
        System.out.println(now);//YEAR 2019

        // 6.某个信息增加或减少
        now.add(Calendar.YEAR, 1);
        System.out.println(now);//YEAR 2020
    }
}

JDK8开始新增的日期、时间

在这里插入图片描述

LocalDate、LocalTime、LocalDateTime

在这里插入图片描述


import java.time.LocalDate;

public class Test1_LocalDate {
    public static void main(String[] args) {
        // 1.获取本地日期对象(不可变对象)
        LocalDate localDate = LocalDate.now();// 年月日
        System.out.println(localDate);

        //2.获取日期对象中的信息
        int year = localDate.getYear();// 年
        int month = localDate.getMonthValue();// 月 1-12
        int day = localDate.getDayOfMonth(); // 日
        System.out.println(year + "年" + month + "月" + day + "日");
        // 一年中的第几天
        int dayOfYear = localDate.getDayOfYear();
        System.out.println(dayOfYear);
        // 获取星期几
        String week = localDate.getDayOfWeek().name();
        System.out.println(week);
        int dayOfWeek = localDate.getDayOfWeek().getValue();
        System.out.println(dayOfWeek);
        // 2.修改某个信息
        LocalDate localDate2 = localDate.withYear(2019);
        LocalDate localDate3 = localDate.withMonth(12);
        System.out.println(localDate);
        System.out.println(localDate2);
        System.out.println(localDate3);

        System.out.println("---------------------------");
        // 3.把某个信息加多少
        LocalDate localDate4 = localDate.plusYears(1);
        LocalDate localDate5 = localDate.plusMonths(1);
        LocalDate localDate6 = localDate.plusWeeks(1);
        LocalDate localDate7 = localDate.plusDays(1);
        System.out.println(localDate);
        System.out.println(localDate4);
        System.out.println(localDate5);
        System.out.println(localDate6);
        System.out.println(localDate7);

        System.out.println("---------------------------");

        //4.把某个信息减多少
        LocalDate localDate8 = localDate.minusYears(1);
        LocalDate localDate9 = localDate.minusMonths(1);
        LocalDate localDate10 = localDate.minusWeeks(1);
        LocalDate localDate11 = localDate.minusDays(1);
        System.out.println(localDate);
        System.out.println(localDate8);
        System.out.println(localDate9);
        System.out.println(localDate10);
        System.out.println(localDate11);

        System.out.println("---------------------------");
        //5.获取指定日期的LocalDate对象
        LocalDate localDate12 = LocalDate.of(2019, 12, 3);
        System.out.println(localDate12);

        //6.判断两个日期是否相等 相等 在前 在后
        LocalDate localDate13 = LocalDate.of(2019, 12, 3);
        LocalDate localDate14 = LocalDate.of(2019, 12, 3);
        System.out.println(localDate13.equals(localDate14));
        System.out.println(localDate13.isBefore(localDate14));
        System.out.println(localDate13.isAfter(localDate14));
        System.out.println("---------------------------");

    }
}

import java.time.LocalTime;

public class Test2_LocalTime {
    public static void main(String[] args) {
        // 0.获取本地时间对象
        LocalTime lt = LocalTime.now();// 时 分 秒 纳秒 不可变
        System.out.println(lt);
        // 1.获取时间中的信息
        int hour = lt.getHour(); //时
        int minute = lt.getMinute(); //分
        int second = lt.getSecond(); //秒
        int nano = lt.getNano(); //纳秒

        // 2.修改时间:withHour\withMinute\withSecond\withNano
        LocalTime lt3 = lt.withHour(10);
        LocalTime lt4 = lt.withMinute(10);
        LocalTime lt5 = lt.withSecond(10);
        LocalTime lt6 = lt.withNano(10);


        // 3.加多少时间:plusHours\plusMinutes\plusSeconds\plusNanos
        LocalTime lt7 = lt.plusHours(1);
        LocalTime lt8 = lt.plusMinutes(1);
        LocalTime lt9 = lt.plusSeconds(1);
        LocalTime lt10 = lt.plusNanos(1);

        // 4.减多少时间:minusHours\minusMinutes\minusSeconds\minusNanos
        LocalTime lt11 = lt.minusHours(1);
        LocalTime lt12 = lt.minusMinutes(1);
        LocalTime lt13 = lt.minusSeconds(1);
        LocalTime lt14 = lt.minusNanos(1);

        // 5.获取指定时间的LocalTime对象
        LocalTime lt15 = LocalTime.of(2, 30); // 指定时分
        LocalTime lt16 = LocalTime.of(2, 30, 40); // 指定时分秒
        LocalTime lt17 = LocalTime.of(2, 30, 40, 987654321); // 指定时分秒纳秒

        // 6.判断时间是否相等 在前还是在后 equals isBefore isAfter
        System.out.println(lt15.isAfter(lt));
        System.out.println(lt15.isBefore(lt));
        System.out.println(lt15.equals(lt));





    }
}

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Test3_LocalDateTime {
    public static void main(String[] args) {
        // 0.获取本地日期和时间对象
        LocalDateTime ldt = LocalDateTime.now(); // 年 月 日 时 分 秒  纳秒
        System.out.println(ldt);

        // 1.可以获取日期和时间全部信息
        int year = ldt.getYear();//年
        int month = ldt.getMonthValue(); // 月
        int day = ldt.getDayOfMonth();//日
        int hour = ldt.getHour();//时
        int minute = ldt.getMinute();//分
        int second = ldt.getSecond();//秒
        int nanosecond = ldt.getNano();//纳秒

        // 2.修改时间信息
        // withYear withMonth withDayOfMonth withHour withMinute withSecond withNano
        LocalDateTime ldt2 = ldt.withYear(2019);
        LocalDateTime ldt3 = ldt.withMonth(1);

        // 3.加多少
        // plusYears plusMonths plusDays plusHours plusMinutes plusSeconds plusNanos
        LocalDateTime ldt4 = ldt.plusYears(1);

        // 4.减多少
        // minusYears minusMonths minusDays minusHours minusMinutes minusSeconds minusNanos
        LocalDateTime ldt5 = ldt.minusMonths(1);

        // 5.获取指定日期和时间的LocalDateTime对象
        // public static  LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute)
        LocalDateTime ldt6 = LocalDateTime.of(2019, 12, 31, 15, 48);

        // 6.判断2个日期、时间对象是否相等 在前还是在后 equals isBefore isAfter
        System.out.println(ldt.equals(ldt2));
        System.out.println(ldt.isBefore(ldt2));
        System.out.println(ldt.isAfter(ldt2));
        System.out.println(ldt6);

        // 7.可以把LocalDateTime对象转换为 LocalDate对象和LocalTime对象
        // toLocalDate 获取日期对象  toLocalTime 获取时间对象
        LocalDate ld1 = ldt.toLocalDate();
        LocalTime lt1 = ldt.toLocalTime();
        LocalDateTime ldt7 = LocalDateTime.of(ld1, lt1);

    }
}

在这里插入图片描述

时区

在这里插入图片描述

import java.time.Clock;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class Test4_ZoneId_ZonedDateTime {
    public static void main(String[] args) {
        // 时区和带时区的时间
        //1.ZoneId常见方法
        // public static ZoneId systemDefault(): 获取系统默认时区
        ZoneId zoneId = ZoneId.systemDefault(); // 获取系统默认时区
        System.out.println(zoneId.getId()); // 获取时区Id
        System.out.println(zoneId); // 获取时区Id

        // public static Set<String> getAvailableZoneIds(): 获取Java支持的全部时区的Id
        System.out.println(ZoneId.getAvailableZoneIds());

        // public static ZoneId of(String zoneId): 把某个时区id封装成ZoneId对象
        ZoneId zoneId1 = ZoneId.of("America/New_York");


        //2.ZonedDateTime : 带时区的时间
        // public static ZonedDateTime now(ZoneId zone): 获取某个时区的ZonedDateTime对象
        ZonedDateTime zonedDateTime = ZonedDateTime.now(zoneId1);
        System.out.println(zonedDateTime);

        ZonedDateTime now1= ZonedDateTime.now(Clock.systemUTC()); //获取UTC时区的时间(世界标准时间)
        System.out.println(now1);
        // public static ZonedDateTime now(): 获取系统默认时区的ZonedDateTime对象
        ZonedDateTime now = ZonedDateTime.now();
        System.out.println(now);


    }
}

Instant

在这里插入图片描述

import java.time.Instant;

public class Test5_Instant {
    public static void main(String[] args) {
        // 1.创建Instant的对象 获取此刻时间信息
        Instant now = Instant.now(); // 不可变对象


        // 2.获取总秒数
        long seconds = now.getEpochSecond();
        System.out.println(seconds);

        // 3.不够1秒的纳秒数
        long nano = now.getNano();
        System.out.println(nano);


        System.out.println(now);

        Instant instant = now.plusNanos(100);
        System.out.println(instant);

        // Instant对象的作用: 做代码的性能分析 或者 记录用户的操作时间点
        Instant now1 = Instant.now();
        // 代码执行
        Instant now2 = Instant.now();

    }
}

DateTimeFormatter

在这里插入图片描述

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class Test6_DateTimeFormatter {
    public static void main(String[] args) {
        // DateTimeFormatter格式化器的用法
        // 1.创建一个日期格式化器对象
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
        // 2.格式化日期对象
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);
        //String strDate = formatter.format(ldt); /正向格式化
        String strDate = ldt.format(formatter);//反向格式化
        System.out.println(strDate);

        // 3.解析日期字符串 一般是用LocalDateTime提供的解析方法来解析
       String dateStr="2018年05月06日 14:37:45";
       LocalDateTime ldt1 = LocalDateTime.parse(dateStr, formatter);
       System.out.println(ldt1);

    }
}

Period

在这里插入图片描述


import java.time.LocalDate;
import java.time.Period;

public class Test7_Period {
    public static void main(String[] args) {
        LocalDate start = LocalDate.of(2019, 3, 5);
        LocalDate end = LocalDate.of(2019, 3, 10);
        // Period作用：计算两个日期相差的年数、月数、天数
        // 1.创建Period对象
        Period period = Period.between(start, end);
        // 2.获取年数
        int years = period.getYears();
        // 3.获取月数
        int months = period.getMonths();
        // 4.获取天数
        int days = period.getDays();
        System.out.println("years = " + years);
        System.out.println("months = " + months);
        System.out.println("days = " + days);
        System.out.println(period);

    }
}

Duration

在这里插入图片描述

import java.time.Duration;
import java.time.LocalDateTime;

public class Test8_Duration {
    public static void main(String[] args) {
        // Duration 计算两个时间对象相差的 天数、小时数、分钟数、秒数、毫秒数、纳秒数
        //1.得到Duration对象
        LocalDateTime start = LocalDateTime.of(2019, 3, 5, 6, 7, 8);
        LocalDateTime end = LocalDateTime.of(2019, 3, 9, 12, 7, 8);
        Duration duration = Duration.between(start, end);
        // 2.获取相差的天数
        long days = duration.toDays();
        // 3.获取相差的小时数
        long hours = duration.toHours();
        // 4.获取相差的分钟数
        long minutes = duration.toMinutes();
        // 5.获取相差的秒数
        long seconds = duration.toSeconds();
        // 6.获取相差的毫秒数
        long milliSeconds = duration.toMillis();
        // 7.获取相差的纳秒数
        long nanoSeconds = duration.toNanos();
        System.out.println(days);
        System.out.println(hours);
        System.out.println(minutes);
        System.out.println(seconds);
        System.out.println(milliSeconds);
        System.out.println(nanoSeconds);

    }
}