Beginning Java 8 Fundamentals

1. Listing 7-1. A Book Class That Reimplements the hashCode() Method
   
2. 
   
3. // Book.java
   
4. package com.jdojo.object;
   
5. 
   
6. public class Book {
   
7.         private String title;
   
8.         private String author;
   
9.         private int pageCount;
   
10.         private boolean hardCover;
    
11.         private double price;
    
12. 
    
13.         /* Other code goes here */
    
14. 
    
15.         /* Must implement the equals() method too. */
    
16. 
    
17.         public int hashCode() {
    
18.                 int hash = 37;
    
19.                 int code = 0;
    
20. 
    
21.                 // Use title
    
22.                 code = (title == null ? 0 : title.hashCode());
    
23.                 hash = hash * 59 + code;
    
24.          
    
25.                 // Use author
    
26.                 code = (author == null ? 0 : author.hashCode());
    
27.                 hash = hash * 59 + code;
    
28. 
    
29.                 // Use pageCount
    
30.                 code = pageCount;
    
31.                 hash = hash * 59 + code;
    
32. 
    
33.                 // Use hardCover
    
34.                 code = (hardCover ? 1 : 0);
    
35.                 hash = hash * 59 + code;
    
36. 
    
37.                 // Use price
    
38.                 long priceBits = Double.doubleToLongBits(price);
    
39.                 code = (int)(priceBits ^ (priceBits >>>32));
    
40.                 hash = hash * 59 + code;
    
41. 
    
42.                 return hash;
    
43.         }
    
44. }

复制代码

The class has five instance variables: title, author, pageCount, hardcover, and price. The implementation uses all five instance variables to compute the hash code for a Book object. You must also implement the equals() method for the Book class, which must use all the five instance variables to check if two Book objects are equal. You need to make sure that the equals() method and thehashCode() method use the same set of instance variables in their logic. Suppose you add one more instance variable to the Book class. Let’s call it ISBN. Because ISBN identifies a book uniquely, you might use only the ISBN instance variable to compute its hash code and to compare for equality with another Book object. In this case, it will be sufficient to use only one instance variable to compute the hash code and check for equality.

There are some misconceptions about the hash code of an object in Java. Developers think that the hash code uniquely identifies an object and it must be a positive integer. However, they are not true. The hash code does not identify an object uniquely. Two distinct objects may have the same hash codes. A hash code does not have to be only a positive number. It could be any integer value, positive as or negative. There is also confusion about the usage of hash codes. They are used solely for the purpose of efficient retrieval of data from a hash-based collection. If your objects are not used as keys in hash based collections and you do not override the equals() method in your class, you do not need to worry about reimplementing the hashCode() method in your class at all. Most likely, it will be overriding the equals() method that will prompt you to override the hashCode() method for your class. If you do not override and provide correct implementation of hashCode() and equals() methods in your class at the same time, the objects of your class would not behave properly in hash-based collections. The Java compiler or the Java runtime will never give you any warnings or errors about the incorrect implementations of these two methods in your class.

1. Listing 7-2. A SmartPoint Class That Reimplements equals() and hashCode() Methods
   
2. 
   
3. // SmartPoint.java
   
4. package com.jdojo.object;
   
5. 
   
6. public class SmartPoint {
   
7.         private int x;
   
8.         private int y;
   
9.      
   
10.         public SmartPoint(int x, int y) {
    
11.                 this.x = x;
    
12.                 this.y = y;
    
13.         }
    
14.      
    
15.         /* Reimplement the equals() method */
    
16.         public boolean equals(Object otherObject) {
    
17.                 // Are the same?
    
18.                 if (this == otherObject) {
    
19.                         return true;
    
20.                 }
    
21.          
    
22.                 // Is otherObject a null reference?
    
23.                 if (otherObject == null) {
    
24.                         return false;
    
25.                 }
    
26.          
    
27.                 // Do they belong to the same class?
    
28.                 if (this.getClass() != otherObject.getClass()) {
    
29.                         return false;
    
30.                 }
    
31.          
    
32.                 // Get the reference of otherObject in a SmartPoint variable
    
33.                 SmartPoint otherPoint = (SmartPoint)otherObject;
    
34.          
    
35.                 // Do they have the same x and y co-ordinates
    
36.                 boolean isSamePoint = (this.x == otherPoint.x && this.y == otherPoint.y);
    
37.          
    
38.                 return isSamePoint;
    
39.         }
    
40.      
    
41.         /* Reimplement hashCode() method of the Object class,
    
42.            which is a requirement when you reimplement equals() method */
    
43.         public int hashCode() {
    
44.                 return (this.x + this.y);
    
45.         }
    
46. }

