当前位置：首页 > article >正文

Java进阶，时间与日期，包装类，正则表达式

article 2025/2/19 13:10:10

Java时间与日期，包装类，正则表达式

一.时间与日期

1.Date

Date类概述

Date类代表当前所在系统的日期时间信息。

Date的构造器

名称

说明

public Date()

创建一个Date对象，代表的是系统当前此刻日期时间。

Date的常用方法

名称

说明

public long getTime()

返回从1970年1月1日 00:00:00走到此刻的总的毫秒数

案例

/**
 学会使用Date类处理时间，获取时间的信息
 */
public class DataDemo1 {
    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);
        System.out.println("-------------------");
        //1.得到当前时间毫秒值
        Date d1 =new Date();
        System.out.println(d1);

        //2.当前时间往后走1小时121s
        long time2 = d1.getTime();
        time2 += (60*60 + 121)*1000;

        //3.把时间毫秒值转换成对应的日期对象
//        Date d2 = new Date(time2);
//        System.out.println(d2);

        Date d3 = new Date();
        d3.setTime(time2);
        System.out.println(d3);
    }
}

时间毫秒值 -> 日期对象

构造器

说明

public Date(long time)

把时间毫秒值转换成Date日期对象。

Date方法

说明

public void setTime(long time)

设置日期对象的时间为当前时间毫秒值对应的时间

2.SimpleDateFormat

代表简单日期格式化，可以用来把日期时间格式化成为我们想要的形式

构造器

构造器

说明

public SimpleDateFormat(String pattern)

创建简单日期格式化对象，并封装格式化的形式信息

格式化方法

格式化方法

说明

public final String format(Date date)

将日期格式化成日期/时间字符串

public final String format(Object time)

将时间毫秒值式化成日期/时间字符串

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

解析方法

说明

public Date parse(String source)

从给定字符串的开始解析文本以生成日期

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

        //2.格式化这个日期对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
        //3.开始格式化日期对象成为喜欢的字符串形式
        String rs = sdf.format(d);
        System.out.println(rs);
        System.out.println("--------------------");
        //4.格式化时间毫秒值
        //121秒后的时间毫秒值是多少
        long time = d.getTime()+121*1000;
        String rs1 = sdf.format(time);
        System.out.println(rs1);
    }
}


public class SimpleDateFormatDemo2 {
    public static void main(String[] args) throws ParseException {
        //目标：学会使用SimpleDateFormat解析字符串时间成为日期对象
        //有一个时间2021年08月06日 11：11：11 往后2天14小时49分04秒的时间是多少
        //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));
    }
}

练习：

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

        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("小皮秒杀失败！");
        }
    }
}

3.Calendar

Calendar代表了系统此刻日期对应的日历对象。
Calendar是一个抽象类，不能直接创建对象。

Calendar日历类创建日历对象的方法：

方法名

说明

public static Calendar getInstance()

获取当前日历对象

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 getTimeInMillis()

拿到此刻时间毫秒值

**注意：**calendar是可变日期对象，一旦修改后其对象本身表示的时间将产生变化

public class CalenderDemo1 {
    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);

        //3.public void add(int foeld,int amount); 为某个字段增加/减少指定的值
        cal.add(Calendar.DAY_OF_YEAR,64);
        cal.add(Calendar.MINUTE,59);
        System.out.println(cal);

        //4.public final Date getTime(); 拿到此时日期对象
        Date d = cal.getTime();
        System.out.println(d);
    }
}

二.包装类

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

基本数据类型

引用数据类型

byte

Byte

short

Short

int

Integer

long

Long

char

Character

float

Float

double

Double

boolean

Boolean

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

自动装箱：基本类型的数据和变量可以直接赋值给包装类型的变量。

**自动拆箱：**包装类型的变量可以直接赋值给基本数据类型的变量。

包装类的特有功能

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

可以把基本类型的数据转换成字符串类型(用处不大)

①调用toString()方法得到字符串结果。

②调用Integer.toString(基本类型的数据)。

可以把字符串类型的数值转换成真实的数据类型（有用）

①Integer.parseInt(“字符串类型的整数”)

②Double.parseDouble(“字符串类型的小数”)。

三.正则表达式

1.正则表达式概述

正则表达式可以用一些规定的字符来制定规则，并用来校验数据格式的合法性。

字符串对象提供了匹配正则表达式的方法

public boolean matches([String](file:///D:/course/%E5%9F%BA%E7%A1%80%E9%98%B6%E6%AE%B5/API%E6%96%87%E6%A1%A3/docs/api/java.base/java/lang/String.html) regex): 判断是否匹配正则表达式，匹配返回true，不匹配返回false

2.案例

public class RegexDemo {
    public static void main(String[] args) {
        //校验 手机号码 邮箱 电话号码
        //checkPhone();
        //checkEmail();
        checkTell();
    }

    public static void checkTell(){
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入您的电话号码：");
            String phone = sc.next();
            //判断电话号码的格式是否正确
            if (phone.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 phone = sc.next();
            //判断邮箱的格式是否正确
            if (phone.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("格式错误，请重新输入~~~");
            }
        }
    }

    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}")){
                System.out.println("手机号码格式正确，注册完成！");
                break;
            }else {
                System.out.println("格式错误，请重新输入~~~");
            }
        }
    }
}

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

方法名

说明

public String replaceAll(String regex,String newStr)

按照正则表达式匹配的内容进行替换

public String[] split(String regex)：

按照正则表达式匹配的内容进行分割字符串，反回一个字符串数组。

