Java高级5——常用API总结（一）

Trazom_

已于 2023-12-02 22:48:41 修改

阅读量168

点赞数 1

文章标签： java 开发语言

于 2023-10-05 01:04:19 首次发布

本文链接：https://blog.csdn.net/weixin_50336543/article/details/133562552

版权

一、常用API

1. 含义

API(Application Programming interface) ：应用程序编程接口
一些Java内置的程序，包括类以及方法，可以调用

2. Object类

2.1 介绍

Object类是Java中所有类的祖宗类，因此，Java中所有类的对象都可以直接使用Object类中提供的一些方法

2.2 常见方法

2.2.1 汇总


public String toString() // 返回对象（信息）的字符串形式
public boolean equals(Object o) // 判断两个对象是否相等
protected Object clone() // 对象克隆

2.2.2 toString和equals方法

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() { // 注意已经重写toString方法 不重写的话返回地址之类的
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        // 1. this代表调用equals方法的对象，先判断两个对象是否一样（地址相同）
        if (this == o) return true;
        // 2. 再判断被比较的对象是否为空或者它的类名和调用类是否相同
        if (o == null || getClass() != o.getClass()) return false;
        // 3. 再把o类型转成调用类型 判断内容是否一样
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class Test {
    public static void main(String[] args) {
        // Object类常用方法
        Student s1 = new Student("jinker", 20);
//        System.out.println(s1.toString());
        System.out.println(s1); // s1 = s1.toString() toString用来返回对象信息，就是用来重写的

        Student s2 = new Student("jinker", 20);
        System.out.println(s2);
        System.out.println(s2.equals(s1)); // 默认比较地址，都是用来重写的
        System.out.println(s2 == s1);
    }
}


// output:
Student{name='jinker', age=20}
Student{name='jinker', age=20}
true // 改写的equals方法比较内容所以是true
false // 直接s2 == s1比较的是地址所以是false
// 这两个方法继承到都是改写的，针对继承对象返回对象存储数据（具体内容（和比较对象存储数据而不是地址

2.2.3 clone方法

（1）深克隆和浅克隆

区别在于两者的对数据的克隆：

基本数据内容直接拷贝
String的字符串数据拷贝地址，因为String是不可变的，即使同时指向同一个值，另外一个克隆对象改变值的时候会指向新值，而不改变原来的对象指向的值
其他引用类型变量存储的对象拷贝数据创建新对象（因为如果同时指向，新克隆的改变值会导致旧的也改变，就不是深克隆了，必须要创建新对象

// Cloneable是一个标记接口
public class User implements Cloneable {
    private int id;
    private String username;
    private String password;
    private double[] scores;

    public User() {
    }

    public User(int id, String username, String password, double[] scores) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.scores = scores;
    }
//      浅克隆
//    @Override
//    protected Object clone() throws CloneNotSupportedException {
//        return super.clone();
//    }
//       深克隆
    @Override
    protected Object clone() throws CloneNotSupportedException {
        User u2 = (User) super.clone(); // protected非子类里不能访问，重写中转
        u2.scores = u2.scores.clone();  // clone方法除String引用类型可以直接复制
        return u2;                      // 新的对象然后赋值 即完成深克隆
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public double[] getScores() {
        return scores;
    }

    public void setScores(double[] scores) {
        this.scores = scores;
    }
}

public class Test2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        User u1 = new User(1, "张三", "123456", new double[]{99.0, 100});
        User u2 = (User) u1.clone();
        System.out.println(u1.getId());
        System.out.println(u1.getUsername());
        System.out.println(u1.getPassword());
        System.out.println(u1.getScores());

        System.out.println(u2.getId());
        System.out.println(u2.getUsername());
        System.out.println(u2.getPassword());
        System.out.println(u2.getScores());
    }
}

3. Objects工具类

3.1 基本介绍

Objects是一个工具类，里面提供了很多操作对象的静态方法给我们调用。

3.2 常用方法

public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
} // Object类的equals方法如果对象是空会报错（可以理解为默认不支持空对象进行内容比较，没意义）
  // Objects类的可以支持空对象送进来比较
public static boolean isNull(Object obj) {  
    return obj == null;  
}
public static boolean nonNull(Object obj) {  
    return obj != null;  
}

 public class Test {  
    public static void main(String[] args) {  
  
        String s1 = null;  
        String s2 = "itheima";  
  
  
//        System.out.println(s1.equals(s2)); 报错 对象是空会异常  
        System.out.println(Objects.equals(s1, s2)); // 用Objects更安全  
        System.out.println(Objects.isNull(s1));  
        System.out.println(s1 == null);             // 等同于上面，只不过代码可读性更好  
        System.out.println(Objects.isNull(s2));  
        System.out.println(s2 == null);  
  
        System.out.println(Objects.nonNull(s1));  
        System.out.println(Objects.nonNull(s2));  
  
  
  
    }  
}

4. 包装类

4.1 介绍

为了满足Java万物皆对象和面向对象编程的理念，Java将基本数据类型各自包装成了一个类，使其数据可以在基本数据类型和引用类型之间进行类型转换，方便实际操作。
![[Pasted image 20231004110633.png]]

4.2 机制

        // 包装类 目的将基本数据类型包装成类使用，方便其他如泛型类等进行操作，满足万物皆对象，对象操作的思想  
//        Integer a1 = new Integer(12); 过时  
        Integer a1 = Integer.valueOf(12);  
  
        // 自动装箱拆箱机制  
        Integer a2 = 23;  // 不需要调用方法
		// 自动拆箱
        int a3 = a2;  
  
        ArrayList<Integer> list = new ArrayList<>();   // 方便进行面向对象操作
        list.add(123);  
        list.add(13);  
        int rs = list.get(0);  
        System.out.println(rs);  
  

}

