煮酒与君饮

这个屌丝很懒，什么也没留下！

热门标签

Java进阶笔记-日期与时间、包装类、正则表达式、Arrays类、常见算法、Lambda表达式枚举_java 正则匹配年月日时分秒

作者：煮酒与君饮 | 2024-07-02 13:58:05

踩

java 正则匹配年月日时分秒

视频地址：https://www.bilibili.com/video/BV1Cv411372m
此笔记是：P120 - P127

1.日期与时间（了解）

1.1 Date

Date 类概述
- Date类代表当前所在系统的日期时间信息。
Date的构造器
Date的常用方法

import java.time.Instant;
import java.time.ZoneId;
import java.util.Date;

/**
    目标：学会使用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 time1 = System.currentTimeMillis();
//        System.out.println(time1);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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

import java.time.Instant;
import java.time.ZoneId;
import java.util.Date;

public class DateDemo1 {
    public static void main(String[] args) {
        // 1、得到当前时间（为了与所算的对比 看是否一样正确）
        Date d1 = new Date();
        System.out.println(d1);

        // 2、当前时间往后走 1小时  121s
        long time2 = System.currentTimeMillis();
        time2 += (60 * 60 + 121) * 1000;  //一定要乘1000 因为是当毫秒看的

        // 3、把时间毫秒值转换成对应的 日期对象。
            //【方法一】 
            // Date d2 = new Date(time2);
            // System.out.println(d2);
        	//【方法二】 
            Date d3 = new Date();
            d3.setTime(time2);
            System.out.println(d3);

    }
}
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

在这里插入图片描述

1.2 SimpleDateFormat

SimpleDateFormat类作用
- 可以把对Date对象或时间毫秒值格式化成我们喜欢的时间形式。
- 也可以把字符串的时间形式解析成日期对象。
SimpleDateFormat 的构造器
SimpleDateFormat 的格式化方法

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

/**
    目标：SimpleDateFormat简单日期格式化类的使用
    格式化时间
    解析时间

 */
public class SimpleDateFormatDemo01 {
    public static void main(String[] args) {
        // 1、日期对象
        Date d = new Date();
        System.out.println(d);

        // 2、格式化这个日期对象 (指定最终格式化的形式) EEE:代表取星期几 a:代表取上午还是下午
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
        // 3、开始格式化日期对象成为喜欢的字符串形式
        String rs = sdf.format(d);
        System.out.println(rs); // 打印结果为：2023年02月09日 16:42:45 周四 下午

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

        // 4、格式化时间毫秒值
        // 需求：请问121秒后的时间是多少 【当前时间本身就是毫秒值，可以直接进行计算】
        long time1 = System.currentTimeMillis() + 121 * 1000; 
        String rs2 = sdf.format(time1);
        System.out.println(rs2);
        
    }
}
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

在这里插入图片描述

import javax.xml.crypto.Data;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatDemo2 {
    public static void main(String[] args) throws ParseException {
        // 目标: 学会使用SimpleDateFormat解析字符串时间成为日期对象。
        // 有一个时间 2021年08月06日 11:11:11 往后 2天 14小时 49分 06秒后的时间是多少。
        
        // 1、把字符串时间拿到程序中来
        String dateStr = "2021年08月06日 11:11:11";

        // 2、把字符串时间解析成日期对象（本节的重点）:形式必须与被解析时间的形式完全一样，否则运行时解析报错！
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); // 与上面字符串时间格式一样
        Date d = sdf.parse(dateStr); //拿到这个时间对应的日期对象

        // 3、往后走2天 14小时 49分 06秒
        long time = d.getTime() + (2L*24*60*60 + 14*60*60 + 49*60 + 6) * 1000;

        // 4、格式化这个时间毫秒值就是结果
        System.out.println(sdf.format(time)); // 打印结果为：2021年08月09日 02:00:17
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

在这里插入图片描述

1.3 案例

在这里插入图片描述

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

public class SimpleDateFormatTest3 {
    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";

        // 3、解析他们的时间
        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("小皮秒杀失败！");
        }
    }
}
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

1.4 Calendar

Calendar概述
- Calendar代表了系统此刻日期对应的日历对象。
- Calendar是一个抽象类，不能直接创建对象。
Calendar日历类创建日历对象的方法：
Calendar常用方法

import javax.xml.crypto.Data;
import java.util.Calendar;
import java.util.Date;

