Given the code fragment:
public class Foo {
public static void main (String [ ] args) {
Map
unsortMap.put (10, "z");
unsortMap.put (5, "b");
unsortMap.put (1, "d");
unsortMap.put (7, "e");
unsortMap.put (50, "j");
Map
Comparator
@Override public int compare (Integer o1, Integer o2) {return o2.compareTo
(o1); } } );
treeMap.putAll (unsortMap);
for (Map.Entry
System.out.print (entry.getValue () + " ");
}
}
}
What is the result?
The code defines a TreeMap with a custom Comparator that sorts the keys in descending order by returning o2.compareTo(o1) in the compare method. When the unsorted HashMap entries are inserted into the TreeMap, they are sorted in descending order based on their keys. The keys in descending order are 50, 10, 7, 5, and 1, corresponding to the values 'j', 'z', 'e', 'b', and 'd', respectively. Thus, the output will be 'j z e b d'.
C (compiled & tested)
Answer is "j z e b d" .If the compare method is returning o1.compareTo(o2) then the answer is "d b e z j ".
Map<Integer, String> treeMap = new TreeMap <Integer, String> ( (Comparator<? super Integer>) new Comparator<Integer> ( ) { @Override public int compare (Integer o1, Integer o2) { return o2.compareTo(o1); } } ); answer is C
import java.util.Comparator; import java.util.HashMap; import java.util.Map; import java.util.TreeMap; public class MyClass { public static void main(String[] args) { //HashMap is an unsorted Map in Java, neither key nor value is sorted. Map<Integer, String> unsortMap = new HashMap<>(); unsortMap.put(10, "z"); unsortMap.put(5, "b"); unsortMap.put(1, "d"); unsortMap.put(7, "e"); unsortMap.put(50, "j"); Map<Integer, String> treeMap = new TreeMap<Integer, String>(new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { //returns values in descending order return o2.compareTo(o1); } }); treeMap.putAll(unsortMap); for (Map.Entry<Integer, String> entry : treeMap.entrySet()) { System.out.print(entry.getValue() + " "); } } } //ANSWER: C. j z e b d
Answer is C (compiled and tested as following): package birdie; import java.util.Comparator; import java.util.HashMap; import java.util.Map; import java.util.TreeMap; import java.util.function.IntFunction; import java.util.function.IntUnaryOperator; import java.util.stream.IntStream; class Vehicle { public static void main (String [ ] args) { Map<Integer, String> unsortMap = new HashMap< > ( ); unsortMap.put (10, "z"); unsortMap.put (5, "b"); unsortMap.put (1, "d"); unsortMap.put (7, "e"); unsortMap.put (50, "j"); Map<Integer, String> treeMap = new TreeMap <Integer, String> (new Comparator<Integer> ( ) { @Override public int compare (Integer o1, Integer o2) {return o2.compareTo (o1); } } ); treeMap.putAll (unsortMap); for (Map.Entry<Integer, String> entry : treeMap.entrySet () ) { System.out.print (entry.getValue () + " "); } } }
Tested
Correct answer is C. Because @Override public int compare (Integer o1, Integer o2) { return o2.compareTo(o1); } is decrease.
C Tested!!
C (Tested)
Correct answer is C because of overriden compare() method which says to compare in DESC order
C is correct, TreeMap need provide a Comparator, sort is DESC -> C
Answer is C since o2.compareTo(o1) sorts keys in descending order.
C is the answer: import java.util.Comparator; import java.util.HashMap; import java.util.Map; import java.util.TreeMap; import java.util.function.IntFunction; import java.util.function.IntUnaryOperator; import java.util.stream.IntStream; class Vehicle { public static void main (String [ ] args) { Map<Integer, String> unsortMap = new HashMap< > ( ); unsortMap.put (10, "z"); unsortMap.put (5, "b"); unsortMap.put (1, "d"); unsortMap.put (7, "e"); unsortMap.put (50, "j"); Map<Integer, String> treeMap = new TreeMap <Integer, String> (new Comparator<Integer> ( ) { @Override public int compare (Integer o1, Integer o2) {return o2.compareTo (o1); } } ); treeMap.putAll (unsortMap); for (Map.Entry<Integer, String> entry : treeMap.entrySet () ) { System.out.print (entry.getValue () + " "); } } }
Answer ist C