Java 替代嵌套循环以提高代码性能？

我已经做了一个小程序，检查哪些索引需要删除，使其成为回文。由于在一次执行中可能有许多测试用例，我不得不使用for循环的深层嵌套。我想知道是否有其他方法可以嵌套循环以提高性能

以下是我的代码：

 import java.util.*;
 import java.io.*;
 public class Testhis {
 public static void main(String[] args) throws Exception {
      Scanner sc=new Scanner(System.in);
     //System.out.println("No. of testcases:");
     int testcases=sc.nextInt();
     String strin[]=new String[testcases];

     for (int i=0;i<testcases;i++)
            strin[i]=sc.next();
     int res[]= checkPalindromeIndex(strin);
     for(int i=0;i<res.length;i++)
       System.out.println(res[i]);
     }

   private static int[] checkPalindromeIndex(String[] strin) {
      int result[]=new int[strin.length];
      a:
      for(int i=0;i<strin.length;i++){
        System.out.println("checking:::::"+strin[i]);
        if(checkPalFlag(strin[i])){
            result[i]=-1;
            continue a;
        }
        else{

            for(int j=0;j<strin[i].length();j++){
                StringBuilder sb=new StringBuilder(strin[i]);
                String teststr=sb.deleteCharAt(j).toString();
                System.out.println("resulting string:"+teststr);
                if(checkPalFlag(teststr)){
                    result[i]=j;
                    continue a;
                }
            }

    }


 }
    return result;
}

private static boolean checkPalFlag(String string) {
    boolean flag=false;int len=string.length();
    for(int i=0;i<(len+1)/2;i++){
        if(string.charAt(i)==string.charAt(len-(i+1))){
            flag=true;
            continue;
        }
        else{
            flag=false;
            break;
        }
    }
    System.out.println("string "+string+" is a palindrome? :"+flag);
    return flag;
}

}

import java.util.*；
导入java.io.*；
公共类测试{
公共静态void main（字符串[]args）引发异常{
扫描仪sc=新的扫描仪（System.in）；
//System.out.println（“测试用例数：”）；
int testcases=sc.nextInt（）；
strin[]=新字符串[testcases]；
对于（inti=0；i，以下代码将返回文本的所有回文

private static String[] findAllPalindromesInText(String text) {
    // Eliminate all non-letter/digit from text
    String normalized = text.toLowerCase(Locale.ROOT).replaceAll("[^\\p{Ll}\\p{N}]", "");
    // Collect all palindromes
    Set<String> allPalindromes = new HashSet<>();
    findPalindromes(normalized, 0, normalized.length() - 1, "", "", allPalindromes);
    // Sort palindromes
    String[] result = allPalindromes.toArray(new String[allPalindromes.size()]);
    Arrays.sort(result, (s1, s2) -> {
        int cmp = Integer.compare(s2.length(), s1.length()); // sort longest first
        if (cmp == 0)
            cmp = s1.compareTo(s2); // sort by text
        return cmp;
    });
    return result;
}
private static void findPalindromes(String text, int first, int last,
                                    String prefix, String suffix, Set<String> allPalindromes) {
    for (int i = first; i <= last; i++) {
        char ch = text.charAt(i);
        allPalindromes.add(prefix + ch + suffix);
        for (int j = last; j > i; j--)
            if (text.charAt(j) == ch) {
                allPalindromes.add(prefix + ch + ch + suffix);
                findPalindromes(text, i + 1, j - 1, prefix + ch, ch + suffix, allPalindromes);
            }
    }
}

findPalindromes（）
的最后3个参数用于收集结果。如果要收集回文字符的索引，可以进行更改

如果要删除字符的索引，我建议您收集回文字符的索引，即要保留的索引，然后在
findPalindromes（）返回后将结果反转为要删除的索引

请注意，尽管此算法比您的算法简单，但如果您想要最长回文，它可能不会更快，因为您必须搜索所有可能的回文。请注意，第三个测试用例确实有一个使用前3个字母的回文
abcba
，但最长回文不会使用前3个字母的全部。
I'm vot我想以离题的形式结束这个问题，因为这个问题属于on。你的意思是这不是一个有效的问题吗？我不希望我的代码被审查。我希望问题的解决方案被审查，而不是代码被审查。代码只是一个例子也许最好用书面文字/伪代码来解释你的方法，而不是在输入的实际代码中，
abcb
，我可以看到以下内容：
a
，
b
，
c
，
bb
，
bcb
。你想要哪一个？如果第一个，答案是删除索引1,2,3。如果最后一个，答案是删除索引0。你没有说你想要最长的回文，所以第一个最简单，但如果你想要的话想要最长的回文，如果有多个最长回文的候选项，您想要哪一个？您正在寻找最短回文、最长回文、任何或每个可能的组合吗？+1.您还可以使用标准比较器进行排序：
Arrays.sort（result，Comparator.comparingInt（String:：length）.reversed（）。然后进行比较（比较器‌​订单（））；
// for input "abcb"
[bcb, bb, a, b, c]

// for input "alibaba"
[ababa, abba, aaa, aba, aia, ala, bab, aa, bb, a, b, i, l]

// for input "abcdabdcabc"
[acdadca, acdbdca, bcdadcb, bcdbdcb, acddca, bcddcb, ababa, abcba, abdba, acaca, acbca, acdca, adada, adbda, babab, bacab, badab, bcacb, bcbcb, bcdcb, bdadb, bdbdb, cabac, cacac, cadac, cbabc, cbcbc, cbdbc, cdadc, cdbdc, abba, acca, adda, baab, bccb, bddb, caac, cbbc, cddc, aaa, aba, aca, ada, bab, bbb, bcb, bdb, cac, cbc, ccc, cdc, dad, dbd, aa, bb, cc, dd, a, b, c, d]