/**
    目标：日历类Calendar的使用,可以得到更加丰富的信息。

    Calendar代表了系统此刻日期对应的日历对象。
    Calendar是一个抽象类，不能直接创建对象。
    Calendar日历类创建日历对象的语法：
        Calendar rightNow = Calendar.getInstance();
    Calendar的方法：
        1.public static Calendar getInstance(): 返回一个日历类的对象。
        2.public int get(int field)：取日期中的某个字段信息。
        3.public void set(int field,int value)：修改日历的某个字段信息。
        4.public void add(int field,int amount)：为某个字段增加/减少指定的值
        5.public final Date getTime(): 拿到此刻日期对象。
        6.public long getTimeInMillis(): 拿到此刻时间毫秒值
    小结：
        记住。
 */
public class CalendarDemo{
    public static void main(String[] args) {
        // 1、拿到系统此刻日历对象
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);

        // 2、获取日历的信息:public int get(int field)：取日期中的某个字段信息。
        int year = cal.get(Calendar.YEAR);
        System.out.println(year); // 取当前年

        int mm = cal.get(Calendar.MONTH) + 1;
        System.out.println(mm);  // 取当前月

        int days = cal.get(Calendar.DAY_OF_YEAR) ;
        System.out.println(days);  // 取当前日

        // 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)：为某个字段增加/减少指定的值
        // 请问64天后是什么时间
        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 getTimeInMillis(): 拿到此刻时间毫秒值
        long time = cal.getTimeInMillis();
        System.out.println(time);

    }
}
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
46
47
48
49
50
51
52
53
54
55
56

在这里插入图片描述

2.JDK8新增日期类（了解）

2.1 概述、LocalTime / LocalDate / LocalDateTime

概述
- 从Java 8开始，java.time包提供了新的日期和时间API，主要涉及的类型有：
- 新增的API严格区分了时刻、本地日期、本地时间，并且，对日期和时间进行运算更加方便。
- 其次，新API的类型几乎全部是不变类型（和String的使用类似），可以放心使用不必担心被修改。
LocalDate、LocalTime、LocalDateTime
- 他们分别表示日期，时间，日期时间对象，他们的类的实例是不可变的对象。
- 他们三者构建对象和API都是通用的。
构建对象的方式如下
LocalDate、LocalTime、LocalDateTime获取信息的API.
LocalDate

import java.time.LocalDate;
import java.time.Month;

public class Demo01LocalDate {
    public static void main(String[] args) {
        // 1、获取本地日期对象。
        LocalDate nowDate = LocalDate.now();
        System.out.println("今天的日期：" + nowDate);// 打印结果为：今天的日期：2023-02-09

        int year = nowDate.getYear();
        System.out.println("year：" + year); // 打印结果为：year：2023


        int month = nowDate.getMonthValue();
        System.out.println("month：" + month); // 打印结果为：month：2

        int day = nowDate.getDayOfMonth();
        System.out.println("day：" + day); // 打印结果为：day：9

        //当年的第几天
        int dayOfYear = nowDate.getDayOfYear();
        System.out.println("dayOfYear：" + dayOfYear); // 打印结果为：dayOfYear：40

        //星期
        System.out.println(nowDate.getDayOfWeek()); // 打印结果为：THURSDAY
        System.out.println(nowDate.getDayOfWeek().getValue()); // 打印结果为：4

        //月份
        System.out.println(nowDate.getMonth());// 打印结果为：FEBRUARY
        System.out.println(nowDate.getMonth().getValue()); // 打印结果为：2

        System.out.println("------------------------");
        LocalDate bt = LocalDate.of(1991, 11, 11); // 指定为哪天
        System.out.println(bt);//直接传入对应的年月日  打印结果为：1991-11-11
        System.out.println(LocalDate.of(1991, Month.NOVEMBER, 11));//相对上面只是把月换成了枚举【Month.NOVEMBER】 打印结果为：1991-11-11
    }
}
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

LocalTime

import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;

