【Java基础概述-4】SimpleDateFormat类、Calendar类、Math类、System类、BigDecimal类、包装类、正则表达式的使用

目录

1.SimpleDateFormat类

2.Calendar类

3.math类

4.System类

5.BigDecimal类

6.包装类

7.正则表达式

---

1.SimpleDateFormat类

        首先我们在了解SimpleDateFormat类之前先了解下DateFormat.

        DateFormat是一个抽象类，不能直接使用，要找它的子类：SimpleDateFormat

        SimpleDateFormat简单日期格式化类：

        包：java.text.SimpleDateFormat

        构造器：SimpleDateFormat(String pattern):指定时间的格式创建简单日期格式化对象

        方法：

        public String   format(Date data):可以把日期对象格式化为我们喜欢的时间格式。

        public String   format(Object time)

        public String     parse(String date):字符串转换成日期对象。

        使用案例：

public class SimpleDateFormatDemo {
    public static void main(String[] args) {
        Date d =new Date();//创建时间对象
        DateFormat DateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        String format = DateFormat.format(d);
        System.out.println(format);
    }
}

public class SimpleDateFormateDemo02 {
    public static void main(String[] args) {
        Date date = new Date();
        long time = date.getTime();
        time = time + 121 * 1000;
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss EEE");
        String format = simpleDateFormat.format(time);
        System.out.println(format);
    }
}

 

public class SimpleDateFormatDemo03 {
    public static void main(String[] args) throws ParseException {
        String date="2012/1/2 12:20:45";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        Date parse = simpleDateFormat.parse(date);
        String format = simpleDateFormat.format(parse);
        System.out.println(parse);
        System.out.println(format);
        Date date1 = new Date();
        afterDate(date1,3,0,30,120);
    }

    //请问y天后h小时，m分s秒的时间多少
    public static void afterDate(Date date,int y,int h,int m,int s){
        //a.定义一个字符串时间。
        long time = date.getTime()+(24L*y*60*60+h*60*60+m*60+s)*1000;//这里()内容是变成秒然后*1000变毫秒
        //加L更加安全
        //获取时间毫秒值
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        String format = simpleDateFormat.format(time);
        System.out.println(format);

    }

}

 

2.Calendar类

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

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

        Calendar rightNow = Calendar.getInstance();

 注意，这里Calendar底层是单例方式创建对象。

        Calendar日历类的方法：

        public static Calendar getInstance():返回一个日历对象。

        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():拿到此刻时间毫秒值。

    public static void main(String[] args) {
        //获取对象
        Calendar instance = Calendar.getInstance();
        System.out.println(instance);
        System.out.println("------------");
        //2.获取年、月
        int year = instance.get(Calendar.YEAR);
        System.out.println(year);
        int month = instance.get(Calendar.MONTH);
        System.out.println(month + 1);
        //日历中月份从0开始

        //3.一年中的第几天：
        int dayOfYear = instance.get(Calendar.DAY_OF_YEAR);
        System.out.println(dayOfYear);
        //4.修改日历信息。
//        instance.set(Calendar.YEAR,2012);
//        System.out.println(instance.get(Calendar.YEAR));

        //4-2可以让日历往后走几天 ：问700天后的时间

        //日历可以得到此刻日期对象。
        Date time = instance.getTime();//拿到日历对象
        System.out.println(time);
        //拿到时间毫秒值
        long timeInMillis = instance.getTimeInMillis();
        System.out.println(timeInMillis);
        //请问701天后15小时的日期
        //把日历的一年中的第几天往后走701天!!!
        instance.add(Calendar.DAY_OF_YEAR, 701);
        long timeInMillis1 = instance.getTimeInMillis();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        System.out.println(simpleDateFormat.format(timeInMillis1));
/*
* 
输出：
2024
1
1
Mon Jan 01 01:09:12 CST 2024
1704042552046
2025/12/02 01:09:12

* */
    }

3.math类

        Math类简称数学类。

        Math类中的全部方法都是静态方法，直接调用类名访问。

        常用方法：

        public static int abs(int a):取绝对值

        public static double ceil(double a ):向上取整。

        public static double floor(double a):向下取整。

        public static double pow(double a,double b)获取a的b次幂

        public static long round(double a)：四舍五入取整

        public static int/double/float/long max(..):取最大值，这里可以传输的类型有好几种，重载机制

        public static int/double/...... min(..):取最小值，支持多种类型传参.

