JAVA-常用API（2）-CSDN博客

本文链接：https://blog.csdn.net/xiaosongshi/article/details/122544317

第一节 Object类

1.1 Object类的toString方法

1.2 Object类的equals方法

Person类默认继承了Object类，所以可以使用Object类的equals方法
boolean equals(object obj)指示其他某个对象是否与此对象“相等”

注意：
基本数据类型：比较的是值
引用数据类型：比较的是两个对象的地址值

public class Equals {
    public static void main(String[] args) {
        Person one = new Person("小松狮",18);
        Person two = new Person("小锦鲤",19);
        boolean b = one.equals(two);
        System.out.println(b);
    }
}

Object类的equals方法，默认比较的是两个对象的地址值，没有意义
所以我们需要重写equals方法，比较两个对象的属性（name,age）
问题：
隐含着一个多态，多态的弊端：无法使用子类持有的内容（属性和方法）
解决：可以使用向下转型（强转）把obj类型转换为Person

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

Objects类的equals方法：对两个对象进行比较，防止空指针异常

import java.util.Objects;
public class Demo01Equals {
        public static void main(String[] args) {
            String s1 = null;
            String s2 = "小锦鲤";
            //boolean b = s1.equals(s2);//NullPointerException,null是不能调用方法的
            //System.out.println(b);
            boolean b = Objects.equals(s1,s2);
            System.out.println(b);//false
        }
 }

第二节日期时间类

2.1 Data类

java.util.Date:表示日期和时间的类，类Date表示特定的瞬间，精确到毫秒
毫秒：千分之一秒 1000毫秒=1秒
特定的瞬间：一个时间点，一刹那时间
毫秒值的作用：可以对时间和日期进行计算

把日期转换为毫秒：
1、当前的日期：2088-01-01
2、时间原点（0毫秒）：1970年1月1日00：00：00（英国格林威治时间）
3、就是计算当前日期到时间原点之间一共经历了多少毫秒
注意：中国属于东八区，会把时间增加8个消失（1970年1月1日08：00：00）
把毫秒转换为日期：
1天 = 24 * 60 * 60 = 86400秒 = 86400 * 1000 = 86400000毫秒

public class Demo01Data {
    public static void main(String[] args) {
        //获取当前系统时间到1970年1月1日00：00：00经历了多少毫秒
        System.out.println(System.currentTimeMillis());
    }
}

import java.util.Date;
public class Demo02Data {
    public static void main(String[] args) {
        demo01();
        demo02();
        demo03();
    }
    /*
    long getTime() 把日期转换为毫秒值（相当于System.currentTimeMills()方法）
     */
    private static void demo03() {
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);//1642425373896
    }

    /*
    Data类的有参数构造方法
    Data（long date）:传递毫秒值，把毫秒值转换为data日期
     */
    private static void demo02() {
        Date date = new Date(1642425081548L);
        System.out.println(date);//Mon Jan 17 21:11:49 CST 2022
    }
    /*
    Data类的空参数构造方法
    Data（）获取当前系统的日期和时间
     */
    private static void demo01() {
        Date date = new Date();
        System.out.println(date);//Mon Jan 17 21:09:42 CST 2022
    }
}

2.2 DateFormat类&SimpleDateFormat类

java.text.DataFormat;
是日期/时间格式化子类的抽象类，通过这个类可以帮我们完成日期和文本之间的转换，也就是可以在Data对象与String对象之间进行来回转换
作用：
格式化（也就是日期–>文本）、解析（文本–>日期）

成员方法：
String format(Date date) 按照指定的模式，把Date日期格式化为符合模式的字符串
Date parse(String source) 把符合模式的字符串，解析为Date日期

DateFormat类是一个抽象类，无法直接创建对象使用，可以使用DateFormat类的子类
java.text.SimpleDataFormat extends DataFormat

构造方法：
SimpleDateFormat(String pattern)
用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat
参数：String pattern 传递指定的模式
模式：区分大小写，写对应的模式，会把模式替换为对应的日期和时间“yyyy-MM-dd HH:mm:ss”
注意：模式中的字母不能更改，连接模式的符号可以改变“yyyy年MM月dd日 HH时mm分ss秒”

