Option A is wrong. HashSet makes no guarantees as to the iteration order of the set; in particular, it does not guarantee that the order will remain constant over time.
Option B is wrong. The set can be modified.
Option D is wrong. This is a Set and not a Map.
(1) and (2) are incorrect because by contract hashCode() and equals() can't be overridden unless both are overridden.
x = 0; if (x1.hashCode() != x2.hashCode() ) x = x + 1; if (x3.equals(x4) ) x = x + 10; if (!x5.equals(x6) ) x = x + 100; if (x7.hashCode() == x8.hashCode() ) x = x + 1000; System.out.println("x = " + x);
Option A is incorrect because if the hashCode() values are not equal, the two objects must not be equal.
Option C is incorrect because if equals() is not true there is no guarantee of any result from hashCode().
Option D is incorrect because hashCode() will often return == even if the two objects do not evaluate to equals() being true.
(2) and (3) are incorrect because the hashCode() method is very flexible in its return values, and often two dissimilar objects can return the same hash code value.
public static void main(String[] args) { Object obj = new Object() { public int hashCode() { return 42; } }; System.out.println(obj.hashCode()); }
In this case the annoynous class is extending the Object class. Within the {} you place the methods you want for that class. After this class has been declared its methods can be used by that object in the usual way e.g. objectname.annoymousClassMethod()
(3) is an incorrect statement and therefore a correct answer because the hashcode for a string is computed from the characters in the string.
class Test1 { public int value; public int hashCode() { return 42; } } class Test2 { public int value; public int hashcode() { return (int)(value^5); } }
Option A and D are incorrect because these classes are legal.
Option B is incorrect based on the logic described above.
class Happy extends Thread { final StringBuffer sb1 = new StringBuffer(); final StringBuffer sb2 = new StringBuffer(); public static void main(String args[]) { final Happy h = new Happy(); new Thread() { public void run() { synchronized(this) { h.sb1.append("A"); h.sb2.append("B"); System.out.println(h.sb1); System.out.println(h.sb2); } } }.start(); new Thread() { public void run() { synchronized(this) { h.sb1.append("D"); h.sb2.append("C"); System.out.println(h.sb2); System.out.println(h.sb1); } } }.start(); } }
class MyThread extends Thread { public static void main(String [] args) { MyThread t = new MyThread(); /* Line 5 */ t.run(); /* Line 6 */ } public void run() { for(int i=1; i < 3; ++i) { System.out.print(i + ".."); } } }
A is incorrect because line 5 is the proper way to create an object.
B is incorrect because it is legal to call the run() method, even though this will not start a true thread of execution. The code after line 6 will not execute until the run() method is complete.
D is incorrect because the for loop only does two iterations.
Comments
There are no comments.Copyright ©CuriousTab. All rights reserved.