学习笔记073——Java中的【Object】和【包装类】

1、Object 类

1.1、什么是 Object 类

Java 通过类来构建代码的结构，类分为两种：

1、Java 提供的工具类，不需要开发者自定义的类，可以直接调用。

2、开发者自定义的类。

Java 程序 = JDK 类库+开发者自定义类+第三方框架

Object 就是 JDK 提供的一个类，并且它很特殊，它是所有类的根节点，Java 中的所有类

包括 JDK 提供，以及开发者自定义的，第三方框架的所有内容都属于 Object 的派生类。

hashCode：每一个 Java 对象都有自己的 hashCode，什么是 hashCode

在 JVM 内存中将对象存入到一个哈希列表中，返回一个数字类型的映射值，就是该对象的 hashCode。

hashCode 的作用是帮助程序判断两个对象是否相等，比较简单，直接比较两个对象的 hashCode 是否相等，

1、如果两个对象的 hashCode 不相等，则两个对象一定不是同一个对象。

2、但是如果两个对象的 hashCode 相等，可能是同一个对象，也可能不是同一个对象。

hashCode–>> 利用散列算法将对象的内存地址+内部信息融合到一起。

除了 hashCode 之外，Object 还提供了一个 equals 方法，也是用来判断两个对象是否相等的。

【面试题】

hashCode 和 equals 的区别是什么？如何使用？

在不重写的情况下，equals 底层就是 = =（双等）, 对象的比较，比较的就是 对象内存地址，
如果比较的是具体数字，equals比较的就是数值。（总之，不管的对象还是数字，都是把栈里面的值拿出来双等对比）
如果重写了，就另当别论。

hashCode 是返回对象的哈希值。

Set 集合的特点，就是不能存入重复的数据。

Set 判断对象是否相等的时候，将 hashCode 和 equals 结合起来使用的。

1、先用 hashCode 判断两个对象是否相等，如果 hashCode 不相等，则这两个对象肯定不是同一个对象，直接得到结论。

2、如果 hashCode 相等，此时还不能断定两个对象相等，这个就需要再使用 equals 来判断了。

1.2、可能被重写的常用方法

toString：默认返回的是类的信息+hashCode，实际开发中更希望看到的是对象的属性值。

原生的 toString 方法：

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

重写根据类的信息由 IDEA 自动生成一个方法，将属性拼接起来展示。

hashCode：

特殊业务的中，可能需要重写，比如 Student ，根据学生编号来决定它的 hashCode

package com.htl.test;

import java.util.Objects;

public class Student {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public int hashCode() {
        return 10*id;
    }
}

equals：

String 类中的重写，JDK 自己完成的重写

// 默认情况下
String str1 = new String("Hello");
String str2 = new String("Hello");
System.out.println(str1 == str2);		// false
System.out.println(str1.equals(str2));	// true
// 因为默认情况下，每new一个String对象，虽然值一样，但是内存地址却不一样。而==比较的就是内存地址，所以是false。
// 为什么 str1.equals(str2)的结果是true？
// 因为String类对 equals方法重写了。（这时比较的是字符串内容）

// String类中的 equals方法源代码。
public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String aString = (String)anObject;
        if (!COMPACT_STRINGS || this.coder == aString.coder) {
            return StringLatin1.equals(value, aString.value);
        }
    }
    return false;
}

// 上面代码中，StringLatin1.equals()方法
public static boolean equals(byte[] value, byte[] other) {
    if (value.length == other.length) {
        for (int i = 0; i < value.length; i++) {
            if (value[i] != other[i]) {
                return false;
            }
        }
        return true;
    }
    return false;
}

自定义 User 类重写 equals 方法

package com.htl.test;

public class User {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if(this == o) return true;
        if(o instanceof User){
            User user = (User) o;
            if(this.id == user.id){
                return true;
            }
        }
        return false;
    }

}

2、包装类

2.1、什么是包装类？

把基本数据类型封装成对象，所用到的类就是包装类。

为什么要将基本数据类型封装成对象？

基本数据类型不能赋 null

数据库中会存储业务数据，保不齐字段会有 null 值。

需要将数据库中的数据读出来，映射成一个对象，根据数据表生成一个对应的类用来存储数据。

null 和 “”

null 压根没有对象

“” 有对象，但是值为空

一共有 8 种包装类

Byte(byte)、Short(short)、Integer(int)、Long(long)

Float(float)、Double(double)、Character(char)、Boolean(boolean)

都是存放于 java.lang 包中，体系结构。

2.2、装箱和拆箱

装箱是指将基本数据类型转为对应的包装类

拆箱是指将包装类类型转为对应的基本数据类型

装箱的方法

1、使用构造器

Integer integer1 = new Integer(1);

不推荐使用，以后尽量别用

2、构造器，参数为 String 类型

Integer integer1 = new Integer("100");

3、valueOf 方法

package com.htl.test;

public class Test2 {
    public static void main(String[] args) {
        Integer integer1 = Integer.valueOf(100);
        Byte byte1 = Byte.valueOf((byte)1);
        Short short1 = Short.valueOf((short)1);
        Long long1 = Long.valueOf(1);
        Double double1 = Double.valueOf(10.5);
        Float float1 = Float.valueOf((float) 10.6);
        Character character1 = Character.valueOf('a');
        Boolean boolean1 = Boolean.valueOf("hello");
        System.out.println(boolean1);
    }
}

Boolean 的 String 参数方法，如果传入的是 “true” 则结果为 true，否则都为 false。

拆箱方法

1、*Value()

每个保证类都有一个 *Value() 方法， * 就是对应的基本数据类型

Integer integer1 = Integer.valueOf(100);
int i = integer1.intValue();

2、static parse*(String value)

每个包装类都有一个将 String 转为基本数据类型的方法，除了 Character。

int i = Integer.parseInt("1900");
System.out.println(i);
boolean flag = Boolean.parseBoolean("abc");
System.out.println(flag);

实际开发中，使用较多的方法是 parse* 方法，装箱方法用的很少。