Tabla de contenido
Clase de propiedades
Propiedades (Java.util.Properties), esta clase se usa principalmente para leer archivos de configuración de Java . Los diferentes lenguajes tienen sus propios archivos de configuración compatibles. Muchas variables en el archivo de configuración se cambian con frecuencia. Para facilitar la configuración del usuario, Permitir a los usuarios modificar la configuración de la variable relacionada sin el programa en sí.
En Java, el archivo de configuración suele ser un archivo ".properties" (por supuesto, también se pueden leer archivos en otros formatos, como un archivo txt), que configura los parámetros en forma de pares clave-valor.
Propiedades. Es una subclase de Hashtable y pertenece a un conjunto de dos columnas. Los pares clave-valor de este conjunto son todos tipos de cadenas y no es necesario especificar genéricos . Usualmente usamos conjuntos de atributos y métodos relacionados con el flujo.
Su método de construcción:
| método | Descripción |
|---|---|
| Propiedades públicas () | Cree una lista de atributos vacía. |
Métodos comunes:
| método | Descripción |
|---|---|
| Objeto setProperty (clave de cadena, valor de cadena) | Agregar pares clave-valor |
| String getProperty (clave de cadena) | Obtenga valor basado en la clave |
| stringPropertyNames () | Consigue todas las llaves |
| carga (flujo de entrada) | Leer los datos del par clave-valor en el archivo en la colección |
| store (flujo de salida, comentarios de cadena) | Guarde los pares clave-valor de la colección en un archivo |
Demostración de código:
//集合相关的方法
import java.util.Properties;
import java.util.Set;
public class Test01 {
public static void main(String[] args) {
//创建对象
Properties pro = new Properties();
//添加键值对
pro.setProperty("username","James");
pro.setProperty("password","123456");
//通过键获取值
String s = pro.getProperty("username");
System.out.println(s); //James
//获取所有的键
Set<String> set = pro.stringPropertyNames();
System.out.println(set); //[password, username]
}
}
//IO相关的方法
import java.io.FileWriter;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) throws IOException {
//创建Properties对象
Properties properties = new Properties();
//添加信息集合
properties.setProperty("品名", "IPhone11 Pro Max");
//创建输出对象
properties.store(new FileWriter("test2.txt"),"add store message");
}
}
public class Demo02 {
public static void main(String[] args) throws IOException {
//创建Properties对象
Properties properties=new Properties();
//读取test2中内容
properties.load(new FileReader("test2.txt"));
//获取所有键
Set<String> set = properties.stringPropertyNames();
//遍历所有键，根据键获取值
for (String s : set) {
String property = properties.getProperty(s);
//打印每个键值对
System.out.println(s + "-->" + property);
}
}
}Flujo de búfer
En las aplicaciones, la eficiencia de uso de los flujos ordinarios es relativamente baja, por lo que se proporcionan cuatro flujos en búfer en Java para mejorar la eficiencia de los cuatro flujos ordinarios presentados en el blog anterior . El flujo de salida almacenado en búfer primero enviará los datos al búfer y luego escribirá en el archivo o leerá, el método es básicamente el mismo que el de los cuatro flujos ordinarios.
FileOutputStream -> BufferedOutputStream
FileInputStream -> BufferedInputStream
FileWriter -> BufferedWriter
FileReader -> BufferedReader
Flujo de búfer de bytes
| Método de construcción | Descripción |
| BufferedInputStream （InputStream en） | Crear un nuevo flujo de entrada almacenado en búfer |
| BufferedOutputStream （OutputStream out） | Cree una nueva secuencia de salida almacenada en búfer |
Demostración de código (el método es el mismo que el flujo normal) :
import java.io.*;
public class Test01 {
public static void main(String[] args) throws IOException {
//public BufferedInputStream(InputStream in) ： 创建一个新的缓冲输入流。
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.txt"));
//public BufferedOutputStream(OutputStream out) ： 创建一个新的缓冲输出流。
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.txt"));
bis.close();
bos.close();
}
}Flujo de búfer de caracteres
Método de construcción:
| método | Descripción |
| BufferedReader (lector en) | Crear un nuevo flujo de entrada almacenado en búfer |
| BufferedWriter (escritor fuera) | Cree una nueva secuencia de salida almacenada en búfer |
Demostración de código (el método es el mismo que el flujo normal):
import java.io.*;
public class Test02 {
public static void main(String[] args) throws IOException {
//public BufferedReader(Reader in) ：创建一个新的缓冲输入流。
BufferedReader br = new BufferedReader(new FileReader("test.txt"));
//public BufferedWriter(Writer out) ： 创建一个新的缓冲输出流。
BufferedWriter bw = new BufferedWriter(new FileWriter("test.txt"));
br.close();
bw.close();
}
}El método único de flujo de búfer de caracteres:
BufferedReader -----> String readLine () ===> Leer una línea de texto
BufferedWriter ------> void newLine () ===> escribir nueva línea, símbolo de definición de propiedad del sistema
Flujo de conversión
El flujo IO de Java proporciona dos flujos de conversión para convertir flujos de bytes en flujos de caracteres. El flujo de entrada de caracteres InputStreamReader se utiliza para leer archivos de texto ( un puente entre el flujo de bytes y los caracteres) . OutputStreamWriter codifica los caracteres que se escribirán en el flujo en bytes y convierte la cadena en bytes de acuerdo con la tabla de codificación especificada. Utilice el flujo de bytes para escribir estos bytes (el puente entre el flujo de caracteres y el flujo de bytes ) .
InputStreamReader
| método | Descripción |
| InputStreamReader (InputStream en) | Crea una secuencia de caracteres usando el juego de caracteres predeterminado |
| InputStreamReader （InputStream in ， String charsetName） | Crear una secuencia de caracteres con un conjunto de caracteres específico |
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
public class Test01 {
public static void main(String[] args) throws IOException {
//输入转换流的构造方法
//idea的默认是UTF-8
//InputStreamReader(InputStream in) : 创建一个使用默认字符集的字符流。
//InputStreamReader isr = new InputStreamReader(new FileInputStream("test.txt"));
//InputStreamReader(InputStream in, String charsetName)
//: 创建一个指定字符集的字符流
InputStreamReader isr = new InputStreamReader(new FileInputStream("test.txt"),"GBK");
//可以调用普通字符流的方法
//读取一个字符
int read = isr.read();
System.out.println((char)read);
int read2 = isr.read();
System.out.println((char)read2);
//关流
isr.close();
}
}OutputStreamWriter
| Método de construcción | Descripción |
| OutputStreamWriter （OutputStream out） | Crea una secuencia de caracteres usando el juego de caracteres predeterminado |
| OutputStreamWrite （OutputStream out ， String charsetName） | Crear una secuencia de caracteres con un conjunto de caracteres específico |
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class Test02 {
public static void main(String[] args) throws IOException {
//输出转换流OutputStreamWriter
//OutputStreamWriter(OutputStream out) : 创建一个使用默认字符集的字符流。
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("test.txt"));
//OutputStreamWriter(OutputStream out, String charsetName)
//: 创建一个指定字符集的字符流
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("test.txt"),"GBK");
//输出字符串
osw.write("中国");
osw.close();
}
}Flujo de secuencia
El flujo de secuencia se puede utilizar para manipular objetos.
Serialización: guardar el objeto de la memoria en el archivo Deserialización: leer el objeto del archivo en la memoria
ObjectOutputStream
Durante el proceso de serialización, la clase que necesita ser serializada debe implementar Serializable. Esta interfaz se llama interfaz marcada . Esta interfaz no tiene ningún método y solo necesita ser marcada durante la serialización.
El objeto serializado muestra caracteres confusos en la computadora, lo cual es normal porque no hay forma de ver este objeto en la computadora.
| método | Descripción |
| Método de construcción: ObjectOutputStream (OutputStream out) | Crear un ObjectOutputStream especificado |
| Método de objeto: pbulic final void writeObject (Object obj) | Escribe el objeto especificado |
package com.james.Demo序列化;
import java.io.Serializable;
public class Student implements Serializable {
private String name;
private String sex;
private transient int age;
//省略全参无参构造方法，以及getter和setter方法
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}
}
import java.io.*;
public class Test01 {
public static void main(String[] args) throws IOException {
//ObjectOutputStream序列化流,对象输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day11\\123.txt"));
//创建对象
Student s = new Student("James",18);
//输出任意类型对象
oos.writeObject(s);
//关流
oos.close();
}
}ObjectInputStream
Flujo de deserialización, flujo de entrada de objetos.
Flujo de deserialización, si la variable miembro no desea ser serializada, entonces las variables miembro pueden usar la modificación de palabras clave transitorias - - "indica un transitorio, se modificó las variables miembro transitorias no se serializan
El objeto serializado tiene un número UID. Después de cada modificación, el número de clase cambiará. Si el número de la clase es diferente entre serialización y deserialización, la deserialización fallará. Si lo desea Si necesita deserializar correctamente después de modificar la clase serializada, debe especificar un número UID antes de serializar. 【Privado estático final largo serialVersionUID = 2423534534634645L ; 】
Si desea serializar varios objetos, se recomienda juntar varios objetos y guardarlos a la vez ( use el almacenamiento de colección )
| método | Descripción |
| Método de construcción: ObjectInputStream (InputStream in) | Crear un ObjectinputStream especificado |
| Método de lectura: objeto público final readObject () | Leer un objeto |
package com.james.Demo序列化;
import java.io.Serializable;
public class Student implements Serializable {
private String name;
private String sex;
//被瞬态修饰的成员变量
private transient int age;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}
//省略构造方法，get和set方法
//定义一个序列号
private static final long serialVersionUID = 201510311730L;
}
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class Test02 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//对象输入流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test.txt"));
//读取对象
Object obj = ois.readObject();
//向下转型
Student s = (Student)obj;
System.out.println(s);
//关流
ois.close();
}
}