JAVA 基础学习之IO 流技术

ゝ一纸荒年。 2023-05-29 13:28 44阅读 0赞

# IO 流 #

##  ##

## 1、概念： ##

对于任何程序设计语言而言，输入输出(Input/Output)系统都是非常核心的功能。输入(Input)指的是：可以让程序从外部系统获得数据(核心含义是“读”，读取外部数据)。输出(Output)指的是：程序输出数据给外部系统从而可以操作外部系统(核心含义是“写”，将数据写出到外部系统)。本章主要围绕着**读和写**这样两个动作来学习

### 1.1、按的细分 ###

> 1.     按流的方向分类：输入流（InputStream、Reader）和输出流(OutputStream、Writer)。
> 2.   按处理的数据单元分类：
>     
>     字节流：以字节为单位获取数据，命名上以Stream结尾的流一般是字节流，如  FileInputStream、FileOutputStream。
>     
>     字符流：以字符为单位获取数据，命名上以Reader/Writer结尾的流一般是字符流，如FileReader、FileWriter。
> 3.  按处理对象不同分类：
> 
>           节点流：可以直接从 “数据源或目的地” 读写数据，
> 
>           处理流：不直接连接到数据源或目的地，是处理流的流。通过对其他流的处理提高程序的性能。（也可以说是直接处理或优化那些节点流）

### 1.2、IO流类的体系 ###

1、字节流的抽象类。

> InputStream / OutputStream

2、字符流的抽象类

> Reader / Writer

3、节点流：以字节为单位直接操作“文件”。

> FileInputStream / FileOutputStream

4、节点流：以字节为单位直接操作“字节数组对象”，也有字符数组对象。

> ByteArrayInputStream / ByteArrayOutputStream  CharArrayReader / CharArrayWriter //字符数组对象

5、处理流：以字节为单位可以直接操作“对象”，也可以直接操作“基本数据类型与字符串类型”。

> ObjectInputStream / ObjectOutputStream

6、处理流：以字节为单位直接操作“基本数据类型与字符串类型”。

> DataInputStream / DataOutputStream

7、节点流：以字符为单位直接操作“文本文件”(注意：只能读写文本文件)。

> FileReader / FileWriter

8、处理流：将Reader/Writer对象进行包装，增加缓存功能，提高读写效率。

> BufferedReader / BufferedWriter

9、处理流：将InputStream/OutputStream对象进行包装，增加缓存功能，提高读写效率。

> BufferedInputStream / BufferedOutputStream

10、处理流：将字节流对象转化成字符流对象。

> InputStreamReader / OutputStreamWriter

11、处理流：将OutputStream进行包装，可以方便地输出字符，更加灵活。（打印流）

> PrintStream

### 1.3、四大IO抽象类 ###

**1、InputStream**

**         ** 是一个抽象类， 是字节输入流的所有类的父类。

常用方法：

int read()：读取一个字节的数据，并将字节的值作为int类型返回(0-255之间的一个值)。如果未读出字节则返回-1(返回值为-1表示读取结束)。

void close()：关闭输入流对象，释放相关系统资源。

**2、OutputStream**

**       ** 是一个抽象类， 是字节输出流的所有类的父类。

常用方法：

void write(int n)：向目的地中写入一个字节。

void close()：关闭输出流对象，释放相关系统资源。

**3、Reader**

**       ** Reader用于读取(输入)的字符流抽象类，数据单位为字符。

int read(): 读取一个字符的数据，并将字符的值作为int类型返回(0-65535之间的一个值，即Unicode值)。如果未读出字符则返回-1(返回值为-1表示读取结束)。

void close() ：关闭流对象，释放相关系统资源。

**4、Writer**

Writer用于写入（输出）的字符流抽象类，数据单位为字符。

void write(int n)： 向输出流中写入一个字符。

void close() ： 关闭输出流对象，释放相关系统资源。

**总结**：字符输入 / 输出(名字)和字节输入 / 输出(名字)的常用方法名字都是一样的。

## 2、流的使用 ##

###   2.1、文件字节流 ###

**2.1.1、文件输入流**

FileInputStream通过字节的方式读取文件，适合读取所有类型的文件(图像、视频、文本文件等)。

