有没有一种方法可以使用java向递归中的if语句添加条件？

作为练习，我正在尝试开发一个程序来输入加扰的字母，并从给定的字典中找到一个有效的单词。我可以使用嵌套for循环来实现这一点，但是，代码变得庞大且重复。我正在考虑将循环结构重建为递归方法，但我不知道如何以及是否可以通过递归向if语句添加条件

//Sample example for "pie"
//"word" is a linked list stack
//each node in the list is a "letter"
word.push('i');
word.push('p');
word.push('e');
for(int a=word.length();a>0;a--) {
    for(int b=word.length();b>0;b--){
        if(b!=a)
            for(int c=word.length();c>0;c--){
                if(c!=b&&c!=a) {
                    order = {a,b,c};
                    if(IsWord(word.toString(order))){    
                        System.out.println(word.toString(order));
                    }
                }
            }
    }
}

我想做的是一个递归方法，它首先在堆栈中接收置乱的单词，并生成一个int[]，该int[]递归地用于添加到if语句中

第一层有if（b！=a）//两个字母的单词

第二层有if（c！=b&&c！=a）//三个字母的单词

第三层有if（d！=c&&d！=b&&d！=a）//四个字母的单词

等等

public static String descramble(int word) {
    int[] letterPos = new int[word.length()];
    for(int a=wordList[word].length();a>0;a--) {
        letterPos[0] = a;
        return descramble(word, letterPos, 1);
    }
    return null;
}
public static String descramble(int word, int[] letterPos, int pos) {
    if(letterPos.length == pos){//final position, only has one possible letter remaining
        for(int a=wordList[word].length();a>0;a--) {
            letterPos[pos] = a;
            if(letterPos[pos]!=letterPos[pos-1])//this needs to add conditions as the recursion goes deeper
                return word.toString(letterPos);
        }
    }
    for(int a=wordList[word].length();a>0;a--) {
        letterPos[pos] = a;
        if(letterPos[pos]!=letterPos[pos-1])//this needs to add conditions as the recursion goes deeper
            return descramble(word, letterPos, pos+1);
    }
    return null;
}

---

编辑1：我试图解决的一个例子是在你们当地报纸中发现的单词混乱问题。问题相对简单，每个单词有4-6个字符，你应该找到一个由这些字母拼写的有效单词。第一个代码示例是任何三个字母单词的硬示例，for循环遍历所有可能的字母组合，而if语句防止字母重复。一旦给了所有字母一个位置，所生成的字符串将被发送到IsWord（）方法，该方法将遍历字典中的单词列表，直到找到一个有效单词，否则将失败。我的工作没有任何问题，如果有匹配，将返回真/假。

我可以建议稍微不同的算法方法吗。通过将按字符排序的字谜词与类似字符排序键的哈希映射匹配到字典词的值 例如，使用英语单词的词典子集 在这里，abel、labe和bela都允许匹配able

注意，这需要处理一个字谜可以解析为多个单词的情况，例如“same”和“seam”

Map<String, ArrayList<String>> anagramToWord = new HashMap<>();
populateAnagramLookup(anagramToWord);

lookupWord(anagramToWord, "abel");
lookupWord(anagramToWord, "labe");
lookupWord(anagramToWord, "bela");

private void lookupWord(Map<String, ArrayList<String>> anagramToWord, String wordToFind) {
    ArrayList<String> words = anagramToWord.get(lexicallySortWord(wordToFind));
    if (words != null) {
        System.out.println(wordToFind + " found as " + words
                .stream()
                .collect(Collectors.joining(",")));
    } else {
        System.out.println(wordToFind + " not present");
    }
}

private void populateAnagramLookup(Map<String, ArrayList<String>> anagramToWord) {
    Path path = Paths.get("C:\\Addison\\wordlist.10000.txt");

    try {
        FileReader fileReader = new FileReader(path.toFile());
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String word;
        while ((word = bufferedReader.readLine()) != null) {
            String sortedCharacters = lexicallySortWord(word);
            ArrayList<String> foundWords = anagramToWord.computeIfAbsent(sortedCharacters, k -> new ArrayList<String>());
            foundWords.add(word);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

private String lexicallySortWord(String word) {
    char[] chars = word.toCharArray();
    Arrays.sort(chars);
    return new String(chars);
}

Map anagramToWord=newhashmap（）；
普普罗泰纳格拉姆查找（阿纳格朗托福德）；
Lookupford（anagramToWord，“亚伯”）；
Lookupford（anagramToWord，labe）；
Lookupford（Anagramtowordbela）；
私有void查找词（映射anagramToWord，字符串wordToFind）{
ArrayList words=anagramToWord.get（lexicalysortword（wordToFind））；
如果（字！=null）{
System.out.println（wordToFind+“查找为”+单词
.stream（）
.collect（收集器。连接（“，”）；
}否则{
System.out.println（wordToFind+“不存在”）；
}
}
私有void populateanagram查找（映射anagramToWord）{
Path Path=Path.get（“C:\\Addison\\wordlist.10000.txt”）；
试一试{
FileReader FileReader=新的FileReader（path.toFile（））；
BufferedReader BufferedReader=新的BufferedReader（文件阅读器）；
字符串字；
while（（word=bufferedReader.readLine（））！=null）{
字符串sortedCharacters=词汇词条（word）；
ArrayList foundWords=anagramToWord.computeIfAbsent（sortedCharacters，k->new ArrayList（））；
foundWords.add（word）；
}
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
专用字符串LexicalySortword（字符串字）{
char[]chars=word.toCharArray（）；
数组。排序（字符）；
返回新字符串（字符）；
}

我无法真正理解您想要实现的目标，请您添加一个示例来澄清您的问题。按照字母顺序对词典单词的字母进行排序、按照字母顺序对输入单词的字母进行排序以及进行直接比较会容易得多。我没有考虑过这种方法，谢谢。这看起来比我所采取的方法要干净得多。