public class MathDemo {

    public static void main(String[] args) {
        //取绝对值
        System.out.println(Math.abs(10));
        System.out.println(Math.abs(-10.3));
        //向上取整:5
        System.out.println(Math.ceil(4.00001));
        //向下取整：4
        System.out.println(Math.floor(4.999990));
        //求指数次方根
        System.out.println(Math.pow(2,10));
        //四舍五入
        System.out.println(Math.round(2.1212));
        System.out.println(Math.round(2.5));
        //最大最小值
        System.out.println(Math.max(1,2));
        System.out.println(Math.min(1,2));
        //输出如下：
//        10
//        10.3
//        5.0
//        4.0
//        1024.0
//        2
//        3
//        2
//        1

    }
}

4.System类

        System类代表当前系统，常用的方法有如下几个：

        --1.public static void exit(int status):终止JVM虚拟机，非0是异常终止。

        --2.public static long currentTimeMills():获取当前系统此刻的时间毫秒值。

        --3.arraycopy(Object var0,int var1,Object var2,int var3,int var4);

        参数一:原数组

        参数二：从原数组的哪个位置开始赋值。

        参数三：目标数组。

        参数四：赋值到目标数组的哪个位置。

        参数五：赋值几个。

案例：

public class SystemDemo {
    public static void main(String[] args) {
        System.out.println("程序开始~~~~");
//        System.exit(0);JVM虚拟机终止
        System.out.println("程序结束~~~~");
        System.out.println("---------------");
        long l = System.currentTimeMillis();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd");
        String format = simpleDateFormat.format(l);
        System.out.println(format);
        System.out.println("--------");
        int[] a =new int[5];
        int[] b ={1,2,3,4,5};
        System.arraycopy(b,0,a,0,5);
        System.out.println(Arrays.toString(a));



    }
}

5.BigDecimal类

        BigDecimal是叫大数据类。

        引入：浮点数在做运算的时候，直接使用+-*/会出现数据失真的情况，BigDecimal可以解决数据失真的问题。

        BigDecimal:

        包：Java.math....

        创建的方式：

        BigDecimal bigDecimal = BigDecimal.valueOf(浮点类型的变量);

        方法：

        public BigDecimal add(BigDecimal value)//加法

        public BigDecimal substract(BigDecimal value)//减法

        public  BigDecimal multiply(BigDecimal value)//乘法

        public BigDecimal divide(BigDecimal value)//除法

        public double doubleValue():把BigDecimal对象值转换成double 存储

        注意:最后一个方法是核心，这里BigDecimal就是一个类，用于处理失去精度的类，不是一个类型，所以我们处理完之后是需要转成double类型来存储的。

        案例：

        

public class BigDecimalDemo {
    public static void main(String[] args) {
        double a = 0.1;
        double b = 0.2;
        double c = a + b;
        System.out.println(c);//失真了
            BigDecimal bigDecimal = BigDecimal.valueOf(a);
        BigDecimal bigDecimal1 = BigDecimal.valueOf(b);
        BigDecimal add = bigDecimal.add(bigDecimal1);
        System.out.println(add);


        //结果可能需要继续使用
        //BigDecimal只是解决精度问题的手段，double数据才是我们的目的！！！
        double v = add.doubleValue();
        System.out.println(v);
        //输出：
//        0.30000000000000004
//        0.3
//        0.3
    }
}

6.包装类

        Java为了让一切皆为对象引用类型，把8种基本数据类型转换成对应的类，这个类称为基本数据类型的包装类：

       

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

        注意：包装类容错更好，默认为null

        包装类的特性：

        自动装箱：直接把基本数据类型的值或者变量赋值给包装类

        自动拆箱：可以把包装类的值自动拆解为对应的基本数据类型。

public class PackageClass {
    public static void main(String[] args) {
        int a=12;
        Integer a1=12;
        Integer s2=12;//自动装箱
        System.out.println(s2==a1);
        System.out.println(a1.equals(s2));
//        System.out.println();

        Integer d=null;//引用数据类型默认可以为null
    }
}

        扩展（重要）：

        Java包装类做了一些特殊功能，以便程序员使用。

        包装类作为类首先继承了Object类的方法。

        包装类作为引用数据类型的值可以存储null的值。

        具体来看特殊功能主要有：

        1.可以把基本数据类型的值转换成字符串。

        --调用toString()方法。

        调用Integer.toString(基本数据类型)得到字符串

        直接把基本数据类型+空字符串也可得到字符串。

        2.把字符串类型的数据转换成对应的基本数据类型。

        ---xxx.parseXxx("字符串的值")//不太用

        ---xxx.valueOf("字符串值");//最多使用

        --例子：Integer.valueOf(numStr);