public class Demo01DataFormat {
    public static void main(String[] args) throws ParseException {
        demo01();
        demo02();
    }
    /*
    使用DateFormat类中的方法parse，把文本解析为日期
    步骤：
    1、创建SimpleDateFormat对象，构造方法中传递指定的模式
    2、调用SimpleDateFormat对象中的方法parse，把符合构造方法中模式的字符串解析为Date日期
    注意：public Date parse(String source) throws ParseException
    parse方法声明了一个异常叫ParseException
    如果字符串和构造方法的模式不一样，那么程序就会抛出异常
    调用一个抛出了异常的方法，就必须得处理这个异常，要么throws继续抛出这个异常，要么try catch自己处理
     */
    private static void demo02() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date date = sdf.parse("2022年01月17日 21时40分53秒");
        System.out.println(date);
    }

    /*
    使用DateFormat类中的方法format，把日期格式化为文本
    步骤：
    1、创建SimpleDateFormat对象，构造方法中传递指定的模式
    2、调用SimpleDateFormat对象中的方法format，按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串（文本）
     */
    private static void demo01() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date date = new Date();
        String d = sdf.format(date);
        System.out.println(date);//Mon Jan 17 21:40:53 CST 2022
        System.out.println(d);//2022年01月17日 21时40分53秒
    }
}

第三节 Calendar类

java.util.Calendar类：日历类
Calendar类是一个抽象类，里面提供了很多操作日历字段的方法（YEAR、MONTH、DAY_OF_MONTH/HOUR）
Calendar类无法直接创建对象使用，里边有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象
static Calendar getInstance()使用默认时区和语言环境获得一个日历

import java.util.Calendar;

public class Demo03Calendar {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        System.out.println(c);
    }
}

Calendar类的常用成员方法：
public int get(int field):返回给定日历字段的值
public void set(int field,int value):将给定的日历字段设置为给定值
public abstract void add(int field,int amount):根据日历的规则，为给定的日历字段添加或减去指定的时间量
public Date getTime():返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象

public class Demo04Calendar {
    public static void main(String[] args) {
        demo01();
        demo02();
        demo03();
        demo04();
    }

    private static void demo04() {
        Calendar instance = Calendar.getInstance();
        Date time = instance.getTime();
        System.out.println(time);//Tue Jan 18 14:51:55 CST 2022
    }

    private static void demo03() {
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.YEAR,6);
        int year = instance.get(Calendar.YEAR);
        System.out.println(year);//2028
    }

    private static void demo02() {
        Calendar instance = Calendar.getInstance();
        instance.set(Calendar.YEAR,2088);
        int year = instance.get(Calendar.YEAR);
        System.out.println(year);//2088
    }

    private static void demo01() {
        Calendar instance = Calendar.getInstance();
        int year = instance.get(Calendar.YEAR);
        System.out.println(year);//2022
        int day = instance.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);//18
    }
}

第四节 System类

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作

常用的方法:
1、public static long currentTimeMillis();
返回以毫秒为单位的当前时间
2、public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int Length)
将数组中指定的数据拷贝到另一个数组中

参数：
src-源数组
srcPos-源数组中的起始位置（起始索引值）
dest-目标数组
destPos-目标数组中的起始位置
Length-要复制的数组元素的数量

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

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

    private static void demo01() {
        /*
        用来测试程序的效率
        验证for循环打印数字1-9999所需要的时间（毫秒）
         */
        //程序执行前，获取一次毫秒值
        long start = System.currentTimeMillis();
        for (int i = 1; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("程序共耗时：" + (end - start) + "毫秒");//程序共耗时：69毫秒
    }
}

第五节 StringBuilder类

String类
字符串是常量，它们的值在创建之后不能更改字符串的底层是一个被final修饰的数组，不能改变，是一个常量

StringBuilder类
字符串缓冲区，可以提高字符串的操作效率（看成一个长度可以变化的字符串）
底层也是一个数组，但是没有final修饰，可以改变长度
StringBuilder在内存中始终是一个数组，占用空间少，效率高，如果超过了StringBuilder类的容量，会自动扩容

构造方法：
StringBuilder()：构造一个不带任何字符的字符串生成器，初始容量为16个字符
StringBuilder(String str)：构造一个字符串生成器，并初始化为指定的字符串内容

