Propósito:
1. Comprender el concepto de flujo de E / S y dominar su clasificación.
2. Dominar la lectura y escritura de archivos de texto y archivos binarios.
Contenido del experimento:
1. Programación para realizar la función de copiar cualquier archivo.
2. Utilice la secuencia de archivos y la secuencia de búfer para copiar el contenido del archivo.
3. Cree un archivo y muestre el nombre y el contenido del archivo.
4. Reciba la cadena de caracteres ingresada por el teclado y muéstrela en la pantalla.
Pasos experimentales:
1. Escriba un programa para escribir la cadena "Mingyue Songjianzhao, Qingquanshi upstream" en C: \ a.txt y lea el archivo.
Código fuente:
paquete de tarea. Experimento 9_ Flujo de entrada y salida ;
importar java.io.BufferedWriter ;
importar java.io.FileWriter ;
importar java.io.IOException ;
importar java.util.Scanner ;
public class sy9_1 {
public static void main ( String [] args ) {
Scanner sc = new Scanner ( System . In );
String s = sc .nextLine ();
System . Out .println ( " Write string: " + s );
intente {
BufferedWriter bw = new BufferedWriter ( nuevo FileWriter ( " d: \\ a.txt " ));
bw .write ( s );
bw .flush ();
bw .close (); //关闭 流
} catch ( IOException e) { e.printStackTrace (); } } }
Captura de pantalla del resultado en ejecución:
2. Escriba un programa para copiar el contenido de C: \ a.txt a otro archivo b.txt usando la secuencia de bytes y pregunte "La copia del archivo se realizó correctamente".
Código fuente:
paquete de tarea实验9_输入 输出 流;
importar java.io. *;
public class sy9_2 {
public static void main ( String [] args) lanza IOException {
FileInputStream read = new FileInputStream ( new File ( "D: \\ a.txt" ));
FileOutputStream wr = new FileOutputStream ( nuevo archivo ( "D: \\ b.txt" ));
byte [] b =nuevo byte [ 1024 ];
int len = 0 ;
while ((len = read .read ( b ))! = - 1 ) {
wr .write ( b , 0 , len);
wr .flush ();
}
wr .close ();
leer .close ();
}
}
Captura de pantalla del resultado en ejecución:
3. Escriba un programa para copiar el contenido de C: \ a.txt a otro archivo b.txt usando la secuencia de caracteres
Código fuente:
.Paquete de tareas Experimento 9_ flujos de entrada y salida ;
i mport java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class sy9_2 {
public static void main (String [] args ) {
// TODO código auxiliar de método generado automáticamente
FileReader fr = null ;
FileWriter fw = null ;
int c = 0;
prueba {
fr = new FileReader ( " d: // a.txt" );
fw = new FileWriter ( " d : //c.txt" );
while (( c = fr .read ())! = - 1) {
fw .escribir ( c );
}
System. Out .println ( " Archivo copiado correctamente " );
} captura (FileNotFoundException e ) {
System. Out .println ( " Archivo no encontrado " );
} captura (IOException e ) {
System. Out .println ( " Error de entrada " );
} finalmente {
prueba {
fw .close ();
} captura (IOException e ) {
// TODO Bloque de captura generado automáticamente
e .printStackTrace ();
}
prueba {
fr .close ();
} captura (IOException e ) {
// TODO Bloque de captura generado automáticamente
e .printStackTrace ();
}
}
}
}
4. El siguiente programa implementa la serialización y deserialización de objetos, complete el programa.
Clase de estudiante:
importar java.io.Serializable;
Estudiante de clase pública implementa Serializable {
nombre de cadena privada;
int edad privada;
dirección de cadena privada;
public String getName () {
nombre de retorno ;
}
setName public void (nombre de cadena) {
this.name = nombre;
}
public int getAge () {
edad de regreso ;
}
public void setAge (int age) {
this.age = edad;
}
public String getAddress () {
dirección de retorno ;
}
public void setAddress (String address) {
this.address = dirección;
}
}
Categoría de prueba:
importar java.io. *;
Prueba de clase pública {
public static void main (String [] args) lanza FileNotFoundException, IOException, ClassNotFoundException {
Estudiante mStudent1 = nuevo Estudiante ();
mStudent1. setName ("Zhang San");
mStudent1.setAge (18);
mStudent1.setAddress ("Ciudad de Wuhan");
// ObjectOutputStream representa el flujo de salida del objeto, y su método writeObject (Object obj) puede serializar el objeto obj especificado por el parámetro,
// Escribe la secuencia de bytes resultante en un flujo de salida de destino, donde se escribe en el flujo de salida del archivo.
ObjectOutputStream oos = new ObjectOutputStream (nuevo FileOutputStream ("D: /Student.txt"));
oos.writeObject ( mStudents1 );
oos.close ();
System.out.println ("Serialización completa");
// ObjectInputStream representa un flujo de entrada de objeto, y su método readObject () lee una secuencia de bytes de un flujo de entrada de origen,
// Deserializarlos en un objeto y devolverlo.
ObjectInputStream ois = new ObjectInputStream (nuevo FileInputStream ("D: /Student.txt"));
Estudiante mStudent2 = ( Estudiante ) ois.readObject ();
ois.close (); System.out.println (mStudent2.getName () + "\ t" + mStudent2.getAge () + "\ t" + mStudent2.getAddress ());
}
}
Resumen del experimento
Proporcione entrada y salida del sistema a través de transmisión de datos, serialización y sistema de archivos. Java abstrae estos datos de diferentes fuentes y destinos en flujos de datos. Las funciones de entrada y salida del lenguaje Java son muy potentes y flexibles, pero el problema es que el código de entrada y salida no es muy conciso, porque a menudo es necesario empaquetar muchos objetos diferentes.
- Conceptos de serialización y deserialización
El proceso de convertir un objeto en una secuencia de bytes se llama serialización del objeto.
El proceso de restaurar la secuencia de bytes en el objeto se llama deserialización del objeto.
La serialización de objetos tiene dos usos principales:
1) Guarde la secuencia de bytes del objeto de forma permanente en el disco duro, normalmente en un archivo;
2) La secuencia de bytes del objeto se transmite en la red.