4.3 常用方法

将基本数据类型的数据转成字符串形式

※ public String toString()

// 方法源码
public String toString() {  // 实例方法但是调用了类方法 可以让你重写实例方法加以
    return toString(value);  // 实现自己想要的功能
}
public static String toString(int i) {  // 类方法不能重写
    int size = stringSize(i);  
    if (COMPACT_STRINGS) {  
        byte[] buf = new byte[size];  
        getChars(i, size, buf);  
        return new String(buf, LATIN1);  
    } else {  
        byte[] buf = new byte[size * 2];  
        StringUTF16.getChars(i, size, buf);  
        return new String(buf, UTF16);  
    }  
}

        // 基本类型转字符串 toString方法  
        Integer a = 23;  
        String rs1 = a.toString();  
        System.out.println(rs1 + 1);  
  
        String rs2 = a + ""; // 效果一样更简洁 这是字符串的拼接功能的隐式类型转换 不管a是什么变量  
        System.out.println(rs2 + 1);  

output：
231
231

将字符串形式里的基本数据类型数据转成对应数据对应的基本数据类型

	int类型    public static int parseInt(String s)；
	double类型 public static double parseDouble(String s)；

※ 通用：包装类名.valueOf(变量名);


        // 字符串类型数值转基本数据类型  
        String ageIntStr = "23";  
  
//        String ageStr = "23.5";  
//        String ageStr = "23a";  都不通过，※只有符合要转的基本数据类型才可以
//        int age = Integer.parseInt(ageStr);  
        int age = Integer.valueOf(ageIntStr); // 通用方法，更好记住   
  
  
        String ageDobStr = "31.3";  
//        Double age1 = Double.parseDouble(ageDobStr);  
        Double age2 = Double.valueOf(ageDobStr); // 通用方法，更好记住

// 源码
       public static Double valueOf(String s) throws NumberFormatException {  
            return new Double(parseDouble(s));        
         } // 其实valueof里面也是调用parseDouble方法

5. 字符串拼接工具

5.1 StringBuilder

5.1.1 基本介绍

一种存储操作字符串且长度可变的类型

5.1.2 优点

StringBuilder比String更适合做字符串拼接操作，效率高，代码简洁

5.1.3 基本方法

构造方法

public StringBuilder()
public StringBuilder(String str)

实例方法

public StringBuilder append(任意类型)    // 添加数据并返回对象本身，支持链式编程
public StringBuilder reverse()          // 将对象内容反转
public int length()                     // 输出长度
public String toString();               // 将该类型数据转换成字符串类型内容

public class Test1 {  
    public static void main(String[] args) {  
//        StringBuilder s = new StringBuilder();  
        StringBuilder s = new StringBuilder("好好学习");  
        s.append(12);  
        s.append("小时");  
        s.append(true); // 可以随意添加任意类型数据  
  
        System.out.println(s); // 已经重写了toString方法，不会输出地址  
  
  
        // 支持链式编程  
        s.append(123).append("支持链式编程");  
//      public StringBuilder append(int i) {  
//        super.append(i);  
//        return this; 返回了对象所以可以链式编程  
//    }  
  
        // 反转操作  
        System.out.println(s);  
        System.out.println(s.reverse());  
  
        System.out.println(s.length());  
        String rs = s.toString(); // 将StringBuilder的对象变量（引用对象的变量）s转为字符串类型  
        System.out.println(rs);  
  
    }  
}

output：
好好学习12小时true
好好学习12小时true123支持链式编程
程编式链持支321eurt时小21习学好好
21
程编式链持支321eurt时小21习学好好

5.2 StringBuffer

5.2.1 基本介绍

类似于线程安全版的StringBuilder

5.3 StringJoiner

5.3.1 基本介绍

类似于格式化输出版的StringBuilder

5.3.2 优点

同时兼顾高效处理字符串的同时代码简洁

5.3.3 基本方法

构造方法

public StringBuilder(间隔符号)
public StringBuilder(间隔符号, 开始符号, 结束符号)

实例方法

public StringBuilder add(字符串类型)    // 添加数据并返回对象本身，支持链式编程
public int length()                     // 输出长度
public String toString();               // 将该类型数据转换成字符串类型内容

public class Test4 {
    public static void main(String[] args) {  
        int [] a = {123, 23, 55, 33};  
        System.out.println(printIntArr(a));; 
  
  
    }  
    public static String printIntArr(int [] arr){  
        if(arr == null ){  
            return null;  
        }  
        StringJoiner s = new StringJoiner(", ", "[", "]");  
        // 可以理解为Stringbuilder的格式化处理版  
  
  
        for(int i = 0; i < arr.length; i++) {  
            s.add(arr[i] + "");  
        }  
        s.add("学习").add("123");  
        return s.toString();  
  
    }  
  
}

output:
[123, 23, 55, 33, 学习, 123]

二、总结

Java为我们使用方便内置了许多API，比较常用的有Object祖宗类、Objects工具类以及方便处理基本数据类型的包装类和对字符串多次拼接处理的String Builder类和String Buffer类以及String Joiner类
其中要注意的一些点有Object类的equals方法toString方法都是需要被子类重写去操作的，目的是返回子类对象的内容和比较子类对象里面存储的数据，但是Object类的equals方法不安全，应该使用Objects的equals方法
包装类的话，它的特点有自动装箱拆箱机制，可以在切换数据类型更加方便，不需要总是调用valueof方法或者toString方法，以及隐式类型转换可以使用基本数据类型+ ""实现
String Builder是用于更快处理大量字符串拼接操作的，String Buffer则线程安全，String Joiner实现又快代码又简洁