Java基础学习笔记（十六）—— IO流（1）

1 IO流

之前存储的数据是不能够永久化存储的只要代码运行结束所有数据都会丢失。而想要数据永久话存储就必须要用到IO可以跟本地硬盘交互。

1.1 IO流概述

• IO输入/输出(Input/Output)
  • I表示input是数据从硬盘进内存的过程称为读
  • O表示output是数据从内存到硬盘的过程称为写
• 流是一种抽象概念是对数据传输的总称也就是说数据在设备间的传输称为流流的本质是数据传输

IO的数据传输可以看做是一种数据的流动按照流动的方向以内存为参照物进行读写操作。

1.2 IO流的分类

• 按照数据的流向
  • 输入流读数据
  • 输出流写数据
• 按照数据类型来分
  • 字节流
    • 字节输入流
    • 字节输出流
  • 字符流
    • 字符输入流
    • 字符输出流

1.3 IO流的使用场景

• 如果操作的是纯文本文件优先使用字符流
• 如果操作的是图片、视频、音频等二进制文件优先使用字节流
• 如果不确定文件类型优先使用字节流字节流是万能的流

纯文本文件用Windows自带的记事本打开能读懂的文件就是纯文本文件txt文件就直接是纯文本文件

2 File类

2.1 File类概述

File类

• 它是文件和目录路径名的抽象表示
• 文件和目录是可以通过File封装成对象的
• 对于File而言其封装的并不是一个真正存在的文件仅仅是一个路径名而已。它可以是存在的也可以是不存在的将来是要通过具体的操作把这个路径的内容转换为具体存在的
• 在读写数据时告诉虚拟机要操作的文件/文件夹在哪
• 对文件/文件夹进行操作包括创建、删除等

2.2 File类构造方法

public static void main(String[] args) {
	//method1();
	//method2();
	//method3();
}

private static void method3() {
	//File​(File parent, String child)      从父抽象路径名和子路径名字符串创建新的File实例
	File file1 = new File("C:\\it");
	String path = "a.txt";
	File file = new File(file1,path);
	System.out.println(file);//C:\it\a.txt
}

private static void method2() {
	//File​(String parent, String child)    从父路径名字符串和子路径名字符串创建新的File实例
	String path1 = "C:\\it";
	String path2 = "a.txt";
	File file = new File(path1,path2);//把两个路径拼接.
	System.out.println(file);//C:\it\a.txt
}

private static void method1() {
	//File​(String pathname)        通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
	String path = "C:\\it\\a.txt";
	File file = new File(path);
	//问题:为什么要把字符串表示形式的路径变成File对象?
	//就是为了使用File类里面的方法.
}

注意

• 绝对路径
  • 是一个完整的路径,从盘符开始
• 相对路径
  • 是一个简化的路径,相对当前项目下的路径

public static void main(String[] args) {
    // 是一个完整的路径,从盘符开始
    File file1 = new File("D:\\it\\a.txt");

    // 是一个简化的路径,从当前项目根目录开始
    File file2 = new File("a.txt");
    File file3 = new File("模块名\\a.txt");
}

2.3 File类常用方法

1. 创建功能

public static void main(String[] args) throws IOException {
	//public boolean createNewFile()    创建一个新的空的文件
			//注意点:
				//1.如果文件存在,那么创建失败,返回false
				//2.如果文件不存在,那么创建成功,返回true
				//3.createNewFile方法不管调用者有没有后缀名,只能创建文件.

	//public boolean mkdir()            创建一个单级文件夹
			//注意点:
				//1.只能创建单级文件夹,不能创建多级文件夹
				//2.不管调用者有没有后缀名,只能创建单级文件夹

	//public boolean mkdirs()           创建一个多级文件夹
			//注意点:
				//1,可以创建单级文件夹,也可以创建多级文件夹
				//2.不管调用者有没有后缀名,只能创建文件夹

	//疑问:
		//既然mkdirs能创建单级,也能创建多级.那么mkdir还有什么用啊? 是的


	//method1();
	//method2();

	File file = new File("C:\\it\\aaa.txt");
	boolean result = file.mkdirs();
	System.out.println(result);
}

private static void method2() {
	File file = new File("C:\\it\\aaa.txt");
	boolean result = file.mkdir();
	System.out.println(result);
}

private static void method1() throws IOException {
	File file1 = new File("C:\\it\\aaa");
	boolean result1 = file1.createNewFile();
	System.out.println(result1);
}

2. 删除功能

