08_Java常用API_java duration between-CSDN博客

本文链接：https://blog.csdn.net/jwsl999/article/details/116166196

内部类 (了解)

1.在一个类的内部定义的类称之为内部类。
有些时候我们创建的一个类指向给某个指定的类进行使用，不想给其他类使用。

内部类的分类:

普通内部类：

public class Outer{
    
	//1.内部类只能通过外部类对象去调用
	class inner{
		//内部类属性
		//内部类的方法
	}
}
具体实例:
public class Outer {
	int age=18;
	class Inner{
		int age=19;
		//1.定义内部类的属性
		//2.定义内部类的方法
		public void method() {
			int age=20;
			System.out.println("内部类的局部变量:"+age);
			System.out.println("内部类的全局变量:"+this.age);
			//1.本来是可以直接访问外部类的资源，但是由于属性名字冲突，程序按照就近原则
			System.out.println("可以访问外部类的全局变量:"+new Outer().age);
		}
	}
}
测试代码:
public class Test {
	public static void main(String[] args) {
		//1.先创建外部类对象
		Outer outer=new Outer();
		//2.通过外部类对象创建内部类对象(先有外部类对象，然后才有内部类对象)
		Outer.Inner inner= outer.new Inner();
		inner.method();
	}
}

静态内部类:


public class Outer {
	static int age=18;
	
	 //1.静态内部类只能访问外部的静态资源 
	 //2.可以通过外部类类名直接创建内部类对象
	static class Inner{
		int age=19;
		public void method() {
			int age=20;
			System.out.println("内部类局部变量:"+age);
			System.out.println("内部类全局变量:"+this.age);
			System.out.println("外部类的静态资源:"+Outer.age);
		}
	}
}
测试:
	public static void main(String[] args) {
		Outer.Inner inner=new Outer.Inner();
		inner.method();
	}

局部内部类(方法内部类)：(了解一下)


public class Outer {
	public void method() {
		class Inner{
			int age=18;
			public void test() {
				System.out.println(age);
			}
		}
		new Inner().test();
	}
}

匿名内部类(重点)

概念:在一个类中创建了一个没有名字的类，像这样的类我们称之为匿名内部类。
有的时候我们创建一个类只是单纯使用一次，无需定义变量去接受。

应用场景分析:
事件监听，创建线程的时候使用匿名内部类比较多。

基本的结构:
new  类名/接口名(){
	//重写其相应功能的方法...
}

使用匿名内部类的目的是为了简化代码，对于很多只需要使用一次的情况下，比如键盘事件，底层拥有，按下，弹起等多个功能，但是我们实用的功能只有一个，而且只需要定义一次即可，采用匿名内部类简化代码。
比如上案例:
没有匿名内部类的写法:
定义了一个键盘监听事件的功能
public interface MyKeyListener {
	void pressKey();
	void keyUp();
	void keyDown();
}
需要编写一个实现类
 public class KeyListenerImpl implements MyKeyListener{

	@Override
	public void pressKey() {
		...
	}

	@Override
	public void keyUp() {
		...
	}

	@Override
	public void keyDown() {
		...
	}
}   
测试:
public class Test {

	public static void main(String[] args) {
		KeyListenerImpl key=new KeyListenerImpl();
		key.keyDown();
	}

}
如果我们应用匿名内部类:（优化之后的代码）
public class Test {

	public static void main(String[] args) {
		//1.创建了一个匿名内部类对象(这个对象是MyKeyListener接口的实现类对象。。。没有名字)
		MyKeyListener key=new MyKeyListener() {
			@Override
			public void pressKey() {
				System.out.println("按压键盘...");
			}
			@Override
			public void keyUp() {
				System.out.println("键盘弹起...");
			}
			@Override
			public void keyDown() {
				System.out.println("键盘按下...");
			}
		};
		key.pressKey();
		key.keyDown();
		key.keyUp();
	}
}

