Java学习—常用类

马俊玮

已于 2023-09-12 21:18:01 修改

阅读量96

点赞数

文章标签：学习

于 2023-09-10 15:55:17 首次发布

本文链接：https://blog.csdn.net/Kochiya_ika/article/details/132788046

版权

今天接着学习常用类

Date类

*使用Date类来代表系统当前时间：

Date d=new Date();

Date d=new Date(long);

具体实例参见下方代码：

import java.util.Date;

public class datedemo {
    public static void main(String[] args) {
        /*
        使用包：import java.util.Date;
        *   new Date();对象 得到一个系统当前的时间
            getYear();上面有一个删除线，表示此方法时期用的方法，不建议使用，有新的方法代替，但也是可以调用的
        */
        //2023年9月10日
        Date date = new Date();
        System.out.println(date);
        //当输入一个对象的时候，输出一个字符串
        System.out.println(date.getYear()+1900);
        //123
        System.out.println(date.getMonth()+1);
        //8
        System.out.println(date.getDay());
        //0
        System.out.println(date.getDate());//月中第几天
        //10
        System.out.println(date.getTime());
        /*1694308222489
            *返回了一个毫秒值
            * 不管在什么地方使用，他的毫秒值已经确定，是在对象被创建的时候得到的毫秒值
            * 例如这个例子，返回的毫秒值就是第十一行得到的毫秒值
            * 获取的是从1970年1月1日0点0分0秒，到现在运行那一刻的时间差
            * 可以测试程序运行的时间：
                * 程序开始运行时new Date().getTime()；
                * 程序运行结束时new Date().getTime()；
        */
        Date d = new Date(1694308222489l);//通过有参的构造方法，将一个毫秒的时间封装成一个日期的对象
        Date n=new Date(date.getTime());
        //如果输入数据，Java默认数据为int类型，所以要加上l表示这个数据是long类型，通过调用getTime()函数，得到的返回值就是long类型
        System.out.println(d);//记录的是第十一行对象被创建的时候的时间
        System.out.println(n);

        //测试程序运行时间？
        Date start=new Date();
        int sum=0;
        System.out.println(start.getTime());
        //1694309908892
        for(int i=0;i<1000000000;i++){
            sum++;
        }
        System.out.println(sum);
        Date end=new Date();
        System.out.println(end.getTime());
        //1694309908894
        Date all=new Date(end.getTime()-start.getTime());
        System.out.println(all);
        //测试数据如果数据计算太过简单运算结果可能不是很明显甚至一模一样
    }
}

Calendar类

Calendar类是一个抽象类，使用的时候需要注意通过子类来调用Calendar类

import java.util.Calendar;
import java.util.GregorianCalendar;

public class calendardemo {
    public static void main(String[] args) {
        /*
        * Calendar 日历类 抽象类 用来定义日历的功能
            具体实现可以交给子类来实现
            * 为什么要交给子类实现？
            * 不止有一个公历，也不止有一种算法，每个不同的历法有不同的算法，但是肯定都有年月日时分秒这些，所以要用子类来继承一个日历类
        * Calendar c = new Calendar();抽象类不可被实例化对象
        * GregorianCalendar是Calendar的具体子类
        */
        Calendar c=new GregorianCalendar();
        Calendar c_1=Calendar.getInstance();//返回值仍旧是一个GregorianCalendar
        //c_1使用方法时，实际上也是格里高利历
        System.out.println(c_1.get(Calendar.YEAR));
        //2023
        System.out.println(c_1.get(Calendar.MONTH)+1);
        //9
        System.out.println(c_1.get(Calendar.DAY_OF_MONTH));
        //10
        System.out.println(c_1.get(Calendar.DAY_OF_WEEK));
        //1
        System.out.println(c_1.get(Calendar.DAY_OF_YEAR));
        //253
        System.out.println(c_1.getTimeInMillis());
        //获取从1970.1.1.00.00.00开始到运行程序那一刻的时间
        //c.set(2022，9，10)；设置系统时间，但是只改程序里面的，跟系统中的无关
        
        //对于Calendar类进行样式格式化可以通过Date类与Format来实现
        Date date=c.getTime();
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");
        System.out.println(simpleDateFormat.format(date));
    }
}

