Java 写文件

此次测试OutputStream都是使用FileOutputStream。

FileOutputStream用于向文件写入文件。实现方式：

FileOutputStream buffer = null;
        try {
            buffer = new FileOutputStream(file);
            byte[] n = "\n".getBytes();
            for (int i = 0; i < maxIndex; i++) {
                buffer.write(line.generateLineMsg().getBytes());  //随机产生一行数据
                buffer.write(n);
//                if (i % 10== 0) {
//                    buffer.flush();
//                }
            }
            buffer.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            FileUtil.closeWriter(buffer);
        }

 

 

OutputStreamWriter：专门用于处理文件的字符写入流对象。实现方式：

OutputStreamWriter writer = null;
        try {
            writer = new OutputStreamWriter(new FileOutputStream(file));
            for(int i = 0;i < maxIndex;i++) {
                writer.write(line.generateLineMsg());  
                writer.write("\n");
//                if(i % 10 == 0) {
//                    writer.flush();
//                }
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally{
            FileUtil.closeWriter(writer);
        }

 

FileWriter：OutputStreamWriter的子类，在构造函数中，创建一个FileOutputStream初始化数据，其余和OutputStreamWriter相同；实现方式

FileWriter writer = null;
        try {
            writer = new FileWriter(file);
            for(int i = 0;i < maxIndex;i++) {
                writer.write(line.generateLineMsg());
                writer.write("\n");
//                if(i % 10 == 0) {
//                    writer.flush();
//                }
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            FileUtil.closeWriter(writer);
        }

BufferedWriter：存储一个char数组（默认值是8192），用于缓存数据，需要一个Writer来写数据，如BufferedWriter和FileWriter；

对于write(int paramInt)，判断当前存储是否超过了缓存最大值，如果超过，则将缓存写入到writer中；否则将数据添加到缓存中；

以下paramInt1 代表起始位置,paramInt2代表结束位置

对于write(char[] paramArrayOfChar, int paramInt1, int paramInt2)

如果paramInt2大于缓存大小（nChars值），即刻将缓存写入到writer中，然后将paramArrayOfChar写入writer中；否则将paramArrayOfChar从paramInt1到paramInt2写入到缓存中，一旦缓存满了，则写入到writer里。

对于write(String paramString, int paramInt1, int paramInt2)

paramString从paramInt1到paramInt2写入到缓存中，一旦缓存满了，则写入到writer里。

 实现方式：

BufferedWriter buffer = null;
        try {
            buffer = new BufferedWriter(new FileWriter(file),8192000);
            for(int i = 0;i < maxIndex;i++) {
                buffer.write(line.generateLineMsg());
                buffer.newLine();
//                if(i % 10 == 0) {
//                    buffer.flush();
//                }
            }
            buffer.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            FileUtil.closeWriter(buffer);
        }

 

FilterOutputStream 需要一个OutputStream来写数据,如FileOutputStream，但是filterOutStream write(byte[] paramArrayOfByte, int paramInt1,int paramInt2) 是将byte数组一个个写入到OutputStream中。

FilterOutputStream buffer = null;
        try {
            buffer = new FilterOutputStream(new FileOutputStream(file));
            byte[] n = "\n".getBytes();
            for (int i = 0; i < maxIndex; i++) {
                buffer.write(line.generateLineMsg().getBytes());
                buffer.write(n);
//                if (i % 100 == 0) {
//                    buffer.flush();
//                }
            }
            buffer.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            FileUtil.closeWriter(buffer);
        }

BufferedOutputStream :是FilterOutputStream的子类，存储一个byte数组（默认值是8192），用于缓存数据，需要一个OutputStream来写数据,如FileOutputStream，

write(byte[] paramArrayOfByte, int paramInt1,int paramInt2)  1.如果paramInt2大于缓存最大数（byte数组大小），将缓存数据写入到流中，然后再将数据写入到流中；在1不成立的情况下，如果paramInt2大于缓存剩余的大小（即还没被写的byte），清空缓存；不管2是否成立，最后都会将数据写入到缓存中。

实现方式：

BufferedOutputStream buffer = null;
        try {
            buffer = new BufferedOutputStream(new FileOutputStream(file),8192000);
            byte[] n = "\n".getBytes();
            for (int i = 0; i < maxIndex; i++) {
                buffer.write(line.generateLineMsg().getBytes());
                buffer.write(n);
//                if (i % 10 == 0) {
//                    buffer.flush();
//                }
            }
            buffer.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            FileUtil.closeWriter(buffer);
        }

 

 

NIO : java1.4开始发布，非阻塞式IO，实现方式：

FileChannel chanel = null;
        FileOutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream(file);
            chanel = outputStream.getChannel();
            ByteBuffer buffer = ByteBuffer.allocateDirect(BUFSIZE);
            byte[] n = "\n".getBytes();
            for(int i = 0;i < maxIndex;i++) {
                buffer.put(line.generateLineMsg().getBytes()); //随机产生一行数据
                buffer.put(n);
                
                if(i % 50000 == 0) {
                    buffer.flip();
                    chanel.write(buffer);
                    buffer.clear();
                }
            }
            buffer.flip();
            chanel.write(buffer);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally{
            FileUtil.closeWriter(outputStream);
            FileUtil.closeWriter(chanel);
        }

要想NIO能快速写文件，Buffer大小需要配置好，大点速度快点。

 

通过让FileOutputStream，OutputStreamWriter，FileWriter，BufferedWriter，FilterOutputStream，BufferedOutputStream 写1G文件的对比，

因为有缓存原因（缓存设置好点），BufferedWriter和BufferedOutputStream NIO 速度差不多且是最快的，只是BufferedOutputStream 要将String转换成byte数组，如果纯粹生成一行数据能用byte存储，则BufferedOutputStream 速度很好，只是一行byte数组数据不好写。

FilterOutputStream速度最慢，主要是一个个byte写入流中。

 

 

部分函数说明

1，write(ch): 将一个字符写入到流中。  

2，write(char[]): 将一个字符数组写入到流中。

3，write(String): 将一个字符串写入到流中。  

4，flush():刷新流，将流中的数据刷新到目的地中，流还存在。  

5，close():关闭资源：在关闭前会先调用flush()，刷新流中的数据去目的地。然流关闭。

 

关于写文件编码格式：

对于OutputStreamWriter可以指定文件编码格式保存数据。

对于FileWriter、FileOutputStream、BufferedWriter、FilterOutputStream、BufferedOutputStream没有提供写文件编码设置，则根据Charset.defaultCharset().name()这个返回的编码保存数据。