[读者文库]Java® Programming Interviews Exposed Wiley 2014

感谢楼主肺腑之言

http://download.csdn.net/detail/bobbyliao/7104475

感谢你的辛劳

学习了，谢谢

thanks

want to look

a glance for interview

1. Listing 4-1: Naturally sorting an array of ints
   
2. 
   
3. @Test
   
4. public void sortInts() {
   
5.     final int[] numbers = {-3, -5, 1, 7, 4, -2};
   
6.     final int[] expected = {-5, -3, -2, 1, 4, 7};
   
7. 
   
8.     Arrays.sort(numbers);
   
9.     assertArrayEquals(expected, numbers);
   
10. }
    
11. For an array of Objects, the type being sorted must implement the Comparable interface, as shown in Listing 4-2.
    
12. 
    
13. Listing 4-2: Sorting objects naturally
    
14. 
    
15. @Test
    
16. public void sortObjects() {
    
17.     final String[] strings = {"z", "x", "y", "abc", "zzz", "zazzy"};
    
18.     final String[] expected = {"abc", "x", "y", "z", "zazzy", "zzz"};
    
19. 
    
20.     Arrays.sort(strings);
    
21.     assertArrayEquals(expected, strings);
    
22. }
    
23. The String class implements the Comparable interface, so the sorting works as you would expect. If the type being sorted does not implement Comparable, this will throw a ClassCastException.
    
24. 
    
25. For your own class definitions, you will need to implement Comparable, such as the implementation described in Listing 4-3.
    
26. 
    
27. Listing 4-3: Sorting without a Comparable interface
    
28. 
    
29. private static class NotComparable {
    
30.     private int i;
    
31.     private NotComparable(final int i) {
    
32.         this.i = i;
    
33.     }
    
34. }
    
35. 
    
36. @Test
    
37. public void sortNotComparable() {
    
38.     final List<NotComparable> objects = new ArrayList<>();
    
39.     for (int i = 0; i < 10; i++) {
    
40.         objects.add(new NotComparable(i));
    
41.     }
    
42. 
    
43.     try {
    
44.         Arrays.sort(objects.toArray());
    
45.     } catch (Exception e) {
    
46.         // correct behavior – cannot sort
    
47.         return;
    
48.     }
    
49. 
    
50.     fail();
    
51. }

复制代码

It is not possible to use the Collections.sort method because the compiler expects the type of the parameter to be an implementation of Comparable. The method signature is:

public static <T extends Comparable<? super T>> void sort(List<T> list)
If you want to provide your own ordering, you provide an implementation of the Comparator interface to the sort method. This interface has two methods: int compare(T o1, T o2) for the implementing type T, and boolean equals(Object o). The compare method returns an int in one of three states: negative if the first argument is sorted before the second, zero if the two are equal, or positive if the second argument is sorted first.

1. Listing 4-4: A reverse numerical order Comparator
   
2. 
   
3. public class ReverseNumericalOrder implements Comparator<Integer> {
   
4.     @Override
   
5.     public int compare(Integer o1, Integer o2) {
   
6.         return o2 - o1;
   
7.     }
   
8.     // equals omitted
   
9. }
   
10. Listing 4-5 uses this Comparator.
    
11. 
    
12. Listing 4-5: Using a custom ordering
    
13. 
    
14. @Test
    
15. public void customSorting() {
    
16.     final List<Integer> numbers = Arrays.asList(4, 7, 1, 6, 3, 5, 4);
    
17.     final List<Integer> expected = Arrays.asList(7, 6, 5, 4, 4, 3, 1);
    
18. 
    
19.     Collections.sort(numbers, new ReverseNumericalOrder());
    
20.     assertEquals(expected, numbers);
    
21. }

复制代码