java I/O，将数组写入文本文件

我正在使用以下代码将数组写入文件：

FileWriter fstream1=new FileWriter("outx.txt");
BufferedWriter out1= new BufferedWriter(fstream1);
FileWriter fstream2=new FileWriter("outy.txt");
BufferedWriter out2= new BufferedWriter(fstream2);
for(int i=0;i<320*240;i++)
{

        out1.write(0+System.getProperty("line.separator"));//
       // out1.write("\n");
        out2.write(0+System.getProperty("line.separator"));
//out2.write("\n");

}

FileWriter fstream1=newfilewriter（“outx.txt”）；
BufferedWriter out1=新的BufferedWriter（fstream1）；
FileWriter fstream2=新的FileWriter（“outy.txt”）；
BufferedWriter out2=新的BufferedWriter（fstream2）；
对于（int i=0；iAdd:

在for循环之后

您的程序很可能在BufferedReader中的缓冲区刷新之前退出，这是处理缓冲输出的常见问题

编辑：更正确的解决方案是：

public static void main(String[] args) throws IOException {
    final String outputString = "0" + System.getProperty("line.separator");
    BufferedWriter out1 = null;
    BufferedWriter out2 = null;
    try {
        out1 = new BufferedWriter(new FileWriter("outx.txt"));
        out2 = new BufferedWriter(new FileWriter("outy.txt"));
        for(int i = 0; i < 320 * 240; i++) {
            out1.write(outputString);
            out2.write(outputString);
        }
        out1.flush(); // Not really needed as close will flush, but it is 
        out2.flush(); // useful for describing the intent of the code
    } finally {
        closeQuietly(out1);
        closeQuietly(out2);
    }
}

private static void closeQuietly(Closeable c) {
    try {
        if (c != null) {
            c.close();
        }
    } catch (Exception e) {
        // No-op
    }
}

publicstaticvoidmain（字符串[]args）引发IOException{
最终字符串outputString=“0”+System.getProperty（“line.separator”）；
BufferedWriter out1=null；
BufferedWriter out2=null；
试一试{
out1=新的BufferedWriter（新的FileWriter（“outx.txt”）；
out2=新的BufferedWriter（新的FileWriter（“outy.txt”）；
对于（int i=0；i<320*240；i++）{
out1.写入（outputString）；
out2.写入（outputString）；
}
out1.flush（）；//实际上不需要close，因为close将刷新，但它是
out2.flush（）；//用于描述代码的意图
}最后{
安静地关闭（out1）；
关闭（关闭2）；
}
}
私有静态无效关闭（可关闭c）{
试一试{
如果（c！=null）{
c、 close（）；
}
}捕获（例外e）{
//无操作
}
}
您是否记得关闭输出流？您的示例没有列出对close（）的调用，close（）也应该刷新流。BufferedWriter的默认行为是在关闭它正在缓冲的流之前刷新（写入）其剩余内容

您可能应该添加：

out1.close（）；

out2.close（）

当文件的结尾被切断时，您忘记关闭用于创建文件的写入程序是一种非常常见的情况，尤其是当您使用了BufferedOutputStream或BufferedWriter，在显式刷新（或更常见的是，关闭）之前可能不会刷新其缓冲区（将其写入文件）

打开流后立即编写close（）调用是一个很好的习惯，然后在调用之间编写处理流的所有代码。考虑到异常情况，标准调用使用以下习惯用法：

Writer myOutWriter = null;
try {
   myOutWriter = new BufferedWriter(new FileWriter("..."));
   // Write to myOutWriter here
} catch (IOException ioe) {
   // Handle any exceptions here
} finally { 
   try {
      if (myOutWriter != null) {
         myOutWriter.close();
      }
   } catch (IOException ioe) {
      // Not much you can do here
   }
}

Apache Commons IO项目（）有一个很好的实用程序，名为IOUtils.closequity（），它通过在一个方法调用中包含try-catch、null-check和对close的调用来清除finally块。使用该库的示例如下所示：

Writer myOutWriter = null;
try {
   myOutWriter = new BufferedWriter(new FileWriter("..."));
   // Write to myOutWriter here
} catch (IOException ioe) {
   // Handle any exceptions here
} finally { 
   IOUtils.closeQuietly(myOutWriter);
}

Writer out1 = new FileWriter("outx.txt");
try {
  out1 = new BufferedWriter(out1);
  Writer out2 = new FileWriter("outy.txt");
  try {
    out2 = new BufferedWriter(out2);
    for (int i = 0; i < 320 * 240; i++) {
      out1.write(0 + System.getProperty("line.separator"));
      out2.write(0 + System.getProperty("line.separator"));
    }
  } finally {
    out2.close();
  }
} finally {
  out1.close();
}

正如其他人所指出的，缓冲区中可能存在未刷新的数据

重写代码的可接受方法如下：

Writer myOutWriter = null;
try {
   myOutWriter = new BufferedWriter(new FileWriter("..."));
   // Write to myOutWriter here
} catch (IOException ioe) {
   // Handle any exceptions here
} finally { 
   IOUtils.closeQuietly(myOutWriter);
}

Writer out1 = new FileWriter("outx.txt");
try {
  out1 = new BufferedWriter(out1);
  Writer out2 = new FileWriter("outy.txt");
  try {
    out2 = new BufferedWriter(out2);
    for (int i = 0; i < 320 * 240; i++) {
      out1.write(0 + System.getProperty("line.separator"));
      out2.write(0 + System.getProperty("line.separator"));
    }
  } finally {
    out2.close();
  }
} finally {
  out1.close();
}

Writer out1=新文件编写器（“outx.txt”）；
试一试{
out1=新的缓冲写入程序（out1）；
Writer out2=新文件编写器（“outy.txt”）；
试一试{
out2=新的缓冲写入程序（out2）；
对于（int i=0；i<320*240；i++）{
out1.write（0+System.getProperty（“line.separator”）；
out2.write（0+System.getProperty（“line.separator”）；
}
}最后{
out2.close（）；
}
}最后{
out1.close（）；
}

此代码：


将通过
close
将始终通过
close
释放文件句柄，即使出现错误（通过使用
finally
）
遵守
可关闭类的合同

不使用null或swallow异常
仅刷新是不够的。您应该显式关闭流以释放资源。
close（）
将已隐式刷新缓冲区。1）您可以重写第一个代码块以消除catch块和无意义的null赋值。2） 如果像这样使用
closequilly
，应用程序可能会将不完整的数据提交到文件，并且不会处理错误。这是因为close可能会写入数据。