JavaSE 进阶 (5) 时间

1
2
3

// Long 是 long 的 包装类
long time = System.currentTimeMillis();  //打印的是从1970年1月1日到现在时间过了这么多毫秒
System.out.println(time);//1575465416955

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public class TestDemo {
	public static void main(String[] args) {
		//那么这个时间就表示电脑中的当前时间。
		Date date1 = new Date();
		System.out.println(date1);
		
		//从计算机的时间原点开始，过了指定毫秒的那个时间。
		Date date2 = new Date(0L);  //L表示的是long长整型
		System.out.println(date2);  //Thu Jan 01 08:00:00 CST 1970
		//从时间原点开始，过了0毫秒。
		//因为我们是在中国，我们是在东八区需要+8小时。

		//1970年1月1日 上午的9点
		//60分 * 60秒 = 3600秒，3600秒 * 1000 = 3600000 毫秒 (参数是毫秒,1秒=1000毫秒)
		Date date3 = new Date(3600L * 1000);
		System.out.println(date3);
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public class TestDemo {
	public static void main(String[] args) {
		//把当前时间封装成一个date对象
		Date date1 = new Date();
		//获取这个date对象的毫秒值---获取当前时间的毫秒值
		long time = date1.getTime();
		System.out.println(time);  //2461471445407
		
		//getTime获得的毫秒值与currentTimeMillis获取的毫秒值进行对比，查看获取的毫秒值是否正确
		long time2 = System.currentTimeMillis();
		System.out.println(time2);  //2461471445407
		
		//将当前系统的时间包装成一个data2对象，再通过setTime()来将data2设置成距1970.1.1.0:0:0过去0秒的时间
		Date date2 = new Date();
		date2.setTime(OL);  //跟new Date(0L)效果一样
		System.out.println(date2);  //Thu Jan 01 08:00:00 CST 1970
	}	
}

1
2
3
4
5
6

// 代码
Date date1 = new Date();
System.out.println(date1);

// 控制台输出
Wed Jan 01  15:00:22  CST  2048

1
2
3
4
5
6
7
8
9

public class TestDemo {
	public static void main(String[] args) {
		//当前时间的Date对象
		Date date = new Date();
		
		//创建了一个日期格式。
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class TestDemo {
	public static void main(String[] args) {
		//当前时间的Date对象
		Date date = new Date();

		//创建了一个日期格式。
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

		String result1 = sdf.format(date);
		System.out.println(result1);
	}
}

public class TestDemo {
	public static void main(String[] args) {
		String s = "2048-01-01";

		//解析的格式要和字符串里时间的格式一样,否则会出现解析异常
		SimpleDateFormat sdf = new simpleDateFormat("yyyy-MM-dd");
		
		Date date = sdf.parse(s);
		System.out.println(date);  //Wed Jan 01 00:00:00 CST 2048
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

public class TestDemo {
	public static void main(String[] args) {
		String start = "2020年11月11日 0:0:0";
		String end = "2020年11月11日 0:10:0";
		
		String jia = "2020年11月11日 0:03:47";
		String pi = "2020年11月11日 0:10:11";
		
		SimpleDateFormat sdf = new simpleDateFormat("yyyyMMdd HH:mm:ss");
		long startTime = sdf.parse(start).getTime();
		long endTime = sdf.parse(end).getTime();
		
		long jiaTime = sdf.parse(jia).getTime();
		long piTime = sdf.parse(pi).getTime();

		if(jiaTime >= startTime && jiaTime <= endTime){
			System.out.println("小贾同学参加上了秒杀活动");
		}else{
			System.out.println("小贾同学没有参加上了秒杀活动");
		}
		//---------------------------------------------
		if(piTime >= startTime && piTime <= endTime){
			System.out.println("小皮同学参加上了秒杀活动");
		}else{
			System.out.println("小皮同学没有参加上了秒杀活动");
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 获取当前 年份、月份、日期
public static void getDateTime() throws ParseException {
    Calendar now = Calendar.getInstance();
    System.out.println("年: " + now.get(Calendar.YEAR));
    System.out.println("月: " + (now.get(Calendar.MONTH) + 1) + "");
    System.out.println("日: " + now.get(Calendar.DAY_OF_MONTH));
    System.out.println("时: " + now.get(Calendar.HOUR_OF_DAY));
    System.out.println("分: " + now.get(Calendar.MINUTE));
    System.out.println("秒: " + now.get(Calendar.SECOND));
    System.out.println("当前时间毫秒数：" + now.getTimeInMillis());
    System.out.println(now.getTime());

    Date d = new Date();
    System.out.println(d);
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String dateNowStr = sdf.format(d);
    System.out.println("格式化后的日期：" + dateNowStr);

    String str = "2012-1-13 17:26:33";    //要跟上面sdf定义的格式一样
    Date today = sdf.parse(str);
    System.out.println("字符串转成日期：" + today);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

@Test
public void localDateCreate() {
	LocalDate yyyyMMdd = LocalDate.now();
	LocalTime HHmmsssss = LocalTime.now();
	LocalDateTime yyyyMMddHHmmssSSs = LocalDateTime.now();
	
	System.out.println("年月日：" + yyyyMMdd);
	System.out,println("时分秒毫秒：" + HHmmssSSS);
	System.out.println("年月日时分秒毫秒：" + yyyyMMddHHmmssSSS):
	
	//输出：
	//年月日：2020-10-16
	//时分秒毫秒：09:55:49.448
	//年月日时分秒毫秒：2020-10-16T09:55:49.448
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

@Test
public void setDate() {
	LocalDate yyyyMMdd = LocalDate.of(2020, 10, 15);
	LocalTime HHmmssSSs = LocalTime.of(10, 10, 10);
	LocalDateTime yyyyMMddHHmmssSss = LocalDateTime.of(2020, 10, 15, 10, 10);
	
	System.out.println("自定义的年月日：" + yyyyMMdd);
	System.out.print1n("自定义时分秒毫秒：" + HHmmssSSS);
	System.out.println("自定义年月日时分秒毫秒：" + yyyyMMddHHmmssSSS);
	
	//输出：
	//自定义的年月日：2020-10-15
	//自定义时分秒毫秒：10:10:10
	//自定义年月日时分秒毫秒：2020-10-15T10:10
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public static void main(String[] args) {
	LocalDate yyyyMMdd = LocalDate.now();
	
	LocalDate addOneDay = yyyyMMdd.plusDays(1L);         //添加一日
	LocalDate addOneMonths = yyyyMMdd.plusMonths(1L);    //添加一月
	LocalDate addOneYears = yyyyMMdd.plusYears(1L);      //添加一年
	LocalDate addOneWeeks = yyyyMMdd.plusWeeks(1L);      //添加一周
	
	LocalDate delOneDay = yyyyMMdd.minusDays(1L);       //减去一日
	LocalDate delOneMonths = yyyyMMdd.minusMonths(1L);  //减去一月
	LocalDate delOneYears = yyyyMMdd.minusYears(1L);    //减去一年
	LocalDate delOneWeeks = yyyyMMdd.minusWeeks(1L);    //减去一周
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public static void main(String[] args) {
	LocalTime HHmmssSSs = LocalTime.now();
	
	LocalTime addOneHours = HHmmssSSS.plusHours(1L);      //添加1小时
	LocalTime addOneMinutes = HHmmssSSS.plusMinutes(1L);  //添加1分钟
	LocalTime addOneSeconds = HHmmssSSS.plusSeconds(1L);  //添加1秒
	LocalTime addOneNanos = HHmmssSSS.plusNanos(1L);      //添加1纳秒
	
	LocalTime delOneHours = HHmmssSSS.minusHours(1L);     //减去1小时
	LocalTime delOneMinutes = HHmmssSSS.minusMinutes(1L); //减去1分钟
	LocalTime delOneSeconds = HHmmssSSS.minusSeconds(1L); //减去1秒
	LocalTime delOneNanos = HHmmssSSS.minusNanos(1L);     //减去1纳秒
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

public static void main(String[] args) {
	LocalDateTime yyyyMMddHHmmssSSs = LocalDateTime.now();
	
	LocalDateTime localDateTimeaddOneDay = yyyyMMddHHmmssSSS.plusDays(1L);           //添加一日
	LocalDateTime localDateTimeaddOneMonths = yyyyMMddHHmmssSSS.plusMonths(1L);      //添加一月
	LocalDateTime localDateTimeaddOneYears = yyyyMMddHHmmssSSS.plusYears(1L);        //添加一年
	LocalDateTime localDateTimeaddOneWeeks = yyyyMMddHHmmssSSS.plusWeeks(1L);        //添加一周
	LocalDateTime localDateTimeaddOneHours = yyyyMMddHHmmssSSS.plusHours(1L);        //添加1小时
	LocalDateTime localDateTimeaddOneMinutes = yyyyMMddHHmmssSSS.plusMinutes(1L);    //添加1分钟
	LocalDateTime localDateTimeaddOneSeconds = yyyyMMddHHmmsssss.plusseconds(1L);    //添加1秒
	LocalDateTime localDateTimeaddOneNanos = yyyyMMddHHmmssSSS.plusNanos(1L);        //添加1纳秒
	
	LocalDateTime localDateTimedelOneDay = yyyyMMddHHmmssSSS.minusDays(1L);          //减去一日
	LocalDateTime localDateTimedelOneMonths = yyyyMMddHHmmssSSS.minusMonths(1L);     //减去一月
	LocalDateTime localDateTimedelOneYears = yyyyMMddHHmmssSSS.minusYears(1L);       //减去一年
	LocalDateTime localDateTimedelOneWeeks = yyyyMMddHHmmssSSS.minusWeeks(1I);       //减去一周
	LocalDateTime localDateTimedelOneHours = yyyyMMddHHmmssSSS.minusHours(1L);       //减去1小时
	LocalDateTime localDateTimedelOneMinutes = yyyyMMddHHmmsssss.minusMinutes (1L);  //减去1分钟
	LocalDateTime localDateTimedelOneSeconds = yyyyMMddHHmmsssss.minusseconds (1L);  //减去1秒
	LocalDateTime localDateTimedelOneNanos = yyyyMMddHHmmssSSS.minusNanos(1L);       //减去1纳秒
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public static void main(String[] args) {
	LocalDate yyyyMMdd = LocalDate.now();
	System.out.println("LocalDate yyyyMMdd 当前时间：" + yyyyMMdd);
	
	LocalDate addDay = yyyyMMdd.plusDays(4);
	System.out.println("LocalDate yyyyMMdd 添加4天后的日期：" + addDay);
	
	LocalDate directDesignationDate = yyyyMMdd.withDayofMonth(20);
	System.out.println("LocalDate yyyyMMdd 直接指定到当月第几号：" + directDesignationDate);
	
	LocalDate directDesignationYearDate = yyyyMMdd.withDayofYear(20);
	System.out.println("LocalDate yyyyMMdd 直接指定到当年第几天：" + directDesignationYearDate);
	
	LocalDate directDesignationYear = yyyyMMdd.withYear(2000);
	System.out.println("LocalDate yyyyMMdd 当前时间直接指定年份：" + directDesignationYear);
	
	LocalDate directDesignationMonth = yyyyMMdd.withMonth(6);
	System.out.println("LocalDate yyyyMMdd 当前时间直接指定月份：" + directDesignationMonth);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

public static void main(String[] args) {
	LocalDateTime yyyyMMddHHmmssSss = LocalDateTime.now();
	
	//本年当中第多少天
	int dayofYear = yyyyMMddHHmmsssss.getDayofYear();
	
	//本月当中第多少天
	int dayofMonth = yyyyMMddHHmmsssss.getDayofMonth();
	
	//本周中星期几
	DayofWeek dayofWeek = yyyyMMddHHmmsssss.getDayofweek();
	int value = dayofweek.getvalue();
	
	System.out.println("今天是" + yyyyMMddHHmmssSSS + "\n"
						+ "本年当中第" + dayofYear + "天" + "\n"
						+ "本月当中第" + dayofMonth + "天" + "\n"
						+ "本周中星期" + value + "-即" + dayofWeek + "\n");
						
	//年
	int year = yyyyMMddHHmmsssss.getYear();
	//月
	Month month = yyyyMMddHHmmsssss.getMonth();
	//直接获取
	int monthValue = yyyyMMddHHmmsssss.getMonthvalue();
	//日
	int dayofMonth1 = yyyyMMddHHmmsssss.getDayofMonth();
	//时
	int hour = yyyyMMddHHmmsssss.getHour();
	//分
	int minute yyyyMMddHHmmsssss.getMinute();
	//秒
	int second = yyyyMMddHHmmsssss.getsecond();
	//纳秒
	int nano = yyyMMddHHmmsssss.getNano();
	
	System.out.println("今天是" + yyyyMMddHHmmssSSS + "\n"
						+ "年：" + year + "\n"
						+ "月：" + monthvalue + "-即" + month + "\n"
						+ "日：" + dayofMonth1 + "\n"
						+ "时：" + hour + "\n"
						+ "分：" + minute + "\n"
						+ "秒：" + second + "\n"
						+ "纳秒：" + nano + "\n"
	);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public static void main(String[] args) {
	LocalDate now = LocalDate.now();
	LocalDate of = LocalDate.of(2020, 10, 15);
	
	//判断of是否在now时间之前
	boolean before = of.isBefore(now);
	System.out.println("判断of是否在now时间之前" + before);
	
	//判断of是否在now时间之后
	boolean after = of.isAfter(now);
	System.out.println("判断of是否在now时间之后" + after);
	
	//判断两个时间是否相等
	boolean equal = of.isEqual(now);
	System.out.println("判断两个时间是否相等" + equal);
	
	//判断是否为闰年
	boolean leapYear = now.isLeapYear();
	System.out.println("判断是否为闰年" + leapYear);
}

1
2
3
4
5
6

public static void main(String[] args) {
	//返回当前时间，根据系统时间和UTC
	Clock clock = Clock.systemUTC();
	System.out.println(clock);
	//运行结果：Systemclock[z]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

/**
* 时间戳
* 事实上Instant就是java8以前的Date,
* 可以使用以下两个类中的方法在这两个类型之间进行转换，
* 比如 Date.from(Instant) 就是用来把Instant转换成java.util.date的，
* 而 new Date().toInstant() 就是将Date转换成Instant的
*/
@Test
public void instant() {
	Instant instant = Instant.now();
	System.out.println(instant);
	
	Date date = Date.from(instant);
	
	Instant instant2 = date.toInstant();
	System.out.println(date);
	System.out.println (instant2);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

/**
* Instant时间戳
* 可以用来统计时间消耗
*/
@Test
public void test7() 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()));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

/**
* 计算时间、日期间隔
* Duration: 用于计算两个 "时间" 间隔
* Period: 用于计算两个 "日期" 间隔
*/
@Test
public void durationorPeriod() {
	LocalDateTime now = LocalDateTime.now();
	System.out.println("duration当前时间：" + now);
	LocalDateTime of = LocalDateTime.of(2020, 10, 15, 10, 24);
	System.out.println("duration自定义时间：" + of);
	//Duration: 用于计算两个"时间"间隔
	Duration duration = Duration.between(now, of);
	System.out.println(now + "与" + of + "间隔" + "\n"
						+ "天：" + duration.toDays() + "\n"
						+"时：" + duration.toHours() + "\n"
						+"分：" + duration.toMinutes() + "\n"
						+ "毫秒：" + duration.toMillis() + "\n"
						+ "纳秒：" + duration.toNanos() + "\n"
	);
	
	

	LocalDate nowDate = LocalDate.now();
	System.out.println("period当前时间：" + now);
	LocalDate ofDate = LocalDate.of(2020, 10, 15);
	System.out.println("period自定义时间：" + of);
	//Period:用于计两个"日期"间隔
	Period period = Period.between(nowDate, ofDate);
	Sy3tem.out.printIn("Period相差年数：" + period.getYears());
	System.out.println("Period相差月数：" + period.getMonths());
	System.out.println("Period相差日数：" + period.getDays());
	//还可以这样获取相差的年月日
	System.out.println("-----");
	long years = period.get(ChronoUnit.YEARS);
	long months = period.get(ChronoUnit.MONTHS);
	long days = period.get(ChronoUnit.DAYS);
	System.out.println("Period相差的年月日分别为：" + years + "," + months + "," + days);
	//注意，当获取两个日期的间隔时，并不是单纯的年月日对应的数字相加减，而是会先算出具体差多少天，在折算成相差几年几月几日的
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

/**
* 将时间对象转化为日期字符串
*
 时间日期的格式化(格式化后返回的类型是String) 自定格式 使用 DateTimeFormatter.ofPattern("yyyy-M-ddHH:mm:ss:SSS");
* 注：自定义转化的格式一定要与日期类型对应
* LocalDate只能设置仅含年月日的格式
* LocalTime只能设置仅含时分秒的格式
* LocalDateTime可以设置含年月日时分秒的格式
*/
@Test
public void formatterl() {
	LocalDateTime now = LocalDateTime.now();
	DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss:SSS");
	String format = now.format(dft);
	System.out.println(format);
	//输出：2020-10-16 14:41:01:086
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

/**
* 将时间字符串形式转化为日期对象
* <p>
* 注：格式的写法必须与字符串的形式一样
* 2018-01-13 21:27:30 对应 yyyy-MM-dd HH:m:ss
* 20180113213328 对应 yyyyMMddHHmmss
* 否则会报运行时异常！
* <p>
* 但要记住：得到的最终结果都是类以2018-01-13T21:27:30的格式
* 因为在输出LocalDateTime对象时，会调用其重写的toString方法。
*/
@Test
public void formatter2() {
	String datestr = "2020-11-12";
	DateTimeFormatter dtf = DateTimeFormatter.ofPattern ("yyyy-MM-dd");
	LocalDate formatterDate = LocalDate.parse(datestr, dtf);
	System.out.println(formatterDate);
	//输出2020-11-12
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

/**
* 将时间日期对象转为格式化后的时间日期对象
*/
@Test
public void formatter3() {
	//新的格式化API中，格式化后的结果都默认是String,有时我们也需要返回经过格式化的同类型对象
	LocalDateTime ldt1 = LocalDateTime.now();
	DateTimeFormatter dtfl = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
	String temp = ldt1.format(dftl);
	LocalDateTime formatedDateTime = LocalDateTime.parse(temp, dftl);
	System.out.println(formatedDateTime);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/**
* 日期格式化
*/
@Test
public void test6() {
	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);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

/**
* localDate 转 date
* localDateTime 转 date
*/
@Test
public void localDateToDate() {
	LocalDate now = LocalDate.now();
	Date from = Date.from(now.atStartOfDay(ZoneOffset.systemDefault()).toInstant());
	
	LocalDateTime localDateTime = LocalDateTime.now();
	Date date = Date.from(localDateTime.atZone(ZoneOffset.ofHours(8)).toInstant())；
	
	System.out.println(from);
	System.out.println(date);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

/**
* date 转 localDate
* date 转 localDateTime
*/
@Test
public void dateToLocalDate() {
	Date date = new Date();
	LocalDate localDate = date.toInstant().atZone(ZoneOffset.systemDefault()).toLocalDate();
	System.out.println(localDate);
	
	LocalDateTime localDateTime = date.toInstant().atZone(ZoneOffset.systemDefault()).toLocalDateTime();
	System.out.println(localDateTime);
}

1
2
3
4
5
6

public static void main(String[] args) {
	LocalDate date = LocalDate.of(2006, 07, 26);
	ZoneId zone = ZoneId.systemDefault();
	Instant instant = date.atStartOfDay().atZone(zone).toInstant();
	java.util.Date da = Date.from(instant);
}

1
2
3
4
5
6

public static void main(String[] args) {
	Instant instant = new Date().toInstant();
	ZoneId zone = ZoneId.systemDefault();
	LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
	LocalDate localDate = localDateTime.toLocalDate();
}

1

new Date().toInstant().atZone(ZoneId.systemDefault()).toLocalDate()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

/**
* LocalDate 转 时间戳
* LocalDateTime 转 时间戳
*/
@Test
public void localDateToInstant() {
	LocalDate localDate = LocalDate.now()；
	long instant = localDate.atStartOfDay(Zoneoffset.systemDefault()).toInstant().toEpochMilli();
	System.out.println(instant);
	
	LocalDateTime now = LocalDateTime.now();
	long instant1 = now.toInstant(ZoneOffset.ofHours(8)).toEpochMilli();
	System.out.println(instant1);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

/**
* 时间戳 转 LocalDate
* 时间戳 转 LocalDateTime
*/
@Test
public void instantToLocalDate() {
	long time = new Date().getTime();
	
	LocalDateTime localDateTime = Instant.ofEpochMilli(time).atZone(ZoneOffset.systemDefault()).toLocalDateTime();
	System.out.println(localDateTime);
	
	LocalDate localDate = Instant.ofEpochMilli(time).atZone(ZoneOffset.systemDefault())toLocalDate();
	System.out.println(localDate);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public static void main(String[] args) {
        String str;
        // %s
        str = String.format("Hi,%s", "布鲁斯");
        System.out.println(str);
        // %c   %n
        str = String.format("字母c的大写是：%c %n", 'C');
        System.out.println(str);
        // %b
        str = String.format("布尔结果是：%b", 3>2);
        System.out.println(str);
        // %d
        str = String.format("100的一半是：%d", 100/2);
        System.out.println(str);
        // %x
        str = String.format("100的16进制数是：%x", 100);
        System.out.println(str);
        // %o
        str = String.format("100的8进制数是：%o", 100);
        System.out.println(str);
        // %f
        str = String.format("50元的书打8.5折扣是：%f 元", 50 * 0.85);
        System.out.println(str);
        // %a
        str = String.format("上面价格的16进制数是：%a", 50 * 0.85);
        System.out.println(str);
        // %e
        str = String.format("上面价格的指数表示：%e", 50 * 0.85);
        System.out.println(str);
        // %g
        str = String.format("上面价格的指数和浮点数结果的长度较短的是：%g", 50 * 0.85);
        System.out.println(str);
        // %d%
        str = String.format("上面的折扣是：%d%%", 85);
        System.out.println(str);
        // %h
        str = String.format("字母A的散列码是：%h",'A');
        System.out.println(str);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public static void main(String[] args) {
    // +
    String str;
    str = String.format("数字的正负表示：%+d %d %+d %d",8,8,-8,-8);
    System.out.println(str);
    // -
    str = String.format("左对齐：%-6d",8);
    System.out.println(str);
    // 0
    str = String.format("缺位补零：%06d",8);
    System.out.println(str);
    // 空格
    str = String.format("缺位补空格：% 6d",8);
    System.out.println(str);
    str = String.format("缺位补空格：% 6d",-8);
    System.out.println(str);
    // ,
    str = String.format("数字分组：%,d",123456789);
    System.out.println(str);
    // (
    str = String.format("括号用法：%(d",-8888);
    System.out.println(str);
    str = String.format("括号用法：%(d",8888);
    System.out.println(str);
    // #
    str = String.format("#括号用法(十六进制)：%#x",12);
    System.out.println(str);
    str = String.format("#括号用法(八进制)：%#o",12);
    System.out.println(str);
    // <
    str = String.format("<括号用法：%f %<3.1f",3.14,3.2);
    // "%<3.1f"作用的对象是前一个"%f"所作用的对象，3.1f
    // f：代表接收的是浮点型参数；.1：保留一位小数；3：占三位字符 (包括小数点和小数部分)
    //3.1 就是三位字符
    System.out.println(str);
}