Java中Object类的equals与hashCode重写解析-CSDN博客

Object

是所有类的总父类，只要是类就一定直接或间接继承自Object

常用方法

Class getClass（）：获取引用的实际对象类型
int hashCode ( ) ：获取当前对象的哈希码值
- 重写原因：该方法默认关注对象地址，地址不同则哈希码值不同.但是开发过程中某些情况下我们需要关注的是对象内容,内容一致则哈希码值必定一致,所以需要对其重写
- 重写规则
1. 整数：直接相加
2. 小数类型：强转int后相加
3. 引用类型：属性名.hashCode（）相加
  - 类库中的应用类型：该方法已经提供过重写，使用直接调用方法
  - 自定义的引用类型：先重写该类的hashCode在调用
boolean equals（Objecti o）：判断当前对象与参数对象是否相同
- 重写原因：该方法默认比较地址，但是实际开发中，在某些需求下比较对象内荣，所以需要重写
- 重写规则
  - 1. 自反性：与自己比较，一定相同
  - 1. 非空判断+类型比较：与null的值比较 ||实际对象类型不一致，一定不同
  - 1. 类型强转把参数对象类型强制转换为当前类型，方便比较1属性值
  - 1. 进行属性比较
      - 基本类型==最近比较，引用类型调动equals方法进行比较
        类库中的引用类型，直接调用
        自定义的引用类型：重写对应的equals，然后调用

public boolean equals(Object o){//Object o=new Student();
        //自反性：自己与自己比，一定相同
        if (this == o) {
            return true;
        }
        //非空判断+类型比较：与null值比或者实际对象类型不一致，一定不同
        if (o == null || this.getClass() != o.getClass()) {
            return false;
        }
        //类型强转：把参数对象类型强转为当前类型，方便比较属性值
        当前类名 引用名 = (当前类名) o;
        //进行属性值比较
    //用this对象和引用名的属性进行比较：
    	//基本类型==直接比较，引用类型调用equals方法进行比较
    		//类库中的引用类型：直接调用
    		//自定义的引用类型：重写对应类的equals，然后调用
        return ...;
    }

public class Student extends Person {
    private String name;
    private int age;
    private double score;
    private Teacher tea;

    //重写方法
    public boolean equals(Object o){//Object o=new Student();
        //自反性：自己与自己比，一定相同
        if (this == o) {
            return true;
        }
        //非空判断+类型比较：与null值比或者实际对象类型不一致，一定不同
        if (o == null || this.getClass() != o.getClass()) {
            return false;
        }
        //类型强转：把参数对象类型强转为当前类型，方便比较属性值
        Student stu = (Student) o;
        //进行属性值比较
        return this.age == stu.age && this.score == stu.score && this.name.equals(stu.name) && this.tea.equals(stu.tea);
    }
    //省略getter、setter、构造
}
public class Teacher extends Person{
    private String name;
    private int age;

    //重写方法
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || this.getClass() != o.getClass()) {
            return false;
        }
        Teacher tea = (Teacher) o;
        return this.name.equals(tea.name) && this.age == tea.age;
    }
    //省略getter、setter、构造
}

String toString: 获取对象的详细内容
- 特点：直接查看引用名时可以默认调用
- 重写原因：该方法默认获取对象地址，但是实际开发，我们可能需要查询对象属性信息，所以重写
- 重写规则：按照需求拼接字符串返回即可

public String toString(){
        return "姓名：" + name + ",年龄：" + age + ",成绩：" + score;
        //return name+age + score;
    }

void finalize（）：用于被虚拟机调用进行垃圾对象回收
- 垃圾回收机制：当内存满到不足以支撑新对象的创建时，虚拟机会进行自动调用垃圾对象的finalize方法对其进行回收销毁，从而释放空间
- 垃圾对象的判断标准：没有任何引用指向的对象（零引用机制）
- 手动垃圾回收：借助垃圾回收器（GC），通过System.gc（）实现手动垃圾回收

保装类

作用将八大基本类型包装为引用类型，使其保留数值操作简单的基础之上可以处理null值

byte	short	int	long	float	double	char	boolean
Byte	Short	Integer	Long	Float	Double	Character	Boolean

