尝试一次写入多个文件-Java

我正在尝试将一个字典文件拆分为多个不同长度的字典，例如，如果我想将其放入长度为2、3、4、。。。。。n、 在那里我可以更快地搜索它们。当我说更快时，我的意思是我将知道输入长度，因此访问相应的长度字典（整个字典的一小部分）将意味着更快的访问。这是我当前的实现，它生成文件，但不像我所希望的那样写入它们。理想情况下，例如，所有长度为2的单词都将写入length2文本文件。有人有什么建议吗

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.PrintWriter;
import java.io.IOException;

public class Main {

public static void main(String[] args) throws IOException {
    FileReader fr = new FileReader("dictionary.txt");
    PrintWriter l2 = new PrintWriter("dictionary_length2.txt", "UTF-8");
    PrintWriter l3 = new PrintWriter("dictionary_length3.txt", "UTF-8");
    PrintWriter l4 = new PrintWriter("dictionary_length4.txt", "UTF-8");
    PrintWriter l5 = new PrintWriter("dictionary_length5.txt", "UTF-8");
    PrintWriter l6 = new PrintWriter("dictionary_length6.txt", "UTF-8");
    PrintWriter l7 = new PrintWriter("dictionary_length7.txt", "UTF-8");
    PrintWriter l8 = new PrintWriter("dictionary_length8.txt", "UTF-8");
    PrintWriter l9 = new PrintWriter("dictionary_length9.txt", "UTF-8");
    PrintWriter l10 = new PrintWriter("dictionary_length10.txt", "UTF-8");
    PrintWriter l11 = new PrintWriter("dictionary_lengty11.txt", "UTF-8");
    PrintWriter l12 = new PrintWriter("dictionary_length12.txt", "UTF-8");
    PrintWriter l13 = new PrintWriter("dictionary_length13.txt", "UTF-8");
    PrintWriter l14 = new PrintWriter("dictionary_length14.txt", "UTF-8");
    PrintWriter l15 = new PrintWriter("dictionary_length15.txt", "UTF-8");
    PrintWriter l16 = new PrintWriter("dictionary_length16.txt", "UTF-8");
    PrintWriter l17 = new PrintWriter("dictionary_length17.txt", "UTF-8");
    PrintWriter l18 = new PrintWriter("dictionary_length18.txt", "UTF-8");
    PrintWriter l19 = new PrintWriter("dictionary_length19.txt", "UTF-8");
    PrintWriter l20 = new PrintWriter("dictionary_length20.txt", "UTF-8");
    PrintWriter l21 = new PrintWriter("dictionary_length21.txt", "UTF-8");

    BufferedReader tr = new BufferedReader(fr);
    String temp;
    int temp_length;

    for(int i = 0; i < 60388; i++){
        temp = new String(tr.readLine());
        temp_length = temp.length();
        if(temp_length == 2)
            l2.println(temp);
        if(temp_length == 3)
            l3.println(temp);
        if(temp_length == 4)
            l4.println(temp);
        if(temp_length == 5)
            l5.println(temp);
        if(temp_length == 6)
            l6.println(temp);
        if(temp_length == 7)
            l7.println(temp);
        if(temp_length == 8)
            l8.println(temp);
        if(temp_length == 9)
            l9.println(temp);
        if(temp_length == 10)
            l10.println(temp);
        if(temp_length == 11)
            l11.println(temp);
        if(temp_length == 12)
            l12.println(temp);
        if(temp_length == 13)
            l13.println(temp);
        if(temp_length == 14)
            l14.println(temp);
        if(temp_length == 15)
            l15.println(temp);
        if(temp_length == 16)
            l16.println(temp);
        if(temp_length == 17)
            l17.println(temp);
        if(temp_length == 18)
            l18.println(temp);
        if(temp_length == 19)
            l19.println(temp);
        if(temp_length == 20)
            l20.println(temp);
        if(temp_length == 21)
            l21.println(temp);
    }

    tr.close();
    l2.close();
    l3.close();
    l4.close();
    l5.close();
    l6.close();
    l7.close();
    l8.close();
    l9.close();
    l10.close();
    l11.close();
    l12.close();
    l13.close();
    l14.close();
    l15.close();
    l16.close();
    l17.close();
    l18.close();
    l19.close();
    l20.close();
    l21.close();
    System.out.println("Complete.");
}
}