//注意点:
	//1.不走回收站的.
	//2.如果删除的是文件,那么直接删除.如果删除的是文件夹,那么能删除空文件夹
	//3.如果要删除一个有内容的文件夹,只能先进入到这个文件夹,把里面的内容全部删除完毕,才能再次删除这个文件夹
//简单来说:
	//只能删除文件和空文件夹.
public static void main(String[] args) {
	//method1();
	File file = new File("C:\\it");
	boolean result = file.delete();
	System.out.println(result);
}

private static void method1() {
	File file = new File("C:\\it\\a.txt");
	boolean result = file.delete();
	System.out.println(result);
}

3. 判断功能

public static void main(String[] args) {
	//method1();
	//method2();
	
private static void method2() {
	File file = new File("a.txt");
	boolean result = file.exists();
	System.out.println(result);
}

private static void method1() {
	File file = new File("C:\\it\\a.txt");
	boolean result1 = file.isFile();
	boolean result2 = file.isDirectory();
	System.out.println(result1);
	System.out.println(result2);
}

4. 获取功能

public static void main(String[] args) {
   File file = new File("D:\\aaa");
   System.out.println(f.getAbsolutePath());
   System.out.println(f.getPath());
   System.out.println(f.getName());

	File[] files = file.listFiles();//返回值是一个File类型的数组
	System.out.println(files.length);
	for (File path : files) {
		System.out.println(path);
	}
}

注意

• 当调用者不存在时listFiles方法返回null
• 当调用者是一个文件时listFiles方法返回null
• 当调用者是一个空文件夹时listFiles方法返回一个长度为0的数组
• 当调用者是一个有内容的文件夹时进入文件夹listFiles方法会获取这个文件夹里面所有的文件和文件夹的File对象并把这些File对象都放在一个数组中返回。包括隐藏文件和隐藏文件夹都可以获取。
• 当调用者是一个有权限才能进入的文件夹时listFiles方法返回null

2.4 File类案例

1. 在当前模块下的aaa文件夹中创建一个a.txt文件

public static void main(String[] args) throws IOException {
   /* File file = new File("filemodule\\aaa\\a.txt");
	file.createNewFile();*/
	//注意点:文件所在的文件夹必须要存在.

	File file = new File("filemodule\\aaa");
	if(!file.exists()){
		//如果文件夹不存在,就创建出来
		file.mkdirs();
	}
	File newFile = new File(file,"a.txt");
	newFile.createNewFile();
}

2. 删除一个多级文件夹

public static void main(String[] args) {
	//delete方法
	//只能删除文件和空文件夹.
	//如果现在要删除一个有内容的文件夹?
	//先删掉这个文件夹里面所有的内容.
	//最后再删除这个文件夹
	File src = new File("C:\\Users\\apple\\Desktop\\src");
	deleteDir(src);
}

private static void deleteDir(File src) {
	//先删掉这个文件夹里面所有的内容.
	//递归 方法在方法体中自己调用自己.
	//注意: 可以解决所有文件夹和递归相结合的题目
	//1.进入 --- 得到src文件夹里面所有内容的File对象.
	File[] files = src.listFiles();
	//2.遍历 --- 因为我想得到src文件夹里面每一个文件和文件夹的File对象.
	for (File file : files) {
		if(file.isFile()){
			//3.判断 --- 如果遍历到的File对象是一个文件,那么直接删除
			file.delete();
		}else{
			//4.判断
			//递归
			deleteDir(file);//参数一定要是src文件夹里面的文件夹File对象
		}
	}
	//最后再删除这个文件夹
	src.delete();
}

3. 统计一个文件夹中每种文件出现的次数

public static void main(String[] args) {
	//统计 --- 定义一个变量用来统计. ---- 弊端:同时只能统计一种文件
	//利用map集合进行数据统计,键 --- 文件后缀名  值 ----  次数

	File file = new File("filemodule");
	HashMap<String, Integer> hm = new HashMap<>();
	getCount(hm, file);
	System.out.println(hm);
}

private static void getCount(HashMap<String, Integer> hm, File file) {
	File[] files = file.listFiles();
	for (File f : files) {
		if(f.isFile()){
			String fileName = f.getName();
			String[] fileNameArr = fileName.split("\\.");
			if(fileNameArr.length == 2){
				String fileEndName = fileNameArr[1];
				if(hm.containsKey(fileEndName)){
					//已经存在
					//将已经出现的次数获取出来
					Integer count = hm.get(fileEndName);
					//这种文件又出现了一次.
					count++;
					//把已经出现的次数给覆盖掉.
					hm.put(fileEndName,count);
				}else{
					//不存在
					//表示当前文件是第一次出现
					hm.put(fileEndName,1);
				}
			}
		}else{
			getCount(hm,f);
		}
	}
}

3 字节流

3.1 字节流写数据

• 字节流抽象基类
  • InputStream这个抽象类是表示字节输入流的所有类的超类
  • OutputStream这个抽象类是表示字节输出流的所有类的超类
  • 子类名特点子类名称都是以其父类名作为子类名的后缀
• 字节输出流
  • FileOutputStream(String name)创建文件输出流以指定的名称写入文件
• 使用字节输出流写数据的步骤
  • 创建字节输出流对象(调用系统功能创建了文件创建字节输出流对象让字节输出流对象指向文件)
  • 调用字节输出流对象的写数据方法
  • 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)