/**
 正则表达式在方法中的应用。
    public String[] split(String regex)
       --按照正则表达式匹配的内容进行分割字符串，返回一个字符串数组
    public String replaceAll(String regex,String newStr)
       --按照正则表达式匹配的内容进行替换
 */
public class RegexDemo1 {
    public static void main(String[] args) {
        String names = "刘备adjoajd张飞ajdiajd关羽aafjaijnoa";
        String[] arrs = names.split("\w+");
        for (int i = 0; i < arrs.length; i++) {
            System.out.println(arrs[i]);
        }

        String names2 = names.replaceAll("\w+","  ");
        System.out.println(names2);
    }
}

4.正则表达式爬取信息

四.Array类

1.Arrays类概述，常用功能演示

数组操作工具类，专门用于操作数组元素的。

Arrays类的常用API

方法名

说明

public static String toString(类型[] a)

返回数组的内容（字符串形式）

public static void sort(类型[] a)

对数组进行默认升序排序

public static void sort(类型[] a, Comparator< super T> c)

使用比较器对象自定义排序

public static int binarySearch(int[] a, int key)

二分搜索数组中的数据，存在返回索引，不存在返回-1

2.Arrays类对于Comparator比较器的支持

Arrays类的排序方法

方法名

说明

public static void sort(类型[] a)

对数组进行默认升序排序

public static void sort(类型[] a, Comparator< super T> c)

使用比较器对象自定义排序

自定义排序规则

设置Comparator接口对应的比较器对象，来定制比较规则。

如果认为左边数据大于右边数据返回正整数

如果认为左边数据小于右边数据返回负整数

如果认为左边数据等于右边数据返回0

五.常见算法

1.冒泡排序

冒泡排序的思想

每次从数组中找出最大值放在数组的后面去。

实现冒泡排序的关键步骤分析

确定总共需要做几轮：数组的长度-1.
每轮比较几次:
当前位置大于后一个位置则交换数据

2.选择排序

选择排序的思想

每轮选择当前位置，开始找出后面的较小值与该位置交换

选择排序的关键

确定总共需要选择几轮：数组的长度-1.
控制每轮从以前位置为基准，与后面元素选择几次。

  /**
   使用选择排序的方法对数组进行排序
   */
  public class Test1 {
      public static void main(String[] args) {
          //1.定义数组
          int[] arr = {5, 3, 6, 8};
          //           0  1  2  3
  
          //2.定义一个循环控制选择几轮： arr.length - 1
          for (int i = 0; i < arr.length - 1; i++) {
              //3.定义内部循环：控制选择几次
              for (int j = i + 1; j < arr.length; j++) {
                  //当前位置： arr[i]
                  //如果有比当前位置数据更小，则交换
                  if (arr[i] > arr[j]){
                      int temp = arr[i];
                      arr[i] = arr[j];
                      arr[j] = temp;
                  }
              }
          }
          System.out.println(Arrays.toString(arr));
      }
  }

3.二分查找

二分查询性能好，二分查找的前提是必须是排好序的数据。
二分查找相当于每次去掉一半的查找范围

结论：二分查找正常的检索条件应该是开始位置****min <= 结束位置****max

数组的二分查找的实现步骤是什么样的

定义变量记录左边和右边位置。

使用while循环控制查询（条件是左边位置<=右边位置）

循环内部获取中间元素索引

判断当前要找的元素如果大于中间元素，左边位置=中间索+1

判断当前要找的元素如果小于中间元素，右边位置=中间索- 1

判断当前要找的元素如果等于中间元素，返回当前中间元素索引。

六.Lambda表达式

1.Lambda概述

Lambda表达式是JDK 8开始后的一种新语法形式。

作用：简化匿名内部类的代码写法。

Lambda表达式的简化格式

(匿名内部类被重写方法的形参列表) -> {
被重写方法的方法体代码。
}

注：-> 是语法形式，无实际含义

注意：Lambda表达式只能简化函数式接口的匿名内部类的写法形式

函数式接口：首先必须是接口、其次接口中有且仅有一个抽象方法的形式

2.Lambda表达式的省略规则

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

public class LambdaDemo1 {
public static void main(String[] args) {
//使用Lambda的标准格式简化匿名内部类的代码形式
//Lambda只能简化接口中只有一个抽象方法的匿名内部类形式
// Swimming s1 = new Swimming() {
// @Override
// public void swim() {
// System.out.println(“老师游泳贼快~~~”);
// }
// };
// go(s1);

// Swimming s1 = () ->System.out.println(“老师游泳贼快~~~”);go(s1);
```
    go(() ->System.out.println("老师游泳贼快~~~"));
    //最终简化形式
}

public static void go(Swimming s) {
    System.out.println("开始~~~");
    s.swim();
    System.out.println("结束！！！");
}
```
}

@FunctionalInterface
interface Swimming{
void swim();
}

public class LambdaDemo2 {
public static void main(String[] args) {
Integer[] ages = {34, 12, 42, 23};
/**
参数一：被排序的数组，必须是引用类型的元素
参数二：匿名内部类对象，代表了一个比较器对象
*/
// Arrays.sort(ages, new Comparator() {
// @Override
// public int compare(Integer o1, Integer o2) {
// return o1 - o2;//升序
// }
// });

// Arrays.sort(ages, ( o1, o2) -> {
// return o1 - o2;//升序
// });
```
    Arrays.sort(ages, ( o1,  o2) -> o1 - o2);
    //最终简化形式

    System.out.println(Arrays.toString(ages));
}
```
}