Java基礎之：equals

"=="比較運算子

首先我們重溫一下一直在使用的"=="比較運算子

1)== ：比較運算子，既可以判斷基本型別，又可以判斷引用型別

2)== ：比較運算子，如果判斷基本型別，判斷的是值是否相等。示例：int i=10; double d=10.0; i==d true

3)== ：比較運算子，如果判斷引用型別，判斷的是地址是否相等.

equals方法

equals： 是Object類中的方法，只能判斷引用型別，判斷的是地址是否相等，子類中往往重寫該方法，用於判斷內容是否相等。比如Integer,String .... 直接上案例

簡單案例

注意案例中的原始碼

package object;

/**
 *  equals與==的區別：
 * 		equals 與  == 相同的作用，在Object.equals沒有被子類重寫之前。
 *		但 equals 通常用於比較引用型別變數，==通常用於比較基本資料型別變數。
 *		不管是equals 還是 == ，比較引用型別變數時，都是比較引用地址是否相等。
 *		對於基本型別而言，equals和== 都是比較大小是否相等 
 *	Object的子類大多都會重寫equals方法， 例如String ，Integer....
 *		
 */
public class ClassTest {

	public static void main(String[] args) {
		
		//檢視Object中equals原始碼	（ctrl + 左鍵） 點選進入原始碼
		Object object = new Object();
		System.out.println(object.equals(new String("hello"))); //F
		
		/*		Object.equals 原始碼 ：
		 *     public boolean equals(Object obj) {
        			return (this == obj);
    		   }
		 */
		String st1 = new String("hello");
		String st2 = new String("hello");
		System.out.println(st1 == st2);	//F
		
		//String 子類重寫了 Object父類的 equals方法
		System.out.println(st1.equals(st2));	//T
		//使用String的equals方法比較一個物件與一個常量時，儘量使用，常量.equals
		System.out.println("hello".equals(st2)); //T   這樣可以避免空指標異常
		
		// String.equals原始碼：
		/*
		 *  public boolean equals(Object anObject) {
        		if (this == anObject) {	//如果是同一個物件，返回true
            		return true;
        		}
        		if (anObject instanceof String) {	
        			//如果是String型別或其父類，進入if判斷內容
            		String anotherString = (String)anObject;
            		int n = value.length;
            		if (n == anotherString.value.length) {
            			//如果長度相等，將兩個字串儲存入char陣列中，逐個字元進行比較
                		char v1[] = value;
                		char v2[] = anotherString.value;
                		int i = 0;
                		while (n-- != 0) {
                			//只要有一個字元不相同 就返回false
                    		if (v1[i] != v2[i])
                        		return false;
                    		i++;
                		}
                		return true;
            		}	
        		}
        		return false;
    		}
		 */

	}

}

簡單案例2

package object;
/**
 *	重寫equals方法，實現比較兩個Person物件的所有屬性是否相同，若相同返回true
 */
public class OverrideEquals {

	public static void main(String[] args) {

		Person person1 = new Person("小范",20,'A');
		Person person2 = new Person("小范",20,'A');
		Person person3 = new Person("小黃",18,'A');
		Object object = new Object();
		
		System.out.println(person1 == person2); //F  比較地址		
		
		System.out.println(person1.equals(person2)); //T 比較屬性值
		System.out.println(person1.equals(person3)); //F
		System.out.println(person1.equals(object)); //F	
	}

}

class Person{
	
	private String name;
	private int age;
	private char gander;	//等級
	public Person(String name, int age, char gander) {
		super();
		this.name = name;
		this.age = age;
		this.gander = gander;
	}
	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 char getGander() {
		return gander;
	}
	public void setGander(char gander) {
		this.gander = gander;
	}
	
	public boolean equals(Person p) {
		boolean flag = false;
		if(this == p) {	//是同一個物件
			flag = true;
		}else {
			if (this.name.equals(p.getName())) {
				if(this.age == p.getAge()) {
					if(this.gander == p.getGander()) {
						flag = true;
					}
				}
			}
		}
		return flag;
	}
	
	// alt + shift + s ==> h 自動生成重寫後的equals
	// 對比自動生成的，看自己重寫的。比較區別，明顯自己的重寫equals有bug
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (gander != other.gander)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
}

應用案例

在自己定義的類中重寫equals方法

package object;
/**
 * 	編寫Order類，有int型的orderId，String型的OrderName，private屬性。
	相應的getter()和setter()方法，兩個引數的構造器，
	重寫父類的equals()方法：public boolean equals(Object obj)，
	並判斷測試類中建立的兩個物件是否相等。
	屬性是否相同, 相同返回 t, 否則返回 False.
 *
 */
public class ClassWork {
	public static void main(String[] args) {
		
		Order order1 = new Order(1001, "小范");
		Order order2 = new Order(1001, "小范");
		Order order3 = new Order(1002, "小黃");
		
		System.out.println(order1.equals(order2)); //T
		System.out.println(order1.equals(order3)); //F
	}
}

class Order{
	
	private int orderId;
	private String orderName;
	
	public Order(int orderId, String orderName) {
		super();
		this.orderId = orderId;
		this.orderName = orderName;
	}
	public int getOrderId() {
		return orderId;
	}
	public void setOrderId(int orderId) {
		this.orderId = orderId;
	}
	public String getOrderName() {
		return orderName;
	}
	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}
	
	public boolean equals(Object obj) {
		if(this == obj) {
			return true;
		}
		
		if(!(obj instanceof Order)) {
			//不是Order型別
			return false;
		}
		//由於已經判斷過Order型別，所以這裡向下轉型一定不會報錯
		Order other = (Order)obj;
		
		return other.orderId == this.orderId && other.orderName.equals(this.orderName);
	}
}