常用API，包装类

一object

1.toString

public String toString()

• 默认返回当前对象在堆内存中的地址信息：类的权限名@内存地址
• 开发中输出对象变量，更多是希望看到对象的内容数据而不是对象的地址信息

toString存在的意义

• 父类toString（）方法存在的意义就是被子类重写，以便返回对象的内容信息，而不是地址信息

public class Student {//extends object
    private String name;
    private char sex;
    private int age;

    public Student() {
    }

    public Student(String name, char sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString(){
        return "Student{name="+name+",sex="+sex+",+age="+age+"}";
    }
}

public class Test1 {
    public static void main(String[] args) {
        //public String toString() 默认返回当前对象在堆内存中的地址信息：类的权限名@内存地址
        //目标：掌握object类中toString方法的使用
        Student s=new Student("周雄",'男',19);
        String rs=s.toString();
        System.out.println(rs);
        System.out.println(s.toString());//toString可以省略不写
        System.out.println(s);
    }
}

2.equals

public Boolean equals(Object o)

• 默认是比较当前对象与另一个对象的地址是否相同
• 直接比较两个对象的地址是否相同完全可以用“==”代替equals
  equals存在的意义
• 父类equals方法存在的意义就是为了被子类复写，以便子类自己来定制比较规则

public class Student {//extends object
    private String name;
    private char sex;
    private int age;

    public Student() {
    }

    public Student(String name, char sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }
    /**
     * 在子类重写equals自己制定相等规则
     * 两个对象的内容相同，就认为相等
     * s1.equals(s2)
     * 比较者 s1==this
     * 被比较者:s2==>o
     */
    @Override
    public boolean equals(Object o){
        //1.判断o是不是学生类型
        if(o instanceof Student){
            //2.判断两个对象的内容
            Student s2=(Student)o;
//            if(this.name.equals(s2.name)&&this.age==s2.age&&this.sex==s2.sex){
//                return true;
//            }else{
//                return false;
//            }
            return this.name.equals(s2.name)&&this.age==s2.age&&this.sex==s2.sex;
        }else{
            //学生只能和学生比较。否则结果一定是false
            return false;
        }
    }
}

public class Test2 {
    public static void main(String[] args) {
        //目标：掌握object类中equals方法的使用
        Student s1= new Student("小花",'女',19);
        Student s2= new Student("小花",'女',19);
        //equals默认是比较两个对象的地址
        System.out.println(s1.equals(s2));
    }
}

官方提供的方法

 @Override
    public boolean equals(Object o) {
        //1判断是否是同一个对象比较
        if (this == o) return true;
        //2.如果o是null返回false,如果o不是学生类，返回false，
        if (o == null || getClass() != o.getClass()) return false;
        //3.o一定是Student类，并且不是null
        Student student = (Student) o;
        return sex == student.sex && age == student.age && Objects.equals(name, student.name);
    }

二、objects

• Object类与Object是继承关系，Object是从JDK1.7之后才有的

官方在进行字符串比较时，没有用自己对象的equals方法，而是选择了Objects方法来比较两个对象
Objects的equals方法比较的结果一样，但是更安全

• Objects常见方法

public static boolean equals（Objects a,Objects b）

比较两个对象，底层先进行非空判断，从而可以避免空指针异常，再进行equals比较

public static boolean equals(Object a, Object b) {
            return (a == b) || (a != null && a.equals(b));
         }

public static boolean iaNall(Objects  obj)

判断变量是否为null，为null返回true,反之false

/**
 * 掌握Objects类的常用方法：equals
 */
public class Test {
    public static void main(String[] args) {
        String s1=null;
        String s2=new String("itheima");
    //    System.out.println(s1.equals(s2));//留下了隐患，可能出现空指针异常
        System.out.println(Objects.equals(s1, s2));//更安全，结果更准确
        /**
         * public static boolean equals(Object a, Object b) {
         *         return (a == b) || (a != null && a.equals(b));
         *     }
         */
    }
}

三、StringBuilder

1.StringBuilder概述

• StringBuilder是一个可变的字符串类，我们可以把它看成是一个对象容器
• 作用：提高字符串的操作效率，如拼接、修改等

2.StringBuilder构造器

• public StringBulider（）创建一个空白的可变的字符串对象，不包含任何内容
• public StringBuilder（String str）创建一个指定字符内容的可变字符串对象

3.StringBulider常用方法

• public StringBuilder append（任意类型）添加数据并返回StringBuilder对象本身
• public StringBuilder reverse（）将对象的内容反转
• public int length（）返回对象内容长度
• public String toString（）通过toString就可以把StringBuilder转换为String

/**
 * 目标：学会使用StringBuilder操作字符串，最终还需要知道它性能好的原因
 */
public class StringBuilderDemo1 {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();//“”
        sb.append("a");
        sb.append("b");
        sb.append("c");
        sb.append(4);
        sb.append(78.5);
        System.out.println(sb);
        StringBuilder sb1=new StringBuilder();
        //支持链式编程
        sb1.append("a").append("b").append(3.2);//链式编程
        System.out.println(sb1);
        //反转内容
        System.out.println(sb1.reverse().append(110));
        System.out.println(sb1.length());
        //StringBuilder只是拼接字符串的手段，效率好
        //最终的目的还是要恢复成String类型
        StringBuilder sb2=new StringBuilder();
        sb2.append("123").append(456);
       // check(sb2);
        //恢复成String的方法
        String rs=sb2.toString();
        check(rs);
    }
    public static void check(String data){
        System.out.println(data);

    }
}