public class Demo06StringBuilder {
    public static void main(String[] args) {
        //空参构造
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1" + bu1);//bu1
        //带字符串的构造
        StringBuilder bu2 = new StringBuilder("小松狮");
        System.out.println("bu2" + bu2);//bu2小松狮
    }
}

5.1 StringBuilder的append方法

StringBuilder的常用方法：
public StringBuilder append(…):添加任意类型数据的字符串形式，并返回当前对象自身

public class Demo07StringBuilder {
    public static void main(String[] args) {
        StringBuilder bu = new StringBuilder();
        //append方法返回的的是this
        /*
        StringBuilder bu2 = bu.append("小松狮");//把bu的地址赋值给了bu2
        System.out.println(bu);//小松狮
        System.out.println(bu2);//小松狮
        System.out.println(bu == bu2);//比较的是地址值 true
        //使用append方法无需接收返回值*/
        //链式编程：方法返回值是一个对象，可以继续调用方法
        bu.append("小松狮").append("小锦鲤");
        System.out.println(bu);
    }
}

5.2 StringBuilder的toString方法

StringBuilder和String可以相互转换：
String–>StringBuilder:可以使用StringBuilder的构造方法
StringBuilder–>String:可以使用StringBuilder中的toString方法
public String toString()：将当前StringBuilder对象转换为String对象

public class Demo08StringBuilder {
    public static void main(String[] args) {
        String str = "小松狮";
        System.out.println("开始的字符串:" + str);
        StringBuilder builder = new StringBuilder(str);
        builder.append("小锦鲤");
        System.out.println("转换后的StringBuilder字符串：" + builder);
        System.out.println("=========");
        String s = builder.toString();
        System.out.println("s:" + s);
    }
}

第六节基本类型包装类

基本数据类型，使用起来非常方便，但是没有对应的方法来操作这些基本类型的数据，可以使用一个类，把基本类型的数据装起来，在类中定义一些方法，这个类就叫做包装类，我们可以使用类中的方法来操作这些基本类型的数据
装箱：从基本类型转换为对应的包装类对象
拆箱：从包装类对象转换为对应的基本类型

装箱：
构造方法：
Integer(int value)构造一个新分配的Integer对象，它表示指定的int值
Integer(String s)构造一个新分配的Integer对象，它表示String参数所指示的int值
传递的字符串，必须是基本类型的字符串，否则抛出异常
静态方法：
static Integer valueOf(int i)返回一个表示指定的int值的Integer实例
static Integer valueOf(String s)返回保存指定的String的值的Integer对象
拆箱：
成员方法： int intValue()以int类型返回该Integer的值

public class Demo01Integer {
    public static void main(String[] args) {
        //装箱
        Integer in1 = new Integer(1);//横线表示方法过时
        System.out.println(in1);//重写了toString方法
        Integer in2 = new Integer("1");
        System.out.println(in2);
        Integer integer = Integer.valueOf(1);
        System.out.println(integer);
        Integer integer1 = Integer.valueOf("1");
        System.out.println(integer1);
        //拆箱
        int i = in1.intValue();
        System.out.println(i);
    }
}

自动装箱：直接把int类型的整数赋值包装类
自动拆箱：in是包装类，无法直接参与运算，可以自动转换为基本数据类型，再进行计算

基本类型与字符串类型之间的相互转换

基本类型–>字符串（String）
1、基本类型的值+”“ 最简单的方法（常用）
2、包装类的静态方法toString(参数)，不是Object类的toString（）重载
static String toString(int i)返回一个表示指定整数的String对象
3、String类的静态方法valueOf(参数)
static String valueOf(int i)返回int参数的字符串表示形式
字符串（String）–>基本类型
使用包装类的静态方法parseXXX（”字符串“）;
Integer类：static int parseInt(String s)
Double类：static double parseDouble(String s)

public class Demo03Integer {
    public static void main(String[] args) {
        int i1 = 100;
        String s1 = i1 + "";
        System.out.println(s1 + 200);//100200
        String s2 = Integer.toString(100);
        System.out.println(s2 + 200);
        String s3 = String.valueOf(100);
        System.out.println(s3 + 200);
        System.out.println("=======");
        int i = Integer.parseInt(s1);
        System.out.println(i - 10);

    }
}