创建接口的匿名内部类需要强制实现所有的抽象方法，因此可以设计一个关于接口的适配器类
    public abstract class MyKeyListenerAdapter implements MyKeyListener{
	@Override
	public void pressKey() {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void keyDown() {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void keyUp() {
		// TODO Auto-generated method stub
		
	}
}
将抽象方法变成了普通方法。
 使用适配器类创建对象即可
public class Test {

	public static void main(String[] args) {
		//1.创建3个匿名的适配器对象 的分别实现对应的3个功能
		new MyKeyListenerAdapter(){
			@Override
			public void pressKey() {
				System.out.println("键盘按压....");
			}
		}.pressKey();
		//2.自己创建
		new MyKeyListenerAdapter(){
			@Override
			public void keyUp() {
				System.out.println("键盘弹起....");
			}
		}.keyUp();
		//3.创建一个键盘按下...
		new MyKeyListenerAdapter(){
			@Override
			public void keyDown() {
				System.out.println("键盘按下....");
			}
		}.keyDown();
	
	}

}

或者还可以利用jdk8 接口支持默认方法
public interface MyKeyListener {
	default void pressKey() {}
	default void keyUp() {}
	default void keyDown(){}
}

测试:
public class Test {
	public static void main(String[] args) {
		//1.匿名内部类对象
		new MyKeyListener() {
			@Override
			public void pressKey() {
				System.out.println("键盘按压...");
			}
		}.pressKey();
		//2.匿名内部类
		new MyKeyListener() {
			@Override
			public void keyDown() {
				System.out.println("键盘按下...");
			}
		}.keyDown();
		
	}

}

日期API

Date

Date:日期工具类...
Date date1 =new Date(); 
		System.out.println("当前系统时间:"+date1);
		System.out.println("按照本地的时间格式打印:"+date1.toLocaleString());
		System.out.println("获取年份:"+(date1.getYear()+1900));
		//0:1月  依次类推...
		System.out.println("获取月份:"+(date1.getMonth()+1));
		System.out.println("获取日子数:"+date1.getDate());
		
		System.out.println("获取小时数:"+date1.getHours());
		System.out.println("获取分钟数："+date1.getMinutes());
		System.out.println("获取秒钟数:"+date1.getSeconds());
		
		//1.获取距离1970年 1月1号  0点0分 (GMT)相隔的毫秒。
		long time1=date1.getTime();
		System.out.println(time1);
		//2.设置时间
		Date date2=new Date(1618978705939L);
		System.out.println(date2.toLocaleString());
		
		//3.设置年月日
		Date date3=new Date(120,4,20);
		System.out.println(date3.toLocaleString());
		
		//4.时间格式化 yyyy ：年   MM:月  dd 日   HH 时（24小时制） hh时（12小时制） mm:分钟   ss:秒钟
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String nowTime1=sdf.format(date1);
		System.out.println(nowTime1);
		
		//5.将字符串转成日期类型
		String nowTime2="2020-05-20 14:00:00";
		
		//将字符串转成date类型，注意:字符串格式与自定义的格式必须保持一致
		Date date4=sdf.parse(nowTime2);
		System.out.println(date4.toLocaleString());
		
		//5.判断在指定日期之前或者之后
		System.out.println(date1.before(date4));//2021 在2020之前吗? false
		System.out.println(date1.after(date4));//2021在2020之后吗?  true

	1.控制台输入2个日期（字符串），计算这2个日期多少年，多少月，多少天，多少分钟，多少秒?
    Scanner sc=new Scanner(System.in);
		//1.从控制台输入指定格式的日期 (字符串类型)
		System.out.println("请输入第一个日期(yyyy-MM-dd HH:mm:ss):");
		String str1=sc.nextLine();
		System.out.println("请输入第一个日期(yyyy-MM-dd HH:mm:ss):");
		String str2=sc.nextLine();
		//2.先定义一个时间格式化的工具类
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		//3.将字符串转成日期类型
		Date date1=sdf.parse(str1);
		Date date2=sdf.parse(str2);
		//4.计算2个日期之间相隔的毫秒数.getTime();
		long time1=date1.getTime();//1970-01-01与date1之间相隔的毫秒数
		long time2=date2.getTime();//1970-01-01与date2之间相隔的毫秒数
		long res=0;
		//res:单位:秒  1s=1000ms
		if(date1.after(date2)) {
			res=(time1-time2)/1000;
		}else {
			res=(time2-time1)/1000;
		}
		System.out.println("2个日期相隔的毫秒为:"+res);
		long year=res/(3600*24*365L);
		System.out.println("相隔"+year+"年");
		long month=res/(3600*24*30);
		System.out.println("相隔多少个月:"+month);
		
		long day=res/(3600*24);
		System.out.println("相隔多少天:"+day);

2.根据出生年份计算你的年龄(date1:你的出生日期，date2:当前系统时间)
3.倒计时(多少天多少小时多少分钟多少秒钟) 预计5月1号，10月1号
   	time  s
    time/(3600*24)  天
    time%(3600*24)/3600 小时
    time%3600/60分钟  
    time%60 秒

Calendar

Calendar:日历类
//1.得到日历类的对象(Calendar抽象类)
		Calendar ca=Calendar.getInstance();
		System.out.println(ca);
		System.out.println("年份:"+ca.get(Calendar.YEAR));//代替了date.getYear()
		System.out.println("月份:"+(ca.get(Calendar.MONTH)+1));
		System.out.println("日字数:"+ca.get(Calendar.DAY_OF_MONTH));
		System.out.println("小时数:"+ca.get(Calendar.HOUR_OF_DAY));
		System.out.println("分钟数:"+ca.get(Calendar.MINUTE));
		System.out.println("秒钟数:"+ca.get(Calendar.SECOND));
		System.out.println("星期数:"+(ca.get(Calendar.DAY_OF_WEEK)-1));
		System.out.println("一个月中的第"+ca.get(Calendar.WEEK_OF_MONTH)+"周");
		System.out.println("一年中的第"+ca.get(Calendar.WEEK_OF_YEAR)+"周");
		System.out.println("一年中的第"+ca.get(Calendar.DAY_OF_YEAR)+"天");
	
		//1.判断月份中的最大值 11 （0代表1月份，11代表的是12月）
		System.out.println(ca.getMaximum(Calendar.MONTH));
	
		//2.一个月中最大的日字数31号
		System.out.println(ca.getMaximum(Calendar.DAY_OF_MONTH));
		
		//3.判断指定日期对应的日子数的最大值 4月30天
		System.out.println(ca.getActualMaximum(Calendar.DAY_OF_MONTH));
		//4.2021最大天数为365天
		System.out.println(ca.getActualMaximum(Calendar.DAY_OF_YEAR));
		
		//5.获取距离1970年1月1号与当前时间相隔的毫秒数
		long time1=ca.getTimeInMillis();
		System.out.println(time1);
		
		//6.将Calendar转成Date类型
		Date date=ca.getTime();
		System.out.println(date.toLocaleString());
		
		Calendar ca1=Calendar.getInstance();
		//7.设置日历类型的时间: 没有设置
		ca1.set(2020,4, 20);//修改年月日，没有修改的默认是当前系统时间
		System.out.println(ca1.getTime().toLocaleString());    
1.利用日历类打印日历（控制台输入年份，输入月份，打印对应的日历）
    <1>.指定年份，月份1号是星期几
    <2>.是星期几补充几个制表符，星期六的时候需要换行。
    <3>.只要不是星期六使用制表符隔开
    日\t一\t二\t三\t四\t五\t六\n
    
  public class Calendar_02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int year = sc.nextInt();
        int month = sc.nextInt();
        Calendar c = Calendar.getInstance();
        c.set(year,month - 1,1);
        int num = c.get(Calendar.DAY_OF_WEEK) - 1;
        System.out.println(c.get(Calendar.DAY_OF_WEEK) - 1);
        int days = c.getActualMaximum(Calendar.DAY_OF_MONTH);
        System.out.println("日\t一\t二\t三\t四\t五\t六\n");

        for (int i = 1; i <= days ; i++) {
            if(i == 1) {
                for (int j = 0; j < num; j++)
                    System.out.print("\t");
                System.out.print(i + "\t");
            }else if((i+num) % 7 == 0) {
                System.out.print(i + "\t");
                System.out.println();
            }else
                System.out.print(i + "\t");

        }
    }
}