public static void byteFun1(String file) {
    		InputStream in=null;
    		try {
    			in=new FileInputStream(file);
    			//为了提高效率，设置缓存数组！
                  //（读取的字节数据会暂存放到该字节数组中）
    			byte[] bs=new byte[1024];
    			int count=0;
                //count指的是本次读取的真实长度，count等于-1时表示读取结束
    			while((count=in.read(bs))!=-1) {
    				//Charset.forName("gbk") 设置编码格式			
         System.out.println(new String(bs,0,count,Charset.forName("gbk")));
    			}
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally {
    			try {
    				in.close();//用完流记得关闭
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}

**2.1.2、文件输出流**

FileOutputStream 通过字节的方式写数据到文件中，适合所有类型的文件。

public static void byteFun(String file,String str) {
    		OutputStream on=null;
    		try {
               //1，连接到目的地
    			on=new FileOutputStream(file);
               //2，需要将转换成字节类型
    		    on.write(str.getBytes());
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally {
    			try {
                   //3、用完流记得关闭
    				on.close();
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}

**注意**：1. 为了减少对硬盘的读写次数，提高效率，通常设置缓存数组。

2. 程序中如果遇到多个流，每个流都要单独关闭。

### 2.2、文件字符流 ###

**2.2.1、输入流**

FileReader专门读取文本文件。

public static void charsFun(String file) {
    		Reader reader=null;
    		try {
    			reader=new FileReader(file);
                //为了提高效率，创建缓冲用的字符数组
    			char[] cs=new char[1024];
    			int count=0;
        //count指的是本次读取的真实长度，count等于-1时表示读取结束
    			while((count=reader.read(cs))!=-1) {
    				System.out.println(new String(cs,0,count));
    			}
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally {
    			try {
    				reader.close();
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}

**2.2.2、输出流**

FileWriter专门写入文本文件

public static void charsFun(String file,String str) {
    		Writer writer=null;
    		try {
    			writer=new FileWriter(file);
    			writer.write(str);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally {
    			try {
    				writer.close();
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}

### 3、缓冲流 ###

通过内部缓存数组来提高操作流的效率。

**3.1、字节缓冲流**

public class TestBuffed {
    	public static void main(String[] args) {
    		long t1=System.currentTimeMillis();
    		copyFile1("F:\\图片\\壁纸包\\合作企业.png","I:\\面试技巧\\test\\来越传奇.png");
    		long t2=System.currentTimeMillis();
    		System.out.println("使用缓冲："+(t2-t1));
    		System.out.println("--------");
    		long t3=System.currentTimeMillis();
    		copyFile2("F:\\图片\\壁纸包\\合作企业.png","I:\\面试技巧\\test\\来越传奇1.png");
    		long t4=System.currentTimeMillis();
    		System.out.println("不使用缓冲"+(t4-t3));
    		
    	}
    	//不使用缓冲
    	public static void copyFile2(String str,String str2) {
    		FileInputStream in=null;//读
    		FileOutputStream ou=null;//写
    		int count=0;
    		try {
    			in=new FileInputStream(str);
    			ou=new FileOutputStream(str2);
    			//使用缓冲字节流包装文件字节流，增加缓冲功能，提高效率
                //缓存区的大小（缓存数组的长度）默认是8192，也可以自己指定大小
    			while((count=in.read())!=-1) {
    				ou.write(count);
    				//System.out.println(count);
    			}
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally {
                try {
                	if (in != null) {
                    	in.close();
                    }
                    if (ou != null) {
                        ou.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
    		}
    	}
    	public static void copyFile1(String str,String str2) {
    		FileInputStream in=null;//读
    		FileOutputStream ou=null;//写
    		BufferedInputStream bi=null;
    		BufferedOutputStream bo=null;
    		int count=0;
    		try {
    			in=new FileInputStream(str);
    			ou=new FileOutputStream(str2);
    			bi=new BufferedInputStream(in);
    			bo=new BufferedOutputStream(ou);
    			while((count=bi.read())!=-1) {
    				bo.write(count);
    			}
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally {
                try {
                	if (bi != null) {
                        bi.close();
                    }
                	if (bo != null) {
                        bo.close();
                    }
                    if (ou != null) {
                        ou.close();
                    }
                	if (in != null) {
                    	in.close();
                    }
                	
                } catch (IOException e) {
                    e.printStackTrace();
                }
    		}
    	}
    }

![20191106165026748.png][]

**注意**： 1. **在关闭流时，应该先关闭最外层的包装流，即“后开的先关闭”。**

2. 缓存区的大小默认是8192字节，也可以使用其它的构造方法自己指定大小。

**3.2、缓冲字符流**

其实缓冲字节流跟字符流操作都差不多

不一样的地方：就是读取文件的方式不一样

//BufferedReader提供了更方便的readLine()方法，直接按行读取文本
                //br.readLine()方法的返回值是一个字符串对象，即文本中的一行内容
                while ((tempString = br.readLine()) != null) {
                    //将读取的一行字符串写入文件中
                    bw.write(tempString);
                    //下次写入之前先换行，否则会在上一行后边继续追加，而不是另起一行
                    bw.newLine();
                }

**注意**

1. readLine()方法是BufferedReader特有的方法，可以对文本文件进行更加方便的读取操作。

2. 写入一行后要记得使用newLine()方法换行。

**3.3、字节数组流**

ByteArrayInputStream则是把内存中的”某个字节数组对象”当做数据源。进行读和写操作。

**3.4、数据流**

public class TestData {
    	public static void main(String[] args) {
    		DataOutputStream dos=null;
    		DataInputStream dis=null;
    		FileInputStream fis=null;
    		FileOutputStream fos=null;
    		try {
    			fos=new FileOutputStream("text.txt");
    			fis=new FileInputStream("text.txt");
    			//使用数据流对缓冲流进行包装，新增缓冲功能
    			dos=new DataOutputStream(new BufferedOutputStream(fos));
    			dis=new DataInputStream(new BufferedInputStream(fis));
    			//将如下数据写入到文件中
    			dos.writeChar('A');
    			dos.writeBoolean(false);
    			dos.writeInt(1343);
    			dos.writeUTF("你好");
    			//手动刷新缓冲区：将流中数据写入到文件中
    			dos.flush();
    			//直接读取数据（需要按照写进去的顺序，读出来）
    			System.out.println("char："+dis.readChar());
    			System.out.println("boolean："+dis.readBoolean());
    			System.out.println("int："+dis.readInt());
    			System.out.println("UTF："+dis.readUTF());
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally {
          //关闭流
    			try {
    				if(dos!=null) {
    				   dos.close();
    				}
    				if(dis!=null) {
    					dis.close();
    				}
    				if(fos!=null) {
    					fos.close();
    				}
                    if(fis!=null) {
    					fis.close();
    				}
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    }

**注意**：使用数据流时，**读取的顺序一定要与写入的顺序一致，否则不能正确读取数据，很有可能报错**。

3.5、对象流

ObjectInputStream/ObjectOutputStream是以“对象”为数据源，但是必须将传输的对象进行序列化与反序列化操作。对象流既可以读取基本类型和字符串，也可以读取对象（读取对象时需要对对象进行序列化和反序列化操作）。以对象为主

> oos.writeObject(已序列化的对象);//存进序列化对象
> 
> ois.readObject();//取出序列化对象

**看下面序列化的示例；**

**注意**：

1.   对象流不仅可以读写对象，还可以读写基本数据类型。
2.   使用对象流读写对象时，该对象必须序列化与反序列化。
3.   系统提供的类(如Date等)已经实现了序列化接口，自定义类必须手动实现序列化接口。

**3.6、转换流**

InputStreamReader/OutputStreamWriter用来实现将字节流转化成字符流。也就是把字节的格式转成换字符格式，

>  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

## 4、序列化和反序列化 ##

###      4.1、什么是序列化和反序列化？ ###

把Java对象转换为字节序列的过程称为对象的序列化。把字节序列恢复为Java对象的过程称为对象的反序列化。

## ##

### 4.2、序列化的作用和什么情况下需要序列化 ###

作用：就是为了保存在内存中的各种对象的状态，并且可以把保存的对象状态再读出来。

使用：

> a）当你想把的内存中的对象保存到一个文件中或者数据库中时候；
> 
> b）当你想用套接字在网络上传送对象的时候；
> 
> c）当你想通过RMI传输对象的时候；

### 4.3、序列化的使用 ###

只有实现了Serializable接口的类的对象才能被序列化。 Serializable接口是一个空接口，只起到标记作用。

步骤：先让需要序列化的类去**实现Serializable接口后**，该该类的对象才可以被序列化，添加序列化ID，它决定着是否能够成功反序列化！

**示例：**

public class TestSerializable {
    	public static void main(String[] args) {
    		Set<Student> set=new TreeSet<>();
    		int A,B,C;
    		String str;
    		for (int i = 0; i < 50; i++) {
    			A=(int)(Math.random()*100);
    			B=(int)(Math.random()*100);
    			C=(int)(Math.random()*100);
    			str="201901";
    			str+=(i<=9)?"0"+i:""+i;
    			set.add(new Student(str,"学生"+i,A,B,C,(A+B+C)));
    		}
    		StringBuilder sb=new StringBuilder("学号\t\t姓名\t语文\t数学\t英语 \t总成绩\n");
    		for (Student s : set) {
    			sb.append(s.getNumber());
    			sb.append("\t");
    			sb.append(s.getName());
    			sb.append("\t");
    			sb.append(s.getLanguage());
    			sb.append("\t");
    			sb.append(s.getMath());
    			sb.append("\t");
    			sb.append(s.getEnglish());
    			sb.append("\t");
    			sb.append(+s.getGrade()+"\n");
    		}
    		XLH(sb);
    		FXLH();
    		
    	}
    	//反序列化
    	public static void FXLH() {
    		FileInputStream fis=null;
    		BufferedInputStream bis=null;
    		ObjectInputStream ois=null;
    		try {
    			fis=new FileInputStream("test.txt");
    			bis=new BufferedInputStream(fis);
    			ois=new ObjectInputStream(bis);
    			
    			try {
    				System.out.println(ois.readObject());
    			} catch (ClassNotFoundException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally {
    			try {
    				ois.close();
    				bis.close();
    				fis.close();
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			
    		}
    	}
    	//序列化
    	public static void XLH(StringBuilder sb) {
    		FileOutputStream fos=null;
    		BufferedOutputStream bos=null;
    		ObjectOutputStream oos=null;
    		try {
    			fos=new FileOutputStream("test.txt");
    			bos=new BufferedOutputStream(fos);
    			oos=new ObjectOutputStream(bos);
    			oos.writeObject(sb);
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally {
    			try {
    				oos.close();
    				bos.close();
    				fos.close();				
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    }
    //某校的学生期末考试成绩单 ：学号、姓名、语文、数学、英语 总成绩  假如：有50个学生
    //序列化记得先实现Serializable 接口
    class Student implements Comparable<Student>,Serializable{
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 1L;
    	private String number;
    	private String name;
    	private int language;
    	private int math;
    	private int english;
    	private int grade;
    
    	public Student(String number, String name, int language, int math, int english, int grade) {
    		super();
    		this.number = number;
    		this.name = name;
    		this.language = language;
    		this.math = math;
    		this.english = english;
    		this.grade = grade;
    	}
    	public String getNumber() {
    		return number;
    	}
    	public void setNumber(String number) {
    		this.number = number;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getLanguage() {
    		return language;
    	}
    	public void setLanguage(int language) {
    		this.language = language;
    	}
    	public int getMath() {
    		return math;
    	}
    	public void setMath(int math) {
    		this.math = math;
    	}
    	public int getEnglish() {
    		return english;
    	}
    	public void setEnglish(int english) {
    		this.english = english;
    	}
    	public int getGrade() {
    		return grade;
    	}
    	public void setGrade(int grade) {
    		this.grade = grade;
    	}
    	@Override
    	public int compareTo(Student o) {
    		// TODO Auto-generated method stub
    		return this.grade>o.grade?-1:(this.grade<o.grade?1:0);
    	}
    	
    }

**注意**：

>       1. static属性不参与序列化。
> 
>       2. 对象中的某些属性如果不想被序列化，不能使用static，而是使用transient修饰。
> 
>       3. 为了防止读和写的序列化ID不一致，一般指定一个固定的序列化ID。

### 4.4、IO流体系中的装饰器模式 ###

IO流体系中大量使用了装饰器模式，让流具有更强的功能、更强的灵活性。

例如：缓冲流，显然BufferedInputStream装饰了原有的FileInputStream，让普通的FileInputStream也具备了缓存功能，提高了效率

> FileInputStream fis = **new** FileInputStream(src);
> 
> BufferedInputStream bis = **new** BufferedInputStream(fis);

[20191106165026748.png]: https://img-blog.csdnimg.cn/20191106165026748.png