Java: Emissione file di testo per console

Question

sto cercando di produrre un file di testo per la console con Java. Mi chiedevo che cosa è il modo più efficace di farlo?

Ho ricercato diversi metodi tuttavia, è difficile discernere che è il meno prestazioni soluzione di impatto.

output di un file di testo alla console comporterebbe lettura in ogni riga del file, allora la scrittura alla console.

E 'meglio utilizzare:

1. tamponata Reader con un FileReader, leggendo nelle linee e facendo un po 'di chiamate System.out.println?

   BufferedReader in = new BufferedReader(new FileReader("C:\\logs\\")); 
   while (in.readLine() != null) {
         System.out.println(blah blah blah);          
   }         
   in.close();
   

2. Scanner leggere ogni riga del file e fare chiamate system.print?

   while (scanner.hasNextLine()) { 
       System.out.println(blah blah blah);   
   }
   

Grazie.

Answer 1

Se non siete interessati a dati di carattere basato il file di testo è che contiene, basta streaming "raw" come byte.

InputStream input = new BufferedInputStream(new FileInputStream("C:/logs.txt"));
byte[] buffer = new byte[8192];

try {
    for (int length = 0; (length = input.read(buffer)) != -1;) {
        System.out.write(buffer, 0, length);
    }
} finally {
    input.close();
}

Ciò consente di risparmiare il costo di massaggio inutilmente tra i byte e caratteri e anche la scansione e la divisione in nuove linee e aggiungendo ancora una volta.

Per quanto riguarda le prestazioni, si possono trovare interessante questo articolo . Secondo l'articolo, un FileChannel con una matrice di 256K byte che viene letto tramite un avvolto ByteBuffer e scritto direttamente dal array di byte è il modo più veloce.

FileInputStream input = new FileInputStream("C:/logs.txt");
FileChannel channel = input.getChannel();
byte[] buffer = new byte[256 * 1024];
ByteBuffer byteBuffer = ByteBuffer.wrap(buffer);

try {
    for (int length = 0; (length = channel.read(byteBuffer)) != -1;) {
        System.out.write(buffer, 0, length);
        byteBuffer.clear();
    }
} finally {
    input.close();
}

Answer 2

Se tutto quello che vogliamo fare è stampare il contenuto di un file (e non si desidera stampare l'int successivo / doppia / etc.) Per la console poi un BufferedReader va bene.

Il codice così com'è non produrrà il risultato che stai dopo, però. Prova a modificare:

BufferedReader in = new BufferedReader(new FileReader("C:\\logs\\log001.txt"));
String line = in.readLine();
while(line != null)
{
  System.out.println(line);
  line = in.readLine();
}
in.close();

Non vorrei arrivare troppo appeso su di esso, però, perché è più probabile che il principale collo di bottiglia sarà la capacità della console per stampare le informazioni che Java trasmette il testo.

Answer 3

Se invece si è in modo più efficiente eseguire il dump dei contenuti del file con la console senza elaborazione in-tra, convertendo i dati in caratteri e trovare le interruzioni di linea è inutile sovraccarico. Invece, si può semplicemente leggere blocchi di byte dal file e scrivere poi dritto verso System.out:

package toconsole;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

public class Main {
    public static void main(String[] args) {
        BufferedInputStream bis = null;
        byte[] buffer = new byte[8192];
        int bytesRead = 0;
        try {
            bis = new BufferedInputStream(new FileInputStream(args[0]));
            while ((bytesRead = bis.read(buffer)) != -1) {
                System.out.write(buffer, /* start */ 0, /* length */ bytesRead);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try { bis.close(); } catch (Exception e) { /* meh */ }
        }
    }
}

Nel caso in cui non hai incontrato questo tipo di linguaggio, prima, l'affermazione contenuta nella condizione di entrambi, mentre assegna il risultato di bis.read per bytesRead e poi lo confronta con -1. Così continuiamo a leggere byte nel buffer fino a quando ci viene detto che siamo alla fine del file. E usiamo bytesRead in System.out.write per assicurarsi che si scrive solo i byte che abbiamo appena letto, in quanto non possiamo assumere tutti i file sono un multiplo di 8 kB lunga!

Answer 4

Se è un file relativamente piccolo, modo in cui una sola riga di Java 7+ per fare questo è:

System.out.println(new String(Files.readAllBytes(Paths.get("logs.txt"))));

https: // docs .oracle.com / / / / / / / file di JavaSE 7 docs API java nio / package-summary.html per ulteriori dettagli.

Cheers!