JAVA—常用API-优快云博客

1.认识API

11.LocalData、LocalTime、LocalDataTime

12.Zonedld、ZonedDateTime

1.认识API

2.Object

import java.util.Objects;

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

    public Student() {
    }

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

    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 double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    /**
     *比较者：t1 ==> this
     * 被比较者：t2 ==> o
     *
     */


    @Override
    public boolean equals(Object o) {
        //1.判断两个对象是否是同一个对象在比较，如果是，直接返回true
        if (this == o) return true;
        //2.判断o如果是null，直接返回false，或者两个对象的类型不一样，直接返回false
        if (o == null || this.getClass() != o.getClass()) return false;
        //3.两个对象肯定都是学生类型，且是不同对象，开始比较内容了！
        Student student = (Student) o;
        return this.age == student.age && Double.compare(this.score, student.score) == 0 &&
                Objects.equals(this.name, student.name);
    }


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

package com.itheima.d11_object;

public class Test {
    public static void main(String[] args) {
        //目标：掌握Object的常用方法
        Student s1 = new Student("小昭",21,100);
        //1.toString默认返回对象的所谓的地址形式其实是没有意义的，开发中输出对象对象更想看内容，因此toString是为了让子类重写
        //System.out.println(s1.toString());//直接输出对象时，toString可以不写
        System.out.println(s1);

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

        //2.equals方法默认是比较两个对象的地址是否一样
        //比较两个对象的地址是否一样可以直接用"=="比较，完全没必要用equals比较
        //因此Object提供的equals的意义是为了让子类重写，以便自己制定比较规则（按照内容比较！）
        Student t1 = new Student("殷素素",35,98);
        Student t2 = new Student("殷素素",35,98);
        System.out.println(t1.equals(t2));//true
        System.out.println(t1 == t2);//false


    }
}

3.Objects类

java中带s的一般都是工具类

import java.util.Objects;

public class Test {
    public static void main(String[] args) {
        //目标：掌握Objects的常用方法
        Student t1 = null;
        Student t2 = new Student("蜘蛛精",300,85.5);
        //System.out.println(t1.equals(t2));//如果主调对象是null，直接爆出空指针异常

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

        //更安全，更可靠，,会进行非空校验，推荐使用
        //今后比较两个对象时，建议用Objects的equals来判断
        System.out.println(Objects.equals(t1,t2));

        System.out.println(Objects.isNull(t1));//true
        System.out.println(t1 == null);//true

        System.out.println(Objects.nonNull(t1));//false
        System.out.println(t1 != null);//false
    }
}

4.包装类

万物皆对象，java中的对象是在堆内存中储存的，而八种基本数据类型是在栈内存中储存的。

在 Java 中，Integer自动装箱机制是指将基本数据类型int自动转换为其对应的包装类Integer对象的过程。这个特性使得 Java 可以在基本类型和对象之间无缝切换，提高了代码的简洁性和可读性。

自动装箱的工作原理：当你将一个int值赋给Integer对象时，Java 编译器会自动调用Integer.valueOf(int)方法。

Integer a = 100; // 自动装箱，等价于 Integer a = Integer.valueOf(100);

缓存机制的细节：

Java 为了优化性能，对Integer类做了特殊处理：

缓存范围：在 - 128 到 127 之间的Integer对象会被缓存。
内存优化：当使用valueOf()创建这个范围内的对象时，会复用缓存中的实例，而不是每次都创建新对象。
超出范围：对于范围外的值（如 128 或 - 129），每次都会创建新的Integer对象。

以下代码展示了缓存机制的效果：

public class IntegerCacheDemo {
    public static void main(String[] args) {
        // 范围内的比较
        Integer a = 100;
        Integer b = 100;
        System.out.println(a == b); // 输出true，因为指向同一个缓存对象

        // 超出范围的比较
        Integer c = 128;
        Integer d = 128;
        System.out.println(c == d); // 输出false，因为是不同的对象

        // 使用new关键字总是创建新对象
        Integer e = new Integer(100);
        Integer f = new Integer(100);
        System.out.println(e == f); // 输出false，因为是不同的对象
    }
}

package com.itheima.d13_integer;

public class Test {
    public static void main(String[] args) {
        //目标:认识包装类，搞清楚包装类的作用
        int a = 12;

        //1.把基本类型通过包装类包装成对象。
        //Integer it1 = new Integer(a);//已过时
        Integer it1 = Integer.valueOf(a);//手动包装
        System.out.println(it1);

        //2.自动装箱机制，基本类型的数据可以直接变成对象赋值给包装类。
        Integer it2 = 12;
        Integer it3 = 12;
        System.out.println(it2 == it3);//true
        //-128~127会在内存中缓存为同一个对象，超过127后才会new新的对象

        //3.自动拆箱机制，包装类的对象可以直接赋值给基本数据类型
        int it4 = it3;
        System.out.println(it4);

        System.out.println("-------java为包装类提供了新功能----------");
        //1.功能一：包装类可以把基本类型的数据转换为字符串
        int a1 = 23;
        String rs = Integer.toString(a1);
        System.out.println(rs + 1);//231

        Integer i = a1;
        String rs2 = i.toString();//"23"
        System.out.println(rs2 + 1);//231

        int a2 = 23;
        String rs3 = a2 + "";//这样更简单
        System.out.println(rs3 + 1);

        //2.功能二：把字符串数据转换成对应的基本数据类型（很有用！！！）
        String ageStr = "23";
        //int age = Integer.parseInt(ageStr);
        int age = Integer.valueOf(ageStr);
        System.out.println(age + 1);//24

        String scoreStr = "99.5";
        //double score = Double.parseDouble(scoreStr);
        double score = Double.valueOf(scoreStr);
        System.out.println(score + 0.5);//100.0

        //3.由于泛型和集合都不支持基本数据类型，因为万物皆对象，因此包装类在集合和泛型中大量使用而且是必须使用的
    }
}

由于泛型和集合都不支持基本数据类型，因为万物皆对象，因此包装类在集合和泛型中大量使用而且是必须使用的（简单操作用基本类型，集合泛型用包装类）