JDK8日期API

背景

JDK8中增加了一套全新的日期时间API，这里进行总结下。
新的时间及日期API位于 java.time 包中，下面是一些关键类。
Instant：代表的是时间戳。
LocalDate：不包含具体时间的日期。
LocalTime：不含日期的时间。
LocalDateTime：包含了日期及时间。

获取日期时间的信息

LocalDate

		LocalDate nowDate = LocalDate.now();
        System.out.println("今天的日期：" + nowDate);//今天的日期：2018-09-06
        int year = nowDate.getYear();//年：一般用这个方法获取年
        System.out.println("year：" + year);//year：2018
        int month = nowDate.getMonthValue();//月：一般用这个方法获取月
        System.out.println("month：" + month);//month：9
        int day = nowDate.getDayOfMonth();//日：当月的第几天，一般用这个方法获取日
        System.out.println("day：" + day);//day：6
		
		//根据输入的数据设置年月
		LocalDate nowDate1 = LocalDate.of(2021,4,22);		

        int dayOfYear = nowDate.getDayOfYear();//日：当年的第几天
        System.out.println("dayOfYear：" + dayOfYear);//dayOfYear：249

        //星期
        System.out.println(nowDate.getDayOfWeek());//THURSDAY
        System.out.println(nowDate.getDayOfWeek().getValue());//4
        //月份
        System.out.println(nowDate.getMonth());//SEPTEMBER
        System.out.println(nowDate.getMonth().getValue());//9

LocalTime

   	LocalTime nowTime = LocalTime.now();
       System.out.println("今天的时间：" + nowTime);//今天的时间：15:33:56.749
       int hour = nowTime.getHour();//时
       System.out.println("hour：" + hour);//hour：15
       int minute = nowTime.getMinute();//分
       System.out.println("minute：" + minute);//minute：33
       int second = nowTime.getSecond();//秒
       System.out.println("second：" + second);//second：56
       int nano = nowTime.getNano();//纳秒
       System.out.println("nano：" + nano);//nano：749000000

LocalDateTime

		LocalDateTime nowDateTime = LocalDateTime.now();
        System.out.println("今天是：" + nowDateTime);//今天是：2018-09-06T15:33:56.750
        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("dayOfYear：" + nowDateTime.getDayOfYear());//dayOfYear：249
        //星期
        System.out.println(nowDateTime.getDayOfWeek());//THURSDAY
        System.out.println(nowDateTime.getDayOfWeek().getValue());//4
        //月份
        System.out.println(nowDateTime.getMonth());//SEPTEMBER
        System.out.println(nowDateTime.getMonth().getValue());//9

获取指定的时间日期

LocalDate

System.out.println(LocalDate.of(1991, 11, 11));//直接传入对应的年月日
System.out.println(LocalDate.of(1991, Month.NOVEMBER, 11));//相对上面只是把月换成了枚举
LocalDate birDay = LocalDate.of(1991, 11, 11);
//第一个参数为年，第二个参数为当年的第多少天
System.out.println(LocalDate.ofYearDay(1991, birDay.getDayOfYear()));
//参数为距离1970-01-01的天数
System.out.println(LocalDate.ofEpochDay(birDay.toEpochDay()));
System.out.println(LocalDate.parse("1991-11-11"));     System.out.println(LocalDate.parse("19911111",DateTimeFormatter.ofPattern("yyyyMMdd")));