导入java.io.BufferedReader；
导入java.io.FileNotFoundException；
导入java.io.FileReader；
导入java.io.PrintWriter；
导入java.io.IOException；
公共班机{
公共静态void main（字符串[]args）引发IOException{
FileReader fr=新的FileReader（“dictionary.txt”）；
PrintWriter l2=新的PrintWriter（“dictionary_length2.txt”、“UTF-8”）；
PrintWriter l3=新的PrintWriter（“dictionary_length3.txt”、“UTF-8”）；
PrintWriter l4=新的PrintWriter（“dictionary_length4.txt”、“UTF-8”）；
PrintWriter l5=新的PrintWriter（“dictionary_length5.txt”、“UTF-8”）；
PrintWriter l6=新的PrintWriter（“dictionary_length6.txt”、“UTF-8”）；
PrintWriter l7=新的PrintWriter（“dictionary_length7.txt”、“UTF-8”）；
PrintWriter l8=新的PrintWriter（“dictionary_length8.txt”、“UTF-8”）；
PrintWriter l9=新的PrintWriter（“dictionary_length9.txt”、“UTF-8”）；
PrintWriter l10=新的PrintWriter（“dictionary_length10.txt”、“UTF-8”）；
PrintWriter l11=新的PrintWriter（“dictionary_lengty11.txt”、“UTF-8”）；
PrintWriter l12=新的PrintWriter（“dictionary_length12.txt”、“UTF-8”）；
PrintWriter l13=新的PrintWriter（“dictionary_length13.txt”、“UTF-8”）；
PrintWriter l14=新的PrintWriter（“dictionary_length14.txt”、“UTF-8”）；
PrintWriter l15=新的PrintWriter（“dictionary_length15.txt”、“UTF-8”）；
PrintWriter l16=新的PrintWriter（“dictionary_length16.txt”、“UTF-8”）；
PrintWriter l17=新的PrintWriter（“dictionary_length17.txt”、“UTF-8”）；
PrintWriter l18=新的PrintWriter（“dictionary_length18.txt”、“UTF-8”）；
PrintWriter l19=新的PrintWriter（“dictionary_length19.txt”、“UTF-8”）；
PrintWriter l20=新的PrintWriter（“dictionary_length20.txt”、“UTF-8”）；
PrintWriter l21=新的PrintWriter（“dictionary_length21.txt”、“UTF-8”）；
BufferedReader tr=新的BufferedReader（fr）；
字符串温度；
内部温度长度；
对于（int i=0；i<60388；i++）{
temp=新字符串（tr.readLine（））；
温度长度=温度长度（）；
如果（温度长度==2）
l2.println（温度）；
如果（温度长度==3）
l3.println（温度）；
如果（温度长度==4）
l4.打印Ln（温度）；
如果（温度长度==5）
l5.打印LN（温度）；
如果（温度长度==6）
l6.打印Ln（温度）；
如果（温度长度==7）
l7.打印Ln（温度）；
如果（温度长度==8）
l8.println（温度）；
如果（温度长度==9）
l9.println（温度）；
如果（温度长度==10）
l10.println（温度）；
如果（温度长度=11）
l11.打印LN（温度）；
如果（温度长度==12）
l12.println（温度）；
如果（温度长度==13）
l13.打印LN（温度）；
如果（温度长度==14）
l14.打印LN（温度）；
如果（温度长度=15）
l15.打印LN（温度）；
如果（温度长度==16）
l16.打印LN（温度）；
如果（温度长度==17）
l17.打印LN（温度）；
如果（温度长度=18）
l18.打印LN（温度）；
如果（温度长度=19）
l19.打印LN（温度）；
如果（温度长度==20）
l20.println（温度）；
如果（温度长度=21）
l21.println（温度）；
}
tr.close（）；
l2.close（）；
l3.关闭（）；
l4.关闭（）；
l5.关闭（）；
l6.关闭（）；
l7.关闭（）；
l8.关闭（）；
l9.close（）；
l10.close（）；
l11.close（）；
l12.close（）；
l13.close（）；
l14.close（）；
l15.close（）；
l16.close（）；
l17.close（）；
l18.close（）；
l19.close（）；
l20.关闭（）；
l21.关闭（）；
System.out.println（“完成”）；
}
}

接下来是切向的“答案”。（这也应该将内容打印到文件中，除非我缺少一些非常基本的内容。）

---

每当有一组变量的形式为

xN

（例如

l2

，

l3

，

l22

），通常应将其替换为列表集合类型，例如

这只是一个示例，说明如何减少重复和固定边界：

int MAX_WORD_LEN = 22; // making this dynamic left as an excercise
List<PrintWriter> writers = new ArrayList<PrintWriter>();

for (int i = 0; i <= MAX_WORD_LEN; i++) {
    PrintWriter w = new PrintWriter("dictionary_length" + i + ".txt", "UTF-8");
    writers.Add(w);
}

String line;
while ((line = tr.readLine()) != null) {
   int len = line.length();
   if (len < writers.size()) {
       writers.get(len).println(line);
   }
}

for (PrintWriter w : writers) {
    w.close();
}

int MAX\u WORD\u LEN=22；//将此动态左移作为练习
列表编写器=新建ArrayList（）；
对于（int i=0；我正在制作一个程序来解决混乱问题，就像在报纸上一样。因此，对字典大小的一小部分的列表进行二进制搜索比对整个列表进行二进制搜索更快。例如，如果有七个混乱的字符，我只搜索字典中包含七个字母的单词。“不是吗？”像我所希望的那样写信给他们”——这很模糊。你想要什么样的行为？实际的行为有何不同？如果这个词是“苹果”例如，它会看到它的长度为5，并将其写入相应的长度为5的文本文件。然而，当我运行此程序时，它只会生成一堆空文件。我不知道我在java中有这种能力，节省了大量的输入！谢谢！@dsiebert424 I.e
BufferedReader tr=new BufferedReader（fr）
我认为，要使其动态化，我所要做的就是让它在找到新的最长单词时生成链表节点？@dsiebert424简单的方法是在找到新的行长度时只将
添加到集合中（对于ArrayList，您需要添加到长度，但对于HashMap，您只需要添加新条目）