Java -- IO流（一）

待我称王封你为后i 2023-05-22 13:24 5阅读 0赞

*  Java的核心库java.io提供了全面的IO接口。包括：文件读写、标准设备输出等。Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center]

## 一、java.io包：File ##

*  字节流：针对二进制文件  
    `InputStream` –`FileInputStream` –`BufferedInputStream` –`ObjectInputStream`  
    `OutputStream` –`FileOutputStream` –`BufferedOutputStream` –`ObjectOutputStream`
 *  字符流：针对文本文件。读写容易发生乱码现象，在读写时最好指定编码集为**utf-8**  
    `Reader` –`BufferedReader` –`InputStreamReader` –`PrintWriter/PrintStream`  
    `Writer` –`BufferedWriter` –`OutputStreamWriter`

## 二、File ##

##### 1、创建对象 #####

*  `File(String pathname)`  
    通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

##### 2、常用方法： #####

*  **文件、文件夹属性**  
    `length()`：文件的字节量  
    `exists()`：是否存在，存在返回true  
    `isFile()`：是否为文件，是文件返回true  
    `isDirectory()`：是否为文件夹，是文件夹返回true  
    `getName()`：获取文件/文件夹名  
    `getParent()`：获取父文件夹的路径  
    `getAbsolutePath()`：获取文件的完整路径
 *  **创建、删除**  
    `createNewFile()`：新建文件，文件夹不存在会异常，文件已经存在返回false  
    `mkdirs()`：新建多层不存在的文件夹\\a\\b\\c  
    `mkdir()`：新建单层不存在的文件夹\\a  
    `delete()`：删除文件，删除空文件夹
 *  **文件夹列表**  
    `list()`：返回String\[\]，包含文件名  
    `listFiles()`：返回File\[\]，包含文件对象

##### 3、测试案例 #####

package cn.tedu.io;
    
    import java.io.File;
    import java.io.IOException;
    import java.util.Arrays;
    
    //这个类用来测试File工具类
    public class Test_File { 
    	public static void main(String[] args) throws IOException { 
    		//1、创建对象 -- 参数是路径，可以是文件的/文件夹的/或者是不存在的
    		File file = new File("C:\\Users\\Administrator\\Desktop\\Tedu\\1.txt");
    		
    		//2、常用方法
    		System.out.println(file.length());//获取文件的字节量
    		System.out.println(file.isFile());//判断file是文件吗
    		System.out.println(file.exists());//判断文件是否存在
    		System.out.println(file.isDirectory());//判断file是文件夹吗
    		System.out.println(file.getName());//获取文件的名字
    		System.out.println(file.getParent());//获取父目录
    		System.out.println(file.getAbsolutePath());//获取文件的完整路径
    		
    		//创建、删除方法
    		file = new File("C:\\Users\\Administrator\\Desktop\\Tedu\\2.txt");
    		System.out.println(file.createNewFile());//创建新文件，创建不存在的返回true，如果存在返回false
    		
    		//创建文件夹
    		file = new File("C:\\Users\\Administrator\\Desktop\\Tedu\\ab");//单层不存在的文件夹
    		System.out.println(file.mkdir());//创建单层不存在的文件夹
    		
    		file = new File("C:\\Users\\Administrator\\Desktop\\Tedu\\a\\b\\c");//多层不存在的文件夹
    		System.out.println(file.mkdirs());//创建多层不存在的文件夹
    		
    		//删除文件或者文件夹
    // file = new File("C:\\Users\\Administrator\\Desktop\\Tedu\\a\\b\\c");
    // file = new File("C:\\Users\\Administrator\\Desktop\\Tedu\\a\\b\\c\\1.txt");
    // System.out.println(file.delete());//删除文件夹，前提是文件夹是空的，或者单独删除指定文件
    		
    		//列表方法
    		file = new File("C:\\Users\\Administrator\\Desktop\\Tedu");
    		String[] strings = file.list();//列出文件的名称放入数组
    		System.out.println(Arrays.toString(strings));
    		
    		File[] files = file.listFiles();//列出文件并封装成file对象放入数组
    		System.out.println(Arrays.toString(files));
    	}
    }

##### 4、练习 #####