localtime

System.out.println(LocalTime.of(8, 20));//时分
System.out.println(LocalTime.of(8, 20, 30));//时分秒
System.out.println(LocalTime.of(8, 20, 30, 150));//时分秒纳秒
LocalTime mTime = LocalTime.of(8, 20, 30, 150);
System.out.println(LocalTime.ofSecondOfDay(mTime.toSecondOfDay()));//参数为距离当天零时的秒数
System.out.println(LocalTime.ofNanoOfDay(mTime.toNanoOfDay()));//参数为距离当天零时的纳秒数
System.out.println(LocalTime.parse("08:20:30"));
System.out.println(LocalTime.parse("082030", DateTimeFormatter.ofPattern("HHmmss")));

LocalDateTime

System.out.println(LocalDateTime.of(birDay, mTime));//参数为LocalDate和LocalTime
System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20));
System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20));
System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20, 30));
System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30));
System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20, 30, 150));
System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30, 150));
System.out.println(LocalDateTime.parse("1991-11-11T08:20:30"));
System.out.println(LocalDateTime.parse("1991-11-11 08:20:30", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));

日期时间的比较

在JDK8中，LocalDate类中使用isBefore()、isAfter()、equals()方法来比较两个日期，可直接进行比较。

以LocalDate为例。

LocalDate myDate = LocalDate.of(2018, 9, 5);
LocalDate nowDate = LocalDate.now();
System.out.println("今天是2018-09-06吗？ " + nowDate.equals(myDate));//今天是2018-09-06吗？ 
System.out.println(myDate + "是否在" + nowDate + "之前？ " + myDate.isBefore(nowDate));//2018-09-05是否在2018-09-06之前？ true
System.out.println(myDate + "是否在" + nowDate + "之后？ " + myDate.isAfter(nowDate));//2018-09-05是否在2018-09-06之后？ false

如何在java中判断是否是某个节日或者重复事件，使用MonthDay类。这个类由月日组合，不包含年信息，可以用来代表每年重复出现的一些日期。它和新的日期库中的其他类一样也都是不可变且线程安全的。

LocalDate birDate = LocalDate.of(1991, 10, 1);
LocalDate nowDate = LocalDate.now();
MonthDay nowDay = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth());
//MonthDay monthDay = MonthDay.of(birDate.getMonth(), birDate.getDayOfMonth());
MonthDay birDay = MonthDay.from(nowDate);
System.out.println("今天是你的生日吗？ " + nowDay.equals(birDay));//今天是你的生日吗？ false

YearMonth表示固定的日期。Year表示年。

YearMonth yearMonth = YearMonth.of(2004, 2);
System.out.println(yearMonth + "有多少天？ " + yearMonth.lengthOfMonth());//2004-02有多少天？ 29
Year year = Year.of(2004);
System.out.println(year + "有多少天？ " + year.length());//2004有多少天？ 366
System.out.println(year + "是否是闰年？ " + year.isLeap());//2004是否是闰年？ true

对日期时间的修改

LocalDateTime 综合了 LocalDate 和 LocalTime 里面的方法，所以下面只用 LocalDate 和 LocalTime 来举例。

这些方法返回的是一个新的实例引用，因为LocalDateTime 、LocalDate 、LocalTime 都是不可变的。

LocalDate nowDate = LocalDate.now();
System.out.println(nowDate);//当前日期
System.out.println(nowDate.minusYears(1));//一年前
System.out.println(nowDate.minusMonths(1));//一月前
System.out.println(nowDate.minusWeeks(1));//一周前
System.out.println(nowDate.minusDays(1));//一天前

System.out.println(nowDate.plusYears(1));//一年后
System.out.println(nowDate.plusMonths(1));//一月后
System.out.println(nowDate.plusWeeks(1));//一周后
System.out.println(nowDate.plusDays(1));//一天后

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(nowTime.plusHours(1));//一小时后
        System.out.println(nowTime.plusMinutes(1));//一分钟后
        System.out.println(nowTime.plusSeconds(1));//一秒后
        System.out.println(nowTime.plusNanos(1));//一纳秒后

时间戳

JDK8获取时间戳特别简单。Instant类由一个静态的工厂方法now()可以返回当前时间戳。

Instant instant = Instant.now();
System.out.println("当前时间戳是：" + instant);//当前时间戳是：2018-09-06T10:14:29.460Z
Date date = Date.from(instant);
System.out.println("当前时间戳是：" + date);//当前时间戳是：Thu Sep 06 18:14:29 CST 2018
instant = date.toInstant();

可以看到，当前时间戳是包含日期和时间的，与java.util.Date很类似，事实上Instant就是JDK8以前的Date，可以使用这两个类中的方法在这两个类型之间进行转换。

日期时间格式化

在JDK8之前，时间日期的格式化非常麻烦，经常使用SimpleDateFormat来进行格式化，但是SimpleDateFormat并不是线程安全的。在JDK8中，引入了一个全新的线程安全的日期与时间格式器DateTimeFormatter。

LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);//2018-09-06T18:22:47.366
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String ldtStr = ldt.format(dtf);
        System.out.println(ldtStr);//2018-09-06 18:22:47
        String ldtStr1 = dtf.format(ldt);
        System.out.println(ldtStr1);//2018-09-06 18:22:47

计算日期时间差

在Java8中，我们可以使用以下类来计算日期时间差异：

java.time.Period

主要是 Period 类方法 getYears()，getMonths() 和getDays()来计算。只能精确到年月日。

用于 LocalDate 之间的比较。

LocalDate today = LocalDate.now();
System.out.println(today);//2018-09-06
LocalDate birthDate = LocalDate.of(1992, 1, 11);
System.out.println(birthDate);//1990-10-01

Period period = Period.between(birthDate, today);//第二个参数减第一个参数
System.out.printf("年龄 : %d 年 %d 月 %d 日", period.getYears(), period.getMonths(), period.getDays());//年龄 : 27 年 11 月 5 日

java.time.Duration

提供了使用基于时间的值测量时间量的方法。

用于 LocalDateTime 之间的比较。也可用于 Instant 之间的比较。

LocalDateTime today = LocalDateTime.now();
        System.out.println(today);
        LocalDateTime birthDate = LocalDateTime.of(1990,10,1,10,50,30);
        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());//两个时间差的纳秒数

java.time.temporal.ChronoUnit

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

LocalDateTime today = LocalDateTime.now();
        System.out.println(today);
        LocalDateTime birthDate = LocalDateTime.of(1990,10,1,10,50,30);
        System.out.println(birthDate);

        System.out.println("相差的年数：" + ChronoUnit.YEARS.between(birthDate, today));
        System.out.println("相差的月数：" + ChronoUnit.MONTHS.between(birthDate, today));
        System.out.println("相差的周数：" + ChronoUnit.WEEKS.between(birthDate, today));
        System.out.println("相差的天数：" + ChronoUnit.DAYS.between(birthDate, today));
        System.out.println("相差的时数：" + ChronoUnit.HOURS.between(birthDate, today));
        System.out.println("相差的分数：" + ChronoUnit.MINUTES.between(birthDate, today));
        System.out.println("相差的秒数：" + ChronoUnit.SECONDS.between(birthDate, today));
        System.out.println("相差的毫秒数：" + ChronoUnit.MILLIS.between(birthDate, today));
        System.out.println("相差的微秒数：" + ChronoUnit.MICROS.between(birthDate, today));
        System.out.println("相差的纳秒数：" + ChronoUnit.NANOS.between(birthDate, today));
        System.out.println("相差的半天数：" + ChronoUnit.HALF_DAYS.between(birthDate, today));
        System.out.println("相差的十年数：" + ChronoUnit.DECADES.between(birthDate, today));
        System.out.println("相差的世纪（百年）数：" + ChronoUnit.CENTURIES.between(birthDate, today));
        System.out.println("相差的千年数：" + ChronoUnit.MILLENNIA.between(birthDate, today));
        System.out.println("相差的纪元数：" + ChronoUnit.ERAS.between(birthDate, today));

String

String 字符串类型
String类由final关键字修饰，String类不能被继承。
String类常见的几种创建方式:
String str1="123";
String str2=new String("123");
String str3=new String(new char[]{'1','2','3'});
String str4=new String(new byte[]{});
------------------------------------------------------------------------
字符串常用的方法介绍:
String str="Made In China";
		System.out.println("原字符串为:"+str);
		System.out.println("1.根据下标返回对饮下标位置的单个字符:"+str.charAt(0));
		System.out.println("2.获得字符串的长度:"+str.length());
		System.out.println("3.根据下标返回对应下标位置的单个字符对应的Unicode值:"+str.codePointAt(1));
		System.out.println("4.将字符串中的字母全部转成大写字母:"+str.toUpperCase());
		System.out.println("5.将字符串中的字母全部转成小写字母:"+str.toLowerCase());
		//1.验证码不区分大小写
		String str1="ACuF";
		String str2="acuf";
		System.out.println("6.不区分大小写比较:"+str1.toLowerCase().equals(str2.toLowerCase()));
		System.out.println("7.不区分大小写比较:"+str1.equalsIgnoreCase(str2));
		System.out.println("8.以什么开头:"+str.startsWith("Ma"));
		System.out.println("9.以什么结尾:"+str.endsWith("China"));
		//10. 空格Made in China空格  --->Made in China
		System.out.println("10.删除左右空格:"+str.trim());
		//2.将空格替换成空字符串
		System.out.println("11.删除所有的空格:"+str.replace(" ", ""));
		System.out.println("12.判断指定的子串在字符串中的位置(存在返回存在的位置，不存在返回-1):"+str.indexOf("M"));
		//3.随便输入一个字符串，要求统计各个字符出现的次数
		String str3="aaabbccccdddeee";
		String str4="";
		//去重
		for(int i=0;i<str3.length();i++) {
      //不存在拼接进去...
			if(str4.indexOf(str3.charAt(i)+"")==-1) {
				str4+=str3.charAt(i)+"";
			}
		}
		System.out.println("去重之后:"+str4);
		//统计
		for(int i=0;i<str4.length();i++) {
			String temp=str3.replace(str4.charAt(i)+"","");
			System.out.println(str4.charAt(i)+"出现的次数为:"+(str3.length()-temp.length()));
		}
		System.out.println("-----------------------------------------------------------");
		//1.存在返回存在的位置，不存在返回-1（一般用于判断某个内容在字符串中是否存在）。左-->右
		System.out.println("1.根据指定的子串返回其在字符串中第一次出现的下边位置:"+str.indexOf("a"));
		System.out.println("2.根据指定子串返回其在字符串中最后一个出现的下标位置:"+str.lastIndexOf("a"));
		//2.如何判断某个字串在字符串中是否重复 存在返回true 不存在返回false
		System.out.println(str.indexOf("a")==str.lastIndexOf("a"));//true 没有重复 false 由重复的
		
		//3.判断指定子串是否存在 存在返回true ,不存在返回false
		System.out.println(str.contains("Made"));
		//4.split根据指定的特殊符号进行字符串的分割 返回的是字符串数组
		String[] strs=str.split(" ");//Made,in,china
		System.out.println(Arrays.toString(strs));
		//5.将数据库的字段名转成java的属性名
		String colName="stu_name_test_user";
		String[] colNames=colName.split("_");//{stu,name}
		String fieldName=colNames[0];//stu
		for(int i=1;i<colNames.length;i++) {
			fieldName+=colNames[i].substring(0,1).toUpperCase()+colNames[i].substring(1);
		}
		System.out.println("java属性名为:"+fieldName);
		//6.字符串截取(一) 1个参数 [1,最后]
		System.out.println(str.substring(1));
		//7.字符串截取(二)2个参数[a,b)
		System.out.println(str.substring(0,1));

