1.逆序 

Collections.reverseOrder() 方法对列表进行逆序排序。通过 Collections.sort() 方法配合 Collections.reverseOrder()，可以轻松实现从大到小的排序。

import java.util.ArrayList; // 导入 ArrayList 类，用于创建动态数组
import java.util.Collections; // 导入 Collections 类，提供集合操作工具方法
import java.util.List; // 导入 List 接口，表示一个有序集合

public class ReverseSortExample { // 定义主类
    public static void main(String[] args) { // 程序的入口点
        // 创建一个整数列表，用于存储数字
        List<Integer> numbers = new ArrayList<>();
        
        // 向列表中添加一些数字
        numbers.add(5); // 添加数字 5
        numbers.add(3); // 添加数字 3
        numbers.add(8); // 添加数字 8
        numbers.add(1); // 添加数字 1
        numbers.add(9); // 添加数字 9
        
        // 使用 Collections.sort() 方法对列表进行排序
        // Collections.reverseOrder() 指定排序顺序为逆序（从大到小）
        Collections.sort(numbers, Collections.reverseOrder());
        
        // 输出排序后的列表
        System.out.println(numbers); // 打印结果，例如：[9, 8, 5, 3, 1]
    }
}

2.数位排序

问题描述

小蓝对一个数的数位之和很感兴趣, 今天他要按照数位之和给数排序。当 两个数各个数位之和不同时, 将数位和较小的排在前面, 当数位之和相等时, 将数值小的排在前面。

例如, 2022 排在 409 前面, 因为 2022 的数位之和是 6, 小于 409 的数位 之和 13 。

又如, 6 排在 2022 前面, 因为它们的数位之和相同, 而 6 小于 2022 。

给定正整数 n,mn,m, 请问对 1 到 nn 采用这种方法排序时, 排在第 mm 个的元 素是多少?

输入格式

输入第一行包含一个正整数 nn 。

第二行包含一个正整数 mm 。

输出格式

输出一行包含一个整数, 表示答案。

样例输入

13
5

样例输出

3

 根据数位之和对数字进行排序，并输出第m个数字。数位之和就是把一个数字的每一位加起来，比如数字123的数位之和是1+2+3=6。

自定义排序规则

我们按照以下规则对数字进行排序：

1. 先比较数位之和：数位之和小的数字排在前面。

2. 如果数位之和相同：就按照数字本身的大小排序，小的排在前面。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 读取n
        int m = sc.nextInt(); // 读取m
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= n; i++) {
            list.add(i); // 把1到n的数字添加到列表中
        }
        
        // 使用自定义比较器进行排序
        Collections.sort(list, new Comparator<Integer>() {
            public int compare(Integer a, Integer b) {
                int sumA = digitSum(a); // 计算a的数位之和
                int sumB = digitSum(b); // 计算b的数位之和
                if (sumA != sumB) {
                    return sumA - sumB; // 数位之和小的排在前面
                } else {
                    return a - b; // 数位之和相同，按数值大小排序
                }
            }
        });
        
        System.out.println(list.get(m - 1)); // 输出第m个元素（索引从0开始）
    }

    // 计算一个数字的数位之和
    private static int digitSum(int num) {
        int sum = 0;
        while (num > 0) {
            sum += num % 10; // 取最后一位数字并加到sum中
            num /= 10; // 去掉最后一位数字
        }
        return sum;
    }
}

封闭图形个数

问题描述

在蓝桥王国，数字的大小不仅仅取决于它们的数值大小，还取决于它们所形成的“封闭图形”的个数。

封闭图形是指数字中完全封闭的空间，例如数字 11、22、33、55、77 都没有形成封闭图形，而数字 00、44、66、99 分别形成了 11 个封闭图形，数字 88 则形成了 22 个封闭图形。值得注意的是，封闭图形的个数是可以累加的。例如，对于数字 6868，由于 66 形成了 11 个封闭图形，而 88 形成了 22 个，所以 6868 形成的封闭图形的个数总共为 33。

在比较两个数的大小时，如果它们的封闭图形个数不同，那么封闭图形个数较多的数更大。例如，数字 4141 和数字 1818，它们对应的封闭图形的个数分别为 11 和 22，因此数字 4141 小于数字 1818。如果两个数的封闭图形个数相同，那么数值较大的数更大。例如，数字 1414 和数字 4141，它们的封闭图形的个数都是 11，但 14<4114<41，所以数字 1414 小于数字 4141。 如果两个数字的封闭图形个数和数值都相同，那么这两个数字被认为是相等的。

小蓝对蓝桥王国的数字大小规则十分感兴趣。现在，他将给定你 nn 个数 a1,a2,…,ana1​,a2​,…,an​，请你按照蓝桥王国的数字大小规则，将这 nn 数从小到大排序，并输出排序后结果。

输入格式

第一行包含一个整数 nn，表示给定的数字个数。

第二行包含 nn 个整数 a1,a2,…,ana1​,a2​,…,an​，表示待排序的数字。

输出格式

输出一行，包含 nn 个整数，表示按照蓝桥王国的数字大小规则从小到大排序后的结果，每两个数字之间用一个空格分隔。

样例输入

3
18 29 6

样例输出

6 29 18

样例说明

对于给定的数字序列 [18,29,6][18,29,6]，数字 1818 的封闭图形个数为 22，数字 2929 的封闭图形个数为 11，数字 66 的封闭图形个数为 11。按照封闭图形个数从小到大排序后，得到 [29,6,18][29,6,18]。

由于数字 2929 和数字 66 的封闭图形个数相同，因此需要进一步按照数值大小对它们进行排序，最终得到 [6,29,18][6,29,18]。

做题思路:根据数字中“封闭图形”的数量对数字进行排序。所谓“封闭图形”是指数字中某些部分是封闭的，比如：

• 数字0、4、6、9各有一个封闭图形。

• 数字8有两个封闭图形。

• 数字1、2、3、5、7没有封闭图形。

•  自定义排序规则

  我们按照以下规则对数字进行排序：

• 先比较封闭图形的数量：封闭图形数量少的数字排在前面。

• 如果封闭图形数量相同：就按照数字本身的大小排序，小的排在前面。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class hh {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 读取n，表示要处理的数字个数
        List<Integer> list = new ArrayList<>();
        for (int i = 1; i <= n; i++) {
            list.add(sc.nextInt()); // 读取n个数字并添加到列表中
        }
        
        // 使用自定义比较器进行排序
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                int suma = f(o1); // 计算o1的封闭图形数量
                int sumb = f(o2); // 计算o2的封闭图形数量
                if (suma == sumb) {
                    return o1 - o2; // 封闭图形数量相同，按数字大小排序
                } else {
                    return suma - sumb; // 封闭图形数量少的排在前面
                }
            }
        });
        
        // 输出排序后的列表
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
    }

    // 计算一个数字中封闭图形的数量
    public static int f(int m) {
        int sum = 0;
        while (m > 0) {
            int a = m % 10; // 取数字的最后一位
            if (a == 0 || a == 4 || a == 6 || a == 9) {
                sum += 1; // 这些数字有一个封闭图形
            } else if (a == 8) {
                sum += 2; // 数字8有两个封闭图形
            } else {
                sum += 0; // 其他数字没有封闭图形
            }
            m = m / 10; // 去掉最后一位数字
        }
        return sum;
    }
}