案例：

public class PackageClass02 {
    public static void main(String[] args) {
        Integer i = 100;
        String string = i.toString();
        System.out.println(string+1);
        //b.调用toString.
        String string1 = Integer.toString(1212);
        System.out.println(string1);
        //直接把基本数据类型+空字符串得到了字符串
        String str = i +"";
        System.out.println(str+1);


        /*
        把字符串数值的类型转换成对应的基本数据类型的值
        * */
        String numStr="23";
        //这里不能真的去输入字符串，例如：abbbb.
        int num = Integer.valueOf(numStr);
        System.out.println(num+7);
        int num2 = Integer.parseInt(numStr);//没有淘汰，但是不常用
        System.out.println(num2+17);
    }
}

7.正则表达式

        引入：正则表达式作用是一套特殊字符组成的校验规则，可以校验信息的正确性，比如我们在网页输入邮箱的时候判断邮箱是否正确，手机号是否正确，qq是否正确等等。

        下面演示用正则和用普通方式来判断QQ号是否输入合法的代码：

public class RegexDemo {
    public static void main(String[] args) {
        System.out.println(checkQQRegex("12334d5"));
    }

    public static boolean checkQQRegex(String qq){
        return qq.matches("\\d{5,10}");//正则方式
    }

    public static boolean checkQQ(String qq){//普通方式
        if(qq == null || qq == "")return false;
        else{
            if (qq.length()>=5){
                boolean rs =
                        true;
                for(int i=0;i<qq.length();i++) {
                    char c = qq.charAt(i);
                    if (c<'0' || c>'9')rs=false;
                }
                return rs;
            }else{
                return false;
            }
        }
    }

}

        由此可以看出，用正则表达式校验代码量及其的少。

        正则的常用校验规则：

        

字符类（只匹配一个字符）	预定义字符（单字符匹配）	多字符规则
[abc]:abc中的一个	.        :任意字符	X?      :X出现一次或多次
[^abc]:除了abc外的任意一个	\d        :任意数字[0-9]	X*       :X出现0次或者多次
[a-zA-Z],[a-z[A-Z]]:a-z或者A-Z中的一个	\D        :非数字[^0-9]	X+        :X出现一次或者多次
[a-c&&[bdf]]:a-c与bdf交集中的一个，即b	\s        :空白字符	X{n}        :X出现n次
[a-e&&[^f-g]]:a-e和非f-g的交集，	\S        :非空白字符	X{n,}        :X出现至少n次
	\w        :英文字母，数字，下划线	X{n,m}        :X至少出现n次，最多m次。
	\W        :等同于[^\w],表示一个非单词字符

校验邮箱和手机号案例：

public class RegexDemo02 {
    public static void main(String[] args) {
        if(checkEmail()){
            System.out.println("合法");
        }else{
            System.err.println("不合法");
        }
//        if(checkPhone()){
//            System.out.println("合法");
//        }else {
//            System.err.println("不合法");
//        }

    }

    public static boolean checkEmail(){
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        return s.matches("\\w{1,}@\\w{2,10}(\\.\\w{2,5}){1,2}");
    }
    public static boolean checkPhone(){
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        return s.matches("1[3-9]\\d{9}");
    }
}

         扩展:

        除了包装类String的matches方法，还有哪些方法可以匹配字符串是否满足条件呢。

        这里再列举两个(也属于String)：

        public String[] split(String regex):

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

        public String replaceAll(String regex,String newStr);

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

public class RegexDemo03 {
    public static void main(String[] args) {
        //1.split的基础用法
                String names = "张三,李四,赵六";
                //2.以","分割
        String[] split = names.split(",");
        System.out.println(Arrays.toString(split));
        String name1 = "张三435535353fwfe王强424232442陈凡";
        String[] nameArrs1 = name1.split("\\w+");
        System.out.println(Arrays.toString(nameArrs1));
        String s = name1.replaceAll("\\w+", "-");
        System.out.println(s);
        /*
        *
        * 输出：
        * 
        [张三, 李四, 赵六]
        [张三, 王强, 陈凡]
        张三-王强-陈凡

        * */
    }
}