StringBuilder，StringBuffer介绍

StringBuider,StringBuffer称之为字符串变量：
StringBuider sb=new StringBuilder();

String字符串常量:改变字符串的值，内存中会重新开辟一个新的空间，而不是将新的值替换之间空间的值，每一个空间的值都是固定不变的。

字符串常量的图解分析:

字符串问题分析:

String str="ab";
str=str+"c"+"d";
字符串创建了几次？
    "ab" "c" "d"  "abc" "abcd"
    5次

StringBuffer或者StringBuider字符串变量的内存分析图解

StringBuffer sb1=new StringBuffer("ab");
sb1.append("c");//abc
sb1.append("d");//abcd

StringBuffer sb2=new StringBuffer("ab");
sb2.append("c");//abc
sb2.append("d");//abcd
执行一个固定的堆内存的地址，堆空间的里面存的内容可以随时修改。

StingBuffer和StringBuilder常用方法介绍:

		//1.默认构造方法值得的长度16
		StringBuffer sb=new StringBuffer();
		System.out.println("获得字符串的容量:"+sb.capacity());
		//2.将指定的内容拼接到字符串中
		sb.append("abc");
		System.out.println(sb);
		System.out.println("拼接完之后对应的容量:"+sb.capacity());
		System.out.println("实际的字符串的长度:"+sb.length());
		sb.append("def");
		System.out.println(sb);
		System.out.println("-------插入之后------");
		//1.根据执行索引值，往前面插入元素
		//abc ---> 123abc
		sb.insert(1, "123");
		System.out.println(sb);
		System.out.println("--------修改之后---------");
		//2.根据执行索引值修改指定的符号
		sb.setCharAt(0,'A');
		System.out.println(sb);
		//3.根据指定的索引值删除字符.
		sb.deleteCharAt(0);
		System.out.println("删除指定位置之后:"+sb);
		//4.根据指定索引范围删除内容[a,b)
		sb.delete(1,3);
		System.out.println("删除[1,3)之后的结果为:"+sb);
		System.out.println("----------------------------------------");
		StringBuilder sb1=new StringBuilder("123");
		System.out.println(sb1);
		//1.要求反转字符串   回文数 12821
		sb1.reverse();
		System.out.println(sb1);
		//2.判断一个数是否是回文数
		StringBuffer sb2=new StringBuffer("1223221");
		System.out.println(sb2.toString().equals(sb.reverse())?sb2+"是回文数":sb2+"不是回文数");
		//返回指定字串在字符串中第一次或者最后一次出现索引位置，不存在返回-1
		System.out.println(sb2.indexOf("4"));
		System.out.println(sb2.lastIndexOf("4"));
		//第二个参数可以设置起始值:[2,最后]
		System.out.println(sb2.indexOf("2",2));java
            
 <1>.控制台输入一个整数金额，要求按照货币的格式输出结果:
	比如:100000000==>100,000,000 ....
  public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String money = sc.next();
        StringBuffer sb = new StringBuffer();
        int n = money.length();
        int index = 1;
        for (int i = n - 1; i >= 0; i--) {
            if ((index % 3) == 0 && index != n) {
                sb.append(money.charAt(i));
                sb.append(",");
            } else
                sb.append(money.charAt(i));

            index++;
        }
        System.out.println(sb.reverse());
    }
}