SimpleDateFormat类

SimpleDateFormat类用于格式化日期，简化操作：

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

public class simpledateformatdemo {
    public static void main(String[] args) throws Exception{
        Date date=new Date();
        String s="二狗";
        //将date类型转换为指定的字符串
        System.out.println(s+" "+date);//二狗Sun Sep 10 10:48:30 GMT+08:00 2023
        /*
        * 如果只想获得年月日该如何？
        */
        System.out.println(s+" "+(date.getYear()+1900)+"年"+(date.getMonth()+1)+"月");
        //过于复杂，但是可以使用sdf来快速格式化
        /*
        * yyyy-4位年
        * MM-月
        * dd-日 月中的天
        * HH-24小时制
        * mm-分钟
        * ss-秒
        * E-星期几
        */
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String date_str = sdf.format(date);
        /*
        * 关键落脚点在于，格式该如何给？
        */
        System.out.println(date_str);

        //把字符串日期 转换成 date类型
        String str="2023-9-10";
        SimpleDateFormat re=new SimpleDateFormat("yyyy-MM-dd");
        Date d=re.parse(str);//报错是由于java认为输入方式可能会出问题
        //解决方法暂时先用throws Exception
        System.out.println(d);
        //Sun Sep 10 00:00:00 GMT+08:00 2023  从2023-9-10转换回去
    }
}

通过使用format();来将date转换为字符串，通过parse来变回去

BigInteger类

由于int类型的限制，我们在使用整数的时候回受到很大的限制，即使是long类型也是有上限的，于是，就诞生了这个BigInteger类型，它相较于int、long类型的数字范围要大得多：

import java.math.BigInteger;

public class bigintegerdemo {
    public static void main(String[] args) {
        //使用int long这些数据类型限制太大
        //BigInteger类型支持所有整数
        BigInteger a=new BigInteger("124932075213560926598269801698012698612098635012");
        BigInteger b=new BigInteger("21094012984093840932809384409328432");
        BigInteger c=a.add(b);
        System.out.println(a);
        //124932075213560926598269801698012698612098635012
        System.out.println(b);
        //21094012984093840932809384409328432
        System.out.println(c);
        //124932075213582020611253895538945507996507963444
        /*
        * add()，subtract()，multiply()，divide() 基本加减乘除运算
        */
    }
}

BigDecimal类

同上，由于二进制的问题，浮点数在计算的时候会丢失精度，所以产生了BigDecimal这个东西：

import java.math.BigDecimal;

public class bigdecimaldemo {
    public static void main(String[] args) {
        //由于浮点数无法在小数位二进制完美的表达，所以要进行一些改动
        BigDecimal a = new BigDecimal("0.1");
        BigDecimal b=new BigDecimal("0.2");
        BigDecimal c=a.add(b);
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        //BigDecimal d=a.divide(c);//无限不循环报错
        BigDecimal d=a.divide(c,2,BigDecimal.ROUND_CEILING);//向上取整，无论多少都向上取
        System.out.println(d);
        //0.34
        BigDecimal d_1=a.divide(c,2,BigDecimal.ROUND_FLOOR);//舍弃设定好的小数位后面
        System.out.println(d_1);
        //0.33
    }
}

正则表达式

package Changyong;

import java.lang.reflect.Array;
import java.util.Arrays;

