Java排序

冒泡排序

 1     public static void main(String[] args) {
 2         // 定义数组
 3         int data[] = new int[4];
 4         // 初始化数组
 5         initData(data);
 6         System.out.println(JSON.toJSONString(data));
 7         // 冒泡排序
 8         bubbleSort(data);
 9         System.out.println(JSON.toJSONString(data));
10     }
11 
12     /**
13      * 冒泡排序：
14      * 每次比较从第一个数据开始，数据两两比较，如果左边数据比右边数据大，则交换左右数据。
15      * 继续比较。
16      * 一次比较结束出现一个最大值在最后一个位置。
17      */
18     private static void bubbleSort(int[] data) {
19         for (int i = data.length - 1; i > 0; i--) {
20             // 每次比较冒泡的过程(查找最大值的过程)
21             // 每次从第一个数据开始，将最大值往后放
22             // 因此j每次都是从零开始。
23             for (int j = 0; j < i; j++) {
24                 // 数据交换
25                 if (data[j] > data[j + 1]) {
26                     int temp = data[j];
27                     data[j] = data[j + 1];
28                     data[j + 1] = temp;
29                 }
30             }
31         }
32     }
33 
34     private static void initData(int data[]) {
35         for (int i = 0; i < data.length; i++) {
36             data[i] = (int) Math.ceil(Math.random() * 10);
37         }
38     }

lambda表达式排序

1、基本类型集合

 1     public static void main(String[] args) {
 2         // 初始化集合
 3         List<Integer> list = Arrays.asList(new Integer[] { 6, 3, 8, 2, 1 });
 4         // 正序
 5         list.sort((a, b) -> a.compareTo(b));
 6         list.sort(Comparator.comparing(a -> a));
 7         list.sort((a, b) -> a - b);
 8         list.sort(new Comparator<Integer>() {
 9             //匿名内部类
10             @Override
11             public int compare(Integer o1, Integer o2) {
12                 return o1 - o2;
13             }
14         });
15         // 降序
16         list.sort((a, b) -> b - a);
17         list.sort(new Comparator<Integer>() {
18 
19             @Override
20             public int compare(Integer o1, Integer o2) {
21                 return o2 - o1;
22             }
23         });
24         System.out.println(list);
25     }

2、对象集合

 1     public static void main(String[] args) {
 2         List<User> list1 = new ArrayList<User>();
 3         User user = new User("张三", "15", "男");
 4         User user1 = new User("李四", "10", "男");
 5         list1.add(user);
 6         list1.add(user1);
 7         //1、年龄升序
 8         list1.sort((a,b) -> a.getAge().compareTo(b.getAge()));
 9         //2、姓名降序排列
10         list1.sort(Comparator.comparing(User::getName).reversed());
11         //等价于 2
12         list1.sort(Comparator.comparing(a->((User)a).getAge()).reversed());
13         //3、先按性别排，如果年龄相同，再按年龄排序
14         list1.sort(Comparator.comparing(User::getSex).reversed().thenComparing(User::getAge));
15     }

3、多字段排序

 1     public List<Map<String, Object>> sortMap(List<Map<String, Object>> list_map, String column, String column2) {
 2         Collections.sort(list_map, new Comparator<Map<String, Object>>() {
 3 
 4             @Override
 5             public int compare(Map<String, Object> o1, Map<String, Object> o2) {
 6                 int value = getCompValue(o1, o2, column);
 7                 if (value == 0) {
 8                     value = getCompValue(o1, o2, column2);
 9                 }
10                 return value;
11             }
12         });
13         return list_map;
14     }
15 
16     private static int getCompValue(Map<String, Object> o1, Map<String, Object> o2, String column) {
17         if (JtCommonUtil.strIsNull(o1.get(column) + "") && !JtCommonUtil.strIsNull(o2.get(column) + ""))
18             return -1;
19         if (!JtCommonUtil.strIsNull(o1.get(column) + "") && JtCommonUtil.strIsNull(o2.get(column) + ""))
20             return 1;
21         if (JtCommonUtil.strIsNull(o1.get(column) + "") && JtCommonUtil.strIsNull(o2.get(column) + ""))
22             return 0;
23         return Integer.valueOf(o1.get(column) + "").compareTo(Integer.valueOf(o2.get(column) + ""));
24     }