NumberFormat

		//1.货币对象
		NumberFormat currency=NumberFormat.getCurrencyInstance();
		String currStr01=currency.format(100000000000000000L);
		System.out.println(currStr01);
		System.out.println(currency.format(132123213));
		
		//2.百分比
		NumberFormat perFormat=NumberFormat.getPercentInstance();
		System.out.println(perFormat.format(0.08));

String，StringBuffer，StringBuilder 对比

String,StringBuffer,StringBuilder之间的区别？
String,StringBuffer,StringBuilder,都由final关键字修饰，代表都不可以被继承，都是处理字符串的一个工具类。  

<1>.String：字符串常量(如果修改字符串的数据，指向的地址会发生改变),一般用于处理少量的字符，处理的效率较低。
<2>.StringBuilder,StringBuffer:字符串变量(修改字符串数据的时候，任然指向堆内存的地址，不会发生改变)，一般用于处理大量的字符，处理的效率较高。(StringBuffer,StringBuilder方法基本上相同的)
<3>StringBuilder属于线程不安全的，一般适用于单线程环境下，处理字符串的效率比StringBuffer更高。
   StringBuffer属于线程安全的， 一般适用于多线程环境下，处理字符串的效率比StringBuilder更低
但是记住StringBuffer,StringBuilder处理字符串的效率都比String要更快。    
 StringBuilder sb=new StringBuilder()

 线程1 sb.append("abc")  ===>
 线程2 sb.append("edf")  ===>
 后续再来解释...

Math

public class Test {

	public static void main(String[] args) {
		System.out.println("圆周率π:"+Math.PI);
		System.out.println("随机数[0,1):"+Math.random());
		System.out.println("幂函数1:"+Math.pow(2, 3));//2的3次方
		System.out.println("幂函数2:"+Math.pow(9,0.5));//9的算数平方根
		System.out.println("算术平方根:"+Math.sqrt(9));
		System.out.println("计算绝对值:"+Math.abs(-10));
		//向上:12.1 介于 12 ,13之中取大的  13
		System.out.println("向上取值1:"+Math.ceil(12.1));//13
		//向上:-13,-12之间 取大的  -12
		System.out.println("向上取值2:"+Math.ceil(-12.9));//-12
		//向下取值 ...取小的。
		System.out.println("向下取值1:"+Math.floor(12.99));//12
		System.out.println("向下取值2:"+Math.floor(-12.1));//-13
		
		System.out.println("四舍五入1:"+Math.round(12.4));
		System.out.println("四舍五入2:"+Math.round(12.5));
	}
}

Random

创建随机数的一个工具类:
		Random ra=new Random();
		//1.产生指定范围的整数[0,num)
		System.out.println("随机产生[0,10)之间的整数:"+ra.nextInt(10));
		//产生任意区间[a,b)的整数值ra.nextInt(b-a)+a;
		for(int i=1;i<=100;i++) {
			System.out.println(ra.nextInt(9000)+1000);
		}
		//2.随机产生[0,1)随机小数
		System.out.println("随机产生小数:"+ra.nextDouble());
		//3.随机产生:true,false
		System.out.println("随机产生一个boolean类型的数据:"+ra.nextBoolean());

BigDecimal

double,float运算存在精度差：
比如：double num=0.1;//结果无限接近于0.1
而且double和float存在精度是有限的

BigDecimal理论上精度，取值范围没有限制的。
构造方法介绍:
new BigDecimal(double num);//不推荐使用 存在精度差 结果会无限接近于num
new BigDecimal("");//推荐使用 不存在精度差。
----------------------------------------------------------------------------
	//1.不推荐使用，存在精度差，最终的结果无限接近于值。
		BigDecimal bg1=new BigDecimal(0.1);
		System.out.println(bg1);
		//2.推荐使用，不存在精度差 取值范围，精度理论上没有限制。
		BigDecimal bg2=new BigDecimal("123.456");
		System.out.println(bg2);
注意:使用BigDecimal无法使用算数运算符进行运算(+ - / * 等等)
----------------------------------------------------------

常用方法:
public static void main(String[] args) {
		//1.不推荐使用，存在精度差，最终的结果无限接近于值。
		BigDecimal bg1=new BigDecimal(0.1);
		System.out.println(bg1);
		//2.推荐使用，不存在精度差 取值范围，精度理论上没有限制。
		BigDecimal bg2=new BigDecimal("123.456");
		System.out.println(bg2);
		System.out.println("------运算--------------");
		BigDecimal bg3=new BigDecimal("10000");
		BigDecimal bg4=new BigDecimal("200");
		System.out.println("加法运算:"+bg3.add(bg4));
		System.out.println("减法运算:"+bg3.subtract(bg4));
		System.out.println("乘法运算:"+bg3.multiply(bg4));
		//3.如果除法运算得到的是一个无限不循环小数，出现运行时错误。ArithmeticException
		System.out.println("除法运算:"+bg3.divide(bg4));
		
		//4.保留指定位数的小数
		BigDecimal bg5=new BigDecimal("12351.3871263908123112412412412431");
		//4.参数1:保留小数的位数    参数2:保留小数的方式(向上，向下，四舍五入)
		System.out.println("保留精度(向上取整):"+bg5.setScale(5,BigDecimal.ROUND_CEILING));
		System.out.println("保留精度(向下取整):"+bg5.setScale(4,BigDecimal.ROUND_FLOOR));
		System.out.println("保留精度(四舍五入):"+bg5.setScale(2,BigDecimal.ROUND_HALF_UP));
		
		//5.转货币类型
		NumberFormat currFormat=NumberFormat.getCurrencyInstance();
		BigDecimal bg6=new BigDecimal("316524316253871263709128312393103213123712");
		System.out.println(currFormat.format(bg6));
	}

