常用API（Java）

常用API

Object

toString方法

场景：当我们使用toString方法想要输出对象变量时，官方提供的toString方法会直接输出对象所在的地址，而不是我们想要的对象变量，所以我们要把toString方法进行重写。

改写代码：

  @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }

---

调用代码：

public static void main(String[] args) {
        Student s = new Student("沙雕", '男', 23);
         String rs = s.toString();
         System.out.println(rs);

         System.out.println(s.toString());

        // 直接输出对象变量，默认可以省略toString调用不写的
        System.out.println(s);
    }

equals方法

场景：当我们想要使用equals方法比较集合中两个对象变量是否相等时，使用官方提供的equals方法比较的是两个对象的地址，结果显然为false（比较的对象不是同一个），那么我们需要将equals方法进行重写。

官方代码改写：

 /**
     定制相等规则。
     两个对象的内容一样就认为是相等的
     s1.equals(s2)
     比较者：s1 == this
     被比较者： s2 ==> o
     */
    @Override
    public boolean equals(Object o) {
        // 1、判断是否是同一个对象比较，如果是返回true。
        if (this == o) return true;
        // 2、如果o是null返回false  如果o不是学生类型返回false  ...Student !=  ..Pig
        if (o == null || this.getClass() != o.getClass()) return false;
        // 3、说明o一定是学生类型而且不为null
        Student student = (Student) o;
        return sex == student.sex && age == student.age && Objects.equals(name, student.name);
    }

自己代码改写：

  /**
       自己重写equals，自己定制相等规则。
        两个对象的内容一样就认为是相等的
     s1.equals(s2)
     比较者：s1 == this
     被比较者： s2 ==> o
     */
 /*   @Override
    public boolean equals(Object o){
        // 1、判断o是不是学生类型
        if(o instanceof Student){
            Student s2 = (Student) o;
            // 2、判断2个对象的内容是否一样。
//            if(this.name.equals(s2.name) &&
//                 this.age == s2.age && this.sex == s2.sex){
//                return true;
//            }else {
//                return false;
//            }
            return this.name.equals(s2.name) && this.age == s2.age
                    && this.sex == s2.sex ;

        }else {
            // 学生只能和学生比较，否则结果一定是false
            return false;
        }
    }*/

代码调用：

public static void main(String[] args) {
        Student s1 = new Student("沙雕", '男', 19);
        Student s2 = new Student("沙雕", '男', 19);
        // equals默认是比较2个对象的地址是否相同，子类重写后会调用子类重写的来比较内容是否相同。
        System.out.println(s1.equals(s2));
        System.out.println(s1 == s2);

        System.out.println(Objects.equals(s1, s2));
    }

Objects（JDK 1.7开始才有）

equals方法

说明：比较两个对象的变量，底层会先进行非空判断，从而可以避免空指针异常。再进行equals方法比较。，相较于Object的equals方法更加安全且结果一样。

代码：

public static boolean equals(Object a, Object b) {
                     return (a == b) || (a != null && a.equals(b));
             }

isNull方法

**说明：判断变量是否为null，为null返回true，反之false。

public static boolean equals(Object a, Object b) {
                     return (a == b) || (a != null && a.equals(b));
             }

---

StringBuilder

• StringBuilder是一个可变的字符串类，我们可以把它看成一个对象容器。
• 作用：提高字符串的操作效率，如拼接、修改等。
• String对象是不可改变的。每次使用 System.String类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。在需要对字符串执行重复修改的情况下，与创建新的 String对象相关的系统开销可能会非常昂贵。如果要修改字符串而不创建新的对象，则可以使用System.Text.StringBuilder类。例如，当在一个循环中将许多字符串连接在一起时，使用 StringBuilder类可以提升性能。

StringBuilder() 无参构造器

StringBuilder sb = new StringBuilder(); // ""
        sb.append("a");
        sb.append("b");
        sb.append("c");
        sb.append(1);
        sb.append(false);
        sb.append(3.3);
        sb.append("abc");
        System.out.println(sb);  //abc1false3.3abc

---

支持链式编程*

StringBuilder sb1 = new StringBuilder();
        // 支持链式编程
        sb1.append("a").append("b").append("c").append("我爱你中国");
        System.out.println(sb1);  //abc我爱你中国

支持反转

 // 反转
        sb1.reverse().append("110");
        System.out.println(sb1);//国中你爱我cba110

字符串长度

  System.out.println(sb1.length()); // 11

StringBuilder() 有参构造器

使用String方法拼接数组使用+会在内存中产生多个对象，所以使用StringBuilder（）方法效率比之高很多。

