Come estrarre righe univoche nel file> 10 GB con 4 GB di RAM

Question

Ho un PC con 4 GB di RAM e un file con 10 GB di memoria. Ora voglio verificare, se ogni riga del file è unica così ho scritto il seguente codice:

import java.io.BufferedReader; 
import java.io.File; 
import java.io.FileReader; 
import java.io.FileWriter; 
import java.io.IOException; 
import java.util.HashSet; 
import java.util.Set; 

public class Cleaner { 

    public static void main(String[] args) throws IOException { 
     if (args.length < 2) { 
      System.out.println("Too less parameters!"); 
      return; 
     } 

     File file = new File(args[0]); 
     BufferedReader buff = new BufferedReader(new FileReader(file)); 
     String line; 
     Set<String> set = new HashSet<String>(); 
     while ((line = buff.readLine()) != null) { 
      set.add(line); 
     } 
     FileWriter fw = new FileWriter(args[1]); 
     for (String s : set) { 
      fw.write(s + "\n"); 
      fw.flush(); 
     } 
     fw.close(); 
     buff.close(); 

    } 

} 

Ma ho un OutOfMemoryException quindi la mia domanda è:
Come dovrei cambiare il mio codice per ottenere un file in cui ogni riga è unica?
Grazie per il vostro aiuto in anticipo.

Answer 1

Si potrebbe provare a cercare la linea duplicata hash primo a identificare potenziali linee duplicate:

Map<Integer, Integer> hashes = new HashMap<>(); 
Map<Integer, Integer> dupes = new HashMap<>(); 
int i = 0; 
while ((line = buff.readLine()) != null) { 
    int hash = line.hashCode(); 
    Integer previous = hashes.get(hash); 
    if (previous != null) { //potential duplicate 
    dupes.put(i, previous); 
    } else { 
    hashes.put(hash, i); 
    } 
    ++i; 
} 

Alla fine si dispone di un elenco di potenziali duplicati. Se dupes è vuoto non c'era duplicato, se non lo è, puoi fare un secondo passaggio sul file per verificare se le linee sono veramente identiche.

Answer 2

Non è possibile eseguire questa operazione in questo modo a causa della memoria RAM. Invece, puoi leggere il file e generare n file con una dimensione fissa (es: 10.000 linee), leggere una riga e inserirla nel file attuale. Quando raggiungi il limite del file, aprine uno nuovo, rilascia tutti gli oggetti per il salvataggio della memoria, quindi esegui un secondo ciclo e confronta ogni riga del file originale usando una stringa (per la linea) con i n file generati. Forse in questo modo puoi evitare il vuoto di memoria.

È un po 'strano e sarà un processo lento, ma in questo modo penso che tu possa raggiungere le tue esigenze.

Se hai bisogno di codice, fammi sapere.

Speranza aiuta

Answer 3

si può barare con qualcosa di simile: (esempio è Groovy, ma l'equivalente Java avrebbe funzionato)

def hashes = [] 
def writer = new PrintWriter(new FileWriter("out.txt")) 
new File('test.txt').eachLine { line -> 
    def hashCode = DigestUtils.sha256Hex(line) //Commons digest library 
    if (!(hashCode in hashes)) { 
     hashes << hashCode 
     writer.println(line) 
    } 
} 
writer.close() 

che non dovrebbe richiedere più di circa 1 GB di RAM per funzionare. Gli hash SHA256 ti daranno probabilmente più certezza sull'unicità di una linea rispetto al metodo standard hashCode.