public class Demo02LocalTime {
    public static void main(String[] args) {
        // 1、获取本地时间对象。
        LocalTime nowTime = LocalTime.now();
        System.out.println("今天的时间：" + nowTime);// 今天的时间：20:10:30.1326738456

        int hour = nowTime.getHour();//时
        System.out.println("hour：" + hour);//hour：20

        int minute = nowTime.getMinute();//分
        System.out.println("minute：" + minute);//minute：10

        int second = nowTime.getSecond();//秒
        System.out.println("second：" + second);//second：30

        int nano = nowTime.getNano();//纳秒
        System.out.println("nano：" + nano);//nano：1326738456

        System.out.println("-----");
        // 指定时刻 时分秒
        System.out.println(LocalTime.of(8, 20));//时分 打印结果为：08:20
        System.out.println(LocalTime.of(8, 20, 30));//时分秒 打印结果为：08:20:30
        System.out.println(LocalTime.of(8, 20, 30, 150));//时分秒纳秒 打印结果为：08:20:30.000000150
        LocalTime mTime = LocalTime.of(8, 20, 30, 150);

        System.out.println("---------------");
        // 指定年月日时分秒
        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));
    }
}
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

LocalDateTime

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

public class Demo03LocalDateTime {
    public static void main(String[] args) {
        // 日期 时间
        LocalDateTime nowDateTime = LocalDateTime.now();
        System.out.println("今天是：" + nowDateTime);//今天是：2023-02-09T20:10:30.1326738456
        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

        // LocalDateTime可以转成LocalDate 或 LocalTime

        LocalDate ld = nowDateTime.toLocalDate(); // 转成日期对象
        System.out.println(ld);  // 打印结果为：2023-02-09

        LocalTime lt = nowDateTime.toLocalTime(); // 转成时间对象
        System.out.println(lt.getHour()); 	// 打印结果为：20
        System.out.println(lt.getMinute());	// 打印结果为：10
        System.out.println(lt.getSecond());	// 打印结果为：30
    }
}
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

在这里插入图片描述

修改相关的API
- LocalDateTime 综合了 LocalDate 和 LocalTime 里面的方法，所以下面只用 LocalDate 和 LocalTime 来举例。
- 这些方法返回的是一个新的实例引用，因为LocalDateTime 、LocalDate 、LocalTime 都是不可变的。

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.MonthDay;

public class Demo04UpdateTime {
    public static void main(String[] args) {
        LocalTime nowTime = LocalTime.now();
        System.out.println(nowTime);//当前时间
        System.out.println(nowTime.minusHours(1));//一小时前 相当于减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));//一小时后 相当于加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吗？ " + nowDate.equals(myDate));//今天是2018-09-06吗？ false
        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

        System.out.println("---------------------------");
        // 判断今天是否是你的生日
        LocalDate birDate = LocalDate.of(1996, 8, 5);
        LocalDate nowDate1 = LocalDate.now();

        MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth()); // 将拿出的月日封装到里面
        MonthDay nowMd = MonthDay.from(nowDate1); // 直接从里面拿月日对象

        System.out.println("今天是你的生日吗？ " + birMd.equals(nowMd));//今天是你的生日吗？ false
    }
}
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

2.2 Instant

Instant时间戳
- JDK8获取时间戳特别简单，且功能更丰富。Instant类由一个静态的工厂方法now()可以返回当前时间戳。
```
Instant instant = Instant.now();
System.out.println("当前时间戳是：" + instant);

Date date = Date.from(instant);
System.out.println("当前时间戳是：" + date);

instant = date.toInstant();
System.out.println(instant);

1
2
3
4
5
6
7
8
9
```
- 时间戳是包含日期和时间的，与java.util.Date很类似，事实上Instant就是类似JDK8 以前的Date。
- Instant和Date这两个类可以进行转换。

import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import java.util.Date;

