theone_ID

java笔记——IO框架

1.流的概念

2.流的分类

3.字节流

3.1文件字节流

3.2案例进行图片复制

3.3字节缓冲流

4.对象流

5序列化和反序列化

5.1序列化

5.2反序列化

注意：

6.字符编码

7.字符流

7.1字符流的父类（抽象类）

7.2文件字符流

案例：使用FileReader和FileWriter复制文本文件

7.3字符缓冲流

7.4PrintWriter

7.5转换流

8.File类

文件操作：

文件夹操作：

8.1FileFilter接口

案例1：遍历文件夹

案例2：递归删除文件夹

学习目标：

1.流的概念	4.编码方式
2.流的分类	5.字符流
3.字节流	6.File类

1.流的概念

内存与存储设备之间传输数据的通道

2.流的分类

按方向【重点】

输入流：将<存储设备>中的内容读到<内存>中
输出流：将<内存>中的内容写到<存储设备>中

按单位

字节流：以字节为单位，可以读写所有数据
字符流：以字符为单位，只能读写文本数据

按功能

节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础之上增强功能

3.字节流

字节流的父类（抽象类）

InputStream：字节输入流
1. 此抽象类是表示字节输入流的所有类的超类


//InputStream 字节输入流
public int read(){}
public int read(byte[] b){}
public int read(byte[] b, int off, int len){}

OutputStream:字节输出流
1. 此抽象类是表示字节输出流的所有类的超类

// OutputStream 字节输出流
public void write(int n){}
public void write(byte[] b){}
public void write(byte[] b, int off, int len){}

3.1文件字节流

FileInputStream:
- . public int read (byte[] b)//从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数;如果达到文件的尾部，则返回-1。

psvm(String[] args) throws Exception{
  // 1 创建FileInputStream 并指定文件路径
  FileInputStream fis = new FileInputStream("d:\\abc.txt");
  // 2 读取文件
  // fis.read();
  // 2.1单字节读取
  int data = 0;
  while((data = fis.read()) != -1){
    sout((char)data);
  }
  // 2.2 一次读取多个字节
  byte[] buf = new byte[3]; // 大小为3的缓存区
  int count = fis.read(buf); // 一次读3个
  sout(new String(buf));
  sout(count);
  int count2 = fis.read(buf); // 再读3个
  sout(new String(buf));
  sout(count2);
  
  // 上述优化后
  int count = 0;
  while((count = fis.read(buf)) != -1){
    sout(new String(buf, 0, count));
  }
  
  // 3 关闭
  fis.close();
}

FileOutputStream:
- public void write(byte[] b)//一次写多个字节将b数组中所有字节,写入输出流。

package com.study.BytesMessage;

import java.io.FileOutputStream;

/*
 * FileOutputStream使用
 * 文件字节输出流
 * */
public class FileOutputStreamDemo {
	public static void main(String[] args) throws Exception{
		//创建FileOutputStream文件字节输出流
		FileOutputStream fos=new FileOutputStream("d:\\fos.txt");
        //加上,true可以在同一个文件重复写
		//写入文件
		fos.write(97);
		fos.write('b');
		fos.write('c');
		//多字节输入
		String string="\n"+"Hello Word!";
		fos.write(string.getBytes());
		fos.close();
		System.out.println("工作完成");
	}
}

3.2案例进行图片复制

package com.study.BytesMessage;

import java.io.FileInputStream;
import java.io.FileOutputStream;

/*
 * 使用文件字节流实现文件的复制
 * */
public class demo {
	public static void main(String[] args) throws Exception {
		//创建文件输入流
		FileInputStream fis=new FileInputStream("d:\\001.png");
		//创建输出流
		FileOutputStream fos=new FileOutputStream("d:\\002.png");
		byte[] buf=new byte[512];
		int count=0;
		while ((count=fis.read(buf))!=-1) {
			fos.write(buf, 0, count);
		}
		fis.close();
		fos.close();
		System.out.println("复制完成");
	}
}

3.3字节缓冲流

缓冲流：BufferedInputStream/ BufferedOutputStream

提高IO效率，减少访问磁盘次数
数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close

BufferedInputStream：

package com.study.BytesMessage;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/*
 * 字节缓冲流
 * BufferedInputStream的使用
 * */
