Java中常用的API(第一篇)

Object类

Object类是所有类的祖宗类，它们都会直接或者间接继承Object类，所以类都能使用Object类中的方法
toString():输出对象的地址值，目的是让子类重写此方法输出对象的具体内容
equals()对比两个对象的地址值是否相等，相等返回true，反之。目的是让子类重写此方法对比两个对象的具体内容是否一样
clone():使用这个方法要让复制的类实现Cloneable接口并重写clone()方法

浅拷贝：创建一个新对象，里面存放跟目标对象一模一样的数据。对象中的基本数据类型复制值，引用数据类型复制地址。
深拷贝：创建一个新对象，里面存放跟目标对象一模一样的数据。对象中的基本数据类型复制值，String类型复制地址值，其它引用类型先创建一个新对象，再把里面的数据拷贝进去

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        //toString() 输出对象地址
        Student s1 = new Student();
        Student s2 = new Student();
        System.out.println(s1);

        //equals() 对比两个对象的地址是否相等
        boolean equals = s1.equals(s2);
        System.out.println(equals);

        //clone()
        //浅克隆
        Object clone = s1.clone();
        System.out.println(s1);
    }
}

//深克隆的重写方法
protected Object clone() throws CloneNotSupportedException {
        //先克隆得到一个新对象
        User u = (User) super.clone();
        //再将新对象中的引用类型数据，再次克隆
        u.scores = u.scores.clone();
        return u;
    }

Objects工具类

Objects类是一个工具类，里面有很多操作类的静态方法

equals():判断类的地址是否一样。那为什么不用Object类的equals()方法？因为两者的调用方式不一样，Objects工具类的是Objects.equals(a,b)，而Object类则是a.equals(b)，如果a为空对象，即a的值为nullObject类的equals()方法就会报空指针异常的错误，而Objects的工具类则不会，相对安全

isNull():判断对象是否为null，是就返回true，反之

nonNull:判断对象是否不为null，是就返回true，反之

public class Test {
    public static void main(String[] args) {
        //equals(a,b) 
        String s1 = "qwq";
        String s2 = "awt";
        System.out.println(Objects.equals(s1, s2));
        // isNull()
        System.out.println(Objects.isNull(s1));
        //nonNull()
        System.out.println(Objects.nonNull(s2));
    }
}

StringBuilder类

StringBuilder类是专门操作字符串的类

创建StringBuilder对象：StringBuilder 对象名 = new StringBuilder(字符字面量);

向一个StringBuilder对象中拼接字符串：对象.append(数据);

把对象中的字符串反转：对象.reverse();

返回对象中字符串的长度：对象.length();

把StringBuilder对象转成字符串对象：对象.toString();

为什么要用StringBuilder对字符串进行操作呢？因为和String比较，字符串拼接StringBuilder比String的拼接速度快得多

StringBuilder和StringBuffer类的区别？

两者本质上没有区别，都是针对字符串的操作，里面的方法一模一样，但是两者的线程安全性不一样。StringBuilder的线程不安全，但拼接速度非常快；StringBuffer的线程安全，但相对于StringBuilder来说拼接速度没这么快

public class StringBuilder {
    public static void main(String[] args) {
        //创建对象
        StringBuffer buffer = new StringBuffer("hello");

        //拼接字符(可以是任何类型的字面量)
        buffer.append(" Java");

        //字符串反转
        buffer.reverse();

        //获取字符串长度
        int len = buffer.length();
        System.out.println(len);

        //把StringBuilder对象转为String对象
        String s = buffer.toString();
        System.out.println(s);
    }
}

StringJoiner类

专门用来拼接字符串的类，被成为字符串的拼接神器

创建对象1：StringJoiner 对象名 = new StringJoiner(分隔符);

创建对象2：StringJoiner 对象名 = new StringJoiner(分隔符,开头符号,结束符号);

拼接数据：add(字符串)

把StringJoiner对象转换成String对象：toString()

public class Test {
    public static void main(String[] args) {
        //创建对象方式一
        StringJoiner s1 = new StringJoiner(",");
        //创建对象方式二
        StringJoiner s2 = new StringJoiner(",","[","]");
        //添加字符
        s2.add("Java");
        s2.add("MySQL");
        s2.add("Python");
        //把StringJoiner对象转换成String对象
        String s = s2.toString();
        System.out.println(s);
    }
}

Math工具类

abs():取绝对值

ceil():向上取整

floor():向下取整

round():四舍五入(针对小数点第一位)

max():两者取最大值

min():两者取最小值

pow():取次方

random()：随机取[0,1)之间的十六位小数

public class Test {
    public static void main(String[] args) {
        //取绝对值
        System.out.println(Math.abs(-12));//12
        //向上取整
        System.out.println(Math.ceil(12.5));//13
        //向下取整
        System.out.println(Math.floor(12.7));//12
        //四舍五入
        System.out.println(Math.round(11.27));//11
        //取两者最大值
        System.out.println(Math.max(10,20));//20
        //取两者最小值
        System.out.println(Math.min(1,10));//1
        //取次方
        System.out.println(Math.pow(2,10));//1024
        //随机取[0,1)之间的两位小数
        System.out.println(Math.random());
    }
}

System类

exit()：人为终止虚拟机，不建议使用

currentTimeMillis():获取从1970-1-1 0:0:0开始走到此刻的总的毫秒值

public class Test {
    public static void main(String[] args) {
        //获取当前毫秒值
        long l = System.currentTimeMillis();
        
        //人为终止虚拟机
        System.exit(0);
    }
}

Runtime类

Runtime类可以获取JVM上的一些信息，也可以用这个类执行其它程序

getRuntime()：返回当前与Java应用程序关联的运行时对象

exit(0)：非0状态标识异常终止程序

availableProcessors()：获取虚拟机可以使用的处理器数

totalMemory()：获取Java虚拟机的内存总量

freeMemory()：获取Java虚拟机的可用内存量

public class Test {
    public static void main(String[] args) {
        //创建对象
        Runtime r = Runtime.getRuntime();

        //获取虚拟机可以使用的处理器数
        int number = r.availableProcessors();

        //获取Java虚拟机的内存总量
        long total = r.totalMemory();

        //获取Java虚拟机的可用内存量
        long free = r.freeMemory();

        //非0状态标识异常终止程序
        r.exit(0);
    }
}

BigDecimal类

BigDecimal类是Java为了解决小数计算精度缺失所设计的类，使用BigDecimal类时一定要创建此类的对象来运算
valueOf(double val)：传入一个double类型的数据，创建对象

BigDecimal(String val)：构造方法

add()：两个对象相加

subtract()：两个对象相减

multiply()：两个对象相乘

divide()：两个对象相除

BigDecimal 对象 = 对象1.divide(对象2, 保留位数, 取舍模式); 取舍模式是RoundingMode.xxx

public class Test {
    public static void main(String[] args) {
        //创建对象
        BigDecimal s1 = BigDecimal.valueOf(0.5);
        BigDecimal s2 = new BigDecimal("1.2");

        //相加
        BigDecimal add = s1.add(s2);

        //相减
        BigDecimal subtract = s1.subtract(s2);

        //相乘
        BigDecimal multiply = s1.multiply(s2);

        //相乘
        BigDecimal divide = s1.divide(s2, 2, RoundingMode.HALF_UP);
    }
}