Java复习笔记进阶06：常用API

最新推荐文章于 2024-08-13 20:14:34 发布

踏上旅途的风

最新推荐文章于 2024-08-13 20:14:34 发布

阅读量135

点赞数

分类专栏： java基础笔记文章标签： java

本文链接：https://blog.csdn.net/wind0223/article/details/126475221

版权

java基础笔记专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1. Object类

1.1 Object类作用：

Object类是java中祖宗类，要么默认继承，要么间接继承；
Object类的方法一切子类都可直接用

1.2 Object类的常用方法

1.2.1 toString()

方法名	说明
public String toString()	默认返回当前对象在堆内存中的地址信息：类的全限名@内存地址
toString()存在意义：	父类toString()方法存在意义为了被子类重写，方便返回对象内容信息，而不是地址信息

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

    public static void main(String[] args) {
        Student student = new Student("zyf", "nan", 18);
        System.out.println(student);//默认使用toString
        System.out.println(student.toString());
    }

1.2.2 equals()

方法名	说明
public Boolean equals(Object o)	默认比较两个对象地址是否相同，相同返回true
意义	子类重写，定制规则

    /** 官方：
     * 同一对象 返回true
     * 如果o为null或者类型不同 返回false
     * @param o
     * @return
     */
    @Override
    public boolean equals(Object o) {
        //1.同一对象 返回true
        if (this == o) return true;
        //2.如果o为null或者类型不同 返回false
        if (o == null || getClass() != o.getClass()) return false;
        //3.强转后比较值
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name) &&
                Objects.equals(sex, student.sex);
    }

==================自制======================
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Student){
            //强转比较
            Student s2 = (Student) obj;
            //字符串的equals是重写过的，比较值
            return this.name.equals(s2.name)
                    && this.sex.equals(s2.sex)
                    && this.age==s2.age ;
        }else {
            //不是学生类，不比较
            return false;
        }
    }

2. Objects类

2.1 Objects类概述

方法名	说明
public static boolean equals(Object a,Object b)	比较两个对象,底层会先进行非空判断，避免空指针异常，再equals比较

Objects类和Object是继承关系，JDK7后出现
官方进行字符串比较时，没有用Object的equals，而是用Objects类的equals方法来比较两个对象；
- Objects类的方法比较结果一样，但更安全；
  - 安全，进行了非空校验；

 		String a = null;
        String b = new String("a");
        //报错
        System.out.println(a.equals(b));
        System.out.println(Objects.equals(a,b));

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

2.2 isNull

方法名	说明
public static boolean isNull(Object obj)	判断变量是否为Null，为null返回true

3. StringBuilder

3.1概述

StringBuilder是一个可变字符串类，可以看为一个对象容器
作用：提高字符操作效率，如：拼接，修改

3.1.1 String类拼接字符串原理

3.1.2 StringBuilder提高效率原理

3.1.3 总结

String拼接需要通过StringBuilder对象；
- 每次拼接创建一个StringBuilder对象；创建一个String对象；
StringBuilder拼接只需一个StringBuilder对象

/**
 * StringBuilder常用API
 */
public class StringBuilderDemo1 {
    public static void main(String[] args) {
        StringBuilder a = new StringBuilder();
        a.append('a');
        a.append(9.9);
        System.out.println(a);

        StringBuilder b = new StringBuilder();
        //支持链式编程，
        b.append('a').append("bcd").append(9).append(2.5);
        System.out.println(b);//abcd92.5

        //reverse()先翻转已有的
        b.reverse().append(110);
        System.out.println(b);//5.29dcba110

        b.length();//取长度

        /**
         * StringBuilder:只是拼接字符串的手段
         * 最终目的恢复成String
         */
        String rs = b.toString();
    }
    
    
/**
 * 拼接输出数组
 */
public class StringBuilderDemo2 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        System.out.println(toString(arr));
        int[] arr2 = {};
        System.out.println(toString(arr2));

    }
    
    public static String toString(int[] arr) {
        if (arr != null){
            StringBuilder data = new StringBuilder("[");
            for (int i = 0; i < arr.length; i++) {
                data.append(arr[i]).append(i == arr.length-1 ?"": ",");
            }
            //"]"写在上面，arr=0，出问题
            data.append("]");
            String rs = data.toString();
            return rs;
        }else {
            return null;
        }

    }
}