public class Demo05Instant {
    public static void main(String[] args) {
        // 1、得到一个Instant时间戳对象
        Instant instant = Instant.now();
        System.out.println(instant); // 打印结果为：2023-02-09T12:10:30.1326738456 会发现与现在时间差8小时 因为打印的是世界标准时间 我们与标准时间差8小时

        // 2、系统此刻的时间戳怎么办？
        Instant instant1 = Instant.now(); 
        System.out.println(instant1.atZone(ZoneId.systemDefault())); // atZone指时区，表示时间戳调到那个时区   ZoneId.systemDefault()指默认时区【即中国】
        // 打印结果为：2023-02-09T20:10:30.1326738456+08:00[Asia/Shanghai]

        // 3、如何去返回Date对象
        Date date = Date.from(instant);
        System.out.println(date);

        Instant i2 = date.toInstant();
        System.out.println(i2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2.3 DateTimeFormatter

DateTimeFormatter[日期时间格式化]
在JDK8中，引入了一个全新的日期与时间格式器DateTimeFormatter。

正反都能调用format方法。

LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);//2021-03-01T15:09:17.444190900

DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String ldtStr = ldt.format(dtf);
System.out.println(ldtStr);//2021-03-01 15:09:17

String ldtStr1 = dtf.format(ldt);
System.out.println(ldtStr1);//2021-03-01 15:09:17
1
2
3
4
5
6
7
8
9

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class Demo06DateTimeFormat {
    public static void main(String[] args) {
        // 本地此刻  日期时间 对象
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt); // 打印结果为：2023-02-09T20:10:30.1326738456

        // 解析/格式化器
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss EEE a");
        // 正向格式化
        System.out.println(dtf.format(ldt)); // 打印结果为：2023-02-09 20:10:30 周四 下午
        // 逆向格式化
        System.out.println(ldt.format(dtf)); // 打印结果为：2023-02-09 20:10:30 周四 下午

        // 解析字符串时间
        DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 解析当前字符串时间成为本地日期时间对象
        LocalDateTime ldt1 = LocalDateTime.parse("2019-11-11 11:11:11" ,  dtf1);
        System.out.println(ldt1); // 打印结果为：2019-11-11T11:11:11
        System.out.println(ldt1.getDayOfYear()); //取一年中的第几天 打印结果为：315
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2.4 Duration / Period

Period

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

 // 当前本地 年月日
LocalDate today = LocalDate.now();
System.out.println(today);     // 2021-08-08
// 生日的 年月日
LocalDate birthDate = LocalDate.of(1995, 10, 13);
System.out.println(birthDate); // 1995-10-13

Period period = Period.between(birthDate, today); //第二个参数减第一个参数
System.out.printf("活了 : %d 年 %d 月 %d 日", period.getYears(), period.getMonths(),period.getDays()); // 打印结果为：活了：22年9月23天

1
2
3
4
5
6
7
8
9
10

Duration

在Java8中，我们可以使用以下类来计算时间间隔差异：java.time.Duration
提供了使用基于时间的值测量时间量的方法。
用于 LocalDateTime 之间的比较。也可用于 Instant 之间的比较。

// 当前 年月日时分秒
LocalDateTime today = LocalDateTime.now();
System.out.println(today); //2021-08-05T15:19:48.669714200
// 出生 年月日时分秒
LocalDateTime birthDate = LocalDateTime.of(1990,10,1,10,50,30);
System.out.println(birthDate); //1990-10-1T01:50:30

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());//两个时间差的纳秒数
1
2
3
4
5
6
7
8
9
10
11
12
13

在这里插入图片描述

2.5 ChronoUnit

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));

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

3.包装类（掌握）

包装类
- 其实就是8种基本数据类型对应的引用类型。
- 为什么提供包装类？
  - Java为了实现一切皆对象，为8种基本类型提供了对应的引用类型。【引用类型当对象看】
  - 后面的集合和泛型其实也只能支持包装类型，不支持基本数据类型。
- 自动装箱：基本类型的数据和变量可以直接赋值给包装类型的变量。
- 自动拆箱：包装类型的变量可以直接赋值给基本数据类型的变量。
- 包装类的特有功能
  - 包装类的变量的默认值可以是null，容错率更高。
  - 可以把基本类型的数据转换成字符串类型(用处不大)
    - 调用**toString()**方法得到字符串结果。
    - 调用Integer.toString(基本类型的数据)。
  - 可以把字符串类型的数值转换成真实的数据类型（真的很有用）
    - Integer.parseInt(“字符串类型的整数”)
    - Double.parseDouble(“字符串类型的小数”)。

/**
    目标：明白包装类的概念，并使用。
 */
