Introducción a la OI
1 Stream Stream
Antes de aprender el flujo IO, el primer concepto que debemos aprender es el flujo Stream
Para facilitar la comprensión, podemos abstraer las operaciones de lectura y escritura de datos como datos que fluyen en la "tubería", pero tenga en cuenta:
1. El flujo solo puede ser un flujo de una sola dirección
2. El flujo de entrada se usa para leer → en
3. El flujo de salida se usa para escribir → fuera
4. Los datos solo se pueden leer y escribir una vez desde el principio hasta el final
. perspectiva del programa, la entrada/salida es relativa al proceso de entrada (lectura)/salida (escritura) del programa.
2 Estructura de herencia del flujo IO
En java, los flujos se pueden dividir en flujos de bytes y flujos de caracteres de acuerdo con las diferentes unidades de datos procesadas Flujo de bytes
: para archivos binarios
Flujo de caracteres: para archivos de texto
Combinados con los tipos correspondientes de direcciones de entrada y salida, los flujos comúnmente utilizados son:
File
Flujo de bytes: para archivos binarios
InputStream
FileInputStream
BufferedInputStream
ObjectInputStream
OutputStream
FileOutputStream
BufferedOutputStream
ObjectOutputStream
字符流:针对文本文件
Reader
FileReader
BufferedReader
InputStreamReader
Writer
FileWriter
BufferedWriter
OutputStreamWriter
PrintWriter Escribir línea por línea
3 Archivo clase de archivo
3.1 Resumen
Encapsule una cadena de ruta de disco y se puede realizar una operación en esta ruta.
Puede encapsular rutas de archivos, rutas de carpetas y rutas no existentes.
3.2 Creación de objetos
File(String nombre de ruta) crea una nueva instancia de archivo al convertir la cadena de nombre de ruta dada en un nombre de ruta abstracto
new File("d:/abc/a.txt");
new File("d:/abc", "a.txt" );
3.3 Métodos comunes
3.4 Ejercicio: Prueba de métodos comunes
Crear paquete: cn.tedu.file
Crear clase: TestFile.java
package cn.tedu.file;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
/*本类用于测试文件类File*/
public class TestFile {
public static void main(String[] args) throws IOException {
//1.创建File类对象
/*1.ready目录与1.txt需要自己手动创建
* 2.File需要导包：import java.io.File;
* 3.路径是String类型，必须写正确，不然找不到文件
* 4.完整的文件名包含两部分：文件名+后缀名*/
File file = new File("E:\\ready\\1.txt");
//2.1测试File中的常用方法
System.out.println(file.length());//3，获取文件的字节量
System.out.println(file.exists());//true,判断文件是否存在
System.out.println(file.isFile());//true,判断是否为文件
System.out.println(file.isDirectory());//false，判断是否为文件夹
System.out.println(file.getName());//1.txt获取文件名
System.out.println(file.getParent());//E:\ready 获取父级路径
System.out.println(file.getAbsolutePath());//E:\ready\1.txt 获取带盘符的完整路径：绝对路径
//2.2 测试创建与删除
/*new 只会帮你在内存中创建一个File类型的对象
* 并不会帮你在磁盘中创建一个真实存在的2.txt文件*/
file = new File("E:\\ready\\2.txt");
//创建一个之前不存在的文件2.txt,如果创建成功，会返回true
/*如果指定创建文件的路径不对，会抛出异常：java.io.Exception
* 所以需要提前处理这个问题，我们暂时选择在main()上抛出
* 这个IO异常是目前我们遇到的强制要求必须预先处理的异常
* 如果不处理，方法的调用会报错，通不过编译*/
System.out.println(file.createNewFile());//创建之前不存在的文件
file = new File("E:\\ready\\m");
System.out.println(file.mkdir());//创建之前不存在的单层文件夹
file = new File("E:\\ready\\a\\b\\c");
System.out.println(file.mkdirs());//创建之前不存在的多层文件夹
System.out.println(file.delete());//c被删除，删除空文件夹或者文件
file = new File("E:\\ready\\a");
System.out.println(file.delete());//false,a文件夹不是空的，里面有内容
file = new File("E:\\ready\\2.txt");
System.out.println(file.delete());//2.txt被删除，可以删除文件
//2.3测试展示文件列表
file = new File("E:\\ready");
String[] list = file.list();/*不常用*/
System.out.println(Arrays.toString(list));
//这句话会报错，因为这是一个String[],所以数组中每个元素都是String类型的
//那么只能用String类中的方法，而isDirectory()是File类中的方法
//System.out.println(list[0].isDirectory());
File[] fs = file.listFiles();/*常用*/
System.out.println(Arrays.toString(fs));
System.out.println(fs[0].isDirectory());
}
}
Lectura de flujo de 4 bytes
Un flujo de bytes se compone de bytes, y un flujo de caracteres se compone de caracteres.
Un carácter en Java se compone de dos bytes. Un flujo de bytes es un flujo básico, utilizado principalmente para procesar datos binarios.
Por lo tanto, los flujos de bytes se usan más comúnmente y pueden manejar muchos tipos diferentes de archivos, como documentos de texto/audio/video, etc.
4.1 Clase abstracta InputStream
Esta clase abstracta es la superclase/clase abstracta de todas las clases que representan flujos de entrada de bytes y no se pueden crear objetos.
Métodos comunes:
abstract int read() lee el siguiente byte de datos del flujo de entrada
int read(byte[] b) lee una cierta cantidad de bytes del flujo de entrada y los almacena en la matriz de búfer b
int read(byte[] b, int off, int len) Leer hasta len bytes de datos en el flujo de entrada en la matriz de bytes, off significa el desplazamiento al guardar void close() Cierra el flujo de entrada y libera los datos asociados con el flujo Todos los recursos del sistema asociados
con
4.2 Subclase de FileInputStream
Insertar directamente en el archivo y leer los datos del archivo directamente
Crear objeto
FileInputStream(File file): pase el objeto de archivo directamente.
Cree un FileInputStream abriendo una conexión con el archivo real especificado por el archivo del objeto File en el sistema de archivos. FileInputStream(String pathname): pase la ruta abriendo una conexión con el archivo real
para crear un FileInputStream para el archivo especificado por el nombre de ruta en el sistema de archivos
4.3 La subclase BufferedInputStream
BufferedInputStream agrega algunas funciones a otro flujo de entrada.Al crear BufferedInputStream, se creará una matriz de búfer interna (tamaño predeterminado de 8k). A medida que se leen u omiten bytes en el flujo, este búfer interno se rellena según sea necesario, varios bytes a la vez, desde el flujo de entrada contenido.
Crear objeto
BufferedInputStream(InputStream in)
crea un BufferedInputStream y guarda su parámetro, el flujo de entrada, para uso futuro.
4.4 Ejercicio: Ejemplo de lectura de flujo de bytes
Crear paquete: cn.tedu.file
Crear clase: TestIn.java
package cn.tedu.file;
import java.io.*;
/*本类用于练习字节输入流*/
public class TestIn {
public static void main(String[] args) {
//method();//字节流的读取
method2();//高效字节流的读取
}
//本方法用于测试高效字节流的读取
private static void method2() {
//定义一个在本方法中都生效的局部变量in,注意手动初始化，值为null
InputStream in = null;
try {
//1.创建高效字节输入流对象
// InputStream in = new BufferedInputStream(
// new FileInputStream(new File("E:\\ready\\1.txt")));
in = new BufferedInputStream
(new FileInputStream("E:\\ready\\1.txt"));
//2.使用流进行读取
int b;
while ((b= in.read())!= -1){
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
//关流操作写在finally{}中
//3.流用完以后一定要关闭！！！
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//本方法用于测试字节流的读取
private static void method() {
//创建一个在本方法都生效的局部变量注意手动初始化
InputStream in = null;
try {
//1.创建字节输入流对象用于读取
//InputStream in = new InputStream();//报错原因：抽象类不可实例化
//InputStream in = new FileInputStream(new File("E:\\ready\\1.txt"));
in = new FileInputStream("E:\\ready\\1.txt");
//2.开始读取
/*read()每次调用都会读取一个字节，如果读到了数据的末尾，返回-1*/
// System.out.println(in.read());
// System.out.println(in.read());
// System.out.println(in.read());
// System.out.println(in.read());
//需求：需要循环读取文件中的所有内容，直至读完
//定义变量，记录读到的数据
int b;
while((b=in.read())!= -1){
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();//打印错误信息
/*try-catch结构中的第三个部分：finally{}
* 这部分不论是否捕获到异常，是一定会被执行到的代码，常用于关流*/
}finally {
try {
//3.释放资源，流资源用完必须释放！！！
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Lectura de flujo de 5 caracteres
A menudo se usa para procesar datos de texto sin formato, y la lectura y la escritura son propensas a caracteres confusos. Al leer y escribir, es mejor especificar el conjunto de codificación como UTF-8.
5.1 Reader抽象类
Clase abstracta para leer secuencias de caracteres.
常用方法：
int read() Lee un solo carácter
int read(char[] cbuf) Lee un carácter en una matriz
abstract int read(char[] cbuf, int off, int len) Lee un carácter en una parte de una matriz
int read(CharBuffer target) Intenta leer caracteres en el búfer de caracteres especificado
abstract void close() Cierra el flujo y libera todos los recursos asociados con él
5.2 Subclase FileReader
Una clase conveniente para leer archivos de caracteres. El constructor de esta clase asume que la codificación de caracteres predeterminada y el tamaño de búfer de bytes predeterminado son apropiados. Para especificar estos valores usted mismo, primero puede construir un InputStreamReader en FileInputStream.
创建对象
FileReader(String fileName) Crea un nuevo FileReader dado el nombre de archivo para leer los datos de
FileReader(File file) Crea un nuevo FileReader dado el archivo para leer los datos
5.3 Subclase BufferedReader
Leer texto del flujo de entrada de caracteres, almacenar en búfer cada carácter, para realizar la lectura eficiente de caracteres, matrices y líneas.
Se puede especificar el tamaño del búfer o se puede usar el tamaño predeterminado. En la mayoría de los casos, el valor predeterminado es lo suficientemente grande.
创建对象
BufferedReader(Reader in) crea un flujo de entrada de caracteres almacenado en búfer utilizando un búfer de entrada del tamaño predeterminado
5.4 Ejercicio: Caso de lectura de flujo de caracteres
Crear paquete: cn.tedu.file
Crear clase: TestIn2.java
package cn.tedu.file;
import java.io.*;
/*本类用于测试字符流的读取*/
public class TestIn2 {
public static void main(String[] args) {
//method();//测试普通字符输入流
method2();//测试高效字符输入流
}
//创建一个用于测试高效字符输入流的方法
private static void method2() {
//1.定义一个在本方法都生效的局部变量，手动初始化值null
Reader in=null;
try{
//1.创建高效字符读取流对象
//in = new BufferedReader(new FileReader(new File("E:\\ready\\1.txt")));
in = new BufferedReader(new FileReader("E:\\ready\\1.txt"));
//2.使用流对象
int b;
while((b=in.read())!=-1){
System.out.println(b);
}
}catch (Exception e){
e.printStackTrace();
}finally {
//3.关闭流对象
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//创建一个用于测试普通字符输入流的方法
private static void method() {
//1.1创建一个在本方法中都生效的局部变量，注意初始化值null
Reader in = null;
try {
//1.2创建字符输入流对象，注意需要捕获异常
//Reader in = new Reader();//报错原因：抽象父级不可实例化
//in = new FileReader(new File("E:\\ready\\1.txt"));
in = new FileReader("E:\\ready\\1.txt");
//2.使用流对象
//System.out.println(in.read());
//需求：循环读取文件中的所有内容，只要不是-1，就说明还有数据，继续读取
//3.1定义变量，记录读取到的数据
int b;
while((b = in.read())!= -1){
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//3.关流
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
flujos de 6 bytes escritos
6.1 Clase abstracta OutputStream
Esta clase abstracta es la superclase de todas las clases que representan un flujo de bytes de salida.Un flujo de salida acepta bytes de salida y los envía a algún sumidero.
常用方法:
Void close() cierra este flujo de salida y libera todos los recursos del sistema asociados con este flujo.
Void flush() vacía este flujo de salida y obliga a que se escriban todos los bytes de salida almacenados
en el búfer. secuencia de salida de la matriz de bytes especificada
Void write(byte[ ] b,int off ,int len) Escribe len bytes a partir de la compensación de off en la matriz de bytes especificada en la secuencia de salida Abstract
void write(int b) escribe los bytes especificados en este flujo de salida
6.2 Subclases de FileOutputStream
Inserte directamente en el archivo, escriba directamente los datos del archivo
构造方法(创建对象):
FileOutputStream(String name): crea un flujo de salida de archivo que escribe datos en un archivo con el nombre especificado
FileOutStream(File file): crea un flujo de salida de archivo que escribe datos en el archivo representado por el objeto File especificado
FileOutStream(File file, boolean agregar): Si el segundo parámetro es verdadero, significa agregar sin sobrescribir.
Cree un flujo de salida de archivo que escriba datos en el archivo representado por el objeto de archivo especificado. Los siguientes parámetros se refieren a si sobrescribir el contenido del archivo original
6.3 Subclase BufferedOutputstream
Esta clase implementa un flujo de salida almacenado en búfer Al configurar este flujo de salida, la aplicación puede escribir cada byte en el flujo de salida subyacente sin tener que llamar al sistema subyacente cada vez que se escribe el byte.
构造方法(创建对象):
BufferedOutputStream(OutputStream out)
crea un nuevo flujo de salida almacenado en búfer para escribir datos en el flujo de salida subyacente especificado
6.4 Ejercicio: prueba de flujo de salida de bytes:
Crear paquete: cn.tedu.file
Crear clase: TestOut.java
package cn.tedu.file;
import java.io.*;
/*本类用于测试字节输出流*/
public class TestOut {
public static void main(String[] args) {
method();//用于测试普通字节输出流
//method2();//用于测试高效字节输出流
}
//创建一个用于测试高效字节输出流的方法
private static void method2() {
//1.创建一个在本方法都生效的局部变量，注意手动初始化
OutputStream out = null;
try{
//2.创建高效字节输出流对象
// out = new BufferedOutputStream(new FileOutputStream(new File("E:\\ready\\2.txt")));
out = new BufferedOutputStream(new FileOutputStream("E:\\ready\\2.txt"));
//3.使用流对象--进行写出操作
out.write(97);
out.write(97);
out.write(97);
}catch (Exception e){
e.printStackTrace();
}finally {
//关流操作要放在finally{}中
try {
//4.关流
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//创建一个用于测试普通字节输出流的方法
private static void method() {
//1.创建一个在本方法中都生效的局部变量，注意手动初始化null
OutputStream out = null;
//2.创建try-catch-finally结构，因为IO操作可能会产生异常
try{
//3.创建普通字节输出流对象
//out = new FileOutputStream(new File("E:\\ready\\2.txt"));
//out = new FileOutputStream("E:\\ready\\2.txt");
out = new FileOutputStream("E:\\ready\\2.txt",true);
//4.使用流对象--进行写出操作
out.write(99);//对应ASCII码表中的a
out.write(99);//对应ASCII码表中的b
out.write(99);//对应ASCII码表中的c
}catch (Exception e){
e.printStackTrace();
}finally {
//如果想要代码一定会执行，需要写在finally中
try {
//5.关流操作
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Escritura de flujo de 7 caracteres
7.1 Clase abstracta de escritor
Clase abstracta para escribir flujos de caracteres
常用方法:
Abstract void close() Cierra este flujo, pero primero límpialo
Void write(char[ ] cbuf) Write character array
Void write(int c) Write solo carácter
Void write(String str) Write string
Void write(String str, int off, int len) Escribe una parte de la cadena
Abstract void write(char[] cbuf, int off, int len) Escribe una parte de la matriz de caracteres
7.2 La subclase FileWriter
es una clase conveniente que se usa para escribir archivos de caracteres. El método de construcción de esta clase asume que la codificación de caracteres predeterminada y el tamaño de búfer de bytes predeterminado son aceptables. Si necesita personalizar estos valores usted mismo, primero puede construir en FileOutputStream Un OutputStreamWriter.
构造方法(创建对象):
FileWriter(String filename)
Construye un objeto FileWriter basado en el nombre de archivo dado
FileWriter(String filename, boolean append)
Construye un FileWriter basado en el nombre de archivo dado y un valor booleano que indica si agregar los datos escritos
7.3 La subclase BufferedWriter
escribe texto en el flujo de salida de caracteres, almacenando en búfer caracteres individuales, proporcionando así una escritura eficiente de caracteres, matrices y cadenas individuales. El tamaño del búfer se puede especificar o se puede aceptar el tamaño predeterminado. En la mayoría de los casos, el valor predeterminado es lo suficientemente grande
构造方法(创建对象):
BufferedWriter(Writer out)
crea un flujo de salida de caracteres almacenados en búfer utilizando un búfer de salida del tamaño predeterminado
7.4 Ejercicio: prueba de flujo de salida de caracteres:
Crear paquete: cn.tedu.file
Crear clase: TestOut2.java
package cn.tedu.file;
import java.io.*;
/*本类用于测试字符输出流*/
public class TestOut2 {
public static void main(String[] args) {
//method();//用于测试普通字符输出流
method2();//用于测试高效字符输出流
}
//创建一个用于测试高效字符输出流的方法
private static void method2() {
//1.创建一个在本方法都生效的局部变量，值为null,注意手动初始化！！！
Writer out = null;
//2.由于程序可能会抛出异常，所以需要写一个try-catch-finally结构
try{
//存放可能会抛出异常的代码
//3.创建普通字符输出流对象
//out = new BufferedWriter(new FileWriter(new File("E:\\ready\\2.txt")));
//out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt"));
out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt",true));
//4.使用流对象
out.write(100);
out.write(100);
out.write(100);
out.write(100);
out.write(100);
}catch (Exception e){
//匹配并捕获异常
e.printStackTrace();//如果捕获到异常就打印错误信息
}finally {
//一定会被执行到的代码块，常用于关流
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//创建一个用于测试普通字符输出流的方法
private static void method() {
//1.创建一个在本方法都生效的局部变量，值为null,注意手动初始化！！！
Writer out = null;
//2.由于程序可能会抛出异常，所以需要写一个try-catch-finally结构
try{
//存放可能会抛出异常的代码
//3.创建普通字符输出流对象
//out = new FileWriter(new File("E:\\ready\\2.txt"));
//out = new FileWriter("E:\\ready\\2.txt");
out = new FileWriter("E:\\ready\\2.txt",true);
//4.使用流对象
out.write(98);
out.write(98);
out.write(98);
out.write(98);
}catch (Exception e){
//匹配并捕获异常
e.printStackTrace();//如果捕获到异常就打印错误信息
}finally {
//一定会被执行到的代码块，常用于关流
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
8 expansión
Al aprender los varios flujos anteriores, también podemos expandir e intentar copiar archivos:
crear paquete: cn.tedu.file
crear clase: TestCopyFile.java
package cn.tedu.file;
import java.io.*;
import java.util.Scanner;
/*本类用于练习文件复制综合案例*/
public class TestCopyFile {
public static void main(String[] args) {
//1.提示并接收用户输入的两个路径
System.out.println("请输入源文件路径");//--被复制的那个文件
String f = new Scanner(System.in).nextLine();
System.out.println("请输入新文件路径：");//--复制好的新文件
String t = new Scanner(System.in).nextLine();
//2.调用创建好的自定义方法完成文件复制
//ZFCopy(f,t);//用字符流完成文件的复制案例
ZJCopy(f,t);//用字节流完成文件的复制案例
}
//利用字节流完成文件复制案例
private static void ZJCopy(String f, String t) {
//1.定义在整个方法都生效的局部变量，注意手动初始化，引用类型默认值为null
InputStream in = null;
OutputStream out = null;
//2.由于代码可能会发生异常，所以需要编写try-catch-finally结构
try{
//3.1创建高效字节输入流对象--FIS的参数是用户传入的源文件路径f
in = new BufferedInputStream(new FileInputStream(f));
//3.2创建高效字节输出流对象--FOS的参数是用户传入的新文件路径t
out = new BufferedOutputStream(new FileOutputStream(t));
//4.利用创建好的流对象完成业务
//4.1定义变量用来保存读到的数据
int b;
//4.2循环读取源文件中的数据，只要不是-1，说明还有数据循环继续
while((b = in.read()) != -1){
//4.3将读到的数据写入到新文件中
out.write(b);
}
System.out.println("恭喜您！文件复制成功！");
}catch (Exception e){
System.out.println("很抱歉！文件复制失败！");
e.printStackTrace();
}finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//利用字符流完成文件复制案例
private static void ZFCopy(String f, String t) {
//1.定义在整个方法中都生效的局部变量，注意手动初始化，默认值为null
Reader in = null;
Writer out = null;
//2.由于代码可能会发生异常，所以需要编写try-catch-finally结构
try{
//3.1创建高效字符输入流对象
in = new BufferedReader(new FileReader(f));
//3.2创建高效字符输出流对象
out = new BufferedWriter(new FileWriter(t));
//4.拿到流对象以后，就可以使用流对象来完成业务了
//4.1定义变量用来保存读到的数据
int b;
//4.2循环读取源文件，直到返回值为-1，说明没有数据了，再结束循环
while ((b=in.read())!=-1) {
//4.3将本轮循环中读到的数据写入到新文件中
out.write(b);
}
System.out.println("恭喜您！文件复制成功！");
}catch (Exception e){
System.out.println("很抱歉！文件复制失败！");
e.printStackTrace();
}finally {
/*关流是有顺序的：如果有多个流，最后创建的流最先关闭
* 多条关流语句需要各自try-catch*/
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
9 Resumen: estructura de herencia IO
1.主流分类
1. Clasificación según la dirección: flujo de entrada flujo de salida (relativo al programa, se emite la escritura de datos del programa en el archivo) 2.
Clasificación según el tipo de transmisión: flujo de bytes flujo de caracteres
3. Combinación: flujo de bytes flujo de entrada sección de palabras flujo de salida flujo de entrada de caracteres flujo de salida de caracteres
2.学习方法:在抽象父类中学习通用的方法,在子类中学习如何创建对象
3.字节输入流:
Clase abstracta InputStream, no puede ser nueva, se puede usar como una súper clase para aprender los métodos comunes que proporciona
--FileInputStream 子类,操作文件的字节输入流,普通类
--BufferedInputStream 子类,缓冲字节输入流,普通类
4、字符输入流
Reader es una clase abstracta, que no puede ser nueva, y puede usarse como una superclase para aprender los métodos comunes que proporciona
--FileReader,子类,操作文件的字符输入流,普通类
--BufferedReader,子类,缓冲字符输入流,普通类
5.字节输出流:
La clase abstracta OutputStream, no nueva, se puede usar como una súper clase para aprender los métodos comunes que proporciona
--FileOutputStream 子类,操作文件的字节输出流,普通类
--BufferedOutputStream 子类,缓冲字节输出流,普通类
6.字符输出流
Writer es una clase abstracta, que no puede ser nueva, y puede usarse como una superclase para aprender los métodos comunes que proporciona.
--FileWriter,子类,操作文件的字符输出流,普通类
--BufferedWriter,子类,缓冲字符输出流,普通类