我创建的代码在查找回文数字时为我提供了数千个解决方案。任务是找到尽可能多的数字：
public static void main(String[] args) {
long product;
outer: for (int i = 999; i >= 100; i--) {
for (int j = 999; j >= 100; j--) {
product = j * i;
if (reverse(product)) {
System.out.printf("%d * %d = %d%n", i, j, product);
continue;
}
}
}
}
private static final boolean reverse(long value) {
String str = String.valueOf(value);
return str.equals(new StringBuilder(str).reverse().toString());
}}
如何才能使代码只显示for循环创建的最高值？
答案 0 :(得分：1)
保存您的产品以供日后比较。 如果你发现一个palindrom与最后一个最高的palindrom相比较。如果它高于保存的值，则将新值存储为最后一个最高的palindrom。同时存储相应的i和j值。 在循环结束时，只打印最后一个最高的palindrom及其i和j值。
答案 1 :(得分：1)
这是我的两分钱。
虽然其他答案包含实际解决问题的有效代码，但它们会严重影响性能。
StringBuilder.reverse() 要检查字符串是否是回文，通常会使用StringBuilder的反向方法。它创建一个新的StringBuilder对象，复制字符串的字符并按相反顺序放置它们。然后检索String实例并将其与原始字符串进行比较
这种方法有两个含义：
最好将第一个字符与最后一个字符进行比较，将第二个字符与第二个字符进行比较，等等。你只需检查前半部分，后半部分已与字符串的前半部分匹配。
所以回文检查功能如下：
private static boolean isPalindrome(String str) {
for (int i = 0; i < str.length() / 2; i++) {
if (str.charAt(i) != str.charAt(str.length() - 1 - i)) {
return false;
}
}
return true;
}
它比使用reverse()大约快七倍。
b已a已被选中，请勿尝试将a与b匹配这个代码段看起来不错，但它不是：
for (int i = 999; i >= 100; i--) {
for (int j = 999; j >= 100; j--) {
...
}
}
检查所有组合需要两倍的时间，因为如果对a检查b，则不必检查b a。以下代码段解决了这个问题：
for (int i = 999; i > 100; i--) {
for (int j = i; j > 100; j--) {
...
}
}
它只会将i存储到j，因此j以i的值开头。
因此，您最好使用此代码：
private static void checkNumbers() {
long max = 0;
long a = 0;
long b = 0;
int lowerBounds = 0;
for (int i = 999; i > lowerBounds; i--) {
for (int j = i; j > lowerBounds ; j--) {
long product = i * j;
// Check if the product is already smaller than our found
// maximum. If that's the case, than any value of j lower
// than the current value of j will always be smaller than
// the currently found value.
if (product <= max) {
break;
}
else if (isPalindrome(String.valueOf(product))) {
max = product;
a = i;
b = j;
// If we found a match, then this is the least of the two
// products of our result. We don't have to go any lower
// than j.
lowerBounds = j;
}
}
}
System.out.println(max);
System.out.println(a + " * " + b);
}
private static boolean isPalindrome(String str) {
for (int i = 0; i < str.length() / 2; i++) {
if (str.charAt(i) != str.charAt(str.length() - 1 - i)) {
return false;
}
}
return true;
}
它比接受的答案至少快15倍。
请注意，有更多方法可以提高性能。例如，您可以存储找到的两个因素中的至少一个，然后i和j都不得低一些。例如：如果我们找到i值为995而j为值583，则我们不得低于583 }。
答案 2 :(得分：0)
当您开始从最大数字到最小数字的迭代时
for (int j = 999; j >= 100; j--)
您将获得的第一个回文数将是最大的回文数。
您将以降序排列结果。
答案 3 :(得分：0)
更新代码，以获得您现在只需打印最大的PALINDROME号码的要求
您将产品作为回文数字，因此请创建数组列表并将结果推送到其中
public static void main(String[] args) {
long product;
ArrayList al=new ArrayList();
outer: for (int i = 999; i >= 100; i--) {
for (int j = 999; j >= 100; j--) {
product = j * i;
if (reverse(product)) {
System.out.printf("%d * %d = %d%n", i, j, product);
al.add(product);
continue;
}
}
}
Collections.sort(al, Collections.reverseOrder());
// System.out.println("ArrayList in descending order:");
System.out.println("The Greatest number is "+al.get(0));
}
在这里，您将按降序获取所有值，因此第一个元素将是最大的回文数
答案 4 :(得分：0)
此代码将解决您的问题。
public static void main(String[] args) {
long product;
long max=0;
outer: for (int i = 999; i >= 100; i--) {
for (int j = 999; j >= 100; j--) {
product = j * i;
if (reverse(product)) {
if(product>max)
{ max=product;
break;
}
continue;
}
}
}
System.out.printf("%d",max);
}
private static final boolean reverse(long value) {
String str = String.valueOf(value);
return str.equals(new StringBuilder(str).reverse().toString());
}}
我所做的是，只保留一个变量max，然后每当你找到一个回文，检查它是否大于最大值，如果是，则设置max = product。
所以，最后得到最大回文数。
注意：观察break声明。我使用它是因为无论何时你找到最大回文，那么具有相同第一个数字的其他回文将小于这个回文。所以你可以直接转到下一个第一个数字。
答案 5 :(得分：-1)
代码中this answer中描述的解决方案：
long highest_palindrome = 0L;
int storeI = 0;
int storeJ = 0;
long product;
outer: for (int i = 999; i >= 100; i--) {
for (int j = 999; j >= 100; j--) {
product = j * i;
if (product < highest_palindrome) break;
if (reverse(product)) {
if (product > highest_palindrome) {
highest_palindrome = product;
storeI = i;
storeJ = j;
}
continue;
}
}
}
System.out.printf("%d * %d = %d%n", storeI, storeJ, highest_palindrome);