Manière plus rapide de lire le fichier

Je suis en train de travailler sur un programme qui a environ 400 fichiers d'entrée et d'environ 40 fichiers de sortie.
C'est simple: il lit chaque fichier d'entrée et génère un nouveau fichier, mais beaucoup plus grand(basé sur un algorithme).

Je suis en utilisant la méthode read() de BufferedReader:

String encoding ="ISO-8859-1";
FileInputStream fis = new FileInputStream(nextFile);
BufferedReader reader = new BufferedReader(new InputStreamReader(fis, encoding));
char[] buffer = new char[8192] ;

De lire les fichiers d'entrée, je suis en utilisant ceci:

private String getNextBlock() throws IOException{
    boolean isNewFile = false;

    int n = reader.read(buffer, 0, buffer.length);
    if(n == -1) {
        return null;
    } else {
        return new String(buffer,0,n);
    }
}

Chaque bloc, je suis en train de faire quelques vérifications (comme le fait de regarder une chaîne de caractères à l'intérieur du bloc) et puis je suis en train d'écrire dans un fichier:

BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(
        new FileOutputStream("fileName"), encoding));

writer.write(textToWrite);

Le problème est que cela prend environ 12 minutes.
J'essaie de trouver quelque chose d'autre beaucoup plus rapide.
Quelqu'un a une idée de quelque chose de mieux?

Grâce.

source d'informationauteur CC.

  1. 21

    Vous devriez être capable de trouver une réponse ici:

    http://nadeausoftware.com/articles/2008/02/java_tip_how_read_files_quickly

    Pour le meilleur Java les performances en lecture, il y a quatre choses à retenir:

    • Minimiser les opérations d'e/S par la lecture d'un tableau à un moment, pas un octet à la fois. Un 8 ko tableau est une bonne taille.

    • Minimiser les appels de méthode par l'obtention de données d'un tableau à un moment, pas un octet à la fois. L'utilisation de la matrice de l'indexation pour obtenir les octets du tableau.

    • Minimiser les verrous de synchronisation des threads si vous n'avez pas besoin de thread. Soit faire moins d'appels de méthode à un thread-safe classe, ou de l'utilisation non thread-safe classe comme FileChannel et MappedByteBuffer.

    • Minimiser la copie de données entre la JVM/OS, des tampons internes, et de l'application des tableaux. Utilisation FileChannel avec mappage de la mémoire, ou directement ou enveloppé tableau ByteBuffer.

  2. 4

    Que vous ne donnez pas trop de détails, je pourrais vous suggérons d'essayer d'utiliser les fichiers mappés en mémoire:

    FileInputStream f = new FileInputStream(fileName);
FileChannel ch = f.getChannel( );
MappedByteBuffer mbb = ch.map( ch.MapMode.READ_ONLY, 0L, ch.size( ) );
while ( mbb.hasRemaining( ) )  {
      //Access the data using the mbb
}

    Il est possible de opitmize si vous souhaitez donner plus detailt sur le type de données de vos fichiers.

    MODIFIER

    Où est le //d'accès de la date à l'aide de la mbb, le froid décoder votre texte:

    String charsetName = "UTF-16"; //choose the apropriate charset.
CharBuffer cb =  Charsert.forName(charsetName).decode(mbb);
String text = cb.toString();
  3. 1

    Mappé octets de la mémoire tampon est le moyen le plus rapide:

     FileInputStream f = new FileInputStream( name );
FileChannel ch = f.getChannel( );
MappedByteBuffer mb = ch.map( ch.MapMode.READ_ONLY,
    0L, ch.size( ) );
byte[] barray = new byte[SIZE];
long checkSum = 0L;
int nGet;
while( mb.hasRemaining( ) )
{
    nGet = Math.min( mb.remaining( ), SIZE );
    mb.get( barray, 0, nGet );
    for ( int i=0; i<nGet; i++ )
    checkSum += barray[i];
}