JAVA基础：常用API

一.常用类API-Object,Object

String 类

1.在对象中，输出地址

Student.java

package Test;

public class Student {//extends Object        默认继承Object
    private String name;
    private char sex;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

Test.java

package Test;

public class Test {
    public static void main(String[] args) {
//        toString存在的意义:
//        就是为了被子类重写，以便返回对象的内容信息，而不是地址信息！！

        Student s=new Student("周雄",'男',19);
//        String rs=s.toString();
//        System.out.println(rs);

//        System.out.println(s.toString());//输出的是地址

        //直接输出对象变量,默认可以省略toString()调用不写的
        System.out.println(s);//输出：Student {name=周雄,sex=男,age=19}

    }
}

2.在String中,直接输出内容

package Test;

public class Test2 {
    public static void main(String args[]) {
        String Str = new String("WWW.RUNOOB.COM");

        System.out.print("返回值 :" );
        System.out.println( Str.toString() );

        String a=Str.toString();
        System.out.println(a);
    }
}

equals()

Student.java

/**
     * 自己重写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;
            }
        }else {
//            学生只能和学生比较，否则结果一定是false
            return false;
        }
    }

Test.java

package Test;

import java.security.spec.RSAOtherPrimeInfo;

public class Test {
    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);
       }
}

解读官方的equals

/**
     * 定制相等规则
     * 两个对象的内容一样就认为是相等的
     * s1.equals(s2)
     * 比较者：s1==this
     * 被比较者：s2==>o
     */
    @Override
    public boolean equals(Object o) {//这里可以是任意对象，特变灵活
        //这里的this代表s1
        if (this == o) return true;
//        o为null   o不是学生类型  返回false
        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);
    }

Object的Objects类的equals

package Test;
import java.util.Objects;

public class Test {
    public static void main(String[] args) {
        Student s1=new Student("周雄",'男',19);
        Student s2=new Student("周雄",'男',19);

//        equals默认是比较2个对象的地址是否相同，和==相同
        System.out.println(Objects.equals(s1, s2));
        
//      public static boolean equals(Object a, Object b) {
    //        return (a == b) || (a != null && a.equals(b));
    //    }
       }
}

二.StringBuilder

StringBuilder高效的原因

StringBuffer的使用

package Test;
import java.util.Objects;
//目标：学会使用StringBuffer操作字符串，最终还需要知道它性能好的原因：
public class Test {
    public static void main(String[] args) {
//    append的源码:
//    @Override
//    public synchronized StringBuffer append(String str) {
//        toStringCache = null;
//        super.append(str);
//        return this;//this就是指对象的实例
//    }
          StringBuffer sb=new StringBuffer();
          sb.append("a");
          sb.append("b");
          sb.append("c");
          sb.append("lp[d");
          System.out.println(sb);

          StringBuffer sb1=new StringBuffer();
//          支持链式编程
        sb1.append("a").append("b").append("c").append("123456");

//        反转
        sb1.reverse().append("110");
        System.out.println(sb1);

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

//        注意：StringBuffer只是拼接字符串的手段：效率好
//        最终的目的是还要恢复成String类型
        StringBuffer sb2=new StringBuffer();
        sb2.append("123").append("456");
//        恢复成String类型
        String rs=sb2.toString();
        check(rs);
    }

    private static void check(String rs) {
        System.out.println(rs);
    }
}

案例

package Test;


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

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

        int[] arr3= {};
        System.out.println(toString(arr1));
    }

//    1.定义方法接受任意整形数组，返回数组内容格式
    public static String toString(int[] arr){
        if (arr!=null){
//            2.开始拼接内容
            StringBuffer sb=new StringBuffer("[");
            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;
        }
    }


}

三.Math类

四.System类

package Test;

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        System.out.println("程序开始.....");
//        System.exit(0);//JVM终止

//        2.计算机认为时间有起源：返回1970-1-1 00：00：00 走到此刻的总的毫秒数：时间毫秒数
        long time = System.currentTimeMillis();
        System.out.println(time);
        long startTime= System.currentTimeMillis();
//        进行时间的计算：性能分析
        for (int i=0;i<100;i++){
            System.out.println("输出："+i);
        }
        long endTime=System.currentTimeMillis();
        System.out.println((endTime-startTime)/1000.0+"s");

//        3.左数组拷贝(了解)
//        arraycopy(Object src,  int  srcPos,
//        Object dest, int destPos,
//        int length);
//        参数一：被拷贝的数组
//        参数二：从哪个索引位置开始拷贝
//        参数三：赋值的目标数组
//        参数四：粘贴位置
//        参数五：拷贝元素的个数
        int[] arr1={12,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));

        System.out.println("程序结束....");

    }
}

输出结果

0.014s
[0, 0, 40, 50, 60, 0]
程序结束....

五.BigDecimal类:

package Test;


import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Arrays;

public class Test {
    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("---------------------------------");
//        包装浮点型数据成为大数据对象BigDecimal
        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.333333333333
        System.out.println(c11);

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

    }
}

valueOf的源码

public static BigDecimal valueOf(double val) {
            // Reminder: a zero double returns '0.0', so we cannot fastpath
            // to use the constant ZERO.  This might be important enough to
            // justify a factory approach, a cache, or a few private
            // constants, later.
            return new BigDecimal(Double.toString(val));
        }