Java排序

冒泡排序

    public static void main(String[] args) {
        // 定义数组
        int data[] = new int[4];
        // 初始化数组
        initData(data);
        System.out.println(JSON.toJSONString(data));
        // 冒泡排序
        bubbleSort(data);
        System.out.println(JSON.toJSONString(data));
    }

    /**
     * 冒泡排序：
     * 每次比较从第一个数据开始，数据两两比较，如果左边数据比右边数据大，则交换左右数据。
     * 继续比较。
     * 一次比较结束出现一个最大值在最后一个位置。
     */
    private static void bubbleSort(int[] data) {
        for (int i = data.length - 1; i > 0; i--) {
            // 每次比较冒泡的过程(查找最大值的过程)
            // 每次从第一个数据开始，将最大值往后放
            // 因此j每次都是从零开始。
            for (int j = 0; j < i; j++) {
                // 数据交换
                if (data[j] > data[j + 1]) {
                    int temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                }
            }
        }
    }

    private static void initData(int data[]) {
        for (int i = 0; i < data.length; i++) {
            data[i] = (int) Math.ceil(Math.random() * 10);
        }
    }

lambda表达式排序

1、基本类型集合

    public static void main(String[] args) {
        // 初始化集合
        List<Integer> list = Arrays.asList(new Integer[] { 6, 3, 8, 2, 1 });
        // 正序
        list.sort((a, b) -> a.compareTo(b));
        list.sort(Comparator.comparing(a -> a));
        list.sort((a, b) -> a - b);
        list.sort(new Comparator<Integer>() {
            //匿名内部类
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        // 降序
        list.sort((a, b) -> b - a);
        list.sort(new Comparator<Integer>() {

            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(list);
    }

2、对象集合

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

 3、多字段排序

    public List<Map<String, Object>> sortMap(List<Map<String, Object>> list_map, String column, String column2) {
        Collections.sort(list_map, new Comparator<Map<String, Object>>() {

            @Override
            public int compare(Map<String, Object> o1, Map<String, Object> o2) {
                int value = getCompValue(o1, o2, column);
                if (value == 0) {
                    value = getCompValue(o1, o2, column2);
                }
                return value;
            }
        });
        return list_map;
    }

    private static int getCompValue(Map<String, Object> o1, Map<String, Object> o2, String column) {
        if (JtCommonUtil.strIsNull(o1.get(column) + "") && !JtCommonUtil.strIsNull(o2.get(column) + ""))
            return -1;
        if (!JtCommonUtil.strIsNull(o1.get(column) + "") && JtCommonUtil.strIsNull(o2.get(column) + ""))
            return 1;
        if (JtCommonUtil.strIsNull(o1.get(column) + "") && JtCommonUtil.strIsNull(o2.get(column) + ""))
            return 0;
        return Integer.valueOf(o1.get(column) + "").compareTo(Integer.valueOf(o2.get(column) + ""));
    }