Arrays

关于数组一个工具类:
		int[] arr= {11,1,8,4,7,19,10};
		System.out.println("排序之前:"+Arrays.toString(arr));
		
		//1.排序
		Arrays.sort(arr);
		System.out.println("排序之后:"+Arrays.toString(arr));

UUID

产生唯一的字符串:一般用UUID当做上传至服务器的文件名(为了防止服务中文件名字出现冲突);
//1.产生一个唯一的uuid
		String uuid=UUID.randomUUID().toString();
		System.out.println("uuid:"+uuid);
		//2.将-去掉
		uuid=uuid.replace("-", "");
		//3.将字母变成大写输出
		uuid=uuid.toUpperCase();
		System.out.println(uuid);

System

系统的一个工具类:System
属性介绍:
out:输出
in:输入
err:输出异常信息(红色字体)
//常用方法介绍:
currentTimeMillis() //返回当前系统时间距离1970 1 1 之间相隔的毫秒数。
exit(int status) ; status:0 代表正常退出jvm  status:非0 异常终止  (结束程序)
    
 ---------------------------  -----------------------------------------
public class Exam {
    public static void main(String[] args) {
        //1.打印输出指定内容
        System.out.println("hello word");
        //2.打印输出错误信息
        System.err.println("异常信息...");
        //3.根据指定通配符打印信息 %d整数   %f小数  %s
        int age=18;//d%
        double money=88.888;//%f 小数
        String name="小强";
        System.out.println("姓名:"+name+",年龄:"+age+",余额:"+money);
        System.out.printf("姓名:%s,年龄:%d,余额:%f",name,age,money);
        System.out.println("毫秒数:"+System.currentTimeMillis());
        int count=0;
        while(true) {
            count++;
            if(count==1000) {
                System.exit(0);//程序结束（有关于这个程序的所有内存全部清空）
            }
        }
    }
}

包装类的概念

回顾一下8大基本数据类型
byte,short,int,long,float,double,char,boolean

基本类型对应的引用类型(对象类型)，分别是：
Byte,Short,Integer,Long,Float,Double,Character,Boolean
 
基本类型不能够拥有方法，同类型之间虽然可以互相转换，但是不同类型之间无法相互转换的，比如
<1>.数值类型转成字符串类型 可以做到(与字符串做+加法运算)
<2>.如果我需要将字符串类型转成数值类型该怎么办呢?"123"===>123 无法实现
使用包装类型可以很好的解决上述问题

包装类的常用方法

1.装箱:将基本类型转成引用类型  int==>Integer  依次类推。
2.拆箱:将引用类型转成基本类型  Integer==>int  以此类推。
		int num=100;
		//1.装箱(一) （int->Integer） 推荐使用
		Integer numPackage1=num;
		//2.装箱(二)  
		Integer numPackage2=new Integer(num);
		System.out.println(numPackage1+","+numPackage2);
		//3.装箱之后，变成了对应类型的引用类型，就可以调用包装类里面定义的功能方法了。
		//4.利用引用类型可以将字符串转成数值（装箱）
		Integer numPackage3=Integer.parseInt("123");
		System.out.println(numPackage3);
		Integer numPackage4=Integer.valueOf("456");
		System.out.println(numPackage4);
		
		System.out.println("------拆箱----");
		Integer num2=200;
		//1.拆箱(一) 推荐使用
		int noPackageNum1=num2;
		//2.拆箱(二) 
		int noPackageNum2=Integer.intValue(num2);
		System.out.println(noPackageNum1);
		System.out.println(noPackageNum2);
		//总结1:包装类型与基本类型之间可以默认互相转型
		//总结2:parseInt(String str) 将字符串类型转成数值类型 返回int   valueOf(String str) 返回的是Integer

Character包装类类型方法介绍:
String str="aabbAAbb112233你好吗我很好";
int numCount=0;
int letterCount=0;
int chineseCount=0;
for(int i=0;i<str.length();i++) {
	//1.是数字返回true  否则返回false
	if(Character.isDigit(str.charAt(i))) {
		numCount++;
		//1.isLetter 即可判断字母也可以判断汉字
	}else if(Character.isLowerCase(str.charAt(i))||Character.isUpperCase(str.charAt(i))){
		letterCount++;
	}else if(Character.isIdeographic(str.charAt(i))) {//判断汉字的
		chineseCount++;
	}
}
System.out.println("数字的个数:"+numCount);
System.out.println("字母的个数:"+letterCount);
System.out.println("中文的个数:"+chineseCount);