public class StringDemo {
    /*
    *   String s="abc";
    *   Char[] c={"a","b","c"}
    *   String s1=new String("abc");
    */
    public static void main(String[] args) {
        /*
        String name="二狗";
        name+=1;
        System.out.println(name);
        */

        String s="ab:cd:efg";
        String[] array=s.split(":");
        //参数名为：regex，名为正则表达式
        System.out.println(Arrays.toString(array));
        /*
            正则表达式：
            规则，是一种模式匹配语法，可以使用一些符号，来定义一个规则，然后用规则域字符串进行匹配
                *例如：验证输入的内容必须是一个手机号格式
                    第一位：1
                    第二位：3、5、7、8、9
                    第三位：都是数字即可
                    拿到字符串的每一位进行判断【charAt()】
                *正则表达式中符号：
                    \d-匹配0-9之间的数字，只能出现一个数字
                    [数字]，只能匹配其中一个
                    [a-zA-Z], 匹配字母
                    \w 匹配[A-z0-9_]
                    \W 匹配大部分符号
                    . 可以匹配任意字符
                        -[A-z],实际上也是一种数字区间
                        -在后面加入”*“可以检索多个数字
                        -在后面使用{数字}，可以检索特定长度
                        -在后面使用{数字，数字}，可以检索特定区间,区间大小在两个数字之间
                检测手机号：regex："1[35789]\\d{9}";
        */

        String t_num="123456789";
        String test="a";
        String test0="aba";
        boolean b=t_num.matches("a");
        boolean b1=test.matches("a");
        boolean b2=test0.matches("a");
        System.out.println(b);
        //false
        System.out.println(b1);
        //true
        System.out.println(b2);
        //false

        String test1="1";
        boolean t=t_num.matches("\\d");//检索数字，但是只能出现一个数字
        boolean t1=test1.matches("\\d");
        System.out.println(t);//false
        System.out.println(t1);//true

        boolean t2=t_num.matches("\\d*");//可以检索任意个数字
        System.out.println(t2);//true

        boolean t3=t_num.matches("\\d{9}");//检索特定长度
        boolean t4=test1.matches("\\d{9}");
        System.out.println(t3);//true
        System.out.println(t4);//false

        String test2="12345";
        boolean t5=t_num.matches("\\d{3,6}");//检索特定区间内是否为数字
        boolean t6=test2.matches("\\d{3,6}");
        System.out.println(t5);//false
        System.out.println(t6);//true

        String test3="334455";
        boolean t7=test2.matches("[345]*");
        boolean t8=test3.matches("[345]*");
        System.out.println(t7);//false
        System.out.println(t8);//true

        //qq号  数字  6-12位   0不能开头
        //"[123456789]\\d{6,12}"
        //"[1-9]\\d{5,11}"
        String qq="1555234260";
        boolean qte=qq.matches("[123456789]\\d{5,11}");
        System.out.println(qte);//true
        String qq1="09834891";
        boolean qte1=qq1.matches("[123456789]\\d{5,11}");
        System.out.println(qte1);//false
        boolean qte2=t_num.matches("[123456789]\\d{5,11}");
        System.out.println(qte2);//true

        /*  匹配邮箱格式
        *   由于"."在正则表达式中有特定的含义，所以在使用的时候要注意
        *   使用”\\“对.进行转义
        */
        String yx="15wde260@qq.com";
        boolean k = yx.matches("\\w{6,10}@\\w{2,6}\\.(com|com\\.cn)");
        System.out.println(k);//true
        String yx0="1234929@qqwXcom";
        boolean k0 = yx0.matches("\\w{6,10}@\\w{2,6}\\.(com|com\\.cn)");
        System.out.println(k0);//false
        boolean k0_1 = yx0.matches("\\w{6,10}@\\w{2,6}.(com|com.cn)");//不进行转义
        System.out.println(k0_1);//true

        //对split进行拆分
        String str="ab3cd5ef6g";
        String [] strings=str.split("\\d");//删去字符串中的数字
        System.out.println(Arrays.toString(strings));

        String str0="abccd438918072ty978di";
        String o1=str0.replace("c","C");
        String o2=str0.replaceAll("\\d","C");//参数为一个正则表达式
        String o3=str0.replaceFirst("A-z","o");
        System.out.println(o1);
        System.out.println(o2);
        System.out.println(o3);
    }
}