Java 递归将一个单词分成三个或更多单词

我正在尝试编写一个程序，该程序将从dictionary.txt文档中获取输入，并将单词存储在字典列表中，然后确定该单词是否可以拆分为三个或更多单词，如果可以，然后打印出原始单词，后跟新词，例如，

discosolateness:disc on so lateness

，这将是composedMore.txt文档中的输出。现在，代码只是继续运行，但我没有得到任何输出，我不确定我做错了什么。如果您能提供任何帮助，我们将不胜感激。我已经在下面发布了我的代码，输入的是字典中的任何单词

import java.util.*;
import java.io.*;
public class CompositionTwo
{
    private static List<String> dictionary = new ArrayList<>();
    public static void main(String []args) { 
        File inputFile = new File("dictionary.txt");
        File outputFile = new File("composedMore.txt");
        Scanner in = null;
        PrintWriter out = null;

        try {
            in = new Scanner(inputFile);
            out = new PrintWriter(outputFile);
            while (in.hasNext()) {
                String input = in.next();
                dictionary.add(input);
                String output = splitWord(input, "");
                if (output != "") {
                    out.println(input + ":" + output);
                }
            }
        } catch (IOException e) {
            System.out.println("An IOException has occurred during output process.");
        } finally {
            in.close();
            out.close();
        }

    } 

    public static String splitWord(String word, String output) {

        if (word.length() == 0) {
            output = output;
        }
        else {
            for (int i = 1; i <= word.length(); i++) {
                // consider all prefixes of current String
                String prefix = word.substring(0, i);

                // if the prefix is present in the dictionary, add prefix to the
                // output String and recurse for remaining String

                if (dictionary.contains(prefix)) {
                    splitWord(word.substring(i), output + " " + prefix);
                }
            }
        }

        return output;
    }  
} 