4.案例：打印整数型数组内容

需求：设计一个方法用于输出任意整型数组的内容，要求输出成如下格式
“该数组的内容为：[11,22,33,44,55]”

public class StringBuilderTest2 {
    public static void main(String[] args) {
        int[] arr1=null;
        System.out.println(toString(arr1));
        int[] arr2={10,28,99};
        System.out.println(toString(arr2));

    }
    /**
     * 1.定义方法，接收任意整形数组，返回数组内容格式
     */
    public static String toString(int[] arr){
        if(arr!=null){
            //2.开始拼接内容
            StringBuilder sb=new StringBuilder("[");
            for(int i=0;i<arr.length;i++){
                sb.append(arr[i]).append(i==(arr.length-1)?"":", ");
            }
            sb.append("]");
            return sb.toString();
        }else{
            return null;
        }
    }
}

四、Math

• 包含执行基本数字运算的方法，Math类没有提供公开的构造器（工具类）
• Math类的常用方法

1.public static  int abs(int a)获取参数绝对值
2.public static double ceil(double a)向上取整
3.public static double floor(double a)向下取整
4.public static int round(float a)四舍五入
5.public static int max(int a,int b)获取两个int值中的较大者
6.public static double pow(double a,double b)返回a的b次幂的值
7.public static double random()  返回值为double的随机值，范围[0.0,1.0)

public class MathDemo {
    public static void main(String[] args) {
        System.out.println(Math.abs(10));
        System.out.println(Math.abs(-10.3));
        System.out.println(Math.ceil(4.00000000001));
        System.out.println(Math.ceil(4.0));
        System.out.println(Math.floor(8.9));
        System.out.println(Math.pow(2, 3));
        System.out.println(Math.round(4.45));
        System.out.println(Math.random());
    }
}

10
10.3
5.0
4.0
8.0
8.0
4
0.30275411429721755

五、System

• System的功能是通用的，都是直接用类名调用，所以System不能被实例化
• System常用方法

1.public static void exit(int status)终止当前运行的Java虚拟机，非零表示异常终止
2.public static long currentTimeMills()返回当前系统的时间毫秒值形式
3.public static void arraycopy(数据源数组、起始索引、目的地数组、起始索引、拷贝个数)数组拷贝

public class SystemDemo {
    public static void main(String[] args) {
        System.out.println("程序开始");
        //1.public static void exit(int status)终止当前运行的Java虚拟机，非零表示异常终止
      //  System.exit(0);//JVM终止(了解)
        System.out.println("程序结束");//不执行

        //2.public static long currentTimeMills()返回当前系统的时间毫秒值形式1970-1-1  00：00：00
        long time=System.currentTimeMillis();
        System.out.println(time);
        //进行时间的计算，性能分析
        long startTime1=System.currentTimeMillis();
        for(int i=0;i<10000;i++){
            System.out.println("输出"+i);
        }
        long endTime=System.currentTimeMillis();
        System.out.println((endTime-startTime1)/1000.0+"s");
        //3.public static void arraycopy(数据源数组、起始索引、目的地数组、起始索引、拷贝个数)数组拷贝
        int[] arr1={10,20,30,40,50,60,70};
        int[] arr2=new int[6];//==>[0,0,0,0,0,0]=>[0,0,40,50,60,0]
        /**
         * Object src,  int  srcPos,
         * Object dest, int destPos,
         *  int length
         *  参数一：被拷贝的数组
         *  参数二：从那个索引处开始拷贝
         *  参数三：复制的目标数组
         *  参数四：粘贴位置
         *  参数五：拷贝元素的个数
         */
        System.arraycopy(arr1,3,arr2,2,3);
        System.out.println(Arrays.toString(arr2));
    }
}