public class Test {
    public static void main(String[] args) {
        int a = 10;
        Integer a1 = 11;
        Integer a2 = a; // 自动装箱 基本类型->包装类型
        System.out.println(a); // 打印结果为: 10
        System.out.println(a1); // 打印结果为: 11

        Integer it = 100;
        int it1 = it; // 自动拆箱 包装类型->基本类型
        System.out.println(it1);  // 打印结果为: 100

        double db = 99.5;
        Double db2 = db; // 自动装箱
        double db3 = db2; // 自动拆箱
        System.out.println(db3);  // 打印结果为: 99.5

        // int age = null; // 报错了！
        Integer age1 = null;
        Integer age2 = 0;

        System.out.println("-----------------");
        // 1、包装类可以把基本类型的数据转换成字符串形式。（没啥用）
        	// 【方法一】
            Integer i3 = 23;
            String rs = i3.toString();
            System.out.println(rs + 1); // 打印结果为: 231 说明rs已经转成字符串
		   // 【方法二】
            String rs1 = Integer.toString(i3);
            System.out.println(rs1 + 1); // 打印结果为: 231 

            // 可以直接+字符串得到字符串类型【常用】
            String rs2 = i3 + "";
            System.out.println(rs2 + 1); // 打印结果为: 231 

        System.out.println("-----------------");
        /**
        	字符串转成数据类型
        */
        String number = "23";
        //转换成整数
        //int age = Integer.parseInt(number);
       	//System.out.println(age + 1); // 打印结果为: 24 
        int age1 = Integer.valueOf(number);
        System.out.println(age1 + 1);// 打印结果为: 24 

        String number1 = "99.9";
        //转换成小数
        //double score = Double.parseDouble(number1);
        //System.out.println(score + 0.1); // 打印结果为: 100.0
        double score1 = Double.valueOf(number1); 
        System.out.println(score1 + 0.1); // 打印结果为: 100.0
    }
}
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
46
47
48
49
50
51
52
53
54
55
56
57

在这里插入图片描述

4.正则表达式(重要)

4.1 正则表达式概述、初体验

正则表示
- 正则表达式可以用一些规定的字符来制定规则，并用来校验数据格式的合法性。
正则表达式初体验
- 需求：假如现在要求校验一个qq号码是否正确，6位及20位之内，必须全部是数字。
- 先使用目前所学知识完成校验需求；然后体验一下正则表达式检验。

public class RegexDemo1 {
    public static void main(String[] args) {
        // 需求：校验qq号码，必须全部数字 6 - 20位
        System.out.println(checkQQ("251425998"));
        System.out.println(checkQQ("2514259a98"));
        System.out.println(checkQQ(null));
        System.out.println(checkQQ("2344"));

        System.out.println("-------------------------");
        // 正则表达式的初体验：
        System.out.println(checkQQ2("251425998"));
        System.out.println(checkQQ2("2514259a98"));
        System.out.println(checkQQ2(null));
        System.out.println(checkQQ2("2344"));

    }

    public static boolean checkQQ2(String qq){
        return qq != null && qq.matches("\\d{6,20}"); // \d表示全是数字 但前面还要加一个 \ 表示转义，即 第一个 \ 告诉第二个 \ 你就是一个 \ 不要和n待在一起变成 \n  {6,20}表示数字最多出现20位，最少出现6位	
    }


    public static boolean checkQQ(String qq){
        // 1、判断qq号码的长度是否满足要求
        if(qq == null || qq.length() < 6 || qq.length() > 20 ) {
            return false;
        }

        // 2、判断qq中是否全部是数字，不是返回false
        //  251425a87
        for (int i = 0; i < qq.length(); i++) {
            // 获取每位字符
            char ch = qq.charAt(i);
            // 判断这个字符是否不是数字，不是数字直接返回false
            if(ch < '0' || ch > '9') { // 即字符超过 0 - 9 的区间
                return false;
            }
        }

        return true; // 肯定合法了！
    }
}
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

4.2 正则表达式的匹配规则

匹配规则

4.3 正则表达式的常见案例

在这里插入图片描述

import java.util.Arrays;
import java.util.Scanner;

