笔试算法准备系列——排序比较器在数组、字符串中的使用

分别比较在int[]数组、Integer[]数组、String数组、list集合中使用Java中常用的排序工具类：

public class TestComparator {

    /**
     * 测试不同情况下的比较器使用
     */
    public static void main(String[] args) {
        //测试comparator的使用
        System.out.println("对int[]数组进行排列： ");
        int[] n1 = {1,4,5,2,3};
        Arrays.sort(n1);
        //n1的升序排列
        System.out.println("对int[]数组升序排列： " + Arrays.toString(n1));
        //Arrays工具包中默认没有对基本类型int数组的降序排列,所以只能自己实现对int类型数组降序排列
        //主要的实现思路就是对升序排列过后的数组翻个头
        int j = n1.length - 1;
        for (int i = 0; i < n1.length / 2; i++) {
            int temp = n1[j];
            n1[j] = n1[i];
            n1[i] = temp;
            j--;
        }
        System.out.println("对int[]数组降序排列: " + Arrays.toString(n1));

        System.out.println("对Integer[]数组进行排列： ");

        Integer[] n2 = {1,4,5,2,3};
        Arrays.sort(n2, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //升序排列
                return o1 - o2;
            }
        });
        //上边的写法等同于：
        Arrays.sort(n2);
        //也等同于
        Arrays.sort(n2,(o1,o2) -> o1 - o2);
        System.out.println("对Integer[]数组进行升序排列： " + Arrays.toString(n2));

        Arrays.sort(n2, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        //上边的写法等同于：
        Arrays.sort(n2,Comparator.reverseOrder());
        System.out.println("对Integer[]数组进行降序排列： " + Arrays.toString(n2));

        //对list集合中的数字排序
        System.out.println("对list集合中的数字排序");

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(4);
        list.add(5);
        list.add(2);
        list.add(3);
        Collections.sort(list);
        System.out.println("对list集合进行升序排列： " + list);

        Collections.sort(list,Collections.reverseOrder());
        System.out.println("对list集合进行降序排列： " + list);


        //对于字符串的按照字典序排序
        System.out.println("对字符串的list集合排序");
        List<String> strList = new ArrayList<>();
        strList.add("cap");
        strList.add("to");
        strList.add("cat");
        strList.add("card");
        strList.add("two");
        strList.add("too");
        strList.add("up");
        strList.add("boat");
        strList.add("boot");

        System.out.println("字符串集合排序前的样子：" + strList);

        Collections.sort(strList, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                char[] chars1=o1.toCharArray();
                char[] chars2=o2.toCharArray();
                int i=0;
                while(i<chars1.length && i<chars2.length){
                    if(chars1[i]>chars2[i]){
                        return 1;
                    }else if(chars1[i]<chars2[i]){
                        return -1;
                    }else{
                        i++;
                    }
                }
                if(i==chars1.length){  //o1到头
                    return -1;
                }
                if(i== chars2.length){ //o2到头
                    return 1;
                }
                return 0;
            }
        });
        System.out.println("字符串集合按照字典序排序后的样子(自定义)：" + strList);
        //直接使用sort的排序和上边的效果是一样的
        Collections.sort(strList);
        System.out.println("字符串集合按照字典序排序后的样子(Collections)：" + strList);

        //反字典序排序
        Collections.sort(strList,Collections.reverseOrder());
        System.out.println("字符串集合按照字典序反排序后的样子(Collections)：" + strList);

        //二维数组的排序
        System.out.println("二维数组的排序");
        int[][] arr = {{1,3},{2,6},{15,18},{8,10}};
        String str1 = "";
        for (int[] num : arr) {
            str1 += Arrays.toString(num) + " , ";
        }
        System.out.println("没有排序之前的数组样子：" + str1);
        //按照数组的第一个数字大小从小到大排列
        Arrays.sort(arr,((o1, o2) -> o1[0] - o2[0]));
        str1 = "";
        for (int[] num : arr) {
            str1 += Arrays.toString(num) + " , ";
        }
        System.out.println("按照数组的首位数字大小排序：" + str1);

    }

	//寻找不同的数字组合下，能组合出的最大数字
	public String largestNumber(int[] nums) {
        String[] strs = new String[nums.length];
        for (int i = 0; i < nums.length; i++) {
            strs[i] = String.valueOf(nums[i]);
        }
        //对数组按照指定的规则排序
        Arrays.sort(strs,new LargestStringComparator());
        String res = "";
        //假如字符串数组中的第一个字符串都为“0”，那么全部的字符串肯定都为0，直接返回0即可
        if ("0".equals(strs[0])) {
            return "0";
        }
        //将字符串数组转换成字符串
        for (String str : strs) {
            res += str;
        }
        return res;
    }

    //寻找不同数字组合的情况下，整个数组能组合出来的最大数字
    static class LargestStringComparator implements Comparator<String> {
        @Override
        public int compare(String s1, String s2) {
            String order1 = s1 + s2;
            String order2 = s2 + s1;
            return order2.compareTo(order1);
        }
    }

    //字典的比较器1
    //长度较长的集合排在后边，短的排在前边，如果两个集合的长度相等，那么集合里边的元素大的排列在后边
    static class SizeComparator implements Comparator<List<Integer>> {
        @Override
        public int compare(List<Integer> l1, List<Integer> l2) {
            if (l1.size() > l2.size()) {
                return 1;
            } else {
                if (l1.size() == l2.size()) {
                    for (int i = 0; i < l1.size(); i++) {
                        if (!l1.get(i).equals(l2.get(i))) {
                            return l1.get(i) > l2.get(i) ? 1 : -1;
                        }
                    }
                }
                return -1;
            }
        }
    }

}

输出：

对int[]数组进行排列： 
对int[]数组升序排列： [1, 2, 3, 4, 5]
对int[]数组降序排列: [5, 4, 3, 2, 1]
对Integer[]数组进行排列： 
对Integer[]数组进行升序排列： [1, 2, 3, 4, 5]
对Integer[]数组进行降序排列： [5, 4, 3, 2, 1]
对list集合中的数字排序
对list集合进行升序排列： [1, 2, 3, 4, 5]
对list集合进行降序排列： [5, 4, 3, 2, 1]
对字符串的list集合排序
字符串集合排序前的样子：[cap, to, cat, card, two, too, up, boat, boot]
字符串集合按照字典序排序后的样子(自定义)：[boat, boot, cap, card, cat, to, too, two, up]
字符串集合按照字典序排序后的样子(Collections)：[boat, boot, cap, card, cat, to, too, two, up]
字符串集合按照字典序反排序后的样子(Collections)：[up, two, too, to, cat, card, cap, boot, boat]
二维数组的排序
没有排序之前的数组样子：[1, 3] , [2, 6] , [15, 18] , [8, 10] , 
按照数组的首位数字大小排序：[1, 3] , [2, 6] , [8, 10] , [15, 18] ,