package cn.tedu.io;
    
    import java.io.File;
    import java.util.Scanner;
    
    //这个类用来测试 -- 递归求目录总大小
    public class File_Practice { 
    	public static void main(String[] args) { 
    		//接收用户输入的路径
    		String path = new Scanner(System.in).nextLine();
    		
    		//把路径封装成file对象
    		File dir = new File(path);
    		
    		//调用size() -- 求大小
    		long total = size(dir);
    		System.out.println(total);
    	}
    
    	public static long size(File dir) { 
    		/* * 1、列出文件夹下的所有资源 * 2、判断当前的资源是文件吗？如果是文件直接length()求字节量的和 * 3、判断当前的资源是文件夹吗？如果是文件夹 -- 重复干123的事情 */
    		//1、列出文件夹下的所有资源
    		File[] files = dir.listFiles();
    		
    		//定义变量，记录和
    		long sum = 0; 
    		
    		//获取每个资源
    		//注意数组越界异常的报错uncaught exception ArrayIndexOutOfBoundsException
    		for (int i = 0; i < files.length; i++) { 
    			//2、判断当前的资源是文件吗？如果是文件直接length()求字节量的和
    			if (files[i].isFile()) { 
    				//如果是文件，要把所有文件求和
    				sum = sum + files[i].length();//每个文件的长度相加求和
    			}else if (files[i].isDirectory()) { 
    				//3、判断当前的资源是文件夹吗？如果是文件夹 -- 重复干123的事情
    				sum = sum + size(files[i]);//递归调用size() 求目前资源的大小
    			}
    		}
    		return sum;
    	}
    }

## 三、读取：是指程序需要读取 / 输入 / in：是从磁盘读到程序中来 ##

**（一）字节流：啥都行**

*  **InputStream**：是字节流 读取流的父类 。是抽象类，不能创建对象，只能学习共性方法。  
    **常用方法：**  
    `void close()`：关闭此输入流并释放与该流关联的所有系统资源。  
    `abstract int read()`：从输入流中读取数据的下一个字节。  
    `int read(byte[] b)`：从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。  
    `int read(byte[] b, int off, int len)`：将输入流中最多 len 个数据字节读入 byte 数组。
 *  **FileInputStream**：子类，继承了父类的方法，就不重复学父类的方法了。直接学习创建对象就行  
    **创建对象：**  
    `FileInputStream(File file)`  
    `FileInputStream(String name)`
 *  **BufferedInputStream**：子类，继承了父类的方法，就不重复学父类的方法了。直接学习创建对象就行  
    **创建对象：**  
    `BufferedInputStream(InputStream in)`
 *  **测试**

package cn.tedu.io;
    
    import java.io.BufferedInputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    
    //这个类用来测试字节流 读取
    public class Test_InputStream { 
    	public static void main(String[] args) { 
    		method();//方法调用
    		method2();//用高效子类BufferedInputStream
    	}
    	public static void method2() { 
    		InputStream is3 = null;
    		try { 
    			//1、创建字节读取流对象
    			//构造方法需要InputStream类型的参数
    			is3 = new BufferedInputStream(new FileInputStream(new File("C:\\Users\\Administrator\\Desktop\\Tedu\\2.txt")));
    			System.out.println(is3.read());
    			//2、开始读取
    			int b = 0;
    			while ((b = is3.read()) != -1) { 
    				System.out.println(b);
    			}
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}finally { 
    			//3、释放资源
    			try { 
    				is3.close();
    			} catch (IOException e) { 
    				e.printStackTrace();
    			}
    		}
    	}
    
    	public static void method() { 
    		InputStream is = null;
    		try { 
    			//1、创建字节读取流对象
    			is = new FileInputStream(new File("C:\\Users\\Administrator\\Desktop\\Tedu\\1.txt"));//触发FileInputStream(File)构造方法
    // is2 = new FileInputStream("C:\\Users\\Administrator\\Desktop\\Tedu\\2.txt");//触发FileInputStream(String)构造方法
    			
    			//2、调用父类的功能，开始读取
    			//从输入流中读取数据的下一个字节
    // System.out.println(is.read());//49
    // System.out.println(is.read());//50
    // System.out.println(is.read());//51
    			
    			//3、当读取到没有数据的时候，read()返回-1
    // System.out.println(is.read());//-1
    			
    			//改造读取的代码
    			int a = 0;//定义变量，记录读取到的数据
    			//有数据才读，没数据返回-1时就不读了，先判断再执行
    			while((a = is.read()) != -1) { //逐个读取
    				System.out.println(a);
    			}
    			
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}finally { 
    			//4、释放资源
    			try { 
    				is.close();
    // is2.close();
    			} catch (IOException e) { 
    				e.printStackTrace();
    			}
    		}
    	}
    }