4.Math类

执行基本数字运算的方法，没有提供公开的构造器，不可new；
工具类直接调用方法；

/**
 * Math类
 */
public class MathDemo {
    public static void main(String[] args) {
        //1.取绝对值
        System.out.println(Math.abs(10.6));
        System.out.println(Math.abs(-10.6));
        //2.向上取整
        System.out.println(Math.ceil(4.0001));//5.0
        //3.向下取整
        System.out.println(Math.floor(4.999));//4.0
        //4.求指数次方
        System.out.println(Math.pow(2,3));//2^3=8.0
        //5.四舍五入
        System.out.println(Math.round(4.4999));//4
        System.out.println(Math.round(4.5001));//5

        System.out.println(Math.random());//【0.0，1.0）之间 包前不包后  0.9855462
        //3-9间随机数  [0-7)+3  取整
        int data = (int) (Math.random()*7 +3);

    }
}

5.System类

系统类，直接调用；

/**
 * System类
 */
public class SystemDemo {
    public static void main(String[] args) {
        System.out.println("start!!!");
        //JVM终止
        //System.exit(0);

        //计算机时间起源为1970-1-1 00:00:00
        long time = System.currentTimeMillis();
        
		//计算时间差
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("循环运行时间："+(startTime-endTime)/1000.0+"s");


        /**
         * 数组拷贝
         * arraycopy(Object src(被拷贝数组),  int  srcPos（拷贝开始索引）,
         *          Object dest（目标数组）, int destPos（数组开始粘贴位置）,
         *          int length（拷贝元素个数）);
         */
        int[] arr1 = {10,20,30,40,50,60};
        int[] arr2 = new int[6];//[0,0,0,....]-->[0,0,40,50,60,0]
        System.arraycopy(arr1,3,arr2,2,3);
        System.out.println(Arrays.toString(arr2));

    }
}

6.BigDecimal类

用于解决浮点型运算精度失真问题；
创建BigDecimal对象封装浮点型数据，进行运算；

/**
 * BigDecimal类
 * 创建该对象一定要调用BigDecimal.valueOf(a);
 * 不能之间new
 */
public class BigDecimalDemo {
    public static void main(String[] args) {
        //浮点型之间运算会数据失真
        System.out.println(0.09 + 0.01);//0.09999999999999999
        System.out.println(1.0 - 0.32);//0.6799999999999999
        System.out.println(1.015 * 100);//101.49999999999999
        System.out.println(1.301 / 100);//0.013009999999999999

        System.out.println("====================");
        double a = 0.1;
        double b = 0.2;
        double c = a+b;
        System.out.println(c);//0.30000000000000004
        
        System.out.println("=========================");
        BigDecimal a1 = BigDecimal.valueOf(a);
        BigDecimal b1 = BigDecimal.valueOf(b);
        BigDecimal c1 = a1.add(b1);
        System.out.println(c1);// + 0.3

        BigDecimal c2 = a1.subtract(b1);
        System.out.println(c2);//-  -0.1

        BigDecimal c3 = a1.multiply(b1);
        System.out.println(c3);//*   0.02

        BigDecimal c4 = a1.divide(b1);
        System.out.println(c4);// /  0.5

        //目的：生成double
        double rs = c1.doubleValue();

        //注意：BigDecimal一定要精确运算有结果，不然报错
        BigDecimal a11 = BigDecimal.valueOf(10.0);
        BigDecimal b11 = BigDecimal.valueOf(3.0);
        //3.3333....除不开；报错;
        //处理，保留两位小数；BigDecimal.ROUND_HALF_UP四舍五入
        BigDecimal c11 = a11.divide(b11,2,BigDecimal.ROUND_HALF_UP);
    }
}