import java.util.*；
导入java.io.*；
公共类组合2
{
私有静态列表字典=新的ArrayList（）；
公共静态void main（字符串[]args）{
File inputFile=新文件（“dictionary.txt”）；
File outputFile=新文件（“composedMore.txt”）；
扫描仪输入=空；
PrintWriter out=null；
试一试{
in=新扫描仪（输入文件）；
out=新的PrintWriter（输出文件）；
while（在.hasNext（）中）{
字符串输入=in.next（）；
添加（输入）；
字符串输出=拆分字（输入“”）；
如果（输出！=“”）{
out.println（输入+“：”+输出）；
}
}
}捕获（IOE异常）{
System.out.println（“输出过程中发生IOException.”）；
}最后{
in.close（）；
out.close（）；
}
} 
公共静态字符串拆分字（字符串字、字符串输出）{
if（word.length（）==0）{
输出=输出；
}
否则{
对于（int i=1；i，首先将所有单词添加到字典中，然后检查每个单词，因为您需要与文件中的所有单词进行比较
您采用的过程只是在比较单词之前比较单词

import java.util.*;

 import java.io.*;

 public class CompositionTwo
 {

private static List<String> dictionary = new ArrayList<>();
public static void main(String []args) { 
    File inputFile = new File("dictionary.txt");
    File outputFile = new File("composedMore.txt");
    Scanner in = null;
    PrintWriter out = null;
    String word;

    try {
        in = new Scanner(inputFile);
        out = new PrintWriter(outputFile);
        //Read the file indictionary
        while (in.hasNext()) {
            String input = in.next();
            dictionary.add(input);
        }

        //Check All the words in dictionary for Splitting
        for(int i=0;i<dictionary.size();i++)
        {
            String output = splitWord(dictionary.get(i), "");
            if (!"".equals(output)) {
                String outa[] = output.split("\\s") ;
                if(outa.length >= 3) // Check if 3 words are created as output
                {
                System.out.println(dictionary.get(i) + ":" + output);
                out.println(dictionary.get(i) + ":" + output);
                }
            }
        }
    } catch (IOException e) {
        System.out.println(e.getMessage());
    } finally {
        in.close();
        out.close();
    }

} 

public static String splitWord(String word, String output) {

    if (word.length() == 0) {
        return output;
    }
    else {
        for (int i = 1; i <= word.length(); i++) {
            // consider all prefixes of current String
            String prefix = word.substring(0, i);

            // if the prefix is present in the dictionary, add prefix to the
            // output String and recurse for remaining String

            if (dictionary.contains(prefix)) {
                return splitWord(word.substring(i), output + " " + prefix);
            }
        }
    }

    return output ;

}  

import java.util.*；
导入java.io.*；
公共类组合2
{
私有静态列表字典=新的ArrayList（）；
公共静态void main（字符串[]args）{
File inputFile=新文件（“dictionary.txt”）；
File outputFile=新文件（“composedMore.txt”）；
扫描仪输入=空；
PrintWriter out=null；
字符串字；
试一试{
in=新扫描仪（输入文件）；
out=新的PrintWriter（输出文件）；
//从索引中读取文件
while（在.hasNext（）中）{
字符串输入=in.next（）；
添加（输入）；
}
//检查字典中的所有单词是否拆分
for（int i=0；i=3）//检查是否创建了3个字作为输出
{
System.out.println（dictionary.get（i）+“：”+输出）；
out.println（dictionary.get（i）+“：”+输出）；
}
}
}
}捕获（IOE异常）{
System.out.println（e.getMessage（））；
}最后{
in.close（）；
out.close（）；
}
} 
公共静态字符串拆分字（字符串字、字符串输出）{
if（word.length（）==0）{
返回输出；
}
否则{
对于（int i=1；i，首先将所有单词添加到字典中，然后检查每个单词，因为您需要与文件中的所有单词进行比较
您采用的过程只是在比较单词之前比较单词

import java.util.*;

 import java.io.*;

 public class CompositionTwo
 {

private static List<String> dictionary = new ArrayList<>();
public static void main(String []args) { 
    File inputFile = new File("dictionary.txt");
    File outputFile = new File("composedMore.txt");
    Scanner in = null;
    PrintWriter out = null;
    String word;

    try {
        in = new Scanner(inputFile);
        out = new PrintWriter(outputFile);
        //Read the file indictionary
        while (in.hasNext()) {
            String input = in.next();
            dictionary.add(input);
        }

        //Check All the words in dictionary for Splitting
        for(int i=0;i<dictionary.size();i++)
        {
            String output = splitWord(dictionary.get(i), "");
            if (!"".equals(output)) {
                String outa[] = output.split("\\s") ;
                if(outa.length >= 3) // Check if 3 words are created as output
                {
                System.out.println(dictionary.get(i) + ":" + output);
                out.println(dictionary.get(i) + ":" + output);
                }
            }
        }
    } catch (IOException e) {
        System.out.println(e.getMessage());
    } finally {
        in.close();
        out.close();
    }

} 

public static String splitWord(String word, String output) {

    if (word.length() == 0) {
        return output;
    }
    else {
        for (int i = 1; i <= word.length(); i++) {
            // consider all prefixes of current String
            String prefix = word.substring(0, i);

            // if the prefix is present in the dictionary, add prefix to the
            // output String and recurse for remaining String

            if (dictionary.contains(prefix)) {
                return splitWord(word.substring(i), output + " " + prefix);
            }
        }
    }

    return output ;

}  

import java.util.*；
导入java.io.*；
公共类组合2
{
私有静态列表字典=新的ArrayList（）；
公共静态void main（字符串[]args）{
File inputFile=新文件（“dictionary.txt”）；
File outputFile=新文件（“composedMore.txt”）；
扫描仪输入=空；
PrintWriter out=null；
字符串字；
试一试{
in=新扫描仪（输入文件）；
out=新的PrintWriter（输出文件）；
//从索引中读取文件
while（在.hasNext（）中）{
字符串输入=in.next（）；
添加（输入）；
}
//检查字典中的所有单词是否拆分
for（int i=0；i=3）//检查是否创建了3个字作为输出
{
System.out.println（dictionary.get（i）+“：”+输出）；
out.println（dictionary.get（i）+“：”+输出）；
}
}
}
}捕获（IOE异常）{
System.out.println（e.getMessage（））；
}最后{
in.close（）；
out.close（）；
}
} 
公共静态字符串拆分字（字符串字、字符串输出）{
if（word.length（）==0）{
返回输出；
}
否则{
对于（int i=1；i假设您有此词典：

disc
on
so
lateness

假设您针对字符串
disconsolatess
运行程序。
我做了一些更改，首先加载字典，然后调用递归方法
splitWord

您应该知道，递归方法是在堆栈中调用的，然后逐个返回一个调用。因此，我选择将递归调用更改为：

返回前缀+“”+splitWord（word.substring（i），输出）；

这样，在每次方法调用之后，找到的每个单词都会连接起来

显然，正如您已经做过的，当变量
输出中没有更多字符时，我的停止条件仍然存在

package io.gdfb.questions；
导入java.util.*；
导入java.io.*；
公共类组合2{
私有静态列表字典=新的ArrayList（）；
公共静态void main（字符串[]args）{
loadDictionary（）；
File outputFile=新文件（“composedMore.txt”）；
PrintWriter out=null；
试一试{
out=新的PrintWriter（输出文件）；
字符串输出=拆分字（args[0]，“”）；
如果（输出！=“”）{
out.println（参数[0]+“：”+输出）；
}
}捕获（IOE异常）{
s