本文详细介绍了如何通过重排任意三位正整数的数字来获取所能构成的最大整数。文章提供了两种java实现方法：一种是利用stream api对数字进行排序，另一种是采用迭代方式直接比较和排列数字。通过这两种方法，读者可以高效地解决数字重排问题，并理解其背后的核心逻辑，适用于处理数字组合优化场景。
引言
在程序设计中，我们有时会遇到需要对一个给定数字的各位数字进行重排，以形成一个新的数字。对于一个任意的三位正整数 n（范围在100到999之间），如果允许我们重新排列它的各位数字，我们如何才能得到所有可能排列中最大的那个整数呢？例如，给定数字165，通过重排可以得到156, 165, 516, 561, 615, 651等，其中最大的数是651。本文将深入探讨解决此问题的两种高效Java实现方法。
核心原理
要从一个数字的各位数字中构造出最大的新数字，核心原理是将其所有数字按照降序排列。例如，对于数字152，其各位数字是1、5、2。将它们降序排列得到5、2、1。然后，按照这个顺序将它们组合起来，即521，这就是所能构成的最大整数。这个原理同样适用于包含重复数字的情况，例如868，降序排列为8、8、6，组合为886。
方法一：基于Stream API的排序实现
Java 8引入的Stream API提供了一种简洁而强大的方式来处理集合数据。我们可以利用它来提取数字的各位，进行排序，然后重新组合。
实现步骤
- 将整数转换为字符串： 方便地将数字拆分为独立的字符。
- 拆分字符并转换为数字流： 将字符串拆分为单个字符的数组，然后转换为整数流。
- 降序排序： 对数字流进行降序排列。
- 重新组合： 将排序后的数字逐个组合成新的整数。
示例代码
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
public class MaxPermutedNumber {
/**
* 使用Stream API和排序获取三位整数的最大重排数
* @param n 待处理的三位正整数 (100 <= n <= 999)
* @return 重排后能得到的最大整数
*/
public static int getMaxNumberWithStreams(int n) {
if (n < 100 || n > 999) {
throw new IllegalArgumentException("输入数字必须是三位正整数 (100-999)");
}
return Arrays.stream(Integer.toString(n).split("")) // 将整数转为字符串，再按位拆分
.sorted(Comparator.reverseOrder()) // 降序排序
.mapToInt(Integer::parseInt) // 将字符串数字转为整数
.reduce(0, (accumulator, digit) -> accumulator * 10 + digit); // 组合成最终数字
}
public static void main(String[] args) {
Random r = new Random();
System.out.println("--- Stream API 方法示例 ---");
for (int i = 0; i < 10; i++) {
int value = r.nextInt(900) + 100; // 生成100到999之间的随机数
int max = getMaxNumberWithStreams(value);
System.out.println(value + " -> " + max);
}
System.out.println("\n--- 固定测试用例 ---");
System.out.println("165 -> " + getMaxNumberWithStreams(165)); // 651
System.out.println("123 -> " + getMaxNumberWithStreams(123)); // 321
System.out.println("868 -> " + getMaxNumberWithStreams(868)); // 886
System.out.println("901 -> " + getMaxNumberWithStreams(901)); // 910
}
}代码解析
- Integer.toString(n).split(""): 将整数 n 转换为字符串，然后使用空字符串作为分隔符将其拆分为一个字符串数组，每个元素是一个数字字符。
- sorted(Comparator.reverseOrder()): 对字符串数组进行降序排序。由于是数字字符，Comparator.reverseOrder() 会按字典序降序排列，这对于单个数字字符来说等同于数值降序。
- mapToInt(Integer::parseInt): 将排序后的字符串数字转换回整数。
- reduce(0, (accumulator, digit) -> accumulator * 10 + digit): 这是一个归约操作。accumulator 初始值为0，每次迭代将当前数字 digit 添加到 accumulator 的末尾，形成新的整数。例如，如果 accumulator 是5，digit 是2，则 5 * 10 + 2 得到52。
示例输出
--- Stream API 方法示例 --- 105 -> 510 694 -> 964 983 -> 983 432 -> 432 792 -> 972 868 -> 886 979 -> 997 839 -> 983 803 -> 830 911 -> 911 --- 固定测试用例 --- 165 -> 651 123 -> 321 868 -> 886 901 -> 910
方法二：迭代式数字比较与重排
除了使用Stream API进行排序，我们也可以通过迭代和比较的方式，在不显式创建数组或进行完整排序的情况下，找出最大的三个数字并按降序排列。这种方法避免了字符串转换和Stream操作的开销，可能在某些场景下更为高效。
实现步骤
- 初始化： 定义三个变量 max1, max2, max3 分别存储当前遇到的最大、次大和第三大数字，初始值为0。
- 逐位提取： 使用 while 循环和取模/除法运算，从原始数字中逐位提取数字。
-
比较与更新： 对于每个提取出的数字 d，与 max1, max2, max3 进行比较：
- 如果 d 大于 max1，则 d 成为新的 max1，原 max1 降为 max2，原 max2 降为 max3。
- 如果 d 小于 max1 但大于 max2，则 d 成为新的 max2，原 max2 降为 max3。
- 如果 d 小于 max2 但大于 max3，则 d 成为新的 max3。
- 组合结果： 循环结束后，将 max1, max2, max3 按照 ((max1 * 10) + max2) * 10 + max3 的方式组合成最终的整数。
示例代码
import java.util.Random;
public class MaxPermutedNumberIterative {
/**
* 使用迭代方式获取三位整数的最大重排数
* @param n 待处理的三位正整数 (100 <= n <= 999)
* @return 重排后能得到的最大整数
*/
public static int getMaxNumberIterative(int n) {
if (n < 100 || n > 999) {
throw new IllegalArgumentException("输入数字必须是三位正整数 (100-999)");
}
int max1 = 0, max2 = 0, max3 = 0; // 存储最大、次大、第三大数字
int temp = n; // 保存原始值用于打印
while (n > 0) {
int digit = n % 10; // 获取当前数字的最后一位
if (digit > max1) {
max3 = max2;
max2 = max1;
max1 = digit;
} else if (digit > max2) {
max3 = max2;
max2 = digit;
} else if (digit > max3) {
max3 = digit;
}
n /= 10; // 移除最后一位，处理下一个数字
}
// 组合成最终的整数
return (((max1 * 10) + max2) * 10) + max3;
}
public static void main(String[] args) {
Random r = new Random();
System.out.println("--- 迭代方法示例 ---");
for (int i = 0; i < 10; i++) {
int value = r.nextInt(900) + 100; // 生成100到999之间的随机数
int max = getMaxNumberIterative(value);
System.out.println(value + " -> " + max);
}
System.out.println("\n--- 固定测试用例 ---");
System.out.println("165 -> " + getMaxNumberIterative(165)); // 651
System.out.println("123 -> " + getMaxNumberIterative(123)); // 321
System.out.println("868 -> " + getMaxNumberIterative(868)); // 886
System.out.println("901 -> " + getMaxNumberIterative(901)); // 910
}
}代码解析
- while (n > 0) 循环：确保处理了数字的所有位。
- int digit = n % 10;: 提取当前数字的个位。
- if-else if 结构：这是核心逻辑，用于维护 max1, max2, max3 始终保持降序排列。当发现一个更大的数字时，原有的最大数字会依次“下沉”到次大、第三大的位置。
- n /= 10;: 将数字 n 右移一位，以便在下一次循环中处理其十位（原百位）。
- (((max1 * 10) + max2) * 10) + max3;: 将找到的三个最大数字按照降序组合成一个三位整数。
示例输出
--- 迭代方法示例 --- 105 -> 510 694 -> 964 983 -> 983 432 -> 432 792 -> 972 868 -> 886 979 -> 997 839 -> 983 803 -> 830 911 -> 911 --- 固定测试用例 --- 165 -> 651 123 -> 321 868 -> 886 901 -> 910
总结与注意事项
本文介绍了两种在Java中解决“通过重排三位正整数的数字获取最大值”问题的方法：
- Stream API 排序法： 简洁、表达力强，利用Java 8的特性，代码可读性高。适用于对数字位数不敏感或需要处理更复杂集合操作的场景。
- 迭代式比较法： 效率较高，避免了字符串转换和额外的内存分配（如数组），直接进行数字操作。对于固定位数（如本例中的三位）的数字处理，其性能可能略优。
两种方法的核心思想都是将数字的各位进行降序排列。在实际应用中，选择哪种方法取决于具体的性能要求、代码风格偏好以及Java版本。对于本例中的三位整数，两种方法的性能差异可以忽略不计。重要的是理解其背后的逻辑：为了获得最大的数字，始终将最大的可用数字放在最高位。