public class BufferedInputStreamDemo {
	public static void main(String[] args) throws Exception {
		FileInputStream fil=new FileInputStream("d:\\file.txt");
		BufferedInputStream bis=new BufferedInputStream(fil);
		//BufferedInputStream存在是为了FileInputStream服务的
		//要使用BufferedInputStream就要有一个节点流
		//BufferedInputStream自带的缓冲去大小8k
//		int data=0;
//		while ((data=bis.read())!=-1) {
//			System.out.println((char)data);
//		}
		//也可以自定义缓冲区
		byte[] buf=new byte[1024];
		int count=0;
		while ((count=bis.read(buf))!=-1) {
			System.out.println(new String(buf, 0, count));
		}
		bis.close();//关闭缓冲流，节点流也会关闭
		System.out.println("工作完成");
	}
}

BufferedOutputStream：

package com.study.BytesMessage;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

/*
 * 字节缓冲流
 * BufferedOutputStream的使用
 * */
public class BufferedOutputStreamDemo {
	public static void main(String[] args) throws Exception {
		FileOutputStream fileOutputStream=new FileOutputStream("d:\\bos.txt");
		BufferedOutputStream bos=new BufferedOutputStream(fileOutputStream);
		//BufferedOutputStream同理
		for(int i=0;i<10;i++) {
			bos.write("Hello Word!\n".getBytes());//此时只是把字节存入8k缓冲区中
			bos.flush();//要不断刷新
		}
	}
}

4.对象流

ObjectOutputStream / ObjectInputStream

增强了缓冲区功能
增强了读写8种基本数据类型和字符串的功能
增强了读写对象的功能
1. readObject() 从流中读取一个对象
2. writeObject(Object obj) 向流中写入一个对象

使用流传输对象的过程称为序列化、反序列化

5序列化和反序列化

5.1序列化

/*
 * 使用ObjectOutputStream实现对象的序列化
 *要求序列化的类要实现Serializable接口
 * */
public class ObjectOutputStreamDemo {
	public static void main(String[] args) throws Exception {
		//创建对象流与缓冲流同理
		FileOutputStream fos=new FileOutputStream("d:\\stu.bin");
		ObjectOutputStream oos=new ObjectOutputStream(fos);
		//序列化（写入操作）
		Student hcq=new Student("hcq", 22);
		oos.writeObject(hcq);
		oos.close();
		System.out.println("工作完成");
		//首次运行会出现报错
		//要对student类里标记一个接口Serializable
	}
}

5.2反序列化

/*
 * 使用ObjectInputStream实现反序列化（读取重构对象）
 * */
public class ObjectInputStreamDemo {
	public static void main(String[] args) throws Exception{
		//创建对象流
		FileInputStream fis=new FileInputStream("d:\\stu.bin");
		ObjectInputStream ois=new ObjectInputStream(fis);
		//读取文件（反序列化）
		Student s=(Student)ois.readObject();
		//关闭
		ois.close();
		System.out.println("工作wc");
		System.out.println(s.toString());
	}
}

注意：

某个类要想序列化必须实现Serializable接口
序列化类中对象属性要求实现Serializable接口
序列化版本号ID，保证序列化的类和反序列化的类是同一个类
使用transient修饰属性，这个属性就不能序列化
静态属性不能序列化
序列化多个对象，可以借助集合来实现

6.字符编码

ISO-8859-1收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
UTF-8 针对Unicode码表的可变长度字符编码
GB2312 简体中文（95年前使用）
GBK 简体中文、扩充（是GB2312的升级）
BIG5台湾,繁体中文
当编码方式和解码方式不一致时, 会出现乱码。

7.字符流

public static void main(String[] args) throws Exception{
		//传统字节流读取
		FileInputStream fis=new FileInputStream("d:\\hello.txt");
		int data=0;
		while ((data=fis.read())!=-1) {
			System.out.print((char)data);
		}
		fis.close();
		/*第一次文本内容：helloword
		 * 输出：helloword
		 * 第二次文本内容：好好学习
		 * 输出：????????????乱码
		 * 因为文本使用utf_8编码4个汉字12字节，一个汉字3字节
		 * 而FileInputStream是一个字节一个字节的读
		 * 无法凑成一个汉字所需的3个字节，所以乱码
		 * */
	}

7.1字符流的父类（抽象类）

reader 字符输入流：

public int read(){}
public int read(char[] c){}
public int read(char[] b, int off, int len){}

Writer 字符输出流：