六、BigDecimal(大数据类型)

BigDecimal作用：

• 用于解决浮点型运算精度失真的问题

使用步骤

• 创建对象BigDecimal封装浮点型数据（最好的方式是调用方法）

public static BigDecimal valueOf(double val):包装浮点数成为BigDecimal对象

BigDemical常用API
public BigDecimal add(BigDecimal b) 加法
public BigDecimal subtract(BigDecimal b) 减法
public BigDecimal multiply(BigDecimal b)乘法
public BigDecimal divide(BigDecimal b) 除法
public BigDecimal divide(另一个Decimal对象，精确几位，舍入模式)

public class BigDecimalDemo {
    public static void main(String[] args) {
        //浮点型运算的时候直接+*/可能会出现数据失真（精度问题）
        System.out.println(0.09+0.01);
        System.out.println(1.0-0.32);
        System.out.println(1.015*100);
        System.out.println(1.301/100);
        System.out.println("----------------------------------");
        double a=0.1;
        double b=0.2;
        double c=a+b;
        System.out.println(c);
        System.out.println("-----------------------");
        //包装浮点型数据成为大数据对象 BigDecimal
        BigDecimal a1=BigDecimal.valueOf(a);
        BigDecimal b1=BigDecimal.valueOf(b);
        BigDecimal c1=a1.add(b1);
        System.out.println(c1);
        System.out.println("--------------------");
        BigDecimal c2=a1.subtract(b1);
        System.out.println(c2);
        BigDecimal c3=a1.multiply(b1);
        System.out.println(c3);
        BigDecimal c4=a1.divide(b1);
        System.out.println(c4);
        //目的：double
        double rs=c1.doubleValue();
        System.out.println(rs);
        //注意事项：BigDecimal是一定要精度运算的
        BigDecimal a11=BigDecimal.valueOf(10.0);
        BigDecimal b11=BigDecimal.valueOf(3.0);
        /**
         * 参数一：代表除数
         * 参数二：保留的小数位
         * 参数三：舍入模式
         */
        BigDecimal c11=a11.divide(b11,2, RoundingMode.HALF_UP);//3.333333333333333333333333333
        System.out.println(c11);
    }
}

七、日期与时间

1.Date

• Date类的对象在Java中代表的是当前所在系统的此刻日期时间

Date的构造器
1.

public Date(){
}

创建一个Date对象，代表的是系统当前此刻时间
Date常用方法

public long getTime();//获取对象的毫秒值

Date类记录时间的2种形式

• 形式一：日期对象

Date d=new Date();//创建一个日期对象，代表了当前系统的此刻日期和时间对象
System.out.println(d);

• 形式二：时间毫秒值

