[Java] array, List, Set, Map 排序

原始碼

1. import java.util.Arrays; 
2. import java.util.Collections; 
3. import java.util.HashMap; 
4. import java.util.HashSet; 
5. import java.util.List; 
6. import java.util.Map; 
7. import java.util.Set; 
8. import java.util.TreeMap; 
9. import java.util.TreeSet; 
10.  
11. public class TestSort { 
12.  
13.    public static void main(String[] args) { 
14.  
15.        /* sort array */ 
16.        String[] array1 = new String[] { 
17.            "Pineapple", "Apple", "Orange", "Banana" 
18.        }; 
19.        Arrays.sort(array1); 
20.  
21.        for (String value : array1) { 
22.            System.out.printf("%s, ", value); 
23.        } 
24.        System.out.println("\n"); 
25.  
26.  
27.  
28.        /* reverse sort array */ 
29.        String[] array2 = new String[] { 
30.            "Pineapple", "Apple", "Orange", "Banana" 
31.        }; 
32.        Arrays.sort(array2, Collections.reverseOrder()); 
33.  
34.        for (String value : array2) { 
35.            System.out.printf("%s, ", value); 
36.        } 
37.        System.out.println("\n"); 
38.  
39.  
40.  
41.        /* sort list */ 
42.        List<String> list1 = Arrays.asList( 
43.            "Pineapple","Apple", "Orange", "Banana" 
44.        ); 
45.        Collections.sort(list1); 
46.  
47.        for (String value : list1) { 
48.            System.out.printf("%s, ", value); 
49.        } 
50.        System.out.println("\n"); 
51.  
52.  
53.  
54.        /* reverse sort list */ 
55.        List<String> list2 = Arrays.asList( 
56.            "Pineapple","Apple", "Orange", "Banana" 
57.        ); 
58.        Collections.sort(list2, Collections.reverseOrder()); 
59.  
60.        for (String value : list2) { 
61.            System.out.printf("%s, ", value); 
62.        } 
63.        System.out.println("\n"); 
64.  
65.  
66.  
67.        /* sort set */ 
68.        Set<String> set = new HashSet<>(); 
69.        set.add("Pineapple"); 
70.        set.add("Apple"); 
71.        set.add("Orange"); 
72.        set.add("Banana"); 
73.  
74.        Set<String> treeSet1 = new TreeSet<>(set); 
75.  
76.        for (String value : treeSet1) { 
77.            System.out.printf("%s, ", value); 
78.        } 
79.        System.out.println("\n"); 
80.  
81.  
82.  
83.        /* reverse sort set */ 
84.        Set<String> treeSet2 = new TreeSet<>(Collections.reverseOrder()); 
85.        treeSet2.addAll(set); 
86.  
87.        for (String value : list2) { 
88.            System.out.printf("%s, ", value); 
89.        } 
90.        System.out.println("\n"); 
91.  
92.  
93.  
94.        /* sort map */ 
95.        Map<String, String> map = new HashMap<>(); 
96.        map.put("Pineapple","z"); 
97.        map.put("Apple", "g"); 
98.        map.put("Orange", "a"); 
99.        map.put("Banana", "f"); 
100.  
101.        Map<String, String> treeMap1 = new TreeMap<>(map); 
102.  
103.        for (Map.Entry<String, String> entry : treeMap1.entrySet()) { 
104.            System.out.printf( 
105.                "Key : %s Value : %s \n", 
106.                entry.getKey(), entry.getValue() 
107.            ); 
108.        } 
109.        System.out.println(); 
110.  
111.  
112.  
113.        /* reverse sort map */ 
114.        Map<String, String> treeMap2 =  
115.            new TreeMap<>(Collections.reverseOrder()); 
116.        treeMap2.putAll(map); 
117.  
118.        for (Map.Entry<String, String> entry : treeMap2.entrySet()) { 
119.            System.out.printf("Key : %s Value : %s \n", 
120.                entry.getKey(), entry.getValue() 
121.            ); 
122.        } 
123.        System.out.println(); 
124.  
125.    } 
126. } 

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

public class TestSort {

    public static void main(String[] args) {

        /* sort array */
        String[] array1 = new String[] {
            "Pineapple", "Apple", "Orange", "Banana"
        };
        Arrays.sort(array1);

        for (String value : array1) {
            System.out.printf("%s, ", value);
        }
        System.out.println("\n");



        /* reverse sort array */
        String[] array2 = new String[] {
            "Pineapple", "Apple", "Orange", "Banana"
        };
        Arrays.sort(array2, Collections.reverseOrder());

        for (String value : array2) {
            System.out.printf("%s, ", value);
        }
        System.out.println("\n");



        /* sort list */
        List<String> list1 = Arrays.asList(
            "Pineapple","Apple", "Orange", "Banana"
        );
        Collections.sort(list1);

        for (String value : list1) {
            System.out.printf("%s, ", value);
        }
        System.out.println("\n");



        /* reverse sort list */
        List<String> list2 = Arrays.asList(
            "Pineapple","Apple", "Orange", "Banana"
        );
        Collections.sort(list2, Collections.reverseOrder());

        for (String value : list2) {
            System.out.printf("%s, ", value);
        }
        System.out.println("\n");



        /* sort set */
        Set<String> set = new HashSet<>();
        set.add("Pineapple");
        set.add("Apple");
        set.add("Orange");
        set.add("Banana");

        Set<String> treeSet1 = new TreeSet<>(set);

        for (String value : treeSet1) {
            System.out.printf("%s, ", value);
        }
        System.out.println("\n");



        /* reverse sort set */
        Set<String> treeSet2 = new TreeSet<>(Collections.reverseOrder());
        treeSet2.addAll(set);

        for (String value : list2) {
            System.out.printf("%s, ", value);
        }
        System.out.println("\n");



        /* sort map */
        Map<String, String> map = new HashMap<>();
        map.put("Pineapple","z");
        map.put("Apple", "g");
        map.put("Orange", "a");
        map.put("Banana", "f");

        Map<String, String> treeMap1 = new TreeMap<>(map);

        for (Map.Entry<String, String> entry : treeMap1.entrySet()) {
            System.out.printf(
                "Key : %s Value : %s \n",
                entry.getKey(), entry.getValue()
            );
        }
        System.out.println();



        /* reverse sort map */
        Map<String, String> treeMap2 = 
            new TreeMap<>(Collections.reverseOrder());
        treeMap2.putAll(map);

        for (Map.Entry<String, String> entry : treeMap2.entrySet()) {
            System.out.printf("Key : %s Value : %s \n",
                entry.getKey(), entry.getValue()
            );
        }
        System.out.println();

    }
}