Comparaison de plusieurs méthodes de saisie de texte JAVA et de sortie

测试写入类


 


/ **
  *测试结果
  * 
  * 1.file LONGUES: 16kb
  * 
  temps de FILEWRITE ---------- 36
  temps de outputStreamTest ---------- 167
  temps de bufferedOutputTest --- ------- 17
  temps de bufferedWriteTest ---------- 14
  temps de bufferedWrite Et FileWriterTest ---------- 9
  temps de bufferedWrite Et BufferedOutputStreamTest ---------- 12
  * 
  * 2.Taille est longue: 1600kb
  temps de FILEWRITE ---------- 69
  temps de outputStreamTest ---------- 1282 le
  temps de bufferedOutputTest ---------- 68
  temps de bufferedWriteTest ---------- 40
  bufferedWrite Et FileWriterTest » s temps ---------- 52
  temps de bufferedWrite Et BufferedOutputStreamTest ---------- 37
  * 
  * 3.file est longue: 16000kb
  temps de FILEWRITE ---------- 555
  temps de outputStreamTest ---------- 12448
  bufferedOutputTest de temps ---------- 599 le
  temps de bufferedWriteTest ---------- 346
  temps de bufferedWrite Et FileWriterTest ---------- 316
  temps de bufferedWrite Et BufferedOutputStreamTest ------ ---- 358
  
  4.file est long: 160000kb
  
  temps de FILEWRITE ---------- 5203 le
  temps de outputStreamTest ---------- 127182
  temps de bufferedOutputTest ---------- 5972
  temps de bufferedWriteTest ---------- 3445最优
  bufferedWrite Et FileWriterTest » s temps ---------- 5904
  temps de bufferedWrite Et BufferedOutputStreamTest ---------- 5353
  
  
  5.File est longue: 1600000kb
  
  temps de FILEWRITE ---------- 50416
  temps de outputStreamTest ---------- 1.303.242 de
  temps de bufferedOutputTest --------- 60931
  temps de bufferedWriteTest ---------- 46697
  temps de bufferedWrite Et FileWriterTest ---------- 48710
  temps de bufferedWrite Et BufferedOutputStreamTest -------- --64354
  * /


 static void main publique (String [] args) {


  String str = "abcdefghijklmn!";
  int count = 1000000;
  TestOutputStream t = new TestOutputStream ();
  longue start = System.currentTimeMillis ();
  t.fileWriteTest (comptage, str);
  à long terme (= System.currentTimeMillis);
  System.out.println ( la "heure de FILEWRITE ---------" + (début - fin));


  start = System.currentTimeMillis ();
  t.outputStreamTest (comptage, str);
  fin = System.currentTimeMillis ();
  System.out.println ( la "heure de outputStreamTest ---------" + (début - fin));


  start = System.currentTimeMillis ();
  t.bufferedOutputTest (comptage, str);
  fin = System.currentTimeMillis ();
  System.out
    de ( "temps de bufferedOutputTest ---------" + (début - fin));
  
  start = System.currentTimeMillis ();
  t.bufferedWriteTest (comptage, str);
  fin = System.currentTimeMillis ();
  System.out.println ( la "heure de bufferedWriteTest ---------" + (début - fin));
  
  start = System.currentTimeMillis ();
  t.bufferedWriteAndFileWriterTest (comptage, str);
  fin = System.currentTimeMillis ();
  System.out.println ( "temps de bufferedWrite et FileWriterTest ---------" + (début - fin));
  
  start = System.currentTimeMillis ();
  t.bufferedWriteAndBufferedOutputStreamTest (comptage, str);
  fin = System.currentTimeMillis ();
  System.out.println ( "temps de bufferedWrite et BufferedOutputStreamTest ---------" + (début - fin));
  
  
  

 










 outputStreamTest public void (nombre int, String str) {
  fichier f = new File ( "f: test1.txt");
  OutputStream os = null;
  try {
   os = new FileOutputStream (f);
   pour (int i = 0; i <count; i ++) {
    os.write (str.getBytes ());
   }
   Os.flush ();
   System.out.println ( "fichier est long:" + f.length ());
  } Catch (FileNotFoundException e) {
   e.printStackTrace ();
  } Catch (IOException e) {
   e.printStackTrace ();
  } Finally {
   try {
    os.close ();
   } Catch (IOException e) {
    e.printStackTrace ();
   }
  }
 }


 / **
  * 2按字节缓冲写入BufferedOutputStream
  * 
  * @param comte写入循环次数
  * @param str写入字符串
  * /
 bufferedOutputTest public void (nombre int, String str) {
  fichier f = new File ( "f : test2.txt ");
  BufferedOutputStream bos = null;
  try {
   OutputStream os = new FileOutputStream (f);
   bos = new BufferedOutputStream (OS);
   pour (int i = 0; i <count; i ++) {
    bos.write (str.getBytes ());
   }
   Bos.flush ();
  } Catch (FileNotFoundException e) {
   e.printStackTrace ();
  } Catch (IOException e) {
   e.printStackTrace ();
  } enfin {
   try {
    bos.close ();
   } Catch (IOException e) {
    e.printStackTrace ();
   }
  }
 }
 
 / **
  * 3按字符写入FileWriter
  * 
  * @param comte写入循环次数
  * @param str写入字符串
  * /
 fileWriteTest public void (int count, String str) {
  fichier f = new File ( » f: test.txt ");
  Scénariste = null;
  try {
   writer = new FileWriter (f);
   pour (int i = 0; i <count; i ++) {
    writer.write (str);
   }
   Writer.flush ();
  } Catch (IOException e) {
   e.printStackTrace ();
  } enfin {
   try {
    writer.close ();
   } Catch (Exception e) {
    e.printStackTrace ();
   }
  }
 }


 / **
  * 4按字符缓冲写入BufferedWriter
  * 
  * @param comte写入循环次数
  * @param str写入字符串
  * /
 bufferedWriteTest public void (int count, String str) {
  fichier f = new File ( "f: test3.txt");
  OutputStreamWriter écrivain = null;
  BufferedWriter pc = null;
  try {
   OutputStream os = new FileOutputStream (f);
   writer = new OutputStreamWriter (os);
   pc = new BufferedWriter (écrivain);
   pour (int i = 0; i <count; i ++) {
    bw.write (STR);
   }
   bw.flush ();
   IF (f.exists ()) {
    f.delete ();
   }
  } le cliquet (un FileNotFoundException e) {
   e.printStackTrace ();
  } le catch (IOException e) {
   e.printStackTrace ();
  } {finally
   l'try {
    bw.close ();
   } les prises (IOException E) {
    e.printStackTrace ();
   }
  }
 }
 
 / **
  . * écrit dans la mémoire tampon de caractères 5 et BufferedOutputStream le BufferedWriter,
  * 
  * @param compter le nombre de cycles d'écriture
  * @param str écrire la chaîne
  * /
 bufferedWriteAndBufferedOutputStreamTest public void (nombre int, String str) {
  fichier f = new File ( "f: test4.txt");
  BufferedOutputStream bos = null;
  OutputStreamWriter écrivain = null;
  BufferedWriter pc = null;
  try {
   OutputStream os = new FileOutputStream (f);
   bos = new BufferedOutputStream (OS);
   writer = new OutputStreamWriter (bos);
   pc = new BufferedWriter (écrivain);
   pour (int i = 0; i <count; i ++) {
    bw.write (str);
   }
   Bw.flush ();
   si (f.exists ()) {
    f.delete ();
    System.out.println ( "delete ---");
   }
  } Catch (FileNotFoundException e) {
   e.printStackTrace ();
  } les prises (IOException E) {
   e.printStackTrace ();
  } {finally
   l'try {
    bw.close ();
   } les prises (IOException E) {
    e.printStackTrace ();
   }
  }
 }
 
 / **
  * 6 est écrit par un tampon de caractères et FileWriter BufferedWriter,
  * 
  * @param COUNT cycles d'écriture
  * @param str écrire la chaîne
  * /
 de bufferedWriteAndFileWriterTest public void (int COUNT, chaîne STR) {
  fichier nouveau fichier nouveau F = ( « F: Test5. TXT « );
  FileWriter FW = null;
  BufferedWriter, BW = null;
  try {
   FW = new new FileWriter (F); 
   pc = new BufferedWriter (fw);
   pour (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 ();
    si (f.exists ()) {
     f.delete ();
    }
   } Catch (IOException e) {
    e.printStackTrace ();
   }
  }
 }


 


总结:


Si classé par octets de caractère et, en plus de 1 et 2, le reste sont écrites dans le fichier par caractère, le caractère est généralement plus rapide que l'octet d'écriture, voir Java API compris que la classe parente OutputStreamWriter FileWriter, ils sont à la fois mis en œuvre classe Writer, à partir de ce point, la méthode est presque pas de différence entre 4 et 6, il y a une légère différence de temps, mais le mécanisme interne est le même, mais la méthode est relativement simple 6, la définition des variables un peu, je l'habitude d'utiliser la méthode 4, il semble que, après trop sous le changement.