Comment copier ligne par ligne de gros fichiers de données?

J'ai un CSVfichier de 35 Go . Je veux lire chaque ligne et écrire la ligne dans un nouveau CSV s'il correspond à une condition.

try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("source.csv"))) {
    try (BufferedReader br = Files.newBufferedReader(Paths.get("target.csv"))) {
        br.lines().parallel()
            .filter(line -> StringUtils.isNotBlank(line)) //bit more complex in real world
            .forEach(line -> {
                writer.write(line + "\n");
        });
    }
}

Cela prend env. 7 minutes. Est-il possible d'accélérer encore plus ce processus?

S'il s'agit d'une option, vous pouvez utiliser GZipInputStream / GZipOutputStream pour minimiser les E / S de disque.

Files.newBufferedReader / Writer utilise une taille de tampon par défaut, 8 Ko je crois. Vous pouvez essayer un tampon plus grand.

La conversion en chaîne, Unicode, ralentit (et utilise deux fois la mémoire). L'UTF-8 utilisé n'est pas aussi simple que StandardCharsets.ISO_8859_1.

Le mieux serait si vous pouvez travailler avec des octets pour la plupart et uniquement pour des champs CSV spécifiques les convertir en chaîne.

Un fichier mappé en mémoire peut être le plus approprié. Le parallélisme peut être utilisé par des plages de fichiers, crachant le fichier.

try (FileChannel sourceChannel = new RandomAccessFile("source.csv","r").getChannel(); ...
MappedByteBuffer buf = sourceChannel.map(...);

Cela deviendra un peu beaucoup de code, pour obtenir des lignes droites (byte)'\n', mais pas trop complexes.

vous pouvez essayer ceci:

try (BufferedWriter writer = new BufferedWriter(new FileWriter(targetFile), 1024 * 1024 * 64)) {
  try (BufferedReader br = new BufferedReader(new FileReader(sourceFile), 1024 * 1024 * 64)) {

Je pense que cela vous fera gagner une ou deux minutes. le test peut être effectué sur ma machine en environ 4 minutes en spécifiant la taille du tampon.

cela pourrait-il être plus rapide? essaye ça:

final char[] cbuf = new char[1024 * 1024 * 128];

try (Writer writer = new FileWriter(targetFile)) {
  try (Reader br = new FileReader(sourceFile)) {
    int cnt = 0;
    while ((cnt = br.read(cbuf)) > 0) {
      // add your code to process/split the buffer into lines.
      writer.write(cbuf, 0, cnt);
    }
  }
}

Cela devrait vous faire économiser trois ou quatre minutes.

Si cela ne suffit toujours pas. (La raison pour laquelle je suppose que vous posez la question est probablement que vous devez exécuter la tâche à plusieurs reprises). si vous voulez le faire en une minute ou même quelques secondes. vous devez alors traiter les données et les enregistrer dans db, puis traiter la tâche par plusieurs serveurs.

Grâce à toutes vos suggestions, le plus rapide que j'ai trouvé a été d'échanger avec l'écrivain BufferedOutputStream, ce qui a donné une amélioration d'environ 25%:

   try (BufferedReader reader = Files.newBufferedReader(Paths.get("sample.csv"))) {
        try (BufferedOutputStream writer = new BufferedOutputStream(Files.newOutputStream(Paths.get("target.csv")), 1024 * 16)) {
            reader.lines().parallel()
                    .filter(line -> StringUtils.isNotBlank(line)) //bit more complex in real world
                    .forEach(line -> {
                        writer.write((line + "\n").getBytes());
                    });
        }
    }

Pourtant, les BufferedReaderperformances sont meilleures que BufferedInputStreamdans mon cas.