一、单个数字重排生成最大数和最小数 #

核心思路 #

要生成给定数字的最大数和最小数，关键是对数字的每一位做针对性排序：

• 最大数：把数字的每一位按降序排列，直接拼接就能得到最大的组合。
• 最小数：先按升序排列每一位，但要注意首位不能为0——如果排序后首位是0，得找到第一个非0的数字和首位交换位置，再拼接剩余数字。

Java实现代码 #

import java.util.Arrays;

public class NumberRearranger {
    public static void main(String[] args) {
        long inputNum = 3134059; // 示例输入
        rearrangeToMaxMin(inputNum);
    }

    public static void rearrangeToMaxMin(long num) {
        // 把数字转成字符数组，方便排序操作
        char[] digits = String.valueOf(num).toCharArray();
        
        // 生成最大数：升序排序后反转数组得到降序
        char[] maxDigits = digits.clone();
        Arrays.sort(maxDigits);
        reverseCharArray(maxDigits);
        long maxNum = Long.parseLong(new String(maxDigits));
        
        // 生成最小数：升序排序，处理首位为0的情况
        char[] minDigits = digits.clone();
        Arrays.sort(minDigits);
        if (minDigits[0] == '0') {
            // 找到第一个非0的数字索引
            int nonZeroIdx = 0;
            while (nonZeroIdx < minDigits.length && minDigits[nonZeroIdx] == '0') {
                nonZeroIdx++;
            }
            // 交换首位和第一个非0数字的位置
            char temp = minDigits[0];
            minDigits[0] = minDigits[nonZeroIdx];
            minDigits[nonZeroIdx] = temp;
        }
        long minNum = Long.parseLong(new String(minDigits));
        
        System.out.println("输入数字：" + num);
        System.out.println("最大数：" + maxNum);
        System.out.println("最小数：" + minNum);
    }

    // 辅助方法：反转字符数组
    private static void reverseCharArray(char[] arr) {
        int left = 0, right = arr.length - 1;
        while (left < right) {
            char temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
}

运行结果 #

输入数字：3134059
最大数：9543310
最小数：1033459

二、修复数组数字组合最大数的Java代码 #

先拆解你遇到的4个编译错误，再给出修复后的完整代码：

编译错误原因解析 #

1. Scanner方法误用：sc.nextString()不是Scanner的合法方法，应该用sc.next()读取字符串。
2. 匿名内部类语法错误：new Comparator<String>()后面缺少{}，匿名内部类必须用{}包裹要实现的方法。
3. 注解位置错误：@Override必须放在要重写的方法上方，且要处于匿名内部类的范围内，不能写在外部。
4. 比较逻辑混乱：原代码的return XY.compareTo(YX)?1:-1;逻辑错误，没有正确实现降序比较的需求。

修复后的完整代码 #

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter The Size of Array");
        int n = sc.nextInt();
        // 跳过nextInt()留下的换行符，避免读取空字符串
        sc.nextLine();
        String[] arr = new String[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.next();
        }
        printLargest(arr);
        sc.close();
    }

    static void printLargest(String[] arr) {
        // 修复匿名内部类语法，正确实现Comparator逻辑
        Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String X, String Y) {
                String XY = X + Y;
                String YX = Y + X;
                // 按组合后的字符串降序排列，确保大的组合排在前面
                return YX.compareTo(XY);
            }
        });

        // 处理数组全为0的特殊情况，避免输出多个0
        if (arr[0].equals("0")) {
            System.out.println("0");
            return;
        }

        // 拼接结果并输出
        StringBuilder result = new StringBuilder();
        for (String numStr : arr) {
            result.append(numStr);
        }
        System.out.println("最大组合数：" + result.toString());
    }
}

代码说明 #

• Scanner优化：添加sc.nextLine()跳过换行符，避免读取空字符串的问题。
• Comparator逻辑：通过比较X+Y和Y+X的大小，按降序排序，保证组合后的数字最大。
• 特殊情况处理：如果数组全为0，直接输出"0"，而不是重复的0字符串。
• 资源管理：添加sc.close()关闭Scanner，避免资源泄漏。

测试示例 #

输入：

Enter The Size of Array
3
3 30 34

输出：

最大组合数：34330

内容的提问来源于stack exchange，提问作者Garvit Tyagi