方法重写代码：

 /**
       1、定义方法接收任意整型数组，返回数组内容格式
     */
    public static String toString(int[] arr){
       if(arr != null){
            // 2、开始拼接内容。
           StringBuilder sb = new StringBuilder("[");
           for (int i = 0; i < arr.length; i++) {
               sb.append(arr[i] ).append(i == arr.length - 1 ? "" : ", ");
           }
           sb.append("]");
           return sb.toString();
       }else {
           return null;
       }

方法调用及结果

public static void main(String[] args) {
        int[] arr1 = null;
        System.out.println(toString(arr1));

        int[] arr2 = {10, 88, 99};
        System.out.println(toString(arr2));

        int[] arr3 = {};
        System.out.println(toString(arr3));
  //结果
      null
      [10, 88, 99]
      []
    }

Math

• 包含执行基本数字运算的方法，Math类没有提供构造器，都是静态方法。
• 直接通过类名调用。

`获取参数a的绝对值：

public static int abs(int a)

向上取整

public static double ceil(double a)

向下取整

public static double floor(double a)

获取a的b次幂

public static double pow(double a, double b)

四舍五入取整

public static long round(double a)

得到3~9之间的随机数

 //  [0 - 6] + 3
        int data =  (int)(Math.random() * 7) + 3;
        System.out.println(data);

System类

• System的功能是通用的，都是直接用类名调用即可，所以System不能被实例化。

public static void exit(int status)

说明：终止当前运行的java虚拟机，非零表示异常终止

System.exit(0); // JVM终止！ 不要用啊，用就跑路！！！（相当于删库）虚拟机干掉了QAQ

public static long currentTimeMillis()

说明：返回当前系统的时间毫秒值形式

// 2、计算机认为时间有起源：返回1970-1-1 00：00：00 走到此刻的总的毫秒值：时间毫秒值。

long time = System.currentTimeMillis();

应用：进行时间的计算：性能分析

// 2、计算机认为时间有起源：返回1970-1-1 00：00：00 走到此刻的总的毫秒值：时间毫秒值。
        long time = System.currentTimeMillis();
        System.out.println(time);

        long startTime = System.currentTimeMillis();
        // 进行时间的计算：性能分析
        for (int i = 0; i < 100000; i++) {
            System.out.println("输出：" + i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println((endTime - startTime)/1000.0 + "s");

public static void arraycopy(数组源数组，起始索引，目的地数组，起始索引，拷贝个数)

说明：数组拷贝

  // 3、做数组拷贝（了解）
        /**
         arraycopy(Object src,  int  srcPos,
         Object dest, int destPos,
         int length)
         参数一：被拷贝的数组
         参数二：从哪个索引位置开始拷贝
         参数三：复制的目标数组
         参数四：粘贴位置
         参数五：拷贝元素的个数
         */
        int[] arr1 = {10, 20, 30, 40, 50, 60, 70};
        int[] arr2 = new int[6]; // [0, 0, 0, 0, 0, 0] ==>  [0, 0, 40, 50, 60, 0]
        System.arraycopy(arr1, 3, arr2, 2, 3);
        System.out.println(Arrays.toString(arr2));

BigDecimal

• 用于解决浮点型运算精度失真的问题。

---

BigDecimal大数据类。

引入：
    浮点型运算的时候直接+  * / 可能会出现数据失真（精度问题）。
    BigDecimal可以解决浮点型运算数据失真的问题。

BigDicimal类：
    包：java.math.
    创建对象的方式（最好的方式：）
          public static BigDecimal valueOf(double val) :包装浮点数成为大数据对象。
    方法声明
          public BigDecimal add(BigDecimal value)       加法运算
          public BigDecimal subtract(BigDecimal value)  减法运算
          public BigDecimal multiply(BigDecimal value)  乘法运算
          public BigDecimal divide(BigDecimal value)    除法运算
          public double doubleValue(): 把BigDecimal转换成double类型。

代码：

public static void main(String[] args) {
        // 浮点型运算的时候直接+  * / 可能会出现数据失真（精度问题）。
        System.out.println(0.09 + 0.01);
        System.out.println(1.0 - 0.32);
        System.out.println(1.015 * 100);
        System.out.println(1.301 / 100);

        System.out.println("-------------------------");
        double a = 0.1;
        double b = 0.2;
        double c = a + b;
        System.out.println(c);
        System.out.println("--------------------------");
        // 包装浮点型数据成为大数据对象 BigDeciaml
        BigDecimal a1 = BigDecimal.valueOf(a);
        BigDecimal b1 = BigDecimal.valueOf(b);
        BigDecimal c1 = a1.add(b1);
        // BigDecimal c1 = a1.subtract(b1);
        // BigDecimal c1 = a1.multiply(b1);
        // BigDecimal c1 = a1.divide(b1);
        System.out.println(c1);

        // 目的：double
        double rs = c1.doubleValue();
        System.out.println(rs);

        // 注意事项：BigDecimal是一定要精度运算的
        BigDecimal a11 = BigDecimal.valueOf(10.0);
        BigDecimal b11 = BigDecimal.valueOf(3.0);
        /**
           参数一：除数 参数二：保留小数位数  参数三：舍入模式
         */
        BigDecimal c11 = a11.divide(b11, 2, RoundingMode.HALF_UP); // 3.3333333333
        System.out.println(c11);

        System.out.println("-------------------");
    }