long time=d.getTime(）；
System.out.println(time);//获取当前时间毫秒值

/**
 * 目标：学会使用Date类处理时间，获取时间的信息
 */
public class DateDemo1 {
    public static void main(String[] args) {
        //1.创建一个Date的对象，代表系统此刻日期时间对象
        Date d=new Date();
        System.out.println(d);
        //2.获取时间毫秒值
        long time=d.getTime();
        System.out.println(time);
        long time2=System.currentTimeMillis();
        System.out.println(time2);//之前学习的，可以做性能分析
    }
}

2.时间毫秒值->日期对象

2.1

public Date(long time) //把时间毫秒值转换成Date日期对象

2.2
Date 方法

public void setTime(long time)//设置日期对象的时间为当前时间毫秒值对应的时间

案例：请计算出当前时间往后走1小时121秒之后的时间是多少

public class DateDemo1 {
    public static void main(String[] args) {
        //1.创建一个Date的对象，代表系统此刻日期时间对象
        Date d=new Date();
        System.out.println(d);
        //2.获取时间毫秒值
        long time=d.getTime();
        System.out.println(time);
        long time2=System.currentTimeMillis();
        System.out.println(time2);//之前学习的，可以做性能分析
        System.out.println("-------------------------");
        //1.得到当前时间毫秒值
        Date d2=new Date();
        System.out.println(d2);
       // 2.当前时间往后走一小时121s
        long time3=System.currentTimeMillis();
        time2+=(60*60+121)*1000;
        //3.将时间毫秒值转换成对应的日期对象
//        Date d3=new Date(time2);
//        System.out.println(d3);
        Date d3=new Date();
        d3.setTime(time2);
        System.out.println(d3);
    }
}

3.SimpleDateFormat

1.SimpleDateFormat类作用

• 1.1可以对Date对象或时间毫秒值格式化成我们喜欢的时间形式

public class SimpleDateFormatDemo1 {
    public static void main(String[] args) {
        //日期对象
        Date d=new Date();
        System.out.println(d);
        //2.格式化日期对象(指定最终格式化的形式)
        /**
         * EEE取星期几
         * a取上午或者下午
         */
        SimpleDateFormat s=new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss EEE a");
        //3.开始格式化日期对象成为喜欢的字符串形式
        String rs=s.format(d);
        System.out.println(rs);
        System.out.println("-----------------------------");
        //需求：请问121s后的时间是多少
        long time1=System.currentTimeMillis()+121*1000;
        String rs2=s.format(time1);
        System.out.println(rs2);
        System.out.println("-----------可以把字符串的时间形式解析成日期对象，下个代码--------------");
    }
}

• 1.2可以把字符串的时间形式解析成日期对象

• SimpleDateFormat的构造器

public SimpleDateFormat() //构造一个SimpleDateFormat,使用默认格式
public SimpleDateFormat()//构造一个SimpleDateFormat使用指定格式

• SimpleDateFormat的格式化方法

public final String format(Date date)//将日期格式化成日期/时间字符串
public final String format(Object time)//将时间毫秒值格式化成日期/时间字符串

• SimpleDateFormat解析字符串时间成为日期对象
  解析方法

public Date parse(String source)//从给定字符串的开始解析文本以生成日期

案例：请计算出2021年08月06日11点11分11秒，往后走2天14小时49分06秒后的时间是多少。

/**
 * 案例：请计算出2021年08月06日11点11分11秒，往后走2天14小时49分06秒后的时间是多少。
 * 目标：学会使用 SimpleDateFormat解析字符串时间成为日期对象
 */
public class SimpleDateFormatDemo2 {
    public static void main(String[] args) throws ParseException {
        //1.把字符串时间拿到程序中来
        String tateStr="2021年08月06日 11:11:11";
        //2.把字符串时间解析成日期对象(本节的重点):形式必须要与被解析时间的形式完全一致，否则运行时报错
        SimpleDateFormat sdf=new SimpleDateFormat("yyy年MM月dd日 hh:mm:ss");
        Date d=sdf.parse(tateStr);
        //3.往后走2天14小时49分06秒
        long time=d.getTime()+(2l*24*60*60+14*60*60+49*60+6)*1000;
        System.out.println(sdf.format(time));
        //4.格式化这个时间毫秒值就是结果
    }
}

练习

public class SimpleDateDemo3 {
    public static void main(String[] args) throws ParseException {
        //1.开始和结束时间
        String startTime="2021-11-11 00:00:00";
        String endTime="2021-11-11 00:10:00";
        //2.记录小贾、小皮下单的时间
        String xiaojia="2021-11-11 00:03:47";
        String xiaopi="2021-11-11 00:10:11";
        //2.解析他们的时间
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        Date d1=sdf.parse(startTime);
        Date d2=sdf.parse(endTime);
        Date d3=sdf.parse(xiaojia);
        Date d4=sdf.parse(xiaopi);
        if(d3.after(d1)&&d3.before(d2)){
            System.out.println("小贾秒杀成功，可以发货了");
        }else{
            System.out.println("小贾秒杀失败");
        }
        if(d4.after(d1)&&d4.before(d2)){
            System.out.println("小皮秒杀成功，可以发货了");
        }else{
            System.out.println("小皮秒杀失败");
        }
    }
}

4.Calendar

1.Calendar代表了系统此刻日期对应的日历对象
2.Calender是一个抽象类，不能直接创建对象
3.Calendar常用方法

public int get(int field)//获取日历中的某个字段信息
public void set(int field.int value)//修改日历的某个字段信息
public void add(int field,int amount)//为某个字段增加/减少指定的值
public final Date getTime()//拿到此刻日期对象
public long getTimeMillis()//拿到此刻时间毫秒值

public class CalendarDemo1 {
    public static void main(String[] args) {
        //1.拿到系统此刻日历对象
        Calendar cal = Calendar.getInstance();
        //2.获取日历信息
       // public int get(int field)
        int year=cal.get(Calendar.YEAR);
        System.out.println(year);
        int mouth=cal.get(Calendar.MONTH)+1;
        System.out.println(mouth);
        int days=cal.get(Calendar.DAY_OF_YEAR);
        System.out.println(days);
        System.out.println(cal);
        //3.public void set(int field,int value):修改日历中的某个字段
//        cal.set(Calendar.HOUR,12);
//        System.out.println(cal);一般不会去修改信息
        //4.public void add(int field,int amount)//为某个字段增加/减少指定的值
        cal.add(Calendar.DAY_OF_YEAR,64);
        cal.add(Calendar.MINUTE,59);
        //5.public final Date getTime()//拿到此刻日期对象
        Date d=cal.getTime();
        System.out.println(d);
        //6.public long getTimeMillis()//拿到此刻时间毫秒值
        long time=cal.getTimeInMillis();
        System.out.println(time);
    }
}

八、JDK8新增日期类

1.概述LocalTime/LocalDate/LocalDateTime

1.1LocalDate

public class DemoLocalDate01 {
    public static void main(String[] args) {
        //1.获取本地对象
        LocalDate nowDate=LocalDate.now();
        System.out.println("今天的日期是"+nowDate);
        int year=nowDate.getYear();
        System.out.println("year:"+year);
        int mouth=nowDate.getMonthValue();
        System.out.println("mouth:"+mouth);
        int day=nowDate.getDayOfMonth();
        System.out.println("day"+day);
        //当年的第几天
        int dayOfYear=nowDate.getDayOfYear();
        System.out.println(dayOfYear);
        //星期
        System.out.println(nowDate.getDayOfWeek());
        System.out.println(nowDate.getDayOfWeek().getValue());
        //月份
        System.out.println(nowDate.getMonth());
        System.out.println(nowDate.getMonth().getValue());
        System.out.println("-------------------------------");
        LocalDate bt=LocalDate.of(2000,11,20);
        System.out.println(bt);
    }
}

1.2LocalTime

public class Demo02LocalTime {
    public static void main(String[] args) {
        //1.获取本地时间对象
        LocalTime nowTime=LocalTime.now();
        System.out.println("今天的时间"+nowTime);
        int hour=nowTime.getHour();
        System.out.println("hour:"+hour);
        int minute= nowTime.getMinute();
        System.out.println("minute"+minute);
        int second= nowTime.getSecond();
        System.out.println("second"+second);
        int nano=nowTime.getNano();
        System.out.println("nano:"+nano);
        System.out.println("---------------------");
        System.out.println(LocalTime.of(8,20));
        System.out.println(LocalTime.of(8,20,30));
        System.out.println(LocalTime.of(8,20,30,150));
        System.out.println("-------------------------------");
        System.out.println(LocalDateTime.of(1991,11,11,8,20));
    }
}

1.3LocalDateTime

public class Demo03LocalDateTime {
    public static void main(String[] args) {
        //日期，时间
        LocalDateTime nowDateTime=LocalDateTime.now();
        System.out.println(nowDateTime);
        System.out.println(nowDateTime.getYear());
        System.out.println(nowDateTime.getMonthValue());
        System.out.println(nowDateTime.getDayOfMonth());
        System.out.println(nowDateTime.getHour());
        System.out.println(nowDateTime.getMinute());
        System.out.println(nowDateTime.getSecond());
        System.out.println(nowDateTime.getNano());
        System.out.println("------------------------");
        //日：当前第几天
        System.out.println("dayOfYear:"+nowDateTime.getDayOfYear());
        //星期
        System.out.println(nowDateTime.getDayOfWeek());
        System.out.println(nowDateTime.getDayOfWeek().getValue());
        //月份
        System.out.println(nowDateTime.getMonth());
        System.out.println(nowDateTime.getMonthValue());
        //LocalDate toLocalDate()
        LocalDate id=nowDateTime.toLocalDate();
        System.out.println(id);
        LocalTime it=nowDateTime.toLocalTime();
        System.out.println(it.getHour());
        System.out.println(it.getMinute());
        System.out.println(it.getSecond());
    }
}

public class Demo04UpdateTime {
    public static void main(String[] args) {
        LocalTime nowTime=LocalTime.now();
        System.out.println(nowTime);//当前时间
        System.out.println(nowTime.minusHours(1));//一小时前
        System.out.println(nowTime.minusMinutes(1));//一分钟前
        System.out.println(nowTime.minusSeconds(1));//一秒前
        System.out.println(nowTime.minusNanos(1));//一纳秒前
        System.out.println("------------------------------");
        System.out.println(nowTime.plusHours(1));//一小时后
        System.out.println(nowTime.plusMinutes(1));//一分钟后
        System.out.println(nowTime.plusSeconds(1));//一秒后
        System.out.println(nowTime.plusNanos(1));//一纳秒后
        System.out.println("------------------------");
        //不可变对象，每次修改产生新对象
        System.out.println(nowTime);
        System.out.println("----------------------------");
        LocalDate myDate=LocalDate.of(2018,9,5);
        LocalDate nowDate=LocalDate.now();
        System.out.println("今天是2018.09-06吗？"+myDate.equals(nowDate));
        System.out.println(myDate+"是否在"+nowDate+"之前?"+myDate.isBefore(nowDate));
        System.out.println(myDate+"是否在"+nowDate+"之后?"+myDate.isAfter(nowDate));
        System.out.println("-----------------------------");
        LocalDate birDate=LocalDate.of(2000,11,20);
        LocalDate nowDate1=LocalDate.now();
        MonthDay birMd=MonthDay.of(birDate.getMonthValue(),birDate.getDayOfMonth());
        MonthDay nowMd=MonthDay.from(nowDate1);
        System.out.println("今天是你的生日吗?"+birMd.equals(nowMd));
    }
}

2.Instant

2.1instant时间戳

• instant类由一个静态的工厂方法now（）可以返回当前的时间戳

public class Demo05Instance {
    public static void main(String[] args) {
        //1.得到一个instance时间戳
        Instant instant=Instant.now();
        System.out.println(instant);
        //2.系统此刻时间戳
        Instant instant1=Instant.now();
        System.out.println(instant1.atZone(ZoneId.systemDefault()));
        //3.如何去返回Date对象,Date类和Instant类可以相互转换
        Date date=Date.from(instant);
        System.out.println(date);
        Instant i2=date.toInstant();
        System.out.println(i2);
    }
}

3.DateTimeFormatter

public class Demo06DateTimeFormat {
    public static void main(String[] args) {
        //本地此刻 日期时间对象
        LocalDateTime ldt=LocalDateTime.now();
        System.out.println(ldt);
        //解析，格式化器
        DateTimeFormatter dtf= DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss EEE a");
        //正向格式化
        String ldtStr1=dtf.format(ldt);
        System.out.println(ldtStr1);
        //逆向格式化
        String ldtStr2=ldt.format(dtf);
        System.out.println(ldtStr2);
        //解析字符串时间
        DateTimeFormatter dtf1=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime dateStr= LocalDateTime.parse("2019-11-11 11:11:11",dtf1);
        System.out.println(dateStr.getDayOfYear());
    }
}

4.Duration/Period

4.1Period

• 在Java中，我们可以使用以下类来计算日期间隔差异：java.time.Period
• 主要是Period类方法getYears(),getMouths()和getDays()来计算，只能精确到年月日
• 用于LocalDate之间的比较

public class Demo07Period {
    public static void main(String[] args) {
        //当前本地 年月日
        LocalDate today=LocalDate.now();
        System.out.println(today);
        //生日的 年月日
        LocalDate birDate=LocalDate.of(2000,11,20);
        System.out.println(birDate);
        Period period=Period.between(birDate,today);//第二个参数减第一个参数
        System.out.println(period.getYears());
        System.out.println(period.getMonths());
        System.out.println(period.getDays());
    }
}

4.2Duration

• 在Java中，我们可以使用以下类来计算日期间隔差异：java.time.Duration
• 主要使用基于时间的值测量时间量的方法
• 用于LocalDateTime之间的比较，也可用于Instant之间的比较

public class Demo08Duration {
    public static void main(String[] args) {
        //本地日期时间对象
        LocalDateTime today=LocalDateTime.now();
        System.out.println(today);
        //出生的日期时间对象
        LocalDateTime birthDate=LocalDateTime.of(2000,11,20,14,50,35);
        System.out.println(birthDate);
        Duration duration=Duration.between(birthDate,today);
        System.out.println(duration.toDays());//两个时间差的天数
        System.out.println(duration.toHours());
        System.out.println(duration.toMinutes());
        System.out.println(duration.toMillis());
        System.out.println(duration.toNanos());
    }
}

5.ChronoUnit

java.time.temporal.ChronoUnit

• ChronoUnit类可以用于在单个时间单位内测量一段时间，这个工具类是最全的，可以用于比较所有的时间单位

public class Demo09ChronoUnit {
    public static void main(String[] args) {
        //本地日期时间对象，此刻的
        LocalDateTime today=LocalDateTime.now();
        System.out.println(today);
        //生日时间
        LocalDateTime birthTime=LocalDateTime.of(2000,11,20,10,20,30);
        System.out.println(birthTime);
        System.out.println("相差的年数"+ ChronoUnit.YEARS.between(birthTime,today));
        System.out.println("相差的月数"+ ChronoUnit.MONTHS.between(birthTime,today));
        System.out.println("相差的天数"+ ChronoUnit.DAYS.between(birthTime,today));
    }
}

九、包装类

• 其实就是8种基本数据类型对应的引用类型

基本数据类型	引用数据类型
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

1.为什么提供包装类？

• java为了实现一切皆对象，为8种基本数据类型提供了对应的引用类型
• 后面的集合和泛型其实也只能支持包装类型，不支持基本数据类型

2.自动装箱：基本类型的数据和变量可以直接赋值给包装类型的变量
3.自动拆箱：包装类型的变量可以直接赋值给基本数据类型的变量
4.包装类的特有功能

• 包装类的变量的默认值可以是null,容错率更高

//int age1=null;//报错
        Integer age=null;

• 可以把基本类型的数据转换成字符串类型（用处不大）
  a.调用toString方法得到字符串结果
  b.调用Integer.toString（基本类型的数据）
• 可以把字符串类型的数据转换成真实的数据类型（用的多）
  a.Integer.parseInt(“字符串类型的整数”)
  b.Double.parseDouble(“字符串类型的小数”)
  注：valueOf更好用

 String number1="34.6";
        double score=Double.valueOf(number1)
        System.out.println(score);

public class Test {
    public static void main(String[] args) {
        int a=10;
        Integer a1=11;
        Integer a2=a;//自动装箱
        System.out.println(a);
        System.out.println(a1);
        Integer it=100;
        int a3=it;//自动拆箱
        System.out.println(a3);
        //int age1=null;//报错
        Integer age=null;
        System.out.println("--------------------");
        /**
         * 包装类的作用：
         * 1.可以把基本类型的数据转换成字符串类型（用处不大）
         * a.调用toString方法得到字符串结果
         * b.调用Integer.toString（基本类型的数据）
         */
        Integer i3=23;
        String rs=i3.toString();
        System.out.println(rs+1);//231
        String rs2=Integer.toString(24);
        System.out.println(rs2+1);//241
        //可以直接加一个空字符串得到字符串类型，不需要上述方法
        String rs3=i3+"";
        System.out.println(rs3+1);
        /**
         * 2.可以把字符串类型的数据转换成真实的数据类型（用的多）
         * a.Integer.parseInt("字符串类型的整数")
         * b.Double.parseDouble("字符串类型的小数")
         */
        String number="23";
        //转换成整数
       // int age1=Integer.parseInt(number);
        int age1=Integer.valueOf(number);
        System.out.println(age1);
        String number1="34.6";
       // double score=Double.parseDouble(number1);
        double score=Double.valueOf(number1);
        System.out.println(score);
    }
}