Java内容梳理（18）API学习（6）I/O流

目录：

1、I/O流的分类

2、常用的I/O流

3、对象的序列化和反序列化

4、对象克隆

5、图片操作

---

1、I/O流的分类

（1）介绍

流说明了Java中读写数据的方式：

顺序读写数据：从左到右，从上到下依此读取数据

数据的流动方向：单向

参照物：程序内存

（2）分类

1.按照方向分：

输入流：InputStream父类/Reader父类

输出流：OutputStream父类/Writer父类

2.按照单位分：

字节流：InputStream父类/OutputStream父类-------以字节为单位进行操作

字符流：Reader父类/Writer父类-------以字符为单位进行操作

3.按照功能分：

节点流（功能流）：提供核心基础读写数据能力的流   

识别节点流：看类名前缀，若是一种明确的数据存放地方，那个流就是节点流。

过滤流（装备流）：在节点流提供的基础能力之上进行功能加强

4、流的父类型

InputStream --- 字节输入流

OutputStream --- 字节输出流

Reader --- 字符输入流

Writer --- 字符输出流

2、常用的I/O流

（1）节点流

FileInputStream类：文件字节输入流，能实现按字节读取文件

构造方法：为欲指定的文件建立输入管道   

FileInputStream( String filepath )

读入数据：read( byte[] buf ) 返回值是int,表示读入的字节个数。

每次从硬盘上最大读满buf数组个字节，返回值为-1时，表示没有读到数据，可以通过循环读完整个文件。

FileOutputStream类：文件字节输出流，能实现将字节写入文件（追加方式和覆盖方式两种）

构造方法：与指定文件建立输出管道(默认是替换模式)

FileOutputStream( File file )

FileOutputStream( String filePath )

按指定的模式与指定的文件建立输出管道（true为追加）

FileOutputStream( File file ，boolean isAppendModel)

FileOutputStream( String filePath ，boolean isAppendModel)

写入数据：

write( byte[] buf )：每次向指定的文件写出整个buf数组个字节

write( byte[] buf,int offset,int len )：从buf数组的offset位置开始，写出len长度的字节

注意：

1.当输出的目标文件不存在时，会自动将其创建

2.输出流默认采用替换方式，不会追加

3.当文件是文本文件时，可以使用字符输入流（FileReader），字符输出流（FileWriter），效率更高。

（2）缓冲过滤流

核心：与磁盘交互的过程是由JVM自动管理，我们都从缓冲区读写数据，一般在字符输入，输出流的基础上使用

BufferedInputStream类  和  BufferedOutputStream类 不常用

BufferedReader类:  带缓冲的字符输入流（将文件数据读取到内存）

构造方法：要依赖于另外一个流来创建 

BufferedReader( Reader in ) 在指定的字符输入流上创建一个缓冲流（默认8k）

BufferedReader( Reader in ,int size)  在指定的字符输入流上创建一个size大小的缓冲流

读方法：

String readLine():  读取一行数据（换行符或回车符表示一行读完）

过程：

BufferedWriter类:带缓冲的字符输出流（将内存数据写到文件中）

不常用，通常情况下我们会使用PrintWriter流替代这个类；

调用写方法时，并不直接向文件输出，而是写到流的缓冲区中；

当缓冲区满了时JVM才会将缓冲区中的数据一次性提交到文件中；

当我们调用close()方法时，JVM在关流之前会将缓冲区中的数据提交到文件；

不关流的情况下可以使用flush()方法，强制将缓冲区中的数据提交一次。

（3）转换流（也是一种过滤流，提升数据处理单位）

InputStreamReader类 作用：InputStream ---> Reader

OuputStreamReader类  不常用，被PrintWriter代替

如下：is是InputStream字节输入流，由InputStreamReader转换成了BufferedReader缓冲字符输入流

（4）特殊流

PrintWriter类，既可以当作节点流，也可以当作过滤流，还可以当作转化流来使用

举例：用PrintWriter去实现文本文件的复制

package stream;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class PrintWriterStream {
	public static void main(String[] args) {
		File file = new File("src/a.txt");
		try {
			/**
			 * 先用字符缓冲输入流BufferedReader将文件和内存建立通道,需要用该流读取文件数据
			 * BufferedReader对象的创建，要依赖另一个字符流创建
			 * 构造方法有2个：BufferedReader( Reader in ); BufferedReader( Reader in ,int size)
			 */
			BufferedReader reader = new BufferedReader(
					new InputStreamReader( new FileInputStream(file) )
			);
			
			//测试文件是否找到
			System.out.println(file.exists());
			
			//建立内存和b.txt文件的输出通道，需要用PrintWriter流写数据到b.txt中,若没有b.txt会自动新建一个
			PrintWriter writer = new PrintWriter("src/b.txt");
			String str = reader.readLine();
			while(str != null) {
                //注意writer.println(line);在输出到bbb之后，会多一个换行	
				writer.println(str);	//用PrintWriter流写数据到b.txt中
				str = reader.readLine();
			}
			
			writer.flush();//强制提交一次，确保提交
			
			reader.close();//关流
			writer.close();//关流
			
		} catch ( IOException e) {
			e.printStackTrace();
		}
	}
}

3、对象的序列化和反序列化

前提：

该对象的类型必须实现Serializable接口；否则报NotSerializableException异常

对象的序列化：（内存对象输出（写）到文件）

ObjectOutputStream类 writeObject方法 将内存中的对象输出

对象的反序列化：（读取文件数据，解析读取出来的对象）

ObjectInputStream类 readObject方法

transient关键字：

当前进行对象序列化，将不会对transient修饰的属性进行序列化

private static final long serialVersionUID = 1L;