public static void main(String[] args) throws IOException {
	//1.创建字节输出流的对象 --- 告诉虚拟机我要往哪个文件中写数据了
	FileOutputStream fos = new FileOutputStream("D:\\a.txt");
	//FileOutputStream fos = new FileOutputStream(new File("D:\\a.txt"));

	//2,写数据传递一个整数时那么实际上写到文件中的是这个整数在码表中对应的那个字符.
	fos.write(97); //会在文件中写入a

	//3,释放资源告诉操作系统我现在已经不要再用这个文件了
	fos.close();
}

注意

• 如果文件不存在会帮我们自动创建出来.
• 如果文件存在会把文件清空.

3.2 字节流写数据的三种方式

public static void main(String[] args) throws IOException {
    FileOutputStream fos = new FileOutputStream("bytestream\\a.txt");
  /*fos.write(97);
    fos.write(98);
    fos.write(99);*/
    
    /* byte [] bys = {97,98,99};
    fos.write(bys);*/

    byte [] bys = {97,98,99,100,101,102,103};
    fos.write(bys,1,2); //98,99即写入bc
    
    fos.close();
}

那么现在有两个小问题

• 字节流写数据如何实现换行
  • windows:\r\n
  • linux:\n
  • mac:\r
  • getBytes()是字符串的一个方法可以将字符串转换为字节
• 字节流写数据如何实现追加写入
  • public FileOutputStream(String name,boolean append)
  • 创建文件输出流以指定的名称写入文件。如果第二个参数为true 则字节将写入文件的末尾而不是开头

public static void main(String[] args) throws IOException {
	//第二个参数就是续写开关,如果没有传递,默认就是false,
	//表示不打开续写功能,那么创建对象的这行代码会清空文件.

	//如果第二个参数为true,表示打开续写功能
	//那么创建对象的这行代码不会清空文件.
	FileOutputStream fos = new FileOutputStream("bytestream\\a.txt",true);

	fos.write(97);
	//加一个换行
	fos.write("\r\n".getBytes());
	fos.write(98);
	//加一个换行
	fos.write("\r\n".getBytes());
	fos.write(99);
	//加一个换行
	fos.write("\r\n".getBytes());
	fos.write(100);
	//加一个换行
	fos.write("\r\n".getBytes());
	fos.write(101);
	//加一个换行
	fos.write("\r\n".getBytes());

	fos.close();
}

3.3 字节流写数据加异常处理

有如下代码

try {
    FileOutputStream fos = new FileOutputStream("a.txt");
    fos.write(97);
    fos.close();
}catch (IOException e){
    e.printStackTrace();
}

我们如何操作才能让close方法一定执行呢

异常处理的标准格式

try{
	可能出现异常的代码;
}catch(异常类名 变量名){
	异常的处理代码;
}finally{
	执行所有清除操作; // 在异常处理时提供finally块来执行所有的清除操作比如IO流的释放资源被finally控制的语句一定会执行除非JVM退出
}

加异常处理后的代码如下

