example - open file java
Diferencia de Java entre FileWriter y BufferedWriter (6)
BufferedWriter es más eficiente si
- tener múltiples escrituras entre flush / close
- las escrituras son pequeñas en comparación con el tamaño del búfer.
En su ejemplo, solo tiene una escritura, por lo que BufferedWriter simplemente agrega una sobrecarga que no necesita.
entonces eso significa que el primer ejemplo escribe los caracteres uno por uno y el segundo primero lo almacena en la memoria y lo escribe una vez
En ambos casos, la cadena se escribe a la vez.
Si usa solo FileWriter, sus llamadas de escritura (String)
public void write(String str, int off, int len)
// some code
str.getChars(off, (off + len), cbuf, 0);
write(cbuf, 0, len);
}
Esto hace que una llamada al sistema, por llamada a escribir (String).
Donde BufferedWriter mejora la eficiencia se encuentra en múltiples pequeñas escrituras.
for(int i = 0; i < 100; i++) {
writer.write("foorbar");
writer.write(NEW_LINE);
}
writer.close();
Sin un BufferedWriter esto podría hacer 200 (2 * 100) llamadas al sistema y escribir en el disco que es ineficiente. Con un BufferedWriter, todos pueden almacenarse en un búfer y, dado que el tamaño del búfer predeterminado es de 8192 caracteres, esto se convierte en solo 1 llamada al sistema para escribir.
¿Cuál es la diferencia entre esos? Estoy aprendiendo Java ATM, pero parece que puedo escribir en un archivo de ambas formas, es decir (no copié el bloque try-catch aquí).
FileWriter file = new FileWriter("foo.txt");
file.write("foobar");
file.close();
y
FileWriter file = new FileWriter("foo.txt");
BufferedWriter bf = new BufferedWriter(file);
bf.write("foobar");
bf.close();
Comprendo primero el concepto de almacenar los datos en la memoria intermedia, ¿significa eso que el primer ejemplo escribe los caracteres uno por uno y el segundo primero lo almacena en la memoria y lo escribe una vez?
BufferedWriter es más eficiente. Guarda pequeñas escrituras y escribe en una porción más grande si la memoria me sirve correctamente. Si haces muchas pequeñas escrituras, entonces usaría BufferedWriter. Llamar a las llamadas de escritura al sistema operativo que es lento por lo que es lo más deseable tener el menor número posible de escrituras.
De la especificación de la API de Java:
Clase de conveniencia para escribir archivos de caracteres. Los constructores de esta clase asumen que la codificación de caracteres predeterminada y el tamaño de byte-buffer predeterminado son aceptables.
Escribir texto en una secuencia de salida de caracteres, almacenar en el búfer los caracteres para proporcionar la escritura eficiente de caracteres individuales, matrices y cadenas.
En la entrada / salida sin búfer (FileWriter, FileReader) la solicitud de lectura o escritura es manejada directamente por el sistema operativo subyacente. https://hajsoftutorial.com/java/wp-content/uploads/2018/04/Unbuffered.gif
Esto puede hacer que un programa sea mucho menos eficiente, ya que cada una de esas solicitudes a menudo desencadena el acceso al disco, la actividad de la red o alguna otra operación que es relativamente costosa. Para reducir este tipo de sobrecarga, la plataforma Java implementa flujos de E / S en búfer. Las clases BufferedReader y BufferedWriter proporcionan búferes de caracteres internos. El texto que se escribe en un escritor en el búfer se almacena en el búfer interno y solo se escribe en el escritor subyacente cuando el búfer se llena o se vacía. https://hajsoftutorial.com/java/wp-content/uploads/2018/04/bufferedoutput.gif
Tienes razón. Así es como se ve el método write() de BufferedWriter :
public void write(int c) throws IOException {
synchronized (lock) {
ensureOpen();
if (nextChar >= nChars)
flushBuffer();
cb[nextChar++] = (char) c;
}
}
Como puede ver, en efecto, comprueba si el búfer está lleno ( if (nextChar >= nChars) ) y vacía el búfer. Luego agrega un nuevo carácter al búfer ( cb[nextChar++] = (char) c; ).
http://docs.oracle.com/javase/1.5.0/docs/api/java/io/BufferedWriter.html
En general, un escritor envía su salida inmediatamente al carácter subyacente o secuencia de bytes. A menos que se requiera una pronta salida, es recomendable envolver un BufferedWriter alrededor de cualquier Escritor cuyas operaciones de escritura () puedan ser costosas, como FileWriters y OutputStreamWriters. Por ejemplo,
PrintWriter out = new PrintWriter (new BufferedWriter (new FileWriter ("foo.out")));
almacenará la salida del PrintWriter en el archivo. Sin almacenamiento en búfer, cada invocación de un método print () haría que los caracteres se convirtieran en bytes que luego se escribirían inmediatamente en el archivo, lo que puede ser muy ineficiente.