Conjunto de atributos
1.Clase
Propiedades La clase Propiedades representa un conjunto persistente de propiedades. Las propiedades se pueden guardar en el flujo o cargar desde el flujo. La
colección de Propiedades es una colección única que se combina con el flujo de IO.
Puede usar el método de almacenamiento en la colección de Propiedades para conservar los datos temporales en la colección y escribirlos en el disco duro para almacenamiento
Puede usar Propiedades El método de carga en la colección lee el archivo (par clave-valor) guardado en el disco duro en la colección
Cada clave y su valor correspondiente en la lista de atributos es una cadena.
La colección Properties es una colección de dos columnas. La clave y el valor son cadenas por defecto.
Método de construcción:
public Properties (): Crea una lista de propiedades vacía.
Método de almacenamiento básico:
public Object setProperty (String key, String value): save a par de propiedades
public String getProperty (String key): use la clave especificada en esta lista de propiedades para buscar valores de propiedad
public Set stringPropertyNames (): Una colección de los nombres de todas las claves
public class Demo01 {
public static void main(String[] args) {
show01();
}
//使用Properties 集合存储数据，遍历取出Properties集合中的数据
private static void show01() {
//创建Properties集合对象
Properties prop=new Properties();
//使用setProperty往集合中添加数据
prop.setProperty("Kobe","24");
prop.setProperty("James","23");
prop.setProperty("Curry","30");
//使用stringPropertyNames把Properties集合中的键取出存储到一个set集合中
Set<String> set=prop.stringPropertyNames();
//遍历set集合，取出Properties集合中的每一个键
for (String s : set) {
//使用getProperty方法通过s获取value
String value=prop.getProperty(s);
System.out.println(s+":"+value);
}
}
}
método de almacenamiento
Puede utilizar el método de almacenamiento en la colección Propiedades para escribir de forma persistente los datos temporales de la colección en el disco duro para su almacenamiento
public class Demo02 {
public static void main(String[] args) throws IOException {
show01();
}
//使用Properties集合中的方法store，把集合中的临时数据，持久化写入硬盘
private static void show01() throws IOException {
//创建Properties集合对象，添加数据
Properties prop=new Properties();
prop.setProperty("Kobe","24");
prop.setProperty("James","23");
prop.setProperty("Curry","30");
//创建字节输出流/字符输出流对象，构造方法中绑定要输出的目的地
FileWriter fw=new FileWriter("F:\\JAVA\\File\\text1.txt");
//使用Properties中的方法store，把集合中的临时数据，永久写入到硬盘中存储
prop.store(fw,"save data");
//释放资源
fw.close();
}
}
Método de carga
Puede utilizar el método de carga en la colección Propiedades para leer el archivo (par clave-valor) guardado en el disco duro en el archivo de la colección que usa el
par clave-valor almacenado. El símbolo de conexión entre la clave y el value can use =, space (Otros símbolos) En
el archivo que almacena pares clave-valor, puede usar # para comentar, y el contenido del comentario no se leerá
. En el archivo que almacena pares clave-valor, la clave y el valor son ambos cadenas por defecto
public class Demo03 {
public static void main(String[] args) throws IOException {
show01();
}
private static void show01() throws IOException {
//创建Properties集合对象
Properties prop=new Properties();
//使用Properties集合对象中的load读取保存键值对的文件
prop.load(new FileReader("F:\\JAVA\\File\\text1.txt"));
//遍历Properties
Set<String> set=prop.stringPropertyNames();
for (String s : set) {
String value = prop.getProperty(s);
System.out.println(s+":"+value);
}
}
}
Flujo de búfer
1. Secuencia de bytes almacenada en búfer
public BufferedInputStream (InputStream in): Cree una nueva secuencia de entrada almacenada en búfer, agregue un búfer (matriz) a la secuencia de entrada de bytes básicos para mejorar los datos de lectura de la secuencia de entrada de bytes básicos
public BufferedOutputStream (OutputStream out): Crea un nuevo flujo
de salida almacenado en búfer de bytes flujo de salida almacenado en búfer:
public BufferedOutputStream (OutputStream out): Crea un nuevo flujo de salida almacenado en búfer que puede pasar la
entrega FileOutputStream, un búfer de flujo almacenado aumentará FileOutputStream, escriba FileOutputStream aumento de la eficiencia de entrada
public class Demo04 {
public static void main(String[] args) throws IOException {
//创建FileOutputStream对象，构造方法中绑定要输出的目的地
FileOutputStream fos=new FileOutputStream("F:\\JAVA\\File\\text1.txt");
//创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStream对象效率
BufferedOutputStream bos=new BufferedOutputStream(fos);
//使用BufferedOutputStream对象中的write，把数据写入到内部缓冲区中
bos.write("写入数据到缓冲区".getBytes());
//使用BufferedOutputStream对象中的方法flush，把内部缓冲区中的数据刷新到文件中
bos.flush();
//释放资源
bos.close();
}
}
Flujo de entrada con búfer de bytes:
public BufferedInputStream (InputStream in):
crea un nuevo flujo de entrada con búfer, que puede pasar FileInputStream. El flujo con búfer agregará un búfer a FileInputStream para mejorar la eficiencia de escritura de FileInputStream
public class Demo05 {
public static void main(String[] args) throws IOException {
//创建FileInputStream对象，构造方法中绑定要读取的数据
FileInputStream fis=new FileInputStream("F:\\JAVA\\File\\text1.txt");
//创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputStream读取效率
BufferedInputStream bis=new BufferedInputStream(fis);
//使用BufferedOutputStream对象中的read，读取文件
int len=0;
while((len=bis.read())!=-1){
System.out.println(len);
}
//释放资源
bis.close();
}
}
Comparación de la eficacia de la copia de archivos:
public class Demo06 {
public static void main(String[] args) throws IOException {
long start=System.currentTimeMillis();
//创建字节缓冲输入流对象，构造方法中传递字节输入流
BufferedInputStream bis=new BufferedInputStream(new FileInputStream("F:\\JAVA\\File\\picture.jpg"));
//创建字节缓冲输出流对象，构造方法中传递字节输出流
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("F:\\JAVA\\File\\FileCopy\\picture.jpg"));
//使用字节缓冲输入流对象中的方法read读取文件
//使用字节缓冲输出流对象中的方法write把读取的数据写入到内部缓冲区中
int len=0;
while((len=bis.read())!=-1) {
bos.write(len);
}
//释放资源
bos.close();
bis.close();
long end=System.currentTimeMillis();
System.out.println("耗时"+(end-start)+"毫秒");
}
}
2. Secuencia de
caracteres en búfer Flujo de salida en búfer de caracteres
Método de construcción:
BufferedWriter (Writer out): Cree un flujo de salida de caracteres en búfer con el tamaño predeterminado del búfer de salida
Writer out:
Secuencia de salida de caracteres que podemos pasar FileWriter, la secuencia en búfer agregará un búfer al Área de FileWriter, mejorar la eficiencia de escritura de FileWriter.
Método de miembro único:
void newLine (): escriba un separador de línea y obtenga diferentes separadores de línea de acuerdo con los diferentes sistemas operativos
public class Demo07 {
public static void main(String[] args) throws IOException {
//创建一个字符缓冲输出流，构造方法中传递字符输出流
BufferedWriter bw=new BufferedWriter(new FileWriter("F:\\JAVA\\File\\text1.txt"));
//调用字符缓冲输出流中的方法write，把数据写入到内存缓冲区中
for(int i=0;i<10;i++){
bw.write("Kobe");
bw.newLine();
}
//调用字符缓冲输出流中的方法flush，把内存缓冲区中的数据刷新到文件中
bw.flush();
//释放资源
bw.close();
}
}
Flujo de entrada con búfer de caracteres
Método de construcción:
BufferedReader (Lector en): Cree un flujo de entrada de caracteres con búfer con un búfer de entrada de tamaño predeterminado
Lector en: Secuencia de entrada de caracteres, podemos pasar FileReader, el flujo con búfer agregará un búfer a FileReader, mejorar FileReader El eficiencia de lectura del
método de miembro único:
String readLine (): lee una línea de texto. Leer una fila de datos
public class Demo08 {
public static void main(String[] args) throws IOException {
//创建字符缓冲输入流对象，构造方法中传递字符输入流
BufferedReader br=new BufferedReader(new FileReader("F:\\JAVA\\File\\text1.txt"));
//使用字符缓冲输入流对象中的方法read/readLine读取文本
String line;
while((line=br.readLine())!=null){
System.out.println(line);
}
br.close();
}
}
Flujo de conversión
1. Codificación de caracteres y juego de
caracteres Codificación de caracteres: Un conjunto de reglas correspondientes entre caracteres de lenguaje natural y números binarios
Juego de caracteres: Tabla de códigos. Una colección de todos los caracteres admitidos por un sistema, incluidos los caracteres nacionales, signos de puntuación, símbolos gráficos, números, etc.
2. Clase
InputStreamReader InputStreamReader (InputStream in): cree una secuencia de caracteres utilizando el juego de caracteres predeterminado
InputStreamReader (InputStream in, String charsetName ): Crea una secuencia de caracteres con un conjunto de caracteres especificado
public class Demo02 {
public static void main(String[] args) throws IOException {
//创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称
InputStreamReader isr=new InputStreamReader(new FileInputStream("F:\\JAVA\\File\\text1.txt"),"UTF-8");
//创建InputStreamReader对象中的方法read读取文件
int len;
while((len=isr.read())!=-1){
System.out.println((char) len);
}
//释放资源
isr.close();
}
}
3. Clase
OutputStreamWriter OutputStreamWriter (OutputStream out): crea un flujo de salida de bytes utilizando el conjunto de caracteres predeterminado que codifica
OutputStreamWriter (OutputStream out, String charsetName): crea un flujo de salida de bytes utilizando el conjunto de caracteres especificado
public class Demo01 {
public static void main(String[] args) throws IOException {
//创建一个OutputStreamWriter对象，构造方法中传递字节输出流和指定的编码表名称
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("F:\\JAVA\\File\\text1.txt"),"utf-8");
//使用OutputStreamWriter对象中的write，把字符转换为字节存储缓冲区中
osw.write("你好");
//使用OutputStreamWriter对象中的方法flush，把内存缓冲区中的字节刷新到文件中
osw.flush();
//释放资源
osw.close();
}
}
Publicación por entregas
Serialización: escriba el objeto en una secuencia en un archivo y guárdelo, llamado objeto de escritura, también llamado serialización y
deserialización: lea el objeto guardado en el archivo en una secuencia, llamado objeto de lectura, también llamado serialización inversa Durante la
serialización y deserialización, NotSerializableException No hay excepción de serialización.
Las clases implementan la interfaz para habilitar la función de serialización. Las clases que no implementan esta interfaz serializarán o deserializarán cualquier estado de Wufu
para ser serializado. La clase de serialización y deserialización debe implementar la interfaz serializable , y se agregará una marca a la clase.
Cuando serialicemos y deserialicemos, detectaremos si la clase tiene esta marca.
Si la hay, podemos serializar y deserializar, de lo contrario, se lanzará una excepción.
1. Clase ObjectOutputStream
Método de construcción:
public ObjectOutputStream (OutputStream out): crear un OutputStream ObjectOutputStream especificado (flujo de salida de bytes)
método de miembro único:
void writeObject (Object obj): se especificará Object write ObjectOutputStream
public class Demo03 {
public static void main(String[] args) throws IOException {
//创建ObjectOutputStream对象，构造方法中传递字节输出流
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("F:\\JAVA\\File\\Person.txt"));
//使用ObjectOutputStream对象中的方法writeObject，把对象写入到文件中
oos.writeObject(new Person("Kobe",24));
//释放资源
oos.close();
}
}
2. Clase ObjectInputStream
Método de construcción:
público ObjectInputStream (InputStream in): crea un
método miembro único de ObjectInputStream leído desde el InputStream especificado :
Object readObject (): Leer objeto desde ObjectInputStream
public class Demo04 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//使用ObjectInputStream对象，构造方法中传递字节输入流
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("F:\\JAVA\\File\\Person.txt"));
//使用ObjectInputStream对象中的方法readObject读取保存对象的文件
Object o=ois.readObject();
//释放资源
ois.close();
//使用读取出来的对象
System.out.println(o);
}
}
transitorio: palabra clave transitoria, las variables miembro modificadas no se pueden serializar
Flujo de impresión
PrintStream: Funciones agregadas para otros flujos de salida, lo que les permite imprimir fácilmente varias representaciones de valores de datos
Características:
1. Solo responsable de la salida de datos, no de la lectura de datos
2. A diferencia de otros flujos de salida, PrintStream no arrojará IOException
3. Hay métodos únicos .
método de construcción:
PrintStream (archivo): El destino de salida es un archivo
PrintStream (OutputStream out): El destino de salida es una corriente de salida de bytes
PrintStream (String nombre del archivo): El destino de salida es una ruta de archivo