public class RegexTest3 {
    public static void main(String[] args) {
        // 目标：校验 手机号码 邮箱  电话号码
         checkPhone();
         checkEmail();
         checkTel();
    }
    /*
    	校验 手机号码
    */
    public static void checkPhone(){
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入您的注册手机号码：");
            String phone = sc.next();
            // 判断手机号码的格式是否正确
            if(phone.matches("1[3-9]\\d{9}")){ 
                // 1[3-9]\\d{9} 意思是: 1 第1位为1   [3-9] 第2位为3-9数字都可   \\d{9} 剩下9位任意数字
                System.out.println("手机号码格式正确，注册完成！");
                break;
            }else {
                System.out.println("格式有误！");
            }
        }
    }

    /*
    	校验 电话号码
    */
    public static void checkTel(){
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入您的电话号码：");
            String tel = sc.next();
            // 判断邮箱格式是否正确   027-3572457  0273572457
            if(tel.matches("0\\d{2,6}-?\\d{5,20}")){
                System.out.println("格式正确，注册完成！");
                break;
            }else {
                System.out.println("格式有误！");
            }
        }
    }

    /*
    	校验 邮箱
    */
    public static void checkEmail(){
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入您的注册邮箱：");
            String email = sc.next();
            // 判断邮箱格式是否正确   3268847878@qq.com
            // 判断邮箱格式是否正确   3268847dsda878@163.com
            // 判断邮箱格式是否正确   3268847dsda878@pci.com.cn
            if(email.matches("\\w{1,30}@[a-zA-Z0-9]{2,20}(\\.[a-zA-Z0-9]{2,20}){1,2}")){
                System.out.println("邮箱格式正确，注册完成！");
                break;
            }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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

4.4 正则表达式在方法中的应用

正则表达式在字符串方法中的使用

/**
    目标：正则表达式在方法中的应用。
        public String[] split(String regex)：
            -- 按照正则表达式匹配的内容进行分割字符串，反回一个字符串数组。
        public String replaceAll(String regex,String newStr)
            -- 按照正则表达式匹配的内容进行替换
 */
public class RegexDemo04 {
    public static void main(String[] args) {
        
        String names = "小路dhdfhdf342蓉儿43fdffdfbjdfaf小何";

        // 正则表达式分割split字符串，返回字符串数组
        String[] arrs = names.split("\\w+");  // \\w+ 匹配中间英文字母和数字
        for (int i = 0; i < arrs.length; i++) {
            System.out.print(arrs[i]); 
        }// 打印结果为: 小路蓉儿小何
        	
        
        // 正则表达式内容替换
        String names2 = names.replaceAll("\\w+", "  "); 
        System.out.println(names2); // 打印结果为: 小路  蓉儿  小何
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

4.5 正则表达式爬取信息

正则表达式支持爬取信息

String rs = "来黑马程序学习Java,电话020-43422424，或者联系邮箱" +
    "itcast@itcast.cn,电话18762832633，0203232323" +
    "邮箱bozai@itcast.cn，400-100-3233 ，4001003232";
// 需求：从上面的内容中爬取出 电话号码和邮箱。
// 1.定义爬取规则
String regex = "(\\w{1,}@\\w{2,10}(\\.\\w{2,10}){1,2})|" +
    "(1[3-9]\\d{9})|(0\\d{2,5}-?\\d{5,15})|400-?\\d{3,8}-?\\d{3,8}";
// 2.编译正则表达式成为一个匹配规则对象
Pattern pattern = Pattern.compile(regex);
// 3.通过匹配规则对象得到一个匹配数据内容的匹配器对象
Matcher matcher = pattern.matcher(rs);
// 4.通过匹配器去内容中爬取出信息
while(matcher.find()){
    System.out.println(matcher.group()); // 每找到就取一组
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在这里插入图片描述

5.Arrays类

5.1 Arrays类概述，常用功能演示

Arrays类概述
- 数组操作工具类，专门用于操作数组元素的。
Arrays类的常用API

import java.util.Arrays;
/**
    目标：学会使用Arrays类的常用API ,并理解其原理
 */
public class ArraysDemo1 {
    public static void main(String[] args) {

        int[] arr = {10, 2, 55, 23, 24, 100};
        System.out.println(arr); // 打印结果为：[I@4c873330

        // 1、返回数组内容的 toString(数组)
//        String rs = Arrays.toString(arr);
//        System.out.println(rs); 
        System.out.println(Arrays.toString(arr)); // 打印结果为：[10, 2, 55, 23, 24, 100]

        // 2、排序的API(默认自动对数组元素进行升序排序)
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr)); // 打印结果为：[2, 10, 23, 24, 55,100]

        // 3、二分搜索技术（前提数组必须排好序才支持，否则出bug）
        int index = Arrays.binarySearch(arr, 55); // 找55的位置
        System.out.println(index); // 打印结果为：4

        // 返回不存在元素的规律： - （应该插入的位置索引 + 1）
        int index2 = Arrays.binarySearch(arr, 22);
        System.out.println(index2);


        // 注意：数组如果没有排好序，可能会找不到存在的元素，从而出现bug!!
        int[] arr2 = {12, 36, 34, 25 , 13,  24,  234, 100};
        System.out.println(Arrays.binarySearch(arr2 , 36));
    }

}
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

5.2 Arrays对于Comparator比较器的支持(重要)

Arrays类的排序方法
自定义排序规则
- 设置Comparator接口对应的比较器对象，来定制比较规则。

import java.util.Arrays;
import java.util.Comparator;
/**
    目标：自定义数组的排序规则：Comparator比较器对象。
 */
public class ArraysDemo2 {
    public static void main(String[] args) {

        // 1、Arrays的sort方法对于有值特性的数组是默认升序排序
        int[] ages = {34, 12, 42, 23};
        Arrays.sort(ages);
        System.out.println(Arrays.toString(ages));

        // 2、需求：降序排序！(自定义比较器对象，只能支持引用类型的排序！！)
        Integer[] ages1 = {34, 12, 42, 23};
        /**
           参数一：被排序的数组 必须是引用类型的元素
           参数二：匿名内部类对象，代表了一个比较器对象。
         */
        Arrays.sort(ages1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // 指定比较规则。
                // 升序
//                if(o1 > o2){
//                    return 1;
//                }else if(o1 < o2){
//                    return -1;
//                }
//                return 0;
                
                // return o1 - o2; // 默认升序
                return o2 - o1; //  降序
            }
        });
        System.out.println(Arrays.toString(ages1));

        System.out.println("----------自定义比较器的应用！---------------");
        // 假设已经定义好Student.java实体类
        // 用数组放对象 Student类型数组  
        Student[] students = new Student[3];
        students[0] = new Student("吴磊",23 , 175.5);
        students[1] = new Student("谢鑫",18 , 185.5);
        students[2] = new Student("王亮",20 , 195.5);
        System.out.println(Arrays.toString(students));

        // Arrays.sort(students);  // 直接运行奔溃,因为里面有姓名、有身高等不知道按照什么排列
        // 那么这时就需要我们自定义比较器！
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 自己指定比较规则
                // return o1.getAge() - o2.getAge(); // 按照年龄升序排序！
                // return o2.getAge() - o1.getAge(); // 按照年龄降序排序！！
                // return Double.compare(o1.getHeight(), o2.getHeight()); // 比较浮点型可以这样写 升序
                return Double.compare(o2.getHeight(), o1.getHeight()); // 比较浮点型可以这样写  降序
            }
        });
        System.out.println(Arrays.toString(students));
    }
}
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

