精华内容
下载资源
问答
  • 最近在考虑一个问题:“如果快速地向文件中写入数据”,java提供了多种文件写入的方式,效率上各有异同,基本上可以分为如下三大类:字节流输出、字符流输出、内存文件映射输出。前两种又可以分为带buffer及不带...

    1. 实验背景

    最近在考虑一个问题:“如果快速地向文件中写入数据”,java提供了多种文件写入的方式,效率上各有异同,基本上可以分为如下三大类:字节流输出、字符流输出、内存文件映射输出。前两种又可以分为带buffer及不带buffer

    2. 实验目标

    通过实验找出单线程场景下文件写入效率最高的方式,并量化各种文件写入方式在效率上的差距。

    3. 实验设计

    为减少其他环节的影响,示例代码使用循环输出同一字符串多次的方式测试整个输出环节的耗时,通过耗时、服务器资源使用情况(cpu、内存使用)等指标评判各种文件写入方式的效率好坏。

    4. 实验环境

    OS: windows 7 64bit

    cpu: 4core, 主频:2.4GHZ

    mem:6G

    jdk version:Java HotSpot(TM) 64-Bit ,1.8.0_101

    5. 实验步骤

    总共进行8次输出实验,依次输出的文件大小为:10M、50M、100M、200M、500M、800M、1G、2G;

    每次输出后记录各种方式的耗时情况,并填表。

    6. 实验结果

    表1、java各种文件写入方法效率对比实验时延数据表

     

    表1、java各种文件写入方法效率对比实验时延结果图(含大文件)

     

     表2、java各种文件写入方法效率对比实验时延结果图(不含大文件)

      

     

    图2、文件大小为2048m时,各个写入方式执行任务时cpu使用情况:

    图3、文件大小为2048m时,各个写入方式执行任务时jvm内存使用情况

    图4、文件大小为2048m时,各个写入方式执行任务时物理内存使用情况:

    上图中红圈中为‘FileChannel’方式下的物理内存使用情况。

    7. 实验结论

    1、基本上,五种写入方式的时延从小到大排序为:FileChannel<BufferedOutputStream<FileOutputStream<BufferedWriter<FileWriter;从表1、图1;可以看出;且该规律在小文件写入的情景下,更为明显,图2可以看出;

    2、在同样文件大小写入的场景中,通常意义上带buffer的字节流输入/字符流输入比不带buffer的对应流效率要高;

    3、各个写入方式的jvm cpu和内存使用情况大致相当,从图2和图3可以看出;

    4、文件达到一定大小后( fileSize >=1.5G ),FileChannel的时延变得很大且不稳定,从图1最右边可以看出;同时,物理内存的使用量基本和写入文件大小相当,从图4可以看出;原因在于FileChannel使用MappedByteBuffer写入,这个buffer是direct buffer,直接操作物理内存写入,故而造成物理内存消耗严重。

    5、小文件写入的场景下(1M左右),FileChannel有些大材小用了,效率上反而没有字节流效率高。

     

    综上,我们可以得到几条有价值的使用经验:

    1、小文件(几M的文件)写入时,使用常规的io输入就行,最优选择是BufferedInportStream,没有必要使用nio的FileChannel;

    2、大文件(fileSize > 1G,这是个经验值,需要根据具体环境具体分析)写入时,使用FileChannel需要小心物理内存的瓶颈带来的写入效率低下,可以考虑使用分段写入的方式(TODO:后续实验给出);

    3、其他场景下,如果效率优先的考虑,则优先选择FileChannel写入文件。

     

    本文转载自:https://www.cnblogs.com/daoqidelv/p/6864403.html

    展开全文
  •  近在考虑一个问题:“如果快速地向文件中写入数据”,java提供了多种文件写入的方式,效率上各有异同,基本上可以分为如下三大类:字节流输出、字符流输出、内存文件映射输出。前两种又可以分为带buffer及不带...
  • JAVA 文件写入 效率测试 fileWrite outputStreamTest bufferedOutputTest bufferedWriteTest bufferedWrite And FileWriterTest bufferedWrite And BufferedOutputStreamTest
  • java的三种写文件方法的效率性能比较转自:http://www.codesky.net/article/200912/118652.html最近对以前开发的一个通用数据迁移的软件进行优化。除了用JDK5.0的多线程技术进行的改进之外,也比较了一下java写文件...
    java的三种写文件方法的效率性能比较
    
    转自:http://www.codesky.net/article/200912/118652.html
    最近对以前开发的一个通用数据迁移的软件进行优化。除了用JDK5.0的多线程技术进行的改进之外,也比较了一下java写文件的性能。


    在 java写文件中,通常会使用FileOutputStream和FileWriter,FileWriter只能写文本文件。 FileOutputStream也经常结合BufferedOutputStream。因为实际应用中写文本文件的情况占了大多数。所以下面测试用不同的方式生成一个相同行数、大小相同的文件的三种不同方式。




    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.*;


    public class FileTest {
    public FileTest() {
    }


    public static void main(String[] args) {
    FileOutputStream out = null;
    FileOutputStream outSTr = null;
    BufferedOutputStream Buff=null;
    FileWriter fw = null;
    int count=1000;//写文件行数
    try {
    out = new FileOutputStream(new File("C:/add.txt"));
    long begin = System.currentTimeMillis();
    for (int i = 0; i < count; i++) {
    out.write("测试java 文件操作\r\n".getBytes());
    }
    out.close();
    long end = System.currentTimeMillis();
    System.out.println("FileOutputStream执行耗时:" + (end - begin) + " 豪秒");


    outSTr = new FileOutputStream(new File("C:/add0.txt"));
    Buff=new BufferedOutputStream(outSTr);
    long begin0 = System.currentTimeMillis();
    for (int i = 0; i < count; i++) {
    Buff.write("测试java 文件操作\r\n".getBytes());
    }
    Buff.flush();
    Buff.close();
    long end0 = System.currentTimeMillis();
    System.out.println("BufferedOutputStream执行耗时:" + (end0 - begin0) + " 豪秒");




    fw = new FileWriter("C:/add2.txt");
    long begin3 = System.currentTimeMillis();
    for (int i = 0; i < count; i++) {
    fw.write("测试java 文件操作\r\n");
    }
    fw.close();
    long end3 = System.currentTimeMillis();
    System.out.println("FileWriter执行耗时:" + (end3 - begin3) + " 豪秒");


    } catch (Exception e) {
    e.printStackTrace();
    }
    finally {
    try {
    fw.close();
    Buff.close();
    outSTr.close();
    out.close();
    } catch (Exception e) {
    e.printStackTrace();
    }
    }
    }
    }    






    以下结果经过多次执行,取常出现的数据,由于只是简单比较,不做详细统计。 


    1.当count=1000的,即写文件1000行的时候,写出的文件大小为18.5KB:
    FileOutputStream执行耗时:46 豪秒
    BufferedOutputStream执行耗时:31 豪秒
    FileWriter执行耗时:15 豪秒


    2.当count=10000的,即写文件10000行的时候,写出的文件大小为185KB:
    FileOutputStream执行耗时:188 豪秒
    BufferedOutputStream执行耗时:32 豪秒
    FileWriter执行耗时:16 豪秒


    3.当count=100000的,即写文件100000行的时候,写出的文件大小为1856KB:
    FileOutputStream执行耗时:1266 豪秒
    BufferedOutputStream执行耗时:125 豪秒
    FileWriter执行耗时:93 豪秒


    4.当count=1000000的,即写文件1000000行的时候,写出的文件大小为18555KB:
    FileOutputStream执行耗时:12063 豪秒
    BufferedOutputStream执行耗时:1484 豪秒
    FileWriter执行耗时:969 豪秒


    由以上数据可以看到,如果不用缓冲流BufferedOutputStream,FileOutputStream写文件的鲁棒性是很不好的。当写 1000000行的文件的时候,FileOutputStream比FileWriter要慢11094毫秒(11 秒),BufferedOutputStream比FileWriter慢515毫秒。


    不要小看这几秒的时间。当操作的数据量很大的时候,这点性能的差距就会很大了。在通用数据迁移工具导出数据库2千万条记录生成sql脚本文件的时候,性能性能相差10分钟以上。
    展开全文
  • 随机IO存在一个寻址的过程,所以效率比较低。而顺序IO,相当于有一个物理索引,在读取的时候不需要寻找地址,效率很高。 网上盗了一个图(侵权删) Java中的随机读写 在Java中读写文件的方式有很多种,先总结...

    顺序IO和随机IO

    对于磁盘的读写分为两种模式,顺序IO和随机IO。 随机IO存在一个寻址的过程,所以效率比较低。而顺序IO,相当于有一个物理索引,在读取的时候不需要寻找地址,效率很高。

    网上盗了一个图(侵权删)

    Java中的随机读写

    在Java中读写文件的方式有很多种,先总结以下3种方法:

     FileWriter和FileReader

    public static void fileWrite(String filePath, String content) {
                File file = new File(filePath);
                //创建FileWriter对象
                FileWriter writer = null;
                try {
                     //如果文件不存在,创建文件
                     if (!file.exists())
                          file.createNewFile();
                     writer = new FileWriter(file);
                     writer.write(content);//写入内容
                     writer.flush();
                     writer.close();
                } catch (IOException e) {
                     e.printStackTrace();
                }
           }
              
           public static void fileRead(String filePath) {
                File file = new File(filePath);
                if (file.exists()) {
                     try {
                          //创建FileReader对象,读取文件中的内容
                          FileReader reader = new FileReader(file);
                          char[] ch = new char[1];
                          while (reader.read(ch) != -1) {
                               System.out.print(ch);
                          }
                          reader.close();
                     } catch (IOException ex) {
                          ex.printStackTrace();
                     }
                        
                }
           } 

    BufferedReader和BufferedWriter BufferedReader和BufferedWriter与FileWriter和FileReader代码的写法一致,Buffer也多了一个读取一行字符的操作。

      public class BuffredRWHelper {
           public static void fileWrite(String filePath, String content) {
                File file = new File(filePath);
                //创建FileWriter对象
                BufferedWriter writer = null;
                try {
                     //如果文件不存在,创建文件
                     if (!file.exists())
                          file.createNewFile();
                     writer = new BufferedWriter(new FileWriter(file));
                     writer.write(content);//写入内容
                     writer.flush();
                     writer.close();
                } catch (IOException e) {
                     e.printStackTrace();
                }
           }
              
           public static void fileRead(String filePath) {
                File file = new File(filePath);
                if (file.exists()) {
                     try {
                          //创建FileReader对象,读取文件中的内容
                          BufferedReader reader = new BufferedReader(new FileReader(file));
                          String line;
                          while ((line = reader.readLine()) != null) {
                               System.out.print(line);
                          }
                          reader.close();
                     } catch (IOException ex) {
                          ex.printStackTrace();
                     }
                        
                }
           }
      } 

    FileInputStream和FileOutputStream 使用Stream的形式是最原始的方式,以字节数组为中间的中转缓解

    public static void fileWrite(String filePath, String content) {
         FileOutputStream outputStream = null;
         try {
             File file = new File(filePath);
             boolean isCreate = file.createNewFile();//创建文件
             if (isCreate) {
                 outputStream = new FileOutputStream(file);//形参里面可追加true参数,表示在原有文件末尾追加信息
                 outputStream.write(content.getBytes());
             }else {
                 outputStream = new FileOutputStream(file,true);//表示在原有文件末尾追加信息
                 outputStream.write(content.getBytes());
             }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             try {
                 outputStream.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
    	
     public static void fileRead(String filePath) {
         File file = new File(filePath);
         if (file.exists()) {
             try {
                 //创建FileInputStream对象,读取文件内容
                 FileInputStream fis = new FileInputStream(file);
                 byte[] bys = new byte[1024];
                 while (fis.read(bys, 0, bys.length) != -1) {
                     //将字节数组转换为字符串
                     System.out.print(new String(bys, StandardCharsets.UTF_8));
                 }
             } catch (IOException ex) {
                 ex.printStackTrace();
             }
    			
         }
     } 

    Java中的顺序读写

    上面的对文件的读写都是随机读写,如果用来写比较小的日志文件还能满足要求,如果用来操作一个文件的读写,那可能带来很大的性能消耗。

    顺序IO的读写在中间件使用的很频繁,尤其是在队列中。几乎所有的队列(kafka,qmq等使用文件存储消息)都采用了顺序IO读写。

    与随机读写不同的是,顺序读写是优先分配一块文件空间,然后后续内容追加到对应空间内。

    在使用顺序IO进行文件读写时候,需要知道上次写入的地方,所以需要维护一个索引或者轮询获得一个没有写入位置。

    public static long fileWrite(String filePath, String content, int index) {
         File file = new File(filePath);
         RandomAccessFile randomAccessTargetFile;
         MappedByteBuffer map;
         try {
              randomAccessTargetFile = new RandomAccessFile(file, "rw");
              FileChannel targetFileChannel = randomAccessTargetFile.getChannel();
              map = targetFileChannel.map(FileChannel.MapMode.READ_WRITE, 0, (long) 1024 * 1024 * 1024);
              map.position(index);
              map.put(content.getBytes());
              return map.position();
         } catch (IOException e) {
              e.printStackTrace();
         } finally {
         }
         return 0L;
    }
    
    public static String fileRead(String filePath, long index) {
         File file = new File(filePath);
         RandomAccessFile randomAccessTargetFile;
         MappedByteBuffer map;
         try {
              randomAccessTargetFile = new RandomAccessFile(file, "rw");
              FileChannel targetFileChannel = randomAccessTargetFile.getChannel();
              map = targetFileChannel.map(FileChannel.MapMode.READ_WRITE, 0, index);
              byte[] byteArr = new byte[10 * 1024];
              map.get(byteArr, 0, (int) index);
              return new String(byteArr);
         } catch (IOException e) {
              e.printStackTrace();
         } finally {
         }
         return "";
    }

    文件合并方法:

    /**
         * 文件合并
         */
        public static void mergeFile(List<String> inputPaths, String outputPath) throws FileNotFoundException {
    
            Vector<InputStream> inputStream = new Vector<InputStream>();
    
            if (CollectionUtils.isEmpty(inputPaths)) {
                throw new LogicException("合并文件路径不能为空");
            }
    
            for (String inputPath : inputPaths) {
                InputStream in = new  FileInputStream(new File(inputPath));
                inputStream.add(in);
            }
    
            //构造一个合并流
            SequenceInputStream stream = new SequenceInputStream(inputStream.elements());
            BufferedOutputStream bos = null;
            try {
                 bos = new BufferedOutputStream(
                        new FileOutputStream(outputPath));
    
                byte[] bytes = new byte[10240];
                int len = -1;
                while((len=stream.read(bytes))!=-1){
                    bos.write(bytes,0,len);
                    bos.flush();
                }
                log.info("文件合并完成!");
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    if (null != bos ) {
                        bos.close();
                    }
                    stream.close();
                } catch (IOException ignored) {
                }
            }
        }

     

    展开全文
  • 比较一下java写文本文件文件的性能

    千次阅读 2009-08-05 10:01:00
    比较一下java写文本文件文件的性能关键字: java比较一下java写文本文件文件的性能 最近对以前开发的一个通用数据迁移的软件进行优化。除了用JDK5.0的多线程技术进行的改进之外,也比较了一下java写文件的性能。 在...

    比较一下java写文本文件文件的性能

    关键字: java

    比较一下java写文本文件文件的性能

        最近对以前开发的一个通用数据迁移的软件进行优化。除了用JDK5.0的多线程技术进行的改进之外,也比较了一下java写文件的性能。
        在java写文件中,通常会使用FileOutputStream和FileWriter,FileWriter只能写文本文件。FileOutputStream也经常结合BufferedOutputStream。因为实际应用中写文本文件的情况占了大多数。所以下面测试用不同的方式生成一个相同行数、大小相同的文件的三种不同方式。
       
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.*;

    public class FileTest {
        public FileTest() {
        }

        public static void main(String[] args) {
            FileOutputStream out = null;
            FileOutputStream outSTr = null;
            BufferedOutputStream Buff=null;
            FileWriter fw = null;
            int count=1000;//写文件行数
            try {
                out = new FileOutputStream(new File("C:/add.txt"));
                long begin = System.currentTimeMillis();
                for (int i = 0; i < count; i++) {
                    out.write("测试java 文件操作/r/n".getBytes());
                }
                out.close();
                long end = System.currentTimeMillis();
                System.out.println("FileOutputStream执行耗时:" + (end - begin) + " 豪秒");

                outSTr = new FileOutputStream(new File("C:/add0.txt"));
                 Buff=new BufferedOutputStream(outSTr);
                long begin0 = System.currentTimeMillis();
                for (int i = 0; i < count; i++) {
                    Buff.write("测试java 文件操作/r/n".getBytes());
                }
                Buff.flush();
                Buff.close();
                long end0 = System.currentTimeMillis();
                System.out.println("BufferedOutputStream执行耗时:" + (end0 - begin0) + " 豪秒");


                fw = new FileWriter("C:/add2.txt");
                long begin3 = System.currentTimeMillis();
                for (int i = 0; i < count; i++) {
                    fw.write("测试java 文件操作/r/n");
                }
                            fw.close();
                long end3 = System.currentTimeMillis();
                System.out.println("FileWriter执行耗时:" + (end3 - begin3) + " 豪秒");

            } catch (Exception e) {
                e.printStackTrace();
            }
            finally {
                try {
                    fw.close();
                    Buff.close();
                    outSTr.close();
                    out.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }


    }   

    以下结果经过多次执行,取常出现的数据,由于只是简单比较,不做详细统计。

    1.当count=1000的,即写文件1000行的时候,写出的文件大小为18.5KB:
    FileOutputStream执行耗时:46 豪秒
    BufferedOutputStream执行耗时:31 豪秒
    FileWriter执行耗时:15 豪秒


    2.当count=10000的,即写文件10000行的时候,写出的文件大小为185KB:
    FileOutputStream执行耗时:188 豪秒
    BufferedOutputStream执行耗时:32 豪秒
    FileWriter执行耗时:16 豪秒

     

    3.当count=100000的,即写文件100000行的时候,写出的文件大小为1856KB:
    FileOutputStream执行耗时:1266 豪秒
    BufferedOutputStream执行耗时:125 豪秒
    FileWriter执行耗时:93 豪秒

     

    4.当count=1000000的,即写文件1000000行的时候,写出的文件大小为18555KB:
    FileOutputStream执行耗时:12063 豪秒
    BufferedOutputStream执行耗时:1484 豪秒
    FileWriter执行耗时:969 豪秒


        由以上数据可以看到,如果不用缓冲流BufferedOutputStream,FileOutputStream写文件的鲁棒性是很不好的。当写1000000行的文件的时候,FileOutputStream比FileWriter要慢11094毫秒(11秒),BufferedOutputStream比FileWriter慢515毫秒。
        不要小看这几秒的时间。当操作的数据量很大的时候,这点性能的差距就会很大了。在通用数据迁移工具导出数据库2千万条记录生成sql脚本文件的时候,性能性能相差10分钟以上。
        下次有时间再写单线程和多线程对性能的影响。

     

     

    from:http://b-qiufeng.javaeye.com/blog/72120

    展开全文
  • java读取文件的方式和效率比较

    千次阅读 2019-06-22 14:46:39
    1.按照字节读取 public String readFileByByte(String filePath){ long beginTime =System.currentTimeMillis(); StringBuffer stringBuffer=new StringBuffer();...//现在一次读取2048字节,可以一次性读取文件的...
  • java排序算法效率比较

    2013-04-27 13:57:10
    java产生多个随机数写入文件中,比较四种排序算法的效率
  • java读写文件时nio、bio对比

    千次阅读 2015-04-15 23:10:06
    1. 基本 概念   IO 是主存和外部设备 ( 硬盘、终端和网络等 ) 拷贝数据的过程。 IO 是操作系统的底层功能实现,底层通过 I/O 指令进行完成。 所有语言运行时系统提供执行 ... Java 标准 IO 类库是 io 面向
  • java文件读写耗时比较

    千次阅读 2017-12-07 16:10:44
    下面是传入4.16M文件 第一种和第二种方法的时间对比,一般情况下文件不是很大的情况下整体读取速度比较文件很大的时候就不要用第一种方式了,容易溢出。 另外还可以用缓冲流读取 BufferedInputStream 一次...
  • java中常见IO的读写效率对比

    千次阅读 2012-03-30 22:45:58
    java中的IO的类库非常的庞大,选择性非常的多,当面临一个问题时,往往不知道如何下手! 更具我现在的理解,在效率不是非常...去包装要是用的类,而如果效率要求比较高则可以考虑是用FileChannel 或者是 file map,其中fil
  • java使用nio读写文件

    千次阅读 2019-11-16 15:49:45
    最近在研究 JAVA NIO 的相关知识,学习NIO,就不能提到IO的原理和事项,必经NIO是基于IO进化而来 IO涉及到的底层的概念大致如下: 缓冲区操作。2) 内核空间与用户空间。3) 虚拟内存。4) 分页技术 一,虚拟存储器 ...
  • JAVA中几种文件操作流的效率对比

    千次阅读 2017-01-14 18:25:28
    以下案例说明了分别采用字节流方式、字节缓冲流方式读写文件效率对比
  •  * 二进制读写文件  */ import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.Fil
  • java文件读写类及其用法介绍

    万次阅读 多人点赞 2016-05-10 13:53:21
    本文主要是对Java文件读写操作中常用的类进行理顺,然后明白其用法,为之后能自如的进行文件读写操作打下基础。
  • c++fstream文件读写(与java比较

    千次阅读 2014-11-21 17:01:05
    (1)之前处理文本数据时,各种清洗数据用的都是java的File,FileReader/FileWriter,BufferedReader/BufferedWriter等类,详见java读写文本文件 (2)应用java的原因是java里面的map非常灵活,eclipse编译器更是给力...
  • Java文件读写IO/NIO及性能比较总结

    万次阅读 2015-03-11 22:59:26
    Java这么久,一直在做WEB相关的项目,一些基础类差不多都已经忘记。经常想得捡起,但总是因为一些原因,不能如愿。 其实不是没有时间,只是有些时候疲于总结,今得空,下定决心将丢掉的都给捡起来。 文件读写是一...
  • java读写文本文件大全

    万次阅读 2011-09-17 22:27:21
    使用Java操作文本文件的方法详解 摘要: 最初java是不支持对文本文件的处理的,为了弥补这个缺憾而引入了Reader和Writer两个类 最初java是不支持对文本文件的处理的,为了弥补这个缺憾而引入了Reader和...
  • 使用Java操作文本文件的方法详解 摘要: 最初java是不支持对文本文件的处理的,为了弥补这个...最初java是不支持对文本文件的处理的,为了弥补这个缺憾而引入了Reader和Writer两个类,这两个类都是抽象类,Writer中 w
  • 刚才使用如下代码进行测试,得到了如下下的结果!! import java.io.FileInputStream; import java.io....在读超大文件的时候会有坑,见这里: http://blog.csdn.net/chaijunkun/article/details/22387305
  • java读取写入文件几种方式效率比较

    千次阅读 2016-08-24 10:05:20
     * 缓冲字符写入文件字符串,数组或字符数据  * @param content  * @throws Exception  */  public static void bufferedWriter(String content,String filePath) throws Exception{   ...
  • Java多线程写文件

    千次阅读 2017-03-19 22:55:41
    用多线程对文件进行读写效率要比用循环进行读写要给许多,接下来以创建100个文件并且写入字符串来测试。 首先用循环的方式进行: public class FileMany { static int name=200; public static void main(String...
  • Java文件读写操作

    万次阅读 多人点赞 2012-08-20 10:50:11
    当我们读写文本文件的时候,采用Reader是非常方便的,比如FileReader,InputStreamReader和BufferedReader。其中最重要的类是InputStreamReader, 它是字节转换为字符的桥梁。你可以在构造器重指定编码的方式,如果...
  • 对于不使用缓存读写文件的操作(1M大小): FileOutputStream fos = new FileOutputStream(file); // BufferedOutputStream bos = new BufferedOutputStream(fos); for (int i
  • java 读写二进制文件

    千次阅读 2012-11-12 20:32:15
    JAVA二进制文件读写代码 /** * 二进制读写文件 */ import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream;
  • Java读写二进制文件操作

    万次阅读 2016-07-05 23:55:51
     * 二进制读写文件  */ import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.FileInputStream; ...
  • 利用JavaCSV API来读写csv文件

    万次阅读 多人点赞 2016-12-01 16:25:48
    利用JavaCSV API读写csv文件,这是一个成熟的三方工具包,可以极大提升开发者开发效率
  • 因为既需要读取数据还需要出到硬盘中,下面提供了三种文件复制的方法 可以对比一下 直接缓冲区与非直接缓冲区的效率对比.public class Nio { public static void main(String[] args) throws IOException { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 340,040
精华内容 136,016
关键字:

java写文件效率对比

java 订阅