public void write(int n){}
public void write(String str){}
public void write(char[] c){}

7.2文件字符流

FileReader:

public int read(char[] c)//从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数;如果达到文件的尾部，则返回-1。

package com.study.Characterstream;

import java.io.FileReader;
import java.io.FileWriter;
import java.nio.charset.Charset;

public class FileReaderDemo {
	public static void main(String[] args) throws Exception {
		//创建
		FileReader fr=new FileReader("d:\\hello.txt");
		//2.1单个字符写入
//		int data=0;
//		while ((data=fr.read())!=-1) {
//			System.out.print((char)data);
//		}
		//2.2自定义数组读
		char[] buf=new char[1024];
		int count=0;
		while ((count=fr.read(buf))!=-1) {
			System.out.println(new String(buf, 0, count));
		}
		fr.close();
		
	}
}

FileWriter:

public void write(String str)//一次写多个字符，将b数组中所有字符，写入输出流。

package com.study.Characterstream;

import java.io.FileWriter;

public class FileWriterDemo {
	public static void main(String[] args) throws Exception{
		//创建FileWriter对象
		FileWriter fw=new FileWriter("d:\\FileWriter.txt");
		//写入
		for (int i = 0; i < 10; i++) {
			fw.write("好好学java"+"\n");
			fw.flush();
		}
		fw.close();
		System.out.println("工作完成");
	}
}

案例：使用FileReader和FileWriter复制文本文件

注意：二者只可以复制文本文件，无法复制图片和其他二进制文件

package com.study.Characterstream;

import java.io.FileReader;
import java.io.FileWriter;

/*
 * 使用FileReader和FileWriter复制文本文件
 * 注意：二者只可以复制文本文件，无法复制图片和其他二进制文件
 * */
public class Demo2 {
	public static void main(String[] args) throws Exception{
		FileReader fr=new FileReader("d:\\FileWriter.txt");
		FileWriter fw=new FileWriter("d:\\FileWriter2.txt");
		int data=0;
		while ((data=fr.read())!=-1) {
			fw.write(data);
			fw.flush();
		}
		fr.close();
		fw.close();
		System.out.println("工作完成");
	}
}

7.3字符缓冲流

BufferedReader / BufferedWriter

高效读写
支持输入换行符
可一次写一行读一行

bufferedReader：

package com.study.Characterbufferstream;

import java.io.BufferedReader;
import java.io.FileReader;

/*
 * 字符缓冲流
 * */
public class bufferedReaderDemo {
	public static void main(String[] args) throws Exception {
		//创建字符缓冲流，要配合字符流使用
		FileReader fr=new FileReader("d:\\FileWriter.txt");
		BufferedReader br=new BufferedReader(fr);
		//读取
		//自定义区间读取
//		char[] buf=new char[1024];
//		int count=0;
//		while ((count=br.read(buf))!=-1) {
//			System.out.println(new String(buf, 0, count));
//		}
		//一行一行读
		String line=null;
		while ((line=br.readLine())!=null) {
			System.out.println(line);
		}
		br.close();
	}
}

BufferedWriter：

package com.study.Characterbufferstream;

import java.io.BufferedWriter;
import java.io.FileWriter;

public class bufferedWriterDemo {
	public static void main(String[] args) throws Exception {
		//创建，同理
		FileWriter fw=new FileWriter("d:\\buff.txt");
		BufferedWriter bw=new BufferedWriter(fw);
		//写入
		for (int i = 0; i < 10; i++) {
			bw.write("好好学习，天天向上");
			bw.newLine();//插入一个换行符，兼容性更好
			bw.flush();
		}
		bw.close();
		System.out.println("工作完成");
	}
}

7.4PrintWriter

封装了print() / println() 方法支持写入后换行

支持数据原样打印

package com.study.Characterstream;

import java.io.PrintWriter;

/*
 * PrintWriter的使用
 * 封装了print() / println() 方法 支持写入后换行
 * 支持数据原样打印
 * */
public class PrintWriterDemo {
	public static void main(String[] args)  throws Exception {
		//创建
		PrintWriter pw=new PrintWriter("d:\\println.txt");
		//打印
		pw.println(true);
		pw.println(3.14);
		pw.println("hcq");
		pw.println(97);
		pw.println('a');
		char[] arr={'a','b','c'};
		pw.println(arr);
		pw.close();
		System.out.println("工作完成");
	}
}