在这里插入图片描述

7.Lambda表达式枚举

7.1 Lambda概述

Lambda概述
- Lambda表达式是JDK 8开始后的一种新语法形式。
- 作用：简化匿名内部类的代码写法。

Lambda表达式的简化格式

(匿名内部类被重写方法的形参列表) -> {
    被重写方法的方法体代码。
}
注：-> 是语法形式，无实际含义
1
2
3
4

/*
   目标：学会使用Lambda的标准格式简化匿名内部类的代码形式
*/
public class LambdaDemo1 {
    public static void main(String[] args) {
        Animal a = new Animal() {
            @Override
            public void run() {
                System.out.println("乌龟跑的很慢~~~~~");
            }
        };
        a.run();

        // 注意：lambda并不是可以简化所有匿名匿名内部类形式！！ 这种就不行，报错！！
//        Animal a1 = () -> {
//            System.out.println("乌龟跑的很慢~~~~~");
//        };
//        a1.run();
        
        // Lambda表达式只能简化函数式接口的匿名内部类的写法形式！！
    }
}

abstract class Animal{
    public abstract void run();
}
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

注意：Lambda表达式只能简化函数式接口的匿名内部类的写法形式
什么是函数式接口？
- 首先必须是接口、其次接口中有且仅有一个抽象方法的形式。
- 通常我们会在接口上加上一个**@FunctionalInterface注解**，标记该接口必须是满足函数式接口。
体验Lambda表达式

7.2 Lambda实战-简化常见函数式接口

Lambda表达式简化Comparator接口的匿名形式
- 注意：通常我们见到的函数式接口上都有一个@FunctionalInterface注解，标记该接口必须是满足函数式接口。
Lambda表达式简化按钮监听器ActionListener的匿名内部类形式

7.3 Lambda表达式的省略规则

Lambda表达式的省略写法（进一步在Lambda表达式的基础上继续简化）
- 参数类型可以省略不写。
- 如果只有一个参数，参数类型可以省略，同时()也可以省略。
- 如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写,同时要省略分号！
- 如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时，如果这行代码是return语句，必须省略return不写，同时也必须省略";"不写

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/煮酒与君饮/article/detail/779830