Cuando necesitamos leer contenido de un archivo de texto, o necesitamos escribir contenido en un archivo, necesitamos usar una secuencia en JAVA.
La secuencia incluye la secuencia de entrada y la secuencia de salida, leer: usar la secuencia de entrada, escribir: usar la secuencia de salida. Para facilitar la memoria, se divide en los siguientes 4 pasos.
Uno, lee
1. Nuevo flujo de entrada de archivo FileInputStream (flujo de bytes, solo se puede leer un byte, fis.read ())
FileInputStream fis = nuevo FileInputStram (filePath);
2. Cree un nuevo flujo de entrada de caracteres InputStramReader , (flujo de caracteres, solo se puede leer un carácter, isr.read ())
InputStramReader isr = new InputStramReader (fis, "UTF-8");
3. Cree un nuevo flujo de entrada almacenado en búfer BufferedReader (puede leer una línea de caracteres)
BufferedReader br = new BufferedReader (isr);
4. Lee la línea
while ((línea = br.readLine ())! = null) {
System.out.println (línea);
}
Dos, escribe
1. Cree un nuevo flujo de salida de archivo FileOutputStream (flujo de bytes)
FileOutputStream fos = nuevo FileOutputStream (filePath);
2. Cree un nuevo flujo de salida de caracteres OutputStreamWriter
OutputStreamWriter osw = nuevo OutputStreamWriter (fos, "UTF-8");
3. Cree un nuevo flujo de salida almacenado en búfer BufferedWriter (puede escribir una línea de caracteres)
BufferedWriter bw = new BufferedWriter (osw);
4, línea de copia
ArrayList <String> popertiesLines = new ArrayList <String> ();
para (Línea de cadena: popertiesLines) {
bw.write (línea);
bw.newLine (); // Nueva línea
}
Ruta de la memoria (tonterías):
读 ： FileInputStream -> InputStreamReader -> BufferedReader -> br.readLine () ；
写 ： FileOutputStream-> OutputStreamWriter -> BufferedWriter -> bw.write (línea);
Fórmula: escribir y leer (todo sangrando, demasiado cruel), una operación de tres tasas
1. Leer y escribir archivos, por supuesto, primero piense en archivos (Archivo), por lo que se utilizan flujos de archivos: FileInputStream, FileOutputStream
Se utiliza la secuencia de archivos, ¿dónde está la ruta del archivo? Por lo tanto, debe especificar la ruta del archivo.
Formato: nuevo FileInputStream (fileRealPath);
2. Con el flujo de archivos, ¿qué operaciones se deben realizar, leer o escribir? Piense en Reader, Writer. Eso es InputStreamReader, OutputStreamWriter
¿Qué archivo se lee y se escribe? Por lo tanto, debe especificar el flujo de archivos creado en el paso 1,
¿Qué tipo de caracteres se utilizan para las operaciones de lectura y escritura? Entonces necesitas especificar caracteres.
格式 ： nuevo InputStreamReader (fis, "utf-8");
3. No hay nada en su lugar en un solo paso, se necesita una cierta cantidad de almacenamiento en búfer. Piense en búfer, es decir, BufferedReader, BufferedWriter
¿Leer búfer o escribir búfer? Por lo tanto, debe especificar el "flujo de lectura y escritura" creado en el paso 2.
Formato: nuevo BufferedReader (isr);
4. La tercera categoría está lista e iniciada.
¿leer? br.readLine ();
¿escribir? bw.write (línea); Recuerde ajustar después de escribir una línea: bw.newLine ();
Ejemplo (modificar un archivo de configuración):
/**
* 修改properties配置文件，保留原有注释。
* @param fileRealPath 文件绝对路径，
Linux: /root/iov_main/ly.mp.iov.login.main/bin
window:E:\后台开发工作空间\iov\ly.mp.iov.example.common\src\main\resources\domainname.properties
* @param keyName 键 ，如键不存在，则新增在后尾
* @param value 值
*/
public static boolean SetPropetyValue(String fileRealPath,String keyName,String value){
ArrayList<String> popertiesLines = new ArrayList<String>();
boolean hasKey=false;
BufferedReader br=null;
BufferedWriter bw=null;
try {
//1、读取配置文件
FileInputStream fis = new FileInputStream(fileRealPath);
InputStreamReader isr = new InputStreamReader(fis, "utf-8");
br = new BufferedReader(isr);
String line = "";
while ((line=br.readLine()) != null){
// 找到该key，重新赋值（修改value）
if(line.startsWith(keyName, 0)){
hasKey=true;
popertiesLines.add(keyName+"="+value);
logger.info("SetPropetyValue----->line.startsWith:"+keyName+"，line:"+line);
}else{ //不是该key的行，直接追加
popertiesLines.add(line);
}
}
//全部没有找到，追加key
if(!hasKey){
popertiesLines.add(keyName+"="+value);
}
//2、重新写入配置文件
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(fileRealPath),"UTF-8");
bw= new BufferedWriter(osw);
for(String lin:popertiesLines){
bw.write(lin);
bw.newLine();
}
bw.flush();
return true;
} catch (FileNotFoundException e) {
logger.error("SetPropetyValue FileNotFoundException---->exception info:" + e.toString());
return false;
} catch (IOException e) {
logger.error("SetPropetyValue IOException---->exception info:" + e.toString());
return false;
}finally{
//关闭流
if(br!=null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bw!=null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
} Puntos de conocimiento:
Separación de barras en el camino.
Windows:
"/" significa parámetro, "\" significa ruta local.
Linux y Unix:
"/" significa ruta, "\" significa escape y "-" y "-" significa parámetros.
La Internet:
Dado que la red usa el estándar Unix, la ruta de la red usa "/".
1 、 InputStream 、 OutputStream
Clase abstracta para manejar flujos de bytes
InputStream es la superclase de todas las clases de flujos de entrada de bytes, y generalmente usamos sus subclases, como FileInputStream.
OutputStream es la superclase de todas las clases de flujos de salida de bytes, y generalmente usamos sus subclases, como FileOutputStream.
InputStream puede leer un byte de la fuente, por lo que es el nivel más bajo.
2.InputStreamReader OutputStreamWriter
Clase abstracta para manejar flujos de caracteres
InputStreamReader es un puente entre el flujo de bytes y el flujo de caracteres, convierte el flujo de bytes en un flujo de caracteres.
OutputStreamWriter es un puente entre el flujo de caracteres y el flujo de bytes, convierte el flujo de caracteres en un flujo de bytes.
InputStreamReader encapsula InputStream en él. Lee un carácter a la vez en una forma de nivel superior, y el carácter debe especificarse durante la inicialización.
3.BufferedReader BufferedWriter
BufferedReader se extiende desde la clase Reader para proporcionar lectura de texto en búfer general, readLine lee una línea de texto,
Leer texto del flujo de entrada de caracteres y almacenar en búfer caracteres individuales para proporcionar una lectura eficiente de caracteres, matrices y líneas.
BufferedWriter se extiende desde la clase Writer para proporcionar escritura de texto en búfer general. NewLine usa el separador de línea propio de la plataforma,
Escriba texto en el flujo de salida de caracteres y almacene en búfer los caracteres individuales para proporcionar una escritura eficiente de caracteres individuales, matrices y cadenas.
BufferedReader es más avanzado que InputStreamReader, encapsula la clase StreamReader.
Todos sabemos que las computadoras solo pueden reconocer 0 y 1, y los datos se almacenan en bytes.
Entonces en Java, si queremos leer un carácter de un archivo, primero necesitamos tener un archivo (fuente de datos), entonces usamos la clase File para formular un archivo;
b) Debido a que los datos en la computadora son códigos 0 y 1, en bytes, el objeto de archivo que especificamos debe convertirse primero en un flujo de bytes, por lo que se debe usar la clase InputStream;
c. En este momento, si acaba de leer el archivo en bytes en Java, es suficiente. Pero si desea leer el archivo con caracteres, también debe codificar el flujo de bytes de cierta manera, porque diferentes caracteres usan diferentes métodos de codificación, si todavía usa el flujo de bytes, es posible que no alcance nuestras expectativas. El efecto deseado . Podemos especificar el método de codificación de caracteres, que se especifica y instancia en el constructor de la clase relacionada InputStreamReader. Por defecto, es el método de codificación Unicode. En este punto, hemos utilizado InputStreamReader.
d. Después de los tres pasos anteriores, ya podemos leer un carácter del archivo, pero leer solo un carácter a la vez no puede satisfacer nuestras necesidades de lectura de big data. En este momento, BufferedReader es útil. A partir del búfer en el nombre, podemos inferir que tiene un efecto de búfer. El hecho es que puede leer varios caracteres a la vez, y el número de caracteres leídos a la vez se puede configurar libremente.