复制代码

You call your new class SmartPoint. Java advises to reimplement hashCode() and equals() methods together if any one of them is reimplemented in your class. The Java compiler would not complain if you reimplement the equals() method and not the hashCode() method. However, you will get unpredictable results when you use the objects of your class in hash-based collections.

The only requirement for a hashCode() method is that if the m.equals(n) method returns true, m.hashCode() must return the same value as n.hashCode(). Because your equals() method uses (x, y) coordinates to test for equality, you return the sum of x and y coordinates from the hashCode() method, which fulfills the technical requirement. Practically, you need to use a better hashing algorithm to compute the hash value.

You have written a few lines of codes in the equals() method of the SmartPoint class. Let’s go through the logic one by one. First, you need to check if the object passed is the same as the object on which the method is called. If two objects are the same, you consider them equal by retuning true. This is accomplished by the following code:

// Are they the same?
if (this == otherObject) {
        return true;
}
If the parameter being passed is null, the two objects cannot be the same. Note that the object on which the method is called can never be null because you cannot call a method on a null reference. Java runtime will throw runtime exception when an attempt is made to call a method on a null reference. The following code makes sure that you are comparing two non-null objects:

// Is otherObject a null reference?
if (otherObject == null) {
        return false;
}
The parameter type of the method is Object. This means that any type of object reference can be passed. For example, you can use apple.equals(orange), where apple and orange are references to an Apple object and an Orange object, respectively. In your case, you want to compare only a SmartPoint object to another SmartPoint object. To make sure that the objects being compared are of the same class, you need the following code. If someone calls the method with a parameter that is not a SmartPoint object, it returns false.

// Do they have the same class?
if (this.getClass() != otherObject.getClass()) {
        return false;
}
At this point, you are sure that someone is trying to compare two non-null SmartPoint objects that have different identity (references). Now you would like to compare the (x, y) coordinates of two objects. To access the x and y instance variables of the otherObject formal parameter, you must cast it to a SmartPoint object. The following statement does it:

// Get the reference of otherObject in a SmartPoint variable
SmartPoint otherPoint = (SmartPoint)otherObject;
At this point, it is just the matter of comparing the values of x and y instance variables of the two SmartPoint objects. If they are the same, you consider two objects equal by returning true. Otherwise, two objects are not equal and you return false. This is accomplished by the following code:

// Do they have the same x and y co-ordinates
boolean isSamePoint = (this.x == otherPoint.x && this.y == otherPoint.y);
return isSamePoint;
It is time to test your reimplementation of the equals() method in the SmartPoint class. Listing 7-3 is your test class. You can observe in the output that you have two ways of comparing two SmartPoint objects for equality. The equality operator (==) compares them based on identity and the equals() method compares them based on values of the (x, y) coordinates. Note that if (x, y) coordinates are the same for two SmartPoint objects, the equals() method returns true.

1. Listing 7-3. A Test Class to Demonstrate the Difference Between Identity and State Comparisons
   
2. 
   
3. // SmartPointTest.java
   
4. package com.jdojo.object;
   
5. 
   
6. public class SmartPointTest {
   
7.         public static void main(String[] args)  {
   
8.                 SmartPoint pt1 = new SmartPoint(10, 10);
   
9.                 SmartPoint pt2 = new SmartPoint(10, 10);
   
10.                 SmartPoint pt3 = new SmartPoint(12, 19);
    
11.                 SmartPoint pt4 = pt1;
    
12.          
    
13.                 System.out.println("pt1 == pt1: " + (pt1 == pt1));
    
14.                 System.out.println("pt1.equals(pt1): " + pt1.equals(pt1));
    
15.          
    
16.                 System.out.println("pt1 == pt2: " + (pt1 == pt2));
    
17.                 System.out.println("pt1.equals(pt2): " + pt1.equals(pt2));
    
18.          
    
19.                 System.out.println("pt1 == pt3: " + (pt1 == pt3));
    
20.                 System.out.println("pt1.equals(pt3): " + pt1.equals(pt3));
    
21.          
    
22.                 System.out.println("pt1 == pt4: " + (pt1 == pt4));
    
23.                 System.out.println("pt1.equals(pt4): " + pt1.equals(pt4));
    
24.         }
    
25. }
    
26. pt1 == pt1: true
    
27. pt1.equals(pt1): true
    
28. pt1 == pt2: false
    
29. pt1.equals(pt2): true
    
30. pt1 == pt3: false
    
