==运算符、equals，toString，hashCode，finalize方法

一、==运算符

1. ==是一个比较运算符：
   • 1. ==：既可以判断基本数据类型，又可以判断引用类型
   • 2. ==：如果判断基本数据类型，判断值是否相等。
   • 3. ==：如果判断引用类型，判断的是地址是否相等，即判定的是不是同一个对象。

public class equals_ {
    public static void main(String[] args) {
        int num1=10;
        double num2=10.0;
        System.out.println(num1==num2);//true
        A a = new A();
        A b=a;
        A c=a;
        System.out.println(a==c);//true
        System.out.println(b==c);//true
        B bObj=a;
        System.out.println(bObj==a);//true
    }
}

class B{

}
class A extends B{

}

二、 equals方法

1. equals方法是object类中的方法，只能判断引用类型。
2. 默认判断的是地址是否相等，但是子类往往会重写该方法，用于判断值是否相等。比如String，Integer类等等

public class equals02 {
    public static void main(String[] args) {
//        equals方法的源码如何查看
//          把光标放在equals方法上，然后输入ctrl+b（idea的）
        /*
//       String类下的 equals的源码：
//    把Object的equals方法改写了：
        public boolean equals(Object anObject) {
        if (this == anObject) {//如果是同一个对象
            return true;
        }
        if (anObject instanceof String) {//判断类型
            String anotherString = (String)anObject;//向下转型
            int n = value.length;
            if (n == anotherString.value.length) {//如果长度相同
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) { //然后一个一个地比较字符
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;  //如果两个字符串的所有字符都相等
            }
        }
        return false; //如果比较的不是字符串，直接返回false
    }


         */
        String str1 = new String("dadao");
        String str2 = new String("dadao");
        //        这里因为是new，所以都是新创建的空间，所以不一样。
        System.out.println(str1==str2);//false
        System.out.println(str1.equals(str2));//true

        /*
            Object 类下的equals方法源码：
            public boolean equals(Object obj) {
                    return (this == obj);
                }

         */

        Integer integer1 = new Integer(5);
        Integer integer2 = new Integer(5);
//        这里因为是new，所以都是新创建的空间，所以不一样。
        System.out.println(integer1==integer2);//false
        System.out.println(integer1.equals(integer2));//true


        /*
//        Integer重新了Object的equals方法：
//        变成了判断两个值是否相等
        public boolean equals(Object obj) {
            if (obj instanceof Integer) {
                return value == ((Integer)obj).intValue();
            }
            return false;
        }

         */

    }
}

三、 hashCode方法

1. hashCode的作用：
   • 1). 主要为了提高具有哈希结构的容器的效率
   • 2). 两个引用（对象），如果指向同一个对象，则哈希值肯定是一样的
   • 3). 两个引用（对象），如果指向的是不同对象，则哈希值不一样的（这里不是绝对的）
   • 4). 哈希值主要是根据地址号来计算的，但是不能完全将哈希值等价于地址。
   • 5). 实例：

public class hashCode_ {
    public static void main(String[] args) {
        AA aa = new AA();
        AA aa2 = new AA();
        System.out.println("aa.hashCode="+aa.hashCode());
        System.out.println("aa2.hashCode="+aa2.hashCode());
        AA aa3=aa;
        System.out.println("aa.hashCode3="+aa3.hashCode( 
        ));
    }
}
class AA{

}

运行结果：

aa.hashCode=460141958
aa2.hashCode=1163157884
aa.hashCode3=460141958

6). 在学习集合的时候，如果需要的话，hashCode也会重写。

四、 toString 方法

1. 基本介绍：返回该对象的字符串表示
2. 默认返回：全类名（包名+类名）+@ + 哈希值的十六进制
3. 子类往往会重写toString方法，用于返回对象的属性信息,当然也可以自己定制里面的方法体
4. 重写toString方法，打印对象或拼接对象时，会自动调用该对象的toString形式。
5. 当我们直接输出一个对象时，toString方法会被默认调用。

代码演示：

public class ToString {
    public static void main(String[] args) {
//        Object的toString方法的源码：
        /*
        1.getClass().getName() 全类名（包名+类名）
        2.Integer.toHexString(hashCode()) 将对象的hashCode值转换成16进制
        public String toString() {
           return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
         */

        Monster monster = new Monster("小妖怪", "巡山的", 1000);
        System.out.println(monster.toString()+" hashCode="+monster.hashCode());
        System.out.println("当我们直接输出一个对象时，toString方法会被默认调用。");
        System.out.println(monster+" hashCode="+monster.hashCode());

    }
}
class Monster{
    private String name;
    private String job;
    private double sal;

    public Monster(String name, String job, double sal) {
        this.name = name;
        this.job = job;
        this.sal = sal;
    }
//    重写toString方法,输出对象的属性
//默认重写后,一般时把对象的属性值输出,当然程序员可以自己定制
    @Override
    public String toString() {
        return "Monster{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                ", sal=" + sal +
                '}';
    }
}

没有重写toString方法之前的

ObjectLei.Monster@1b6d3586 hashCode=460141958
当我们直接输出一个对象时，toString方法会被默认调用。
ObjectLei.Monster@1b6d3586 hashCode=460141958

重写toString方法之后的

Monster{name='小妖怪', job='巡山的', sal=1000.0} hashCode=460141958
当我们直接输出一个对象时，toString方法会被默认调用。
Monster{name='小妖怪', job='巡山的', sal=1000.0} hashCode=460141958

五、 finalize方法

1. 基本介绍：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此finalize方法
2. 当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源（数据库的连接，打开文件…）的操作
3. 垃圾什么时候会被回收：当某个对象没有任何引用时，则JVM就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象的时候，会先调用finalize方法
4. 垃圾回收机制的调用，是由系统来决定的（即系统有自己的GC算法），也可以通过System.gc()方法主动触发垃圾回收机制（但是不一定会被响应）
5. 我们在实际开发中，几乎不会应用finalize方法，所以更多的就是为了应付面试。

public class finalize_ {
    public static void main(String[] args) {
        car car1 = new car("宝马");
        car1=null;
        //这时new car("宝马");对象就是一个垃圾,垃圾回收器就会销毁这个对象
//        在销毁对象前,会调用该对象的finalize方法
//        之后,程序员就可以在这个方法中写入自己的业务逻辑
//        比如释放资源:(数据库连接,或者打开文件...)
//        如果程序员不重写finalize方法,那么就会调用Object类的finalize,即默认处理
//        如果程序员重写了finalize方法,就可以实现自己的逻辑

//        垃圾回收器什么时候回收(系统程序有自己的一套算法)
//        我们可以通过System.gc()主动触发垃圾回收器(但是不一定能够成功)
        System.gc();
//        调用gc方法后,程序不会阻塞在这里
        System.out.println("程序退出了...");
    }
}
class car{
    private String name;

    public car(String name) {
        this.name = name;
    }

//    重写finalize方法

    @Override
    protected void finalize() throws Throwable {
        System.out.println("我们销毁了汽车"+name);
    }
}

运行结果：
下面是重写了finalize方法之后，并且主动触发垃圾回收机制（不一定被响应）的运行结果

程序退出了...
我们销毁了汽车宝马