尝试使用FileWriter写入输出文件

Question

我目前正在尝试将代码的输出保存到文本文件中，当我在另一个项目中运行它时，它会生成输出文件并分别存储输出，但是当我在另一个项目中运行相同的代码时，它会给我输出文件为空白，我真的不知道怎么回事。 我对在哪里放置.close（）函数和flush函数感到困惑。 先感谢您！

    FileWriter output = new FileWriter("set.txt");
    BufferedWriter writer = new BufferedWriter(output);
    InputStream fis_n = new     FileInputStream("/Users/User/NetBeansProjects/Test/src/test/sample.txt");
    InputStreamReader isr_n = new InputStreamReader(fis_n, Charset.forName("UTF-8"));
    BufferedReader br_n = new BufferedReader(isr_n);

 while ((input = br_n.readLine()) != null) {
        String[] s = input.split(":");
        if (s[1].equals(text)) {
            writer.write(s[0] + "'s result is " + sample_text);
            writer.newLine();
            break;
        }
 }
  writer.close();
  output.close();

这就是编辑后的代码的样子，但是运行程序后输出文件“ set.txt”仍然为空。

    FileWriter output = new FileWriter("set.txt");
    BufferedWriter writer = new BufferedWriter(output);
    InputStream fis_n = new     FileInputStream("/Users/User/NetBeansProjects/Test/src/test/sample.txt");
    InputStreamReader isr_n = new InputStreamReader(fis_n, Charset.forName("UTF-8"));
    BufferedReader br_n = new BufferedReader(isr_n);

  try {
        while ((input = br_n.readLine()) != null) {

            String[] s = input.split(":");
        if (s[1].equals(text)) {
            writer.write(s[0] + "'s result is " + sample_text);
            writer.newLine();
            break;
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            writer.close();
            fis_n.close();
            isr_n.close();
            br_n.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    // fis_n.close();
    //isr_n.close();
    //br_n.close();
}

最终代码如下所示：

     public static void dictionary(String sample_text, String text) throws FileNotFoundException, IOException {

 try {
        BufferedReader reader = new BufferedReader(new InputStreamReader(
                new      FileInputStream("/Users/User/NetBeansProjects/Test/src/test/sample.txt"),
                Charset.forName("UTF-8")
        ));
             try {
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(
                    new FileOutputStream("/Users/User/NetBeansProjects/Test/src/test/set.txt"),
                    Charset.forName("UTF-8")
            ));
            try {
                String input;
                while ((input = reader.readLine()) != null) {
                    String[] s = input.split(":");
                    if (s[1].equals(text)) {
                        writer.write(s[0] + "'s result is " + sample_text);
                        writer.newLine();
                        break;
                    }
                }
            } finally {
                writer.close();
            }
        } finally {
            reader.close();
        }
    } catch (IOException e) {
        // Error handling
    }
  }

这是调用字典方法的主要方法。

   public static void main(String[] args) throws FileNotFoundException, IOException {

 case 2: {
                BufferedReader d_br = new BufferedReader(new InputStreamReader(
                        new FileInputStream("/Users/User/NetBeansProjects/Test/src/test/input_file.txt"),
                        Charset.forName("UTF-8")
                ));

                try {

                    String d_line;
                    while ((d_line = d_br.readLine()) != null) {

                    String h_input = test(d_line);
                    dictionary(d_line, h_input);

                    }
                } catch(IOException e){

                }finally {
                    d_br.close();
                }
                break;
            }
  }

Answer 1

你应该把writer.close()后while循环，最好，进入finally一节。

如果不需要存储部分处理的文件（在大多数情况下），则可以完全删除flush 。 在另一种情况下，最好将其保留在原处。

Java 7+上资源使用的一般情况如下所示（此语法称为try-with-resources ：

try (
    Resource resource1 = // Resource 1 initialization
    Resource resource2 = // Resource 2 initialization
    ...
) {
    // Resource utilization
} catch (XXXException e) {
    // Something went wrong
}

资源由try-with-resources自动释放（关闭）。

如果您需要使用Java 6或更早版本，则可以将以上代码粗略地翻译为以下代码（实际上存在一些细微的差异，在此级别的细节上并不重要）。

try {
    Resource1 resource1 = // Resource initialization
    try {
        Resource2 resource2 = // Resource initialization
        try {
            // Resource utilization
        } finally {
            // Free resource2
            resource2.close();
        }
    } finally {
        // Free resource1
        resource1.close();
    }
} catch (XXXException e) {
    // Something went wrong
}

注意，嵌套的try-finally块如何用于资源管理。

在您的特定情况下，我们需要管理两个资源： Reader和Writer ，因此代码如下所示：

try (
        // Notice, we build BufferedReader for the file in a single expression
        BufferedReader reader = new BufferedReader(new InputStreamReader(
                new FileInputStream("sample.txt"),
                StandardCharsets.UTF_8 // Better replacement for Charset.forName("UTF-8")
        ));
        // Alternative way to do the same
        // BufferedReader reader = Files.newBufferedReader(Paths.get("sample.txt"), StandardCharsets.UTF_8);

        // Output charset for writer provided explicitly
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(
                new FileOutputStream("set.txt"),
                StandardCharsets.UTF_8
        ))
        // Alternative way to do the same
        // BufferedWriter writer = Files.newBufferedWriter(Paths.get("set.txt"), StandardCharsets.UTF_8)
) {
    String input;
    while ((input = reader.readLine()) != null) {
        String[] s = input.split(":");
        if (s[1].equals(text)) {
            writer.write(s[0] + "'s result is " + text);
            writer.newLine();
            break;
        }
    }
} catch (IOException e) {
    // Error handling
}

或者，使用Java7之前的语法：

try {
    BufferedReader reader = new BufferedReader(new InputStreamReader(
            new FileInputStream("sample.txt"),
            Charset.forName("UTF-8")
    ));
    try {
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(
                new FileOutputStream("set.txt"),
                Charset.forName("UTF-8")
        ));
        try {
            String input;
            while ((input = reader.readLine()) != null) {
                String[] s = input.split(":");
                if (s[1].equals(text)) {
                    writer.write(s[0] + "'s result is " + text);
                    writer.newLine();
                    break;
                }
            }
        } finally {
            writer.close();
        }
    } finally {
        reader.close();
    }
} catch (IOException e) {
    // Error handling
}

Answer 2

首先，每当要立即写入当前缓冲区时，就调用编写器的flush方法。 如果您仅在输出上没有任何中间操作的情况下完全写入文件，则无需显式调用它，因为close调用将为您完成此操作。

reader or writer, in your case BufferedWriter . 其次，仅在您使用BufferedWriter的情况下调用读取器或写入器的close方法。 close呼叫将转发给其他分配的读者或作家。 多个连续的close调用对先前关闭的实例没有任何影响，请参见此处 。

作为使用读者和作家的一般注意事项，请考虑以下模式：

// This writer must be declared before 'try' to
// be visible in the finally block
AnyWriter writer = null;

try {

    // Instantiate writer here, because it can already
    // throw an IOException
    writer = new AnyWriter();

    // The the writing in a loop or as you wish
    // If you need to write out the buffer in 
    // between, call flush

} catch (IOException e) {

    // Something went wrong while writing

} finally {

    try {
        if (writer != null)
            writer.close();
    } catch (IOException e) {
        // Exception while trying to close
    }

}

finally块始终执行。 如果您需要更紧凑的语法并且至少使用Java 7，则可以在此处查看try-with表示法。