contenido principal
Flujo de conversión Flujo de
búfer Flujo de
serialización Flujo de
impresión
objetivos de enseñanza
Puede usar el flujo de búfer de bytes para leer datos en el programa
Puede usar el flujo de búfer de bytes para escribir datos en el archivo
Puede aclarar el papel y el uso básico del flujo de búfer de caracteres
Puede usar funciones especiales del flujo de búfer
Puede explicar el significado de la tabla de codificación
Puede usar el flujo de conversión para leer Tome un archivo de texto
con una codificación específica, puede usar una secuencia de conversión para escribir un archivo de texto con una codificación específica,
puede decir las características de una secuencia de impresión,
puede usar una secuencia serializada para escribir objetos en un archivo,
puede usar una secuencia deserializada para leer archivos en un programa
Capítulo uno Transmisión en búfer
Ayer aprendimos algunas transmisiones básicas. Como introducción a las transmisiones IO, hoy queremos ver algunas transmisiones más potentes. Por ejemplo, una secuencia de búfer que se puede leer y escribir de manera eficiente, una secuencia de conversión que puede convertir codificación, una secuencia serializada que puede conservar objetos de almacenamiento, etc. Estos flujos más poderosos se crean sobre la base de objetos de flujo básicos, al igual que un samurái con armadura, lo que equivale a una mejora de los objetos de flujo básicos.
1.1 Resumen
El flujo almacenado en búfer, también llamado flujo de alta eficiencia, es una mejora de los 4 flujos básicos de FileXxx, por lo que también hay 4 flujos, clasificados según los tipos de datos:
字节缓冲流：BufferedInputStream，BufferedOutputStream
字符缓冲流：BufferedReader，BufferedWriter
El principio básico de un flujo almacenado en búfer es que cuando se crea un objeto de flujo, se crea una matriz de búfer incorporada con un tamaño predeterminado y la lectura y escritura a través del búfer reduce el
número de E / S del sistema , lo que mejora la eficiencia de lectura y escritura.
Secuencia almacenada en búfer de 1,2 bytes
Método de construcción
public BufferedInputStream(InputStream in) ：创建一个 新的缓冲输入流。
public BufferedOutputStream(OutputStream out)： 创建一个新的缓冲输出流。
Por ejemplo, el código es el siguiente:
Prueba de eficiencia
Query API, el método de lectura y escritura del flujo de búfer es el mismo que el flujo básico, probamos su eficiencia copiando archivos grandes (375 MB).
1. Flujo básico, el código es el siguiente:
2. Secuencia de búfer, el código es el siguiente:
// Crear flujo de entrada con búfer de bytes
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
public class BufferedDemo {
public static void main(String[] args) throws FileNotFoundException {
// 记录开始时间
long start = System.currentTimeMillis();
// 创建流对象
try (
FileInputStream fis = new FileInputStream("jdk9.exe");
FileOutputStream fos = new FileOutputStream("copy.exe")
){
// 读写数据
int b;
while ((b = fis.read()) != ‐ 1 ) {
fos.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("普通流复制时间:"+(end ‐ start)+" 毫秒");
}
}
十几分钟过去了...
public class BufferedDemo {
public static void main(String[] args) throws FileNotFoundException {
// 记录开始时间
long start = System.currentTimeMillis();
// 创建流对象
try (
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
){
¿Cómo puede ser más rápido?
Usando una matriz, el código es el siguiente:
1.3 Flujo de búfer de caracteres
Método de construcción
public BufferedReader(Reader in) ：创建一个 新的缓冲输入流。
public BufferedWriter(Writer out)： 创建一个新的缓冲输出流。
// leer y escribir datos
int b;
while ((b = bis.read()) != ‐ 1 ) {
bos.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("缓冲流复制时间:"+(end ‐ start)+" 毫秒");
}
}
缓冲流复制时间: 8016 毫秒
public class BufferedDemo {
public static void main(String[] args) throws FileNotFoundException {
// 记录开始时间
long start = System.currentTimeMillis();
// 创建流对象
try (
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
){
// 读写数据
int len;
byte[] bytes = new byte[ 8 * 1024 ];
while ((len = bis.read(bytes)) != ‐ 1 ) {
bos.write(bytes, 0 , len);
}
} catch (IOException e) {
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("缓冲流使用数组复制时间:"+(end ‐ start)+" 毫秒");
}
}
缓冲流使用数组复制时间: 666 毫秒
Por ejemplo, el código es el siguiente:
Método único
El método básico del flujo de búfer de caracteres es el mismo que el de la llamada de flujo de caracteres ordinario, por lo que no profundizaremos, veamos sus métodos únicos.
BufferedReader：public String readLine(): 读一行文字。
BufferedWriter：public void newLine(): 写一行行分隔符,由系统属性定义符号。
readLine方法演示，代码如下：
newLine方法演示，代码如下：
// Crear flujo de entrada de búfer de caracteres
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
// 创建流对象
BufferedReader br = new BufferedReader(new FileReader("in.txt"));
// 定义字符串,保存读取的一行文字
String line = null;
// 循环读取,读取到最后返回null
while ((line = br.readLine())!=null) {
System.out.print(line);
System.out.println("‐‐‐‐‐‐");
}
// 释放资源
br.close();
}
}
public class BufferedWriterDemo throws IOException {
public static void main(String[] args) throws IOException {
// 创建流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
// 写出数据
bw.write("黑马");
// 写出换行
bw.newLine();
bw.write("程序");
bw.newLine();
bw.write("员");
bw.newLine();
// 释放资源
bw.close();
}
}
输出效果:
黑马
1.4 Ejercicio: clasificación de texto
Restaure el orden de los mensajes de texto.
analisis de CASO
1. Lea la información de texto línea por línea.
2. Analice la información del texto en la colección.
3. Recorra la colección y escriba la información del texto en orden.
Realización de casos
programa
miembro
3. Shi Zhong, Shi Lang Guo Youzhi, Fei Yi, Dong Yun, etc., todos los cuales son buenos y verdaderos, y sus aspiraciones son leales y puras, y son heredadas por el primer emperador. Creo que las cosas en el palacio no tienen ninguna magnitud.
Al consultarlo y luego implementarlo, será beneficioso compensar las deficiencias y obtener un amplio beneficio.
8. Que Su Majestad encomiende a sus ministros que busquen el efecto del avivamiento de los ladrones, y si fracasa, los crímenes de los ministros se regirán para informar el espíritu del primer emperador. Si no hay noticias de Xingde, entonces la responsabilidad, el yi, el permiso, etc. tardan en demostrarlo
Culpa; Su Majestad también debería planear por su cuenta, consultando el buen camino, examinando el Yayan, siguiendo el edicto del primer emperador, y los ministros están agradecidos.
4. El general Xiang Chong, Shujun de comportamiento sexual, Xiao Chang militar, lo intentó en el pasado, y el primer emperador lo llamó Neng, y fue supervisado por la multitud para votar a favor. Pensé que era algo en el campamento, lo sabía
Debe poder hacer la línea de armonía, buena y mala.
2. En el palacio y el palacio, todos están integrados, y no debe haber semejanzas ni diferencias. Si alguien comete un delito y es una persona leal, debe recibir una recompensa por su castigo.
Es recomendable ser parcial, para que las leyes internas y externas sean diferentes.
1. El primer emperador no había comenzado su propio negocio, pero el camino del medio colapsó. Hoy, los tres puntos están abajo. Yizhou está exhausto, y este es el otoño de la vida y la muerte. Sin embargo, los ministros de los guardias son incansables por dentro, y los leales se olvidan de sí mismos.
Aquellos que cubren la experiencia especial de perseguir al primer emperador, quieren informarlo a Su Majestad. Es sincero abrir la escucha sagrada del legado del emperador y el espíritu de grandes ideales elevados.
Saizhong también aconseja el camino.
9. Aléjate ahora, afronta las lágrimas, no sé qué decir.
6. El plebeyo de Chenben, arando en Nanyang, la vida de Gou Quan en tiempos difíciles, no busca escuchar a los príncipes. El primer emperador no consideró a sus ministros como despreciables y humillados.
Por las cosas del mundo, por la gratitud, Xu Xiandi solía conducir. Después de que se voltee el valor, cuando esté a cargo del ejército derrotado, se le ordena que esté en crisis, y durará veintiún años.
7. El emperador y sus ministros son cautelosos, por lo que enviará a sus ministros a eventos importantes. Desde que recibió la orden, Suye suspiró, temiendo que la encomienda no fuera efectiva, con el fin de dañar el brillo del emperador, por lo que el mayo cruza el Lu, y no es peludo.
Ahora el sur se ha establecido, los soldados están llenos, los tres ejércitos serán recompensados, el norte establecerá las llanuras centrales, estará exhausto y obtuso, se deshará de los intrusos, revivirá la sala Han y regresará a la antigua capital. Este ministro es leal al Emperador
La publicación también está debajo. En cuanto a sopesar las ganancias y las pérdidas, y hacer la mejor fe, es el correcto, el único y el correcto.
5. Prósperos ministros, Yuan Xiaoren, esta vez la dinastía Han prosperó; pro-hombres pequeños, Yuanxian Chens, después de la dinastía Han. Cuando el primer emperador estuvo allí, suspiró cada vez que discutía el asunto con sus ministros.
Odio a Yu Huan y Ling Ye. Manteniendo a Shangshu, Changshi y uniéndose al ejército, este ministro que se enteró del día de la muerte de Zhenliang, espero que los parientes de su majestad crean en la prosperidad de la dinastía Han, y pueden contar con ello.
public class BufferedTest {
public static void main(String[] args) throws IOException {
// 创建map集合,保存文本数据,键为序号,值为文字
HashMap<String, String> lineMap = new HashMap<>();
// 创建流对象
BufferedReader br = new BufferedReader(new FileReader("in.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
// 读取数据
String line = null;
while ((line = br.readLine())!=null) {
// 解析文本
String[] split = line.split("\\.");
// 保存到集合
lineMap.put(split[ 0 ],split[ 1 ]);
Capítulo 2 Flujo de conversión
2.1 Codificación de caracteres y juego de caracteres
Codificación de caracteres
La información almacenada en la computadora está representada por números binarios, y los números, inglés, signos de puntuación, caracteres chinos y otros caracteres que vemos en la pantalla son binarios.
El resultado después de la conversión numérica. De acuerdo con cierta regla, almacenar caracteres en la computadora se llama codificación. Por el contrario, los números binarios almacenados en la computadora son
Se muestra un determinado análisis de reglas, que se denomina decodificación. Por ejemplo, si se almacena de acuerdo con la regla A y se analiza de acuerdo con la regla A, se puede mostrar el símbolo f de texto correcto
. Por el contrario, almacenar de acuerdo con la regla A y analizar de acuerdo con la regla B provocará caracteres confusos.
字符编码Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。
conjunto de caracteres
字符集 Charset：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符
号、数字等。
Para que las computadoras almacenen y reconozcan con precisión varios símbolos de juegos de caracteres, se requiere la codificación de caracteres, y un juego de caracteres debe tener al menos una codificación de caracteres. Los
juegos de caracteres comunes incluyen el juego de caracteres ASCII, el juego de caracteres GBK, el juego de caracteres Unicode, etc.
}
// liberar recursos
br.close();
// 遍历map集合
for (int i = 1 ; i <= lineMap.size(); i++) {
String key = String.valueOf(i);
// 获取map中文本
String value = lineMap.get(key);
// 写出拼接文本
bw.write(key+"."+value);
// 写出换行
bw.newLine();
}
// 释放资源
bw.close();
}
}
Se puede ver que cuando se especifica el código, el conjunto de caracteres al que corresponde se especifica naturalmente, por lo que el código es lo que en última instancia debe preocuparnos.
Conjunto de caracteres ASCII:
ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁
字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显
示字符（英文大小写字符、阿拉伯数字和西文符号）。
基本的ASCII字符集，使用 7 位（bits）表示一个字符，共 128 字符。ASCII的扩展字符集使用 8 位（bits）
表示一个字符，共 256 字符，方便支持欧洲常用字符。
ISO-8859-1字符集：
拉丁码表，别名Latin-1，用于显示欧洲使用的语言，包括荷兰、丹麦、德语、意大利语、西班牙语等。
ISO-5559-1使用单字节编码，兼容ASCII编码。
GBxxx字符集：
GB就是国标的意思，是为了显示中文而设计的一套字符集。
GB2312：简体中文码表。一个小于 127 的字符的意义与原来相同。但两个大于 127 的字符连在一起时，
就表示一个汉字，这样大约可以组合了包含 7000 多个简体汉字，此外数学符号、罗马希腊的字母、日文
的假名们都编进去了，连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这
就是常说的"全角"字符，而原来在 127 号以下的那些就叫"半角"字符了。
GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了
21003 个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等。
GB18030：最新的中文码表。收录汉字 70244 个，采用多字节编码，每个字可以由 1 个、 2 个或 4 个字节
组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等。
Unicode字符集 ：
Unicode编码系统为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国
码。
它最多使用 4 个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF-
32 。最为常用的UTF-8编码。
UTF-8编码，可以用来表示Unicode标准中任何字符，它是电子邮件、网页及其他存储或传送文字的应用
中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。所以，
我们开发Web应用，也要使用UTF-8编码。它使用一至四个字节为每个字符编码，编码规则：
1. 128 个US-ASCII字符，只需一个字节编码。
2. 拉丁文等字符，需要二个字节编码。
3. 大部分常用字（含中文），使用三个字节编码。
4. 其他极少使用的Unicode辅助字符，使用四字节编码。
2.2 Problemas causados por la codificación
2.2 Problemas causados por la codificación
En IDEA, use FileReader para leer archivos de texto en el proyecto. Dado que la configuración de IDEA es toda la codificación UTF-8 predeterminada, no hay
problema. Sin embargo, al leer un archivo de texto creado en el sistema Windows, dado que la codificación predeterminada del sistema Windows es GBK, aparecerán caracteres confusos.
Entonces, ¿cómo leer archivos codificados en GBK?
2.3 InputStreamReader 类
El flujo de conversión java.io.InputStreamReader, una subclase de Reader, es un puente entre el flujo de bytes y el flujo de caracteres. Lee los bytes y los
decodifica en caracteres utilizando el juego de caracteres especificado . Su juego de caracteres se puede especificar por el nombre, o puede aceptar el juego de caracteres predeterminado de la plataforma.
Método de construcción
InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。
InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流。
Por ejemplo, el código es el siguiente:
Lectura de código especificado
public class ReaderDemo {
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("E:\\File_GBK.txt");
int read;
while ((read = fileReader.read()) != ‐ 1 ) {
System.out.print((char)read);
}
fileReader.close();
}
}
输出结果：
���
InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");
public class ReaderDemo2 {
public static void main(String[] args) throws IOException {
// 定义文件路径,文件为gbk编码
String FileName = "E:\\file_gbk.txt";
// 创建流对象,默认UTF8编码
InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
// 创建流对象,指定GBK编码
InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");
// 定义变量,保存字符
int read;
// 使用默认编码字符流读取,乱码
while ((read = isr.read()) != ‐ 1 ) {
System.out.print((char)read); // ��Һ�
2.4 OutputStreamWriter 类
El flujo de conversión java.io.OutputStreamWriter, una subclase de Writer, es un puente entre el flujo de caracteres y el flujo de bytes.
Codifique caracteres en bytes utilizando el juego de caracteres especificado . Su juego de caracteres se puede especificar por el nombre, o puede aceptar el juego de caracteres predeterminado de la plataforma.
Método de construcción
OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流。
OutputStreamWriter(OutputStream in, String charsetName): 创建一个指定字符集的字符流。
Por ejemplo, el código es el siguiente:
Especifica el código a escribir
Diagrama de comprensión del flujo de conversión
}
isr.close();
// 使用指定编码字符流读取,正常解析
while ((read = isr2.read()) != ‐ 1 ) {
System.out.print((char)read);// 大家好
}
isr2.close();
}
}
OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");
public class OutputDemo {
public static void main(String[] args) throws IOException {
// 定义文件路径
String FileName = "E:\\out.txt";
// 创建流对象,默认UTF8编码
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
// 写出数据
osw.write("你好"); // 保存为 6 个字节
osw.close();
// 定义文件路径
String FileName2 = "E:\\out2.txt";
// 创建流对象,指定GBK编码
OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
// 写出数据
osw2.write("你好");// 保存为 4 个字节
osw2.close();
}
}
¡El flujo de conversión es el puente entre bytes y caracteres!
2.5 Ejercicio: convertir la codificación de archivos
Convierta archivos de texto codificados en GBK en archivos de texto codificados en UTF-8.
analisis de CASO
1. Especifique el flujo de conversión de la codificación GBK y lea el archivo de texto.
2. Utilice el flujo de conversión codificado en UTF-8 para escribir un archivo de texto.
Realización de casos
Capítulo 3 Serialización
public class TransDemo {
public static void main(String[] args) {
// 1.定义文件路径
String srcFile = "file_gbk.txt";
String destFile = "file_utf8.txt";
// 2.创建流对象
// 2.1 转换输入流,指定GBK编码
InputStreamReader isr = new InputStreamReader(new FileInputStream(srcFile) , "GBK");
// 2.2 转换输出流,默认utf8编码
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(destFile));
// 3.读写数据
// 3.1 定义数组
char[] cbuf = new char[ 1024 ];
// 3.2 定义长度
int len;
// 3.3 循环读取
while ((len = isr.read(cbuf))!=‐ 1 ) {
// 循环写出
osw.write(cbuf, 0 ,len);
}
// 4.释放资源
osw.close();
isr.close();
}
}
Capítulo 3 Serialización
3.1 Resumen
Java proporciona un mecanismo para la serialización de objetos. Un objeto se puede representar mediante una secuencia de bytes, que contiene los datos del objeto, el
tipo de objeto y los atributos almacenados en el objeto. Una vez que la secuencia de bytes se escribe en el archivo, es equivalente a conservar la información de un objeto en el archivo.
Por el contrario, la secuencia de bytes también se puede leer del archivo, reconstruir el objeto y deserializarlo. Los datos del objeto, el tipo de objeto y
la información de los datos almacenados en el objeto pueden usarse para crear objetos en la memoria. Mire la imagen para comprender la serialización:
3.2 ObjectOutputStream 类
java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。
Método de construcción
public ObjectOutputStream(OutputStream out)： 创建一个指定OutputStream的ObjectOutputStream。
Por ejemplo, el código es el siguiente:
Operación de serialización
1. Para que un objeto se serialice, se deben cumplir dos condiciones:
该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任
何状态序列化或反序列化，会抛出NotSerializableException 。
该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用
transient 关键字修饰。
FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
2. Escribe el método del objeto
public final void writeObject (Object obj) : 将指定的对象写出。
3.3 Clase ObjectInputStream
ObjectInputStream deserializa la secuencia y restaura los datos originales previamente serializados usando ObjectOutputStream en objetos.
Método de construcción
public ObjectInputStream(InputStream in)： 创建一个指定InputStream的ObjectInputStream。
Operación de deserialización 1
Si podemos encontrar el archivo de clase de un objeto, podemos realizar la deserialización y llamar al método ObjectInputStream para leer el objeto:
public final Object readObject () : 读取一个对象。
public class Employee implements java.io.Serializable {
public String name;
public String address;
public transient int age; // transient瞬态修饰成员,不会被序列化
public void addressCheck() {
System.out.println("Address check : " + name + " ‐‐ " + address);
}
}
public class SerializeDemo{
public static void main(String [] args) {
Employee e = new Employee();
e.name = "zhangsan";
e.address = "beiqinglu";
e.age = 20 ;
try {
// 创建序列化流对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
// 写出对象
out.writeObject(e);
// 释放资源
out.close();
fileOut.close();
System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列
化。
} catch(IOException i) {
i.printStackTrace();
}
}
}
输出结果：
Serialized data is saved
public class DeserializeDemo {
Para que la JVM deserialice un objeto, debe ser una clase que pueda encontrar el archivo de clase. Si no se puede encontrar el archivo de clase de la clase, se lanzará una
ClassNotFoundException.
Operación de deserialización 2
Además, cuando la JVM deserializa el objeto, puede encontrar el archivo de clase, pero si el archivo de clase se modifica después de serializar el objeto, la operación de deserialización
también fallará y se lanzará una InvalidClassException. Las razones de esta excepción son las siguientes:
该类的序列版本号与从流中读取的类描述符的版本号不匹配
该类包含未知数据类型
该类没有可访问的无参数构造方法
La interfaz serializable proporciona un número de versión de serie para la clase que debe serializarse. serialVersionUID El propósito de este número de versión es verificar
si el objeto serializado y la clase correspondiente coinciden con la versión.
public static void main(String [] args) {
Employee e = null;
try {
// 创建反序列化流
FileInputStream fileIn = new FileInputStream("employee.txt");
ObjectInputStream in = new ObjectInputStream(fileIn);
// 读取一个对象
e = (Employee) in.readObject();
// 释放资源
in.close();
fileIn.close();
}catch(IOException i) {
// 捕获其他异常
i.printStackTrace();
return;
}catch(ClassNotFoundException c) {
// 捕获类找不到异常
System.out.println("Employee class not found");
c.printStackTrace();
return;
}
// 无异常,直接打印输出
System.out.println("Name: " + e.name); // zhangsan
System.out.println("Address: " + e.address); // beiqinglu
System.out.println("age: " + e.age); //
}
}
3.4 Ejercicio: serializar una colección
1. 将存有多个自定义对象的集合序列化操作，保存到list.txt文件中。
2. 反序列化list.txt ，并遍历集合，打印对象信息。
analisis de CASO
1. Guarde varios objetos de estudiantes en la colección.
2. Serialice la colección.
3. Al deserializar y leer, solo es necesario leerlo una vez y convertirlo en un tipo de colección.
4. Recorre la colección, puedes imprimir toda la información de los estudiantes.
Realización de casos
public class Employee implements java.io.Serializable {
// 加入序列版本号
private static final long serialVersionUID = 1L;
public String name;
public String address;
// 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.
public int eid;
public void addressCheck() {
System.out.println("Address check : " + name + " ‐‐ " + address);
}
}
public class SerTest {
public static void main(String[] args) throws Exception {
// 创建 学生对象
Student student = new Student("老王", "laow");
Student student2 = new Student("老张", "laoz");
Student student3 = new Student("老李", "laol");
ArrayList<Student> arrayList = new ArrayList<>();
arrayList.add(student);
arrayList.add(student2);
arrayList.add(student3);
// 序列化操作
// serializ(arrayList);
// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("list.txt"));
// 读取对象,强转为ArrayList类型
ArrayList<Student> list = (ArrayList<Student>)ois.readObject();
for (int i = 0 ; i < list.size(); i++ ){
Student s = list.get(i);
System.out.println(s.getName()+"‐‐"+ s.getPwd());
}
Capítulo 4 Flujo de impresión
4.1 Resumen
Por lo general, imprimimos la salida en la consola llamando al método de impresión y al método println.Estos dos métodos provienen de la
clase java.io.PrintStream, que puede imprimir fácilmente los valores de varios tipos de datos, lo cual es conveniente método de salida.
4.2 Clase PrintStream
Método de construcción
public PrintStream(String fileName)： 使用指定的文件名创建一个新的打印流。
Por ejemplo, el código es el siguiente:
Cambiar el flujo de impresión
System.out es del tipo PrintStream, pero su dirección de flujo la especifica el sistema y se imprime en la consola. Sin embargo, dado que es un objeto de flujo,
podemos jugar un "truco" para cambiar su dirección de flujo.
}
}
private static void serializ(ArrayList<Student> arrayList) throws Exception {
// 创建 序列化流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
// 写出对象
oos.writeObject(arrayList);
// 释放资源
oos.close();
}
}
PrintStream ps = new PrintStream("ps.txt")；
public class PrintDemo {
public static void main(String[] args) throws IOException {
// 调用系统的打印流,控制台直接输出 97
System.out.println( 97 );
// 创建打印流,指定文件的名称
PrintStream ps = new PrintStream("ps.txt");
// 设置系统的打印流流向,输出到ps.txt
System.setOut(ps);
// 调用系统的打印流,ps.txt中输出 97
System.out.println( 97 );
}
}