Java常用实用类(我的简单理解)

Java常用实用类(我的简单理解)

Object

类默认继承Object类，所以可以重写Object类中toString

类默认继承Object类，所以可以重写Object类中toString和equals

注意：如果没有重写equals：

​ 基本数据类型:比较值

​ 引用数据类型：比较地址值

自定义重写equals方法

@Override
public boolean equals(Object o) {
    //增加一个判断，传递的参数obj是this本身，直接返回true，提高程序效率
    if (o==this){
        return true;
    }
    //增加一个判断，传递的参数obj是null，直接返回false，提高程序效率
    if (o==null){
        return false;
    }
    if (o instanceof Person) {//问题在于，如果比较的不是person类怎么办
        //使用向下转型（强转）把object转为person
        Person person = (Person) o;
        boolean b=this.name.equals(person.name) &&  this.age== person.age;//equals比较基本数据类型:比较值
        return b;
    }
    //不是person类直接false
    return false;
}

idea模板重写

 @Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    Person person = (Person) o;

    if (age != person.age) return false;
    return name != null ? name.equals(person.name) : person.name == null;
}

Date

java.util.Date:表示时间的类，精确到毫秒 1000毫秒（ms）=1秒（s）

用来计算时间

构造方法

Date date = new Date(); //Date类的空参数构造方法：Date()获取的就是当前系统的日期和时间

Date date = new Date(1000); //Date类的带参数构造方法：Date（long date）:传递毫秒值，把毫秒转换为Data日期

成员方法

public long getTime();//long getTime() 返回1970年...至今的毫秒数

测试

public class demo1概述 {
    public static void main(String[] args) {
        demo1();
        demo2();
        demo3();
    }
    //Date类的空参数构造方法：
        /*
        Date（）获取的就是当前系统的日期和时间
        */
    private static void demo1() {
        Date date = new Date();
        System.out.println(date);//Thu Jun 03 17:20:41 CST 2021
    }
    // Date类的带参数构造方法：
        /*
        Date（long date）:传递毫秒值，把毫秒转换为Data日期
        */
    private static void demo2() {
        Date date = new Date(1000);
        System.out.println(date);//Thu Jun 03 17:20:41 CST 2021
    }
    //Date类的成员方法
    /*
    long getTime() 返回1970年...至今的毫秒数
     */
    private static void demo3() {
        Date date = new Date();
        System.out.println(date.getTime());
    }
}

结果

Fri Jun 04 13:50:54 CST 2021
Thu Jan 01 08:00:01 CST 1970
1622785854797

DateFormat

java.text.DateFormat（抽象类）:日期于文本的相互转换

格式化：（日期->文本）
   String format(Date date)

解析： （文本->日期）
   Date parse(String source)

使用：DateFormat是抽象类，无法直接使用，那么可以间接使用子类simpleFormat类

直接上案例

public class demo1概述 {
    //构造方法
    /*
      simpleDateFormat(String pattern)
                 参数：String pattern 指定的模式
                 模式（pattern）：  yyyy:MM:dd  HH:mm:ss
      这个怎么玩？
              1.创建simpleDateFormat对象，构造方法中传递指定的模式
              2(格式化).调用simpleDateFormat对象的方法format，按照构造方法中指定的模式，把日期转为符合模式的文本（String）
              2(解析).调用simpleDateFormat对象的方法parse，按照构造方法中指定的模式，把文本（String）转为符合模式的日期（Date）
     */
    public static void main(String[] args) throws ParseException {
        //1.创建simpleDateFormat对象，构造方法中传递指定的模式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy:MM:dd  HH:mm:ss");
        Date date=new Date();
        //2(格式化).调用simpleDateFormat对象的方法format，按照构造方法中指定的模式，把日期转为符合模式的文本（String）
        String s = simpleDateFormat.format(date);
        System.out.println(s);
        //2(解析).调用simpleDateFormat对象的方法parse，按照构造方法中指定的模式，把文本（String）转为符合模式的日期（Date）
        Date parse = simpleDateFormat.parse(s);
        System.out.println(parse);
    }

}

运行结果

2021:06:04 13:35:44
Fri Jun 04 13:35:44 CST 2021

案例升级

//练习：
      /*
      请使用日期时间相关的api，计算出一个人已经出生了多少天？
      */