**（二）字符流：只能读取字符文件，txt**

*  Reader：是字符流读取流的父类。是抽象类，不能创建对象，所以只能学共性方法。  
    **常用方法：**  
    `abstract void close()`：关闭该流并释放与之关联的所有资源。  
    `int read()`：读取单个字符。  
    `int read(char[] cbuf)`：将字符读入数组。  
    `abstract int read(char[] cbuf, int off, int len)`：将字符读入数组的某一部分。  
    `int read(CharBuffer target)`：试图将字符读入指定的字符缓冲区。
 *  `FileReader`子类，继承了父类的共性方法，直接学子类创建对象  
    **创建对象：**  
    `FileReader(File file)`  
    `FileReader(String fileName)`
 *  `BufferedReader`子类，继承了父类的共性方法，直接学子类创建对象  
    **创建对象：**  
    `BufferedReader(Reader in)`  
    **测试案例**

package cn.tedu.io;
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    import java.io.Reader;
    //这个类用来测试 字符 读取流
    //总结：
    //字符读取流：普通对象读取FileReader，高效对象读取BufferedReader
    //效率来讲：BufferedReader > FileReader
    //原因：BufferedReader底层也维护了一个char[](默认容量是8K)，读取时满了一个数组给程序一次，减少交互提高效率
    public class Test3_Reader { 
    	public static void main(String[] args) { 
    		method();//普通读取流FileReader
    		method2();//高效读取流BufferedReader
    	}
    	private static void method2() { 
    		Reader in = null;//声明变量，为了finally也能用
    		try { 
    			//1，创建对象
    			in = new BufferedReader(new FileReader("C:\\Users\\Administrator\\Desktop\\Tedu\\1.txt"));
    			//2，开始读取
    			int b = 0;//定义变量，记录每次读取到的数据
    			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();
    			}			
    		}
    	}
    	//普通读取流
    	public static void method() { 
    		Reader in = null;
    		try { 
    			//1，创建对象
    			in = new FileReader("C:\\Users\\Administrator\\Desktop\\Tedu\\1.txt");//触发FileReader(String)构造方法
    // Reader in2 = new FileReader( new File("C:\\Users\\Administrator\\Desktop\\Tedu\\1.txt"));//触发FileReader(File)构造方法
    			//2，开始读取
    			int b = 0;//定义变量，记录每次读取到的数据
    			while((b = in.read()) != -1) { 
    				System.out.println(b);
    			}
    		} catch (Exception e) { // 捕获大异常
    			e.printStackTrace();
    		}finally { 
    			//3，释放资源
    			try { 
    				in.close();
    // in2.close();
    			} catch (IOException e) { 
    				e.printStackTrace();
    			}
    		}
    	}
    	
    }

## 四、写出：是指程序需要写出/输出/out：是从程序写出到磁盘中 ##

1.  **字节流：啥都行**

*  `OutputStream`，字节输出流的父类。抽象类，不能创建对象，只能学习共性方法  
    **共性方法：**  
    `void close()`：关闭此输出流并释放与此流有关的所有系统资源。  
    `void flush()`：刷新此输出流并强制写出所有缓冲的输出字节。  
    `void write(byte[] b)`：将 b.length 个字节从指定的 byte 数组写入此输出流。  
    `void write(byte[] b, int off, int len)`：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。  
    `abstract void write(int b)`：将指定的字节写入此输出流。
 *  `FileOutputStream`：子类，使用了父类的共性方法，只要学习创建对象  
    **创建对象**  
    `FileOutputStream(File file)`  
    `FileOutputStream(File file, boolean append)`  
    `FileOutputStream(String name)`  
    `FileOutputStream(String name, boolean append)`
 *  `BufferedOutputStream` ：子类，使用了父类的共性方法，只要学习创建对象  
    **创建对象**  
    `BufferedOutputStream(OutputStream out)`
 *  测试案例