public static void main(String[] args) {
	FileOutputStream fos = null;
	try {
		//System.out.println(2/0);
		fos = new FileOutputStream("D:\\a.txt");
		fos.write(97);
	}catch(IOException e){
	   e.printStackTrace();
	}finally {
		//finally语句里面的代码,一定会被执行.
		if(fos != null){
			try {
				fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

3.4 字节流读数据

字节输入流

• FileInputStream(String name)通过打开与实际文件的连接来创建一个FileInputStream该文件由文件系统中的路径名name命名

字节输入流读取数据的步骤

• 创建字节输入流对象
• 调用字节输入流对象的读数据方法
• 释放资源

1. 一次读一个字节数据

public static void main(String[] args) throws IOException {
	//如果文件存在,那么就不会报错.
	//如果文件不存在,那么就直接报错.
	FileInputStream fis = new FileInputStream("bytestream\\a.txt");

	int read = fis.read();
	//一次读取一个字节,返回值就是本次读到的那个字节数据.
	//也就是字符在码表中对应的那个数字.
	//如果我们想要看到的是字符数据,那么一定要强转成char

	System.out.println(read); // 97
	System.out.println((char)read); //a

	//释放资源
	fis.close();
}

2. 一次读多个字节数据

public static void main(String[] args) throws IOException {
	FileInputStream fis = new FileInputStream("bytestream\\a.txt");
	//文件中多个字节我怎么办?
	/*while(true){
		int i1 = fis.read(); 内容读取结束读取到空格时返回-1
		System.out.println(i1); 
	}*/ 

	int b;
	while ((b = fis.read())!=-1){
		System.out.println((char) b);
	}
	fis.close();
}

3.5 字节流复制文件

1. 小文件复制

将C:\it\a.jpg的文件复制到模块bytestream下

public static void main(String[] args) throws IOException {
	//创建了字节输入流,准备读数据.
	FileInputStream fis = new FileInputStream("C:\\it\\a.jpg");
	//创建了字节输出流,准备写数据.
	FileOutputStream fos = new FileOutputStream("bytestream\\a.jpg");

	int b;
	while((b = fis.read())!=-1){
		fos.write(b);
	}

	fis.close();
	fos.close();
}

2. 大文件复制

对于大文件的复制问题字节流通过创建字节数组可以一次读写多个数据

一次读一个字节数组的方法

• public int read(byte[] b)从输入流读取最多b.length个字节的数据
• 返回的是读入缓冲区的总字节数也就是实际的读取字节个数

public static void main(String[] args) throws IOException {
	FileInputStream fis = new FileInputStream("C:\\itheima\\a.avi");
	FileOutputStream fos = new FileOutputStream("bytestream\\a.avi");

	byte [] bytes = new byte[1024];// 该字节数组的大小是1024字节
	int len;//本次读到的有效字节个数 --- 这次读了几个字节

	while((len = fis.read(bytes))!=-1){  // 循环读取
		fos.write(bytes,0,len);//0索引开始读取len个字节
	}

	fis.close();
	fos.close();
}

4 字节缓冲流

4.1 字节缓冲流概述

• BufferedOutputStream该类实现缓冲输出流通过设置这样的输出流应用程序可以向底层输出流写入字节而不必为写入的每个字节导致底层系统的调用
• BufferedInputStream创建BufferedInputStream将创建一个内部缓冲区数组当从流中读取或跳过字节时内部缓冲区将根据需要从所包含的输入流中重新填充一次很多字节

4.2 字节缓冲流构造方法

1. 一次读写一个字节

public static void main(String[] args) throws IOException {
	//就要利用缓冲流去拷贝文件

	//创建一个字节缓冲输入流
	//在底层创建了一个默认长度为8192的字节数组。
	BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bytestream\\a.avi"));
	//创建一个字节缓冲输出流
	//在底层也创建了一个默认长度为8192的字节数组。
	BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bytestream\\copy.avi"));

	int b;
	while((b = bis.read()) != -1){
		bos.write(b);
	}

	//方法的底层会把字节流给关闭。
	bis.close();
	bos.close();
}

2. 一次读写一个字节数组

public static void main(String[] args) throws IOException {
	//缓冲流结合数组进行文件拷贝

	//创建一个字节缓冲输入流
	BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bytestream\\a.avi"));

	//创建一个字节缓冲输出流
	BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bytestream\\copy.avi"));

	byte [] bytes = new byte[1024];
	int len;
	while((len = bis.read(bytes)) != -1){
		bos.write(bytes,0,len);
	}

	bis.close();
	bos.close();
}

为什么构造方法需要的是字节流而不是具体的文件或者路径呢

• 字节缓冲流仅仅提供缓冲区而真正读写数据还是得依靠基本的字节流对象进行操作

4.3 小结

字节流

• 可以操作拷贝所有类型的文件

字节缓冲流

• 可以提高效率
• 不能直接操作文件需要传递字节流

拷贝文件的四种方式

• 字节流一次读写一个字节
• 字节流一次读写一个字节数组
• 字节缓冲流一次读写一个字节
• 字节缓冲流一次读写一个字节数组