包装类型和基本类型

基转包

利用构造

保证类名 引用名=new 包装类名（基本类型）;

利用valueOf方法

包装类名 引用名=包装类名.valueOf(基本类型);

包转基

利用xxxValue 方法

基本类型 变量名= 包装类对象.xxxValue();
注：xxx表示对应基本类型名

拆箱封箱

JDK5.0之后，为了提高包装类型与基本类型之间转换的效率，提供了自动封箱和自动拆箱操作，使其可以直接相互赋值自动完成转换

封箱：基转包
拆箱：包转基

		int n1=10;
        //转为包装类型
        Integer i1 = new Integer(n1);
        Integer i2 = Integer.valueOf(n1);
        //将i1转为基本类型
        int n2 = i1.intValue();

        //自动封箱和拆箱
        int n3=20;
        Integer i3 = n3;
        int n4 = i3;

基本类型与String

基转String

1.拼接双引导

String 引用名=基本类型+"";
String 引用名=""+基本类型;

String转基

利用parse

基本类型 变量名=对应包装类型.parseXxx(String 类型);
注：Xxx对应基本类型，首字母大写

String类型转向其他类型时，字符串数据必须为对方能够接收的数据，否则会报出数据类型转换异常

	int n1=10;
        //转为String
        String s1 = n1 + "";
        String s2 = "" + n1;
        String s3 = String.valueOf(n1);
        //转为基本类型
        int n2 = Integer.parseInt(s1);
        System.out.println(n2);
        String str = "abc";
       // int n3 = Integer.parseInt(str);  NumberFormatException数据类型转换异常

包装类型与String

包转String

拼接双引号

   String 引用名=包装类型+"";
   String 引用名=""+包装类型;

利用toString

String 引用名=包装类对象.toString();


#### String 转包

- 与基转包的两种方式一致

~~~java
  	Integer i1=10;
      //转为String
      String s1 = i1 + "";
      String s2 = "" + i1;
      String s3 = i1.toString();
      //转包
      Integer i2 = new Integer(s1);
      Integer i3 = Integer.valueOf(s1);

      String str = "abc";
     // Integer i4 = new Integer(str); 数据类型转换异常

整数缓冲区

官方认定，-128至127是最常用的256个数字，为了避免包装类型数字重复使用带来的内存压力，在方法区中设立了整数缓冲区，缓冲区中存放该256个数字，当包装类型使用的数字在此范围内时，会直接引用缓冲区地址

==比较引用类型时，堆地址优先

 		Integer i1 = 200;//封箱
        Integer i2 = 200;
        System.out.println(i1 == i2);//f
        Integer i3 = 100;
        Integer i4 = 100;
        System.out.println(i3 == i4);//t

        Integer i5 = new Integer(100);
        Integer i6 = new Integer(100);
        System.out.println(i5 == i6);//f

        Integer i7 = new Integer(100);//堆地址(对象地址)-->缓冲区地址
        Integer i8 = 100;//缓冲区地址
        System.out.println(i7 == i8);//f

String

是内存中的常量，值在内存中一旦创建，不可改

		String s1 = "abc";
        String s2 = s1;

        System.out.println("s1:" + s1);//abc
        System.out.println("s2:" + s2);//abc
        System.out.println(s1 == s2);//t

        s2 = "edf";
        System.out.println("s1:" + s1);//abc
        System.out.println("s2:" + s2);//edf
        System.out.println(s1 == s2);//f

创建方式

直接双引号赋值

String 引用名 =“值”;

构造赋值

String 引用名= new String（“值”）;

串池：全程字符串常量池。实例开发中，字符串是使用评率最高的数据模型，且复用度也最高，为了避免重复的字符串内容反复开辟空间造成的空间资源浪费，所以在方法区中设立了串池，目的为了节省空间。

区别

第一种创建方式：优先使用串池，先从串池中查找有无对应字符串内容，有，让引用直接指向对应串池地址，无，则先在串池中创建该字符串内容，然后再让引用指向
第二种创建方式：无论如何都会开辟对象空间地址。开辟完对象空间之后，进入串池查找内容是否存在，存在，则直接存放对应串池地址，不存在，则先在串池中创建该内容，然后再存放串池地址