package cn.tedu.io;
    
    import java.io.BufferedOutputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    
    //这个类用来测试 字节输出流
    /* * 1、字节流的写出流：两种普通流 FileOutputStream 和高级流 BufferedOutputStream * 2、效率上来说：BufferedOutputStream > FileOutputStream * 3、原因：BufferedOutputStream 底层维护了一个byte[]，默认大小是8k，减少给磁盘的次数，提高效率 */
    public class Test5_OutPutStream { 
    	public static void main(String[] args) { 
    // method();//普通输出流
    		method2();//高效输出流
    	}
    
    	public static void method2() { 
    		OutputStream ou3 = null;
    		try { 
    			//1、创建对象
    			ou3 = new BufferedOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\Tedu\\1.txt",true));
    			//2、开始写出
    			ou3.write(100);
    			ou3.write(101);
    			ou3.write(102);
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}finally { //为了保证资源一定会释放
    			//3、释放资源
    			try { 
    				ou3.close();
    			} catch (IOException e) { 
    				e.printStackTrace();
    			}
    		}
    	}
    	public static void method() { 
    		OutputStream ou1 = null;
    		try { 
    			//1、创建对象
    			//传两个参数就是数据追加，不覆盖原来的
    			ou1 = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\Tedu\\1.txt",true);
    			//只传一个参数，那么就是数据覆盖模式，
    // ou1 = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\Tedu\\1.txt");
    // OutputStream ou2 = new FileOutputStream(new File("C:\\Users\\Administrator\\Desktop\\Tedu\\1.txt"));
    			
    			//2、开始写出
    			ou1.write(97);
    			ou1.write(98);
    			ou1.write(47);
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}finally { 
    			//3、释放资源
    			try { 
    				ou1.close();
    			} catch (IOException e) { 
    				e.printStackTrace();
    			}
    		}
    	}
    }

1.  **字符流：写出文本数据**

*  **Writer**
 *  **BufferedWriter**
 *  **OutputStreamWriter**
 *  **测试案例**

package cn.tedu.io;
    
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.Writer;
    /* * 总结 * 1、字符输出流：两种 -- FileWriter 和 BufferedWriter * 2、效率上来讲：BufferedWriter > FileWriter * 3、BufferedWriter底层维护了一个缓冲数组char[]，默认大小8k，减少给磁盘次数，提高效率 */
    public class Test_Writer { 
    	//这个类用来测试--字符输出流
    	public static void main(String[] args) { 
    // method();//普通对象FileWriter
    		method2();//高级流
    	}
    
    	public static void method2() { 
    		Writer wr2 = null;
    		try { 
    			wr2 = new BufferedWriter(new FileWriter(new File("C:\\Users\\Administrator\\Desktop\\Tedu\\1.txt")));
    // wr2.write(101);
    			wr2.write("我爱java，我信你个鬼，");
    			wr2.write("但是我真想静静，别问我静静是谁，啊哈哈哈");
    			
    // wr2.flush();//把缓冲区的数据，刷到磁盘里显示
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}finally { 
    			try { 
    				//释放资源
    				wr2.close();
    				/** * close两个功能： * 1、先把数据从缓冲区刷出去 * 2、然后释放资源 */
    			} catch (IOException e) { 
    				e.printStackTrace();
    			}
    		}
    	}
    
    	public static void method() { 
    		Writer wr = null;
    		try { 
    			//1、创建对象
    			wr = new FileWriter(new File("C:\\Users\\Administrator\\Desktop\\Tedu\\1.txt"));
    			
    			//2、开始写出
    			wr.write("火箭101，吴宣仪");
    			wr.write("婷姐跟吴宣仪好像啊，漂亮");//字符流可以写出字符串
    			
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}finally { 
    			try { 
    				wr.close();//3、释放资源
    			} catch (IOException e) { 
    				e.printStackTrace();
    			}
    		}
    	}
    }

**【下篇预告】**

*  文件复制
 *  批量读写
 *  序列化/反序列化

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20230521/6c4703e9e3a845129c7c2a13a2c0b2c8.png