31. pt1.equals(pt3): false
    
32. pt1 == pt4: true
    
33. pt1.equals(pt4): true

复制代码

There are some specifications for implementing the equals() method in your class, so your class will work correctly when used with other areas (e.g. hash-based collections) of Java. It is the responsibility of the class designer to enforce these specifications. If your class does not conform to these specifications, the Java compiler or Java runtime will not generate any errors. Rather, objects of your class will behave incorrectly. For example, you will add your object to a collection, but you may not be able to retrieve it. Here are specifications for the equals() method’s implementation. Assume that x, y, and z are non-null references of three objects.

Reflexivity: It should be reflexive. The expression x.equals(x) should return true. That is, an object must be equal to itself.
Symmetry: It should be symmetric. If x.equals(y) returns true, y.equals(x) must return true. That is, if x is equal to y, y must be equal to x.
Transitivity: It should be transitive. If x.equals(y) returns true and y.equals(z) returns true, x.equals(z) must return true. That is, if x is equal to y and y is equal to z, x must be equal to z.
Consistency: It should be consistent. If x.equals(y) returns true, it should keep returning true until the state of x or y is modified. If x.equals(y) returns false, it should keep returning false until the state of x or y is modified.
Comparison with null reference: An object of any class should not be equal to a null reference. The expression x.equals(null) should always return false.
Relationship with hashCode() method: If x.equals(y) returns true, x.hashCode() must return the same value as y.hashCode(). That is, if two objects are equal according to the equals() method, they must have the same hash code values returned from their hashCode() methods. However, the opposite may not be true. If two objects have the same hash codes, that does not imply that they must be equal according to the equals() method. That is, if x.hashCode() is equal to y.hashCode(), that does not imply that x.equals(y) will return true.
Your SmartPoint class satisfies all six rules for equals() and hashCode() methods. It was fairly easy to implement the equals() method for the SmartPoint class. It has two primitive type instance variables and you used both of them in comparison for equality.

There are no rules as to how many of instance variables should be used to compare for equality of two objects of a class. It all depends on the use of the class. For example, if you have an Account class, the account number itself may be sufficient in your case to compare for the equality of two Account objects. However, make sure you use the same instance variables in the equals() method to compare for equality and in the hashCode() method to compute hash code value. If your class has reference instance variables, you may call their equals() methods from inside the equals() method of your class. Listing 7-4 shows how to use a reference instance variable comparison inside the equals() method.

1. Listing 7-4. Overriding the equals() and hsshCode() Methods in a Class
   
2. 
   
3. // SmartCat.java
   
4. package com.jdojo.object;
   
5. 
   
6. public class SmartCat {
   
7.         private String name;
   
8. 
   
9.         public SmartCat(String name) {
   
10.                 this.name = name;
    
11.         }
    
12. 
    
13.         /* Reimplement the equals() method */
    
14.         public boolean equals(Object otherObject) {
    
15.                 // Are they the same?
    
16.                 if (this == otherObject) {
    
17.                         return true;
    
18.                 }
    
19. 
    
20.                 // Is otherObject a null reference?
    
21.                 if (otherObject == null) {
    
22.                         return false;
    
23.                 }
    
24. 
    
25.                 // Do they belong to the same class?
    
26.                 if (this.getClass() != otherObject.getClass()) {
    
27.                         return false;
    
28.                 }
    
29. 
    
30.                 // Get the reference of otherObject is a SmartCat variable
    
31.                 SmartCat otherCat = (SmartCat)otherObject;
    
32. 
    
33.                 // Do they have the same names
    
34.                 boolean isSameName = (this.name == null? otherCat.name == null
    
35.                                                    :this.name.equals(otherCat.name) );
    
36. 
    
37.                 return isSameName;
    
38.         }
    
39. 
    
40.         /* Reimplement the hashCode() method, which is a requirement
    
41.            when you reimplement equals() method */
    
42.         public int hashCode() {
    
43.                 return (this.name == null? 0 : this.name.hashCode());
    
44.         }
    
45. }

复制代码

The SmartCat class has a name instance variable, which is of the type String. The String class has its own version of the equals() method implementation that compares two strings character by character. The equals() method of the SmartCat class calls the equals() method on the name instance variables to check if two names are equal. Similarly, it makes use of the hashCode() method’s implementation in the String class in its hashCode() method.

本帖隐藏的内容

Beginning Java 8 Fundamentals.pdf (9.02 MB, 需要: 20 个论坛币)

2015-7-1 10:13:32 上传

需要: 20 个论坛币  [购买]

thankthanks