目录
一、==与equals()的区别
(一)==是一个比较运算符
(二)equals是Object类中的方法,只能判断引用类型
(三)equals方法重写练习
1.练习1
2.练习2
3.练习3
二、hashCode方法
三、toString方法
1.默认返回:全类名(包名+类名)+@+哈希值的十六进制
(1)不重写toString方法
(2)重写toString方法
2.当直接输出一个对象时,toString方法会被默认地调用
四、finalize关键字(开发中用得不多)
一、==与equals()的区别
(一)==是一个比较运算符
(二)equals是Object类中的方法,只能判断引用类型
默认判断的是地址是否相等,子类中往往重写该方法,用于判断内容是否相等。比如Integer、String
Object类的equals源码:判断俩个对象的地址是否相同
System.out.println("hello".equals("abc")); // false
// 即Object 的equals 方法默认就是比较对象地址是否相同
// 也就是判断两个对象是不是同一个对象.
public boolean equals(Object obj) {
return (this == obj);
}
Integer类的equals源码:判断值的内容是否相同
//从源码可以看到 Integer 也重写了Object的equals方法,
//变成了判断两个值是否相同
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}
Integer integer1 = new Integer(1000);
Integer integer2 = new Integer(1000);
System.out.println(integer1 == integer2);//false
System.out.println(integer1.equals(integer2));//true
String类的equals源码:比较两个字符串值是否相同。
public boolean equals(Object anObject) {
if (this == anObject) {//如果是同一个对象
return true;//返回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;//如果两个字符串的所有字符都相等,则返回true
}
}
return false;//如果比较的不是字符串,则直接返回false
}
String str1 = new String("helloworld");
String str2 = new String("helloworld");
System.out.println(str1 == str2);//false
System.out.println(str1.equals(str2));//true
(三)equals方法重写练习
1.练习1
应用实例:判断两个Person对象的内容是否相等,如果两个Person对象的各个属性值都一样,则返回true,反之false。
public class EqualsExercise01 {
public static void main(String[] args) {
Person p1 = new Person("zhangsan", 16, '男');
Person p2 = new Person("zhangsan", 16, '男');
System.out.println(p1.equals(p2)); // true
}
}
class Person {
private String name;
private int age;
private char gender;
// 重写equals方法
public boolean equals(Object obj) {
// 先判断地址是否相等
if (this == obj) {
return true;
}
if (obj instanceof Person) {
// 向下转型,因为要取得obj中的各个属性
Person p = (Person) obj;
return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
}
return false;
}
public Person(String name, int age, char gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
}
2.练习2
public class EqualsExercise02 {
public static void main(String[] args) {
Person_ p1 = new Person_();
p1.name = "hspedu";
Person_ p2 = new Person_();
p2.name = "hspedu";
System.out.println(p1 == p2); // false
System.out.println(p1.name.equals(p2.name));// true
System.out.println(p1.equals(p2));// false
String s1 = new String("asdf");
String s2 = new String("asdf");
System.out.println(s1.equals(s2));// true
System.out.println(s1 == s2); // false
}
}
class Person_ {
public String name;
}
3.练习3
int it = 65;
float fl = 65.0f;
System.out.println(it == fl); // true
char ch1 = 'A';
char ch2 = 12;
System.out.println(it == ch1); // true
System.out.println(12 == ch2); // true
String str1 = new String("hello");
String str2 = new String("hello");
System.out.println(str1 == str2); // false
System.out.println(str1.equals(str2)); // true
// System.out.println("hello" = new java.sql.Date()); 编译报错
二、hashCode方法
- hashCode能够提高具有哈希结构的容器的效率,例如HashSet、LinkedHashSet、Hashtable
- 两个引用,如果指向的是同一个对象,则哈希值肯定是一样的!
- 两个引用,如果指向的是不同对象,则哈希值是不一样的
- 哈希值主要是根据地址号来的!不能完全将哈希值等价于地址
- 在集合中也可能会需要重写hashCode
public class HashCode_ {
public static void main(String[] args) {
AA aa = new AA();
AA aa2 = new AA();
AA aa3 = aa;
System.out.println("aa.hashCode()=" + aa.hashCode());
// aa.hashCode()=1163157884
System.out.println("aa2.hashCode()=" + aa2.hashCode());
// aa2.hashCode()=1956725890
System.out.println("aa3.hashCode()=" + aa3.hashCode());
// aa.hashCode()=1163157884
}
}
class AA {}
三、toString方法
基本介绍:
1.默认返回:全类名(包名+类名)+@+哈希值的十六进制
子类往往重写toString方法,用于返回对象的属性信息
Object类的toString方法的源码:
// (1)getClass().getName() 类的全类名(包名+类名 )
// (2)Integer.toHexString(hashCode()) 将对象的hashCode值转成16进制字符串
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
(1)不重写toString方法
public class ToString_ {
public static void main(String[] args) {
Monster monster = new Monster("小妖怪", "巡山的", 1000);
System.out.println(monster.toString() + " hashcode=" + monster.hashCode());
// 未重写toString方法的输出:
// com.testdemo.object_.Monster@4554617c hashcode=1163157884
}
}
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;
}
}
(2)重写toString方法
打印对象或拼接对象时,都会自动调用该对象的toString形式。
public class ToString_ {
public static void main(String[] args) {
Monster monster = new Monster("小妖怪", "巡山的", 1000);
System.out.println(monster.toString() + " hashcode=" + monster.hashCode());
// 重写了toString方法的输出:
// Monster{name='小妖怪', job='巡山的', sal=1000.0} hashcode=1163157884
}
}
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方法, 输出对象的属性
// 使用快捷键即可 alt+insert -> toString
// 重写后,一般是把对象的属性值输出,当然程序员也可以自己定制
@Override
public String toString() {
return "Monster{" +
"name='" + name + '\'' +
", job='" + job + '\'' +
", sal=" + sal +
'}';
}
}
2.当直接输出一个对象时,toString方法会被默认地调用
即:System.out.println(monster.toString());等价于 System.out.println(monster);
四、finalize关键字(开发中用得不多)
- 当对象被回收时,系统自动调用该对象的finalize方法。子类可以重写该方法,做一些释放资源的操作。
- 什么时候被回收:当某个对象没有任何引用时,则JVM就认为这个对象时一个垃圾对象,就会使用垃圾回收机制来销毁该对象,在销毁该对象前,会先调用finalize方法。
- 垃圾回收机制的调用,是由系统来决定(即由自己的GC算法),也可以通过System.gc()主动触发垃圾回收机制。
public class Finalize_ {
public static void main(String[] args) {
Car bmw = new Car("宝马");
// 这时 car对象就是一个垃圾,垃圾回收器就会回收(销毁)对象, 在销毁对象前,会调用该对象的finalize方法
// 可以在 finalize中,写自己的业务逻辑代码(比如释放资源:数据库连接,或者打开文件..)
// 如果不重写 finalize,那么就会调用 Object类的 finalize, 即默认处理
// 如果重写了finalize, 就可以实现自己的逻辑
bmw = null;
System.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);
System.out.println("释放了某些资源...");
}
}