反序列化是否成功主要依据serialVersionUID的值

举例：将自定义对象写到文件中，再从文件中读取出来，输出到控制台上

第一步：将对象从内存写到文件

public class Student implements Serializable{
	private static final long serialVersionUID = 1L;
	
	private String name;
	private int age;
	
	
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
//...省略get和set方法
}

package stream;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Run {
	public static void main(String[] args) {
		Student stu1 = new Student("Jack",18);
		Student stu2 = new Student("Rose",13);
	
		try {
			/*建立内存和文件的输出通道*/
			ObjectOutputStream oos = new ObjectOutputStream(
					//true表示追加，后一个写进文件的数据不会覆盖前一个
					new FileOutputStream("src/c.txt",true)
			);
			
			/*将两个Student对象写（输出）到文件c.txt中去*/
			oos.writeObject(stu1);
			oos.writeObject(stu2);
			
			/*关流*/
			oos.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

第二步：从文件中读取数据到内存，并输出到控制台上；为了代码完整，在上面的代码上添加

package stream;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Run {
	public static void main(String[] args) {
		Student stu1 = new Student("Jack",18);
		Student stu2 = new Student("Rose",13);
	
		try {
			/*建立内存和文件的输出通道*/
			ObjectOutputStream oos = new ObjectOutputStream(
					//true表示追加，后一个写进文件的数据不会覆盖前一个
					new FileOutputStream("src/c.txt",true)
			);
			
			/*将两个Student对象写（输出）到文件c.txt中去*/
			oos.writeObject(stu1);
			oos.writeObject(stu2);
			
			/*关流*/
			oos.close();
			
			ObjectInputStream ois = new ObjectInputStream(
					new FileInputStream("src/c.txt")
			);
			
			Student s1 = (Student)ois.readObject();
			System.out.println(s1);
			
			Student s2 = (Student)ois.readObject();
			System.out.println(s2);
			
			ois.close();
		} catch (IOException | ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
}

4、对象克隆

含义：

复制一个副本，并不是同一个对象

浅克隆：

能被浅克隆的前提是：

类型必须实现Clonable接口，没有任何抽象方法，称为标识接口

仅复制一层 Object中的clone方法是浅克隆

深克隆：

所有层次均复制一个副本

利用对象的序列化和反序列化来完成深克隆：

ByteArrayInputStream类

ByteArrayOutputStream类

来完成内存到内存，再到内存的一个深克隆的过程，把对象转化成Byte数组，再转化成对象

浅克隆举例：

package clone;


public class Resume implements Cloneable{
	
	private String name;
	private int age;
	private WorkExperience work;
	

	public Resume(String name, int age, WorkExperience work) {
		super();
		this.name = name;
		this.age = age;
		this.work = work;
	}
	

	public WorkExperience getWork() {
		return work;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public void setWork(WorkExperience work) {
		this.work = work;
	}




	//Object中clone（）方法是被声明为protected
	//protected被修饰的方法只能在本类，同一个包中的类，或它的子类中使用；
	public Resume Clone() {
		try {
			return (Resume) this.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return null;
	}

	@Override
	public String toString() {
		return "Resume [name=" + name + ", age=" + age + ", work=" + work + "]";
		
	}
	
	
}

package clone;

public class WorkExperience {
	private String timeArea;
	private String company;
	
	public WorkExperience(String timeArea, String company) {
		super();
		this.timeArea = timeArea;
		this.company = company;
	}

	@Override
	public String toString() {
		return "WorkExperience [timeArea=" + timeArea + ", company=" + company + "]";
	}

	public String getTimeArea() {
		return timeArea;
	}

	public void setTimeArea(String timeArea) {
		this.timeArea = timeArea;
	}

	public String getCompany() {
		return company;
	}

	public void setCompany(String company) {
		this.company = company;
	}
	
	
}

package clone;

public class Run {
	public static void main(String[] args) {
		WorkExperience work1 = new WorkExperience("1999-2008", "中国航空公司");
		Resume r1 = new Resume("小明", 12, work1) ;
		System.out.println(r1);
		Resume r2 =(Resume) r1.Clone();
		System.out.println(r2);
		
		System.out.println(r1 == r2);//显示false，表示克隆出来的对象和原来的对象不是一个
		System.out.println(r1.getWork() == r2.getWork());//显示true，表示它们内部的WorkExperience对象其实是一个
		
		//上面的测试表明，浅克隆其实只复制了一层对象，对象中的对象并没有克隆，String对象是特殊对象，也被复制了一份
		//再测试：如修改work1的内容两个Resume的WorkExperience都会改变；但r2改变name不会影响r1
		work1.setCompany("美国白宫");
		r2.setName("小红");
		System.out.println(r1);
		System.out.println(r2);
		
	}
}

举例：深克隆：利用对象序列化实现深克隆；A对象被序列化，而B是A下的属性也会被序列化，C在B类下，也会被序列化；序列化完成再反序列化成对象；赋值给新的A对象，就实现了深克隆。

5、图片操作

1、图片类： java.awt.Image类

用来表示图片数据 是一个抽象类，是所有图片类的父类

BufferedImage类 是Image类的实现类，封装了图片数据

2、图片读写： 主要用的是BufferedImage类

当程序需要使用一张图片时（或者需要使用到BufferedImage类对象时），我们可以利用ImageIO来读写图片。

ImageIO的用法（了解）：

BufferedImage read( File file ): 加载指定的图片文件到内存（通常用来加载本地文件）

BufferedImage read( URL url ) 加载指定url位置上的图片文件到内存（通常用来加载网络图片）

BufferedImage read( InputStream input ) 将图片数据在网络上传输

write( File file )

write( OutputStream output )