public class Test {
       //分析
       /*
        1.获取出生日期，Scanner.next()方法
        2.把获取到的日期解析
        3.把出生日期转化为毫秒值
        4.获取当前日期，转化为毫秒值
        5.用现在时间的毫秒值减去出生日期毫秒值
        6.转化为天数
         */
    public static void main(String[] args) throws ParseException {
        //1.获取出生日期，Scanner.next()方法
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的出生日期，格式为yyyy-MM-dd");
        String birthDay = scanner.next();
        //2.把获取到的日期解析
        SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd");
        Date birthDay2 = s.parse(birthDay);
        //3.把出生日期转化为毫秒值
        long birthDay2Time = birthDay2.getTime();
        //4.获取当前日期，转化为毫秒值
        Date date = new Date();
        long nowDate = date.getTime();
        //5.用现在时间的毫秒值减去出生日期毫秒值
        long day = nowDate - birthDay2Time;
        // 6.转化为天数
        System.out.println("您至今出生了："+day/1000/24/60/60+"天.");
    }
}

运行结果

请输入您的出生日期，格式为yyyy-MM-dd
2008-12-5
您至今出生了：4564天.

Calendar

java.util.Calendar（抽象类）：日历类

/*
   Calendar是一个抽象类，提供了很多操作日历字段的方法（year，month，day_of_month,hour）
   Calendar类无法直接创建对象，只能通过getInstance（），该方法返回Calendar的子类对象
   static Calendar getInstance（）
 */

测试

public class Test {
    /*
    Calendar常用方法
    1.public int get(int field)               field:日历字段（year，month，day_of_month,hour）
    2.public void set(int field,int value)
    3.public abstract void add(int field,int amount)     amount:时间量
    4.public Date getTime()                              把calendar对象转换为日期
     */
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        //1.get()
        System.out.println(calendar.get(YEAR));
        //2.set()
        calendar.set(YEAR,2020);
        System.out.println(calendar.get(YEAR));
        //3.add
        calendar.add(YEAR,20);
        System.out.println(calendar.get(YEAR));
        //4.getTime
        System.out.println(calendar.getTime());
    }
}

运行结果

2021
2020
2040
Mon Jun 04 13:41:36 CST 2040

System

java.lang.System:获取于系统相关的信息或者系统级操作

/*
   常用方法：
        public static long currentTimeMills();返回以毫秒为单位的当前时间
        public static void arrayCopy(Object src,int srcPos,Object dest,int destPos,int length)
        ：将数组中指定的数据拷贝到另一数组中
 */

测试

public class Test {
    public static void main(String[] args) {
        demo02();
    }

    private static void demo02() {
        //将数组A中前三个元素，复制到B的前三个位置上
        int[] A={1,2,3,4,5};
        int[] B={6,7,8,9,0};
        System.out.println("复制前："+ Arrays.toString(B));
        System.arraycopy(A,0,B,1,3);
        System.out.println("复制后："+ Arrays.toString(B));
    }

    private static void demo1() {
        System.out.println(System.currentTimeMillis());//用来测试程序的效率
        long start = System.currentTimeMillis();
        for (int i = 0; i<1000; i++){
            System.out.print(i);
            if (i%50==0){
                System.out.println(" ");
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时"+(end-start));
    }
}

测试结果

复制前：[6, 7, 8, 9, 0]
复制后：[6, 1, 2, 3, 0]
1622785586922
0
1234567891011121314151617181920
2122232425262728293031323334353637383940
4142434445464748495051525354555657585960
6162636465666768697071727374757677787980
81828384858687888990919293949596979899
用时22473

StringBuilder

Java.lang.StringBuilder: 字符串缓冲区，提高效率

/*
    构造方法：
          public StringBuilder():构造一个空的StringBuilder容器
          public StringBuilder(String str):构造一个空的StringBuilder容器,并把字符串添加进去
    常用方法：
          public StringBuilder append(....):添加任意类型的字符串形式，并返回当前对象自身
          public String toString():将当前的对象转换为String对象
          public StringBuilder reverse():反转内容
*/

测试

public class test {
    public static void main(String[] args) {
        //构造方法
        /*StringBuilder builder = new StringBuilder();
        System.out.println("builder:"+builder);
        StringBuilder builder2 = new StringBuilder("aaaa");
        System.out.println("builder:"+builder2);*/

        //常用方法
        StringBuilder builder = new StringBuilder();
        builder.append("ccc");
        System.out.println(builder);
        /*
        链式编程：
         */
        builder.append("ccc").append(123).append(true);
        System.out.println(builder);
        builder.reverse();
        System.out.println(builder);


        //字符串和StringBuilder相互转化
        /*
           String->StringBuilder:StringBuilder构造方法
           StringBuilder->String:toString
         */
    }
}