Comparação de vários métodos de fluxos de entrada de texto e de saída Java

测试写入类


 


/ **
  *测试结果
  * 
  * 1.file do longa: 16kb
  * 
  tempo de FileWrite ---------- 36
  tempo de outputStreamTest ---------- 167
  tempo de bufferedOutputTest --- ------- 17
  tempo de bufferedWriteTest ---------- 14
  tempo de bufferedWrite E FileWriterTest ---------- 9
  tempo de bufferedWrite E BufferedOutputStreamTest ---------- 12
  * 
  * 2.file é longa: 1600kb
  tempo de FileWrite ---------- 69
  tempo de outputStreamTest ---------- 1282
  o tempo de bufferedOutputTest ---------- 68
  tempo de bufferedWriteTest ---------- 40
  bufferedWrite E FileWriterTest' s tempo ---------- 52
  tempo de bufferedWrite E BufferedOutputStreamTest ---------- 37
  * 
  * 3.file é longa: 16000kb
  tempo de FileWrite ---------- 555
  tempo de outputStreamTest ---------- 12448
  bufferedOutputTest de tempo ---------- 599
  tempo de bufferedWriteTest ---------- 346
  tempo de bufferedWrite E FileWriterTest ---------- 316
  tempo de bufferedWrite E BufferedOutputStreamTest ------ ---- 358
  
  4.file é longa: 160000kb
  
  tempo de FileWrite ---------- 5203
  o tempo de outputStreamTest ---------- 127182
  tempo de bufferedOutputTest ---------- 5972
  tempo de bufferedWriteTest ---------- 3445最优
  bufferedWrite E FileWriterTest' é hora ---------- 5904
  tempo de bufferedWrite E BufferedOutputStreamTest ---------- 5353
  
  
  5.File é longa: 1600000kb
  
  tempo de FileWrite ---------- 50416
  tempo de outputStreamTest ---------- 1.303.242
  tempo- de bufferedOutputTest --------- 60931
  tempo de bufferedWriteTest ---------- 46697
  tempo de bufferedWrite E FileWriterTest ---------- 48710
  tempo de bufferedWrite E BufferedOutputStreamTest -------- --64354
  * /


 public static void main (string [] args) {


  string str = "ABCDEFGHIJKLMN!";
  int count = 1000000;
  TestOutputStream t = novo TestOutputStream ();
  longo start = System.currentTimeMillis ();
  t.fileWriteTest (contagem, str);
  longo final = System.currentTimeMillis ();
  System.out.println ( "tempo de FileWrite ---------" + (início - fim));


  start = System.currentTimeMillis ();
  t.outputStreamTest (contagem, str);
  acabar = System.currentTimeMillis ();
  System.out.println ( "tempo de outputStreamTest ---------" + (início - fim));


  start = System.currentTimeMillis ();
  t.bufferedOutputTest (contagem, str);
  acabar = System.currentTimeMillis ();
  System.out
    .println ( "tempo de bufferedOutputTest ---------" + (início - fim));
  
  start = System.currentTimeMillis ();
  t.bufferedWriteTest (contagem, str);
  acabar = System.currentTimeMillis ();
  System.out.println ( "tempo de bufferedWriteTest ---------" + (início - fim));
  
  start = System.currentTimeMillis ();
  t.bufferedWriteAndFileWriterTest (contagem, str);
  acabar = System.currentTimeMillis ();
  System.out.println ( "tempo de bufferedWrite E FileWriterTest ---------" + (início - fim));
  
  start = System.currentTimeMillis ();
  t.bufferedWriteAndBufferedOutputStreamTest (contagem, str);
  acabar = System.currentTimeMillis ();
  System.out.println ( "tempo de bufferedWrite E BufferedOutputStreamTest ---------" + (início - fim));
  
  
  

 










 outputStreamTest public void (int count, String str) {
  arquivo f = new File ( "f: test1.txt");
  OutputStream os = nulo;
  try {
   OS = new FileOutputStream (f);
   for (int i = 0; i <count; i ++) {
    os.write (str.getBytes ());
   }
   Os.flush ();
   System.out.println ( "arquivo é longa:" + f.length ());
  } Catch (FileNotFoundException e) {
   e.printStackTrace ();
  } Catch (IOException e) {
   e.printStackTrace ();
  } Finally {
   try {
    os.close ();
   } Catch (IOException e) {
    e.printStackTrace ();
   }
  }
 }


 / **
  * 2按字节缓冲写入BufferedOutputStream
  * 
  * @ param contagem写入循环次数
  * @param str写入字符串
  * /
 público bufferedOutputTest void (int count, String str) {
  arquivo f = new File ( "f : test2.txt ");
  BufferedOutputStream bos = nulo;
  try {
   OutputStream os = new FileOutputStream (f);
   Bos = novo BufferedOutputStream (OS);
   for (int i = 0; i <count; i ++) {
    bos.write (str.getBytes ());
   }
   Bos.flush ();
  } Catch (FileNotFoundException e) {
   e.printStackTrace ();
  } Catch (IOException e) {
   e.printStackTrace ();
  } finalmente {
   try {
    bos.close ();
   } Catch (IOException e) {
    e.printStackTrace ();
   }
  }
 }
 
 / **
  * 3按字符写入FileWriter
  * 
  * @ param contagem写入循环次数
  * @param str写入字符串
  * /
 public void fileWriteTest (int count, String str) {
  arquivo f = new File (" f: test.txt ");
  Escritor writer = null;
  try {
   escritor = new FileWriter (f);
   for (int i = 0; i <count; i ++) {
    writer.write (str);
   }
   Writer.flush ();
  } Catch (IOException e) {
   e.printStackTrace ();
  } finalmente {
   try {
    writer.close ();
   } Catch (exceção e) {
    e.printStackTrace ();
   }
  }
 }


 / **
  * 4按字符缓冲写入BufferedWriter
  * 
  * @ param contagem写入循环次数
  * @param str写入字符串
  * /
 public void bufferedWriteTest (int count, String str) {
  arquivo f = new File ( "f: test3.txt");
  OutputStreamWriter escritor = nulo;
  BufferedWriter bw = nulo;
  try {
   OutputStream os = new FileOutputStream (f);
   escritor = novo OutputStreamWriter (OS);
   bw = novo BufferedWriter (escritor);
   for (int i = 0; i <count; i ++) {
    bw.write (STR);
   }
   bw.flush ();
   IF (f.exists ()) {
    f.delete ();
   }
  } o engate (uma FileNotFoundException E) {
   e.printStackTrace ();
  } o prendedor (IOException e) {
   e.printStackTrace ();
  } {a finalmente
   o try {
    bw.close ();
   } o prendedor (IOException e) {
    e.printStackTrace ();
   }
  }
 }
 
 / **
  . * escrito no buffer de caracteres 5 e BufferedOutputStream o BufferedWriter,
  * 
  * @ param contar o número de ciclos de escrita
  * @param str escrever a string
  * /
 bufferedWriteAndBufferedOutputStreamTest public void (int count, String str) {
  arquivo f = new File ( "f: test4.txt");
  BufferedOutputStream bos = nulo;
  OutputStreamWriter escritor = nulo;
  BufferedWriter bw = nulo;
  try {
   OutputStream os = new FileOutputStream (f);
   Bos = novo BufferedOutputStream (OS);
   escritor = novo OutputStreamWriter (BOS);
   bw = novo BufferedWriter (escritor);
   for (int i = 0; i <count; i ++) {
    bw.write (str);
   }
   Bw.flush ();
   if (f.exists ()) {
    f.delete ();
    System.out.println ( "excluir ---");
   }
  } Catch (FileNotFoundException e) {
   e.printStackTrace ();
  } o prendedor (IOException e) {
   e.printStackTrace ();
  } {a finalmente
   o try {
    bw.close ();
   } o prendedor (IOException e) {
    e.printStackTrace ();
   }
  }
 }
 
 / **
  * 6 é escrito por buffer de caracteres e FileWriter BufferedWriter,
  * 
  * ciclos de escrita @param COUNT
  * @param str escrever a string
  * /
 bufferedWriteAndFileWriterTest public void (int count, corda STR) {
  Ficheiro nova nova F = ( "F: Test5. TXT ");
  FileWriter FW = null;
  BufferedWriter, BW = null;
  o try {
   FW = new new FileWriter (F); 
   bw = novo BufferedWriter (fw);
   for (int i = 0; i <count; i ++) {
    bw.write (str);
   }
   Bw.flush ();
  } Catch (FileNotFoundException e) {
   e.printStackTrace ();
  } Catch (IOException e) {
   e.printStackTrace ();
  } Finally {
   try {
    bw.close ();
    if (f.exists ()) {
     f.delete ();
    }
   } Catch (IOException e) {
    e.printStackTrace ();
   }
  }
 }


 


总结:


Se classificados por bytes de caracteres e, além de 1 e 2, o resto são gravados no arquivo pelo caráter, o personagem é normalmente mais rápido do que o byte de gravação, ver java API entendido, que a classe pai OutputStreamWriter FileWriter, ambos são implementadas classe escritor, a partir deste ponto, o método é quase nenhuma diferença entre 4 e 6, há uma ligeira diferença de tempo, mas o mecanismo interno é o mesmo, mas o método é relativamente simples 6, a definição de variáveis ​​um pouco, eu costumava usar o método 4, parece que depois de muito sob a mudança.