IO流

java.io包

1.什么是流？

io流就是java中运输数据的一种载体

它能够把数据从一个地方运输到另一个地方
2.流的分类

a 根据流运输数据的方向<以内存为参考物>

输入流

输出流
 b 根据数据传输时转换的类型
           字节流    byte           
           字符流    char  
           
           字符流主要运用于纯文本的传输   

3.流的体系

以上两种流的分类可以互相组合成下面四种

字节输入流   字节输出流    字符输入流   字符输出流
    整个流的体系结构如下
     closeable<可关闭的>(close())          flushable<可刷新的>(flush())
 
inputStream   OutputStream   Reader    Writer
   所有的字节输入流都是 inputStream的子类
   所有的字节输出流都是 OutputStream的子类
   所有的字符输入流都是 Reader的子类
   所有的字符输出流都是 Writer的子类
   以上4个流都实现了closeable接口
   以上2个输出流都实现了flushable接口 

4.我们要学习的流<16>

4个文件流<掌握>

FileInputStream

FileOutputStream

FileReader

FileWriter
FileInputStream fis = new FileInputStream("D:/c.txt");
	byte [] bytes = new byte[1024];
	int temp;
	while((temp=fis.read(bytes))!=-1){
		System.out.print(new String(bytes,0,temp));
	}
	
	fis.close();


/*

* 文件输出流如果指向的文件不存在

* 则会自动创建一个

*/

FileOutputStream fos = new FileOutputStream(“D:/a.txt”);
	String info = "许俊皇是个皇军";
	
	//把数据转成byte数组《String-->数组》
	byte [] bytes = info.getBytes();
	
	//fos.write(bytes);
	fos.write(bytes,0,12);
	
	//刷新  强制写入
	fos.flush();
	
	fos.close();


public static void main(String[] args) {
	FileReader fr=null;
	FileWriter fw=null;
	
	try {
		
		fr=new FileReader("D:\\b.txt");
		fw=new FileWriter("D:\\c.txt");
		
		char [] bytes=new char[100];
		int i;
		while((i=fr.read(bytes))!=-1) {
			
			fw.write(bytes,0,i);
			
		}
		
		fw.flush();
		
	}catch(IOException e){
		
		e.printStackTrace();
		
	}finally {
		
		if(fr!=null) {
			
			try {
				fr.close();
			}catch(IOException e) {
				e.printStackTrace();
			}
		}
		
		if(fw!=null) {
			try {
				fw.close();
			}catch(IOException e) {
				e.printStackTrace();
			}
			
		}
	}
}


public static void main(String[] args) {

FileInputStream file1 = null ;

FileOutputStream file2 = null;

try {
		byte[] bytes = new byte[1024];
		int a;
		while((a=file1.read(bytes))!=-1){
			file2.write(bytes,0,a);
		}
		
		file2.flush();
		
	}catch(IOException e){
		e.printStackTrace();
	}finally {
		if(file1 != null) {
			try {
				file1.close();
			}catch(IOException e){
				e.printStackTrace();
			}
			
		}
		if(file2 != null) {
			try {
				file2.close();
			}catch(IOException e){
				e.printStackTrace();
			}
			
		}
	}
}

4个缓冲流<掌握>

BufferedInputStream

BufferedOutputStream

BufferedReader

BufferedWriter
public static void main(String[] args) throws IOException {
	
	FileInputStream fis = new FileInputStream("D:/b.txt");
	
	InputStreamReader  isr = new InputStreamReader(fis);
	
	BufferedReader br = new BufferedReader(isr);
	
	String temp;
	
	while((temp=br.readLine())!=null){
		System.out.println(temp);
	}
	
	br.close();

}


public static void main(String[] args) throws IOException {

	FileWriter fw = new FileWriter("D:/b.txt");
	
	BufferedWriter bw = new BufferedWriter(fw);
    		
	bw.write("哈哈哈  许俊黄");
	bw.newLine();
	bw.write("哈哈哈  张建兵");
	bw.write("哈哈哈  许俊慌");
	
	bw.flush();		
	bw.close();

}

2个转换流<掌握>

InputStreramReader

OutputSTreamWriter
2个打印流<掌握>

PrintWriter

PrintStream
2个数据流

DataInputStream

DataOutputStream
 序列化与反序列化流

ObjectInputStream

ObjectOutputStream
java.io.File: 表示文件和文件夹类

File不是流  不能直接操作文件

IO流
IO流:
1. 字节缓冲流
2. 字符缓冲流
3. 对象流

IO流:
Reader  reader = new FileReader(File file);

Writer writer = new Writer writer(File file);
InputStream is = new FileInputStream(File file);

OutputStream os = new FileOutputStream(File file);
缓冲流: 属于功能流,用于增强性能,提高功能,提高读写速度.

功能流的使用:功能流包裹节点流.  功能流(节点流)
1. 字节缓冲流
BufferedInputStream和BufferedOutputStream
InputStream is = new BufferedInputStream(new FileInputStream("X:/xxx/xx"))
OutputStream os = new BufferedOutputStream(new FileOutputStream("X:/xxx/xx"))

2. 字符缓冲流
新增方法:  String readLine()  读取 一个文本行

void newLine() 写入一个行分隔符

BufferedRead rd = new BufferedReader(new FileReader(“X:/xxx/xx”))

BufferedWriter rw = new BufferedWriter(new FileReader(“X:/xxx/xx”))
3. 对象流
对象流:保留数据+数据类型

使用方式: 对象流包节点流  对象流(节点流)

序列化:将对象的信息状态,变为可存储,可传输的过程

序列化输出流:ObjectOutputStream(OutputStream)

新增方法: void writeObject(Object obj)将指定的对象写入objectOutputStream.

反序列化输入流 ObjectInputStream(InputStream)
注意:

不是所有类型的对象都能序列化  实现 java.io.Serializable
先序列化后反序列化  写出读入的过程一致
不是对象的所有属性都需要序列化 transient
static不能被序列化
如果父类实现了Serializable接口,子类中所有内容都能序列化
如果父类没有实现,子类实现了Serializable接口,只能序列化子类中独有的内容

public class ObjectDemo04 {
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		write("D:/bbb.txt");
		read("D:/bbb.txt");
	}
	
	//读入对象信息
	public static void read(String pathName) throws FileNotFoundException, IOException, ClassNotFoundException{
		//流
		ObjectInputStream is=new ObjectInputStream(new BufferedInputStream(new FileInputStream(pathName)));
		//读
		Person obj1=(Person)(is.readObject());
		String[] obj2=(String[])(is.readObject());
		System.out.println(obj1+"-->"+Arrays.toString(obj2));
		//关闭
		is.close();
	}
	
	//写出对象信息
	public static void write(String pathName) throws FileNotFoundException, IOException{
		//构建流
		ObjectOutputStream wr=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(pathName)));
		Person p=new Person("李毅",25,"hehe");
		String[] arr={"呵呵","哈哈"};
		//写出
		wr.writeObject(p);
		wr.writeObject(arr);
		
		p.setName("老裴");
		p.haha="lllllllllll";
		//刷出
		wr.flush();
		//关闭
		wr.close();
	}
}

class Person implements Serializable{
	private String name;
	private transient int age;
	static String haha="123345";
	public Person() {
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age,String haha) {
		super();
		this.name = name;
		this.age = age;
		this.haha=haha;
	}
	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;
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ","+age+","+haha+"]";
	}
	
}

目录

1、流的概念和作用

1.2、Java IO所采用的模型

1.3、IO流的分类

1.4、IO流特性

1.5、IO流常用到的五类一接口

1.6、Java IO流对象

1.6.1、输入字节流InputStream

1.6.2、输出字节流OutputStream

1.6.3、字符输入流Reader

1.6.4、字符输出流Writer

1.6.5、字节流和字符流使用情况：（重要）

1.7、字符流与字节流转换

1.8、字节流和字符流的区别（重点）

1.9、System类对IO的支持​

2.0、处理流BufferedReader，BufferedWriter,BufferedInputStream

2.1、什么是装饰者模式？

2.2、Scanner类

2.3、序列化

反序列化

transient关键字（一个类某些属性不需要序列化）

2.2、总结

1、流的概念和作用

流：代表任何有能力产出数据的数据源对象或者是有能力接受数据的接收端对象<Thinking in Java>

流的本质:数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。 

作用：为数据源和目的地建立一个输送通道

1.2、Java IO所采用的模型

Java的IO模型设计非常优秀，它使用Decorator(装饰者)模式，按功能划分Stream，您可以动态装配这些Stream，以便获得您需要的功能。

       例如，您需要一个具有缓冲的文件输入流，则应当组合使用FileInputStream和BufferedInputStream。

1.3、IO流的分类

              1.3.1、按数据流的方向分为 输入流、输出流

　　　　　　　　此输入、输出是相对于我们写的代码程序而言，

　　　　　　　　输入流：从别的地方(本地文件，网络上的资源等)获取资源 输入到 我们的程序中

　　　　　　　　输出流：从我们的程序中 输出到 别的地方(本地文件)， 将一个字符串保存到本地文件中，就需要使用输出流。

　　　　1.3.2、按处理数据单位不同分为 字节流、字符流  

　　　　　　　　　1字符 = 2字节 、 1字节(byte) = 8位(bit)  、 一个汉字占两个字节长度

　　　　　　　字节流：每次读取(写出)一个字节，当传输的资源文件有中文时，就会出现乱码，

　　　　　　　　字符流：每次读取(写出)两个字节，有中文时，使用该流就可以正确传输显示中文。

　　　　1.3.3、按功能不同分为 节点流、处理流

　　　　　　　   节点流：以从或向一个特定的地方（节点）读写数据。如FileInputStream　

　　　　　　　   处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，

　　　　1.3.4、4个基本的抽象流类型，所有的流都继承这四个。

　　　　　　　　　　　输入流　　　　　　输出流

　　　　　　字节流　　InputStream　　outputStream

　　　　　　字符流　　Reader　　　　　　Writer

　　　　　　inputStream：字节输入流



　　　　　　outputStream：字节输出流



　　　　　　Reader：字符输入流



　　　　　　Writer：字符输出流



　　　　　

　　　　1.5、总结流的分类

　　　　　　　　看上面的几个分类，可能对于初次学io的同学会感觉到有些混乱，那什么时候用字节流，什么时候该用输出流呢？其实非常简单，举一个例子就学会了，


　　　　　　　　1、首先自己要知道是选择输入流还是输出流，这就要根据自己的情况而定，如果你想从程序写东西到别的地方，那么就选择输出流，反之用输入流

　　　　　　　　2、然后考虑你传输数据时，是选择使用字节流传输还是字符流，也就是每次传1个字节还是2个字节，有中文肯定就选择字符流了。（详情见1.8）

　　　　　　　　3、前面两步就可以选出一个合适的节点流了，比如字节输入流inputStream，如果要在此基础上增强功能，那么就在处理流中选择一个合适的即可。


字符流的由来： Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。

1.4、IO流特性

1、先进先出，最先写入输出流的数据最先被输入流读取到。

2、顺序存取，可以一个接一个地往流中写入一串字节，读出时也将按写入顺序读取一串字节，不能随机访问中间的数据。（RandomAccessFile可以从文件的任意位置进行存取（输入输出）操作）

3、只读或只写，每个流只能是输入流或输出流的一种，不能同时具备两个功能，输入流只能进行读操作，对输出流只能进行写操作。在一个数据传输通道中，如果既要写入数据，又要读取数据，则要分别提供两个流。

1.5、IO流常用到的五类一接口

在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader；一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了。

主要的类如下：

     1. File（文件特征与管理）：File类是对文件系统中文件以及文件夹进行封装的对象，可以通过对象的思想来操作文件和文件夹。 File类保存文件或目录的各种元数据信息，包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名，判断指定文件是否存在、获得当前目录中的文件列表，创建、删除文件和目录等方法。  

     2. InputStream（二进制格式操作）：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。

     3. OutputStream（二进制格式操作）：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。

     4.Reader（文件格式操作）：抽象类，基于字符的输入操作。

     5. Writer（文件格式操作）：抽象类，基于字符的输出操作。

     6. RandomAccessFile（随机文件操作）：一个独立的类，直接继承至Object.它的功能丰富，可以从文件的任意位置进行存取（输入输出）操作。



1.6、Java IO流对象

 

1.6.1、输入字节流InputStream



认识每个类的功能即作用

　　　　　ByteArrayInputStream：字节数组输入流，该类的功能就是从字节数组(byte[])中进行以字节为单位的读取，也就是将资源文件都以字节的形式存入到该类中的字节数组中去，我们拿也是从这个字节数组中拿

　　　　　PipedInputStream：管道字节输入流，它和PipedOutputStream一起使用，能实现多线程间的管道通信

　　　　　FilterInputStream ：装饰者模式中处于装饰者，具体的装饰者都要继承它，所以在该类的子类下都是用来装饰别的流的，也就是处理类。具体装饰者模式在下面会讲解到，到时就明白了

　　　　　BufferedInputStream：缓冲流，对处理流进行装饰，增强，内部会有一个缓存区，用来存放字节，每次都是将缓存区存满然后发送，而不是一个字节或两个字节这样发送。效率更高

　　　　   DataInputStream：数据输入流，它是用来装饰其它输入流，它“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”

　　　　　FileInputSream：文件输入流。它通常用于对文件进行读取操作

　　　　　File：对指定目录的文件进行操作，具体可以查看讲解File的博文。注意，该类虽然是在IO包下，但是并不继承自四大基础类。

 　　　　  ObjectInputStream：对象输入流，用来提供对“基本数据或对象”的持久存储。通俗点讲，也就是能直接传输对象（反序列化中使用），

 

1.6.2、输出字节流OutputStream



IO 中输出字节流的继承图可见上图，可以看出：

OutputStream 是所有的输出字节流的父类，它是一个抽象类。
	
ByteArrayOutputStream、FileOutputStream 是两种基本的介质流，它们分别向Byte 数组、和本地文件中写入数据。PipedOutputStream 是向与其它线程共用的管道中写入数据，
	
ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流(序列化中使用)。
       

1.6.3、字符输入流Reader



在上面的继承关系图中可以看出：

Reader 是所有的输入字符流的父类，它是一个抽象类。
	
CharReader、StringReader 是两种基本的介质流，它们分别将Char 数组、String中读取数据。PipedReader 是从与其它线程共用的管道中读取数据。
	
BufferedReader 很明显就是一个装饰器，它和其子类负责装饰其它Reader 对象。
	
FilterReader 是所有自定义具体装饰流的父类，其子类PushbackReader 对Reader 对象进行装饰，会增加一个行号。
	
InputStreamReader 是一个连接字节流和字符流的桥梁，它将字节流转变为字符流。FileReader 可以说是一个达到此功能、常用的工具类，在其源代码中明显使用了将FileInputStream 转变为Reader 的方法。我们可以从这个类中得到一定的技巧。Reader 中各个类的用途和使用方法基本和InputStream 中的类使用一致。后面会有Reader 与InputStream 的对应关系。
1.6.4、字符输出流Writer



在上面的关系图中可以看出：

Writer 是所有的输出字符流的父类，它是一个抽象类。
	
CharArrayWriter、StringWriter 是两种基本的介质流，它们分别向Char 数组、String 中写入数据。PipedWriter 是向与其它线程共用的管道中写入数据，
	
BufferedWriter 是一个装饰器为Writer 提供缓冲功能。
	
PrintWriter 和PrintStream 极其类似，功能和使用也非常相似。
	
OutputStreamWriter 是OutputStream 到Writer 转换的桥梁，它的子类FileWriter 其实就是一个实现此功能的具体类（具体可以研究一SourceCode）。功能和使用和OutputStream 极其类似，后面会有它们的对应图。


1.6.5、字节流和字符流使用情况：（重要）

字符流和字节流的使用范围：字节流一般用来处理图像，视频，以及PPT，Word类型的文件。字符流一般用于处理纯文本类型的文件，如TXT文件等，字节流可以用来处理纯文本文件，但是字符流不能用于处理图像视频等非文本类型的文件。

1.7、字符流与字节流转换



转换流的作用，文本文件在硬盘中以字节流的形式存储时，通过InputStreamReader读取后转化为字符流给程序处理，程序处理的字符流通过OutputStreamWriter转换为字节流保存。

转换流的特点：

其是字符流和字节流之间的桥梁
	
可对读取到的字节数据经过指定编码转换成字符
	
可对读取到的字符数据经过指定编码转换成字节
何时使用转换流？

当字节和字符之间有转换动作时；
	
流操作的数据需要编码或解码时。
具体的对象体现：

InputStreamReader:字节到字符的桥梁
	
OutputStreamWriter:字符到字节的桥梁
这两个流对象是字符体系中的成员，它们有转换作用，本身又是字符流，所以在构造的时候需要传入字节流对象进来。

 

OutputStreamWriter(OutStreamout):将字节流以字符流输出。

InputStreamReader(InputStream in)：将字节流以字符流输入。

1.8、字节流和字符流的区别（重点）

字节流和字符流的区别：(详细可以参见http://blog.csdn.net/qq_25184739/article/details/51203733)    

         节流没有缓冲区，是直接输出的，而字符流是输出到缓冲区的。因此在输出时，字节流不调用colse()方法时，信息已经输出了，而字符流只有在调用close()方法关闭缓冲区时，信息才输出。要想字符流在未关闭时输出信息，则需要手动调用flush()方法。

·        读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

·        处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

结论：只要是处理纯文本数据，就优先考虑使用字符流。除此之外都使用字节流。

1.9、System类对IO的支持


 针对一些频繁的设备交互，Java语言系统预定了3个可以直接使用的流对象，分别是：

·        System.in（标准输入），通常代表键盘输入。

·        System.out（标准输出）：通常写往显示器。

·        System.err（标准错误输出）：通常写往显示器。

 标准I/O

      Java程序可通过命令行参数与外界进行简短的信息交换，同时，也规定了与标准输入、输出设备，如键盘、显示器进行信息交换的方式。而通过文件可以与外界进行任意数据形式的信息交换。

2.0、处理流BufferedReader，BufferedWriter,BufferedInputStream

BufferedOutputsStream，都要包上一层节点流。也就是说处理流是在节点流的基础之上进行的，带有Buffered的流又称为缓冲流，缓冲流处理文件的输入输出的速度是最快的。所以一般缓冲流的使用比较多。

 

2.1、什么是装饰者模式？

       推荐一篇博文，http://blog.csdn.net/jason0539/article/details/22713711  就详细说明了什么是装饰者模式？用我自己的话来说，就是往一个添加更多的功能，而我们首先想到的是继承，继承就很好的符合了我们的要求，不管你想加多少层的功能，都可以使用继承一层层的实现，但是这带来了一个问题，一旦我需要改变我的需求，那么我就需要往源码中改东西，再就是在这个继承链中某个类做一些修改，这不符合我们的设计模式思想，所以就有了装饰者模式，装饰者中拥有被装饰者的实例，然后有什么具体的装饰我们都另写一个类来继承该装饰者，当我们需要该装饰时，就new出该类来，然后将其被装饰者当作参数传递进去。

 　　　　　　　　　　　　　　　　　　

　　　　　　　　　　关说可能没理解那么清楚，现在来看看一个具体的实例。比如，我们需要制作一份鸡腿堡，流程是怎样的呢？看下图

　　　　　　　　　　　　　　1、先有基本原料，也就是两块面包，这是不管做什么汉堡都需要的，

　　　　　　　　　　　　　　2、做什么汉堡，取决于加什么材料，比如生菜，鸡肉等，所以根据材料来做汉堡，想做什么汉堡就加什么材料

　　　　　　　　　　　　　　3、所有材料加完之后，直接计算价格即可

　　　　　　　　　　　　这样使用装饰者模式，是不是比一直使用继承方便的多的多呢？换一种汉堡，也不需要改源码，什么也不需要，希望你能够理解清楚其中的思想。

　　　　　　　　　　　　　　　　　　　　

 

　　　　　　3.2、io流中的装饰者模式的运用

　　　　　　　　　　　　画张图，在结合源码和自己写的代码来看。

　　　　　　　　　　　　　　　　　　

 

　　　　　　　　　　到这里，应该可以对前面的处理流和节点流有所理解了把，其实处理流就是一个具体的装饰者，而节点流就是被装饰者。

2.2、Scanner类

 Java 5添加了java.util.Scanner类，这是一个用于扫描输入文本的新的实用程序。它是以前的StringTokenizer和Matcher类之间的某种结合。由于任何数据都必须通过同一模式的捕获组检索或通过使用一个索引来检索文本的各个部分。于是可以结合使用正则表达式和从输入流中检索特定类型数据项的方法。这样，除了能使用正则表达式之外，Scanner类还可以任意地对字符串和基本类型(如int和double)的数据进行分析。借助于Scanner，可以针对任何要处理的文本内容编写自定义的语法分析器。

Scanner套接字节流或字符流：

字节流的套接：在Scanner的构造方法中Scanner(InputStream source)，InputStream只要经过适当的套接，总能获得你想要的流接口。

字符流的套接：Scanner(Readable source)，你需要使用Java SE5中新加入的一个接口Readable，该接口表示“具有read()方法的某种东西”，查看Readable接口的API你可以发现你想要的带有Reader的类基本都在其中。

2.3、序列化

将保存在内存中的对象数据转化为二进制数据流进行传输，任何对象都可以序列化

实现方法：实现java.io.Serializable接口

作用：把一个Java对象写入到硬盘或者传输到网路上面的其它计算机，这时我们就需要自己去通过java把相应的对象写成转换成字节流。对于这种通用的操作，我们为什么不使用统一的格式呢？没错，这里就出现了java的序列化的概念。在Java的OutputStream类下面的子类ObjectOutput-Stream类就有对应的WriteObject(Object object) 其中要求对应的object实现了java的序列化的接口。

在使用tomcat开发JavaEE相关项目的时候，我们关闭tomcat后，相应的session中的对象就存储在了硬盘上，如果我们想要在tomcat重启的时候能够从tomcat上面读取对应session中的内容，那么保存在session中的内容就必须实现相关的序列化操作，还有jdbc加载驱动用的就是反序列化，将字符串变为对象。。。

//序列化类：java.ioObjectOutputStream

//讲对象变为指定的二进制数据

class Book implements Serializable{

	private String title;

	private double price;

	public Book(String tit,double pri){

		this.title=tit;

		this.price=pri;

	}

	public String toString() {

		return "书名："+this.title+",价格："+this.price;

	}

}

public class Demo10 {

	public static void main(String[] args) throws Exception {

//序列化到指定的文本

		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(new File("e:"+File.separator+"demoA.txt")));

		oos.writeObject(new Book("java开发", 45.2));

		oos.close();

	}

}/

反序列化

将二进制数据换回原对象

构造：

    ObjectInputStream（InputStream in）

方法:

     Object readObject() 从 ObjectInputStream 读取对象 


class Book implements Serializable{

	private String title;

	private double price;

	public Book(String tit,double pri){

		this.title=tit;

		this.price=pri;

	}

	public String toString() {

		return "书名："+this.title+",价格："+this.price;

	}

}

public class Demo11 {

	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {

		ObjectInputStream ois=new ObjectInputStream(new FileInputStream(new File("e:"+File.separator+"demoA.txt")));

		Object obj=ois.readObject();

		Book book=(Book) obj;

		System.out.println(book);

		ois.close();

	}

}

transient关键字（一个类某些属性不需要序列化）

以上序列化和反序列化实现了的对象序列化，但是可以发现，操作时是将整个对象的所有属性序列化，那么transient关键字可以将某些内容不需要保存，就可以通过transient关键字来定义

private transient string title；

此时title属性无法被序列化，

2.2、总结

inputStream类的功能不足被Scanner解决了

OutputStream类的功能不足被PrintStream解决了

Reader类功能不足被BufferReader解决了

Writer类的功能不足被PrintWriter解决了

输出数据用printStream，printwriter读取数据用Scanner其次是bufferReader

借鉴的博客有：

https://www.cnblogs.com/ylspace/p/8128112.html

https://www.cnblogs.com/runningTurtle/p/7088125.html

https://www.jb51.net/article/112602.htm

https://www.cnblogs.com/whgk/p/6920018.html

io流概述：
IO流用来处理设备之间的数据传输，上传文件和下载文件，Java对数据的操作是通过流的方式，Java用于操作流的对象都在IO包中。
IO流分类
按照数据流向
输入流	读入数据
输出流	写出数据
按照数据类型
字节流
字符流
什么情况下使用哪种流呢?
如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流，其他用字节流。
如果你什么都不知道，就用字节流。
IO流常用基类
字节流的抽象基类：
InputStream ，OutputStream。
字符流的抽象基类：
Reader ， Writer。
注：

由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

如：InputStream的子类FileInputStream。

如：Reader的子类FileReader。
OutputStream的子类FileOutputStream
构造方法：
FileOutputStream(File file)
FileOutputStream(String name)
推荐第二种构造方法：
FileOutputStream outputStream = new FileOutputStream("a.txt");

创建字节输出流对象了做了几件事情：
A:调用系统功能去创建文件
B:创建outputStream对象
C:把foutputStream对象指向这个文件

通过字节输出流写出数据到文本
public void write(int b)
public void write(byte[] b)
public void write(byte[] b,int off,int len)

从方法中可看出，只能通过字节写出
outputStream.write("hello".getBytes()); 文本中出现hello
outputStream.write(96)  //文本中出现 a

byte[] bys={97,98,99,100,101};
outputStream.write(bys,1,3); 文本中出现bcd

如此写出，文本中数据不会换行，不会追加，每次写出都是覆盖原来。
追加：
FileOutputStream outputStream = new FileOutputStream("a.txt",true);
//第二个参数true设置为可追加。

换行 \n\r ：
for (int i = 0; i <5 ; i++) {
    outputStream.write("hello".getBytes());
    outputStream.write("\n\r".getBytes());
    }

注：用完流一定要记得关闭。
outputStream.close();

完整示例：
package io2;

import java.io.FileOutputStream;
import java.io.IOException;
/**
 * new FileOutputStream("a.txt",true);  第二个参数true，设置为写入的数据拼接在尾部
 * \n\r 换行
 * write(bys,1,3);  写入字节数组
 */
public class out {
    public static void main(String args[]){
        FileOutputStream outputStream = null;
        try {
            //FileOutputStream fos = new FileOutputStream(file);
            outputStream = new FileOutputStream("a.txt",true);
            /*
             * 创建字节输出流对象了做了几件事情：
             * A:调用系统功能去创建文件
             * B:创建outputStream对象
             * C:把foutputStream对象指向这个文件
             */

//            for (int i = 0; i <5 ; i++) {
//                outputStream.write("hello".getBytes());
//                outputStream.write("\n\r".getBytes());
//            }
            byte[] bys={97,98,99,100,101};
            outputStream.write(bys,1,3);
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}


InputStream的子类FileInputStream
FileInputStream的构造方法
FileInputStream(File file)
FileInputStream(String name)

推荐第二种构造方法：
 FileInputStream inputStream = new FileInputStream("a.txt");

把刚才写的数据现在读取到控制台：
public int read()
public int read(byte[] b)

第一个read是读一个字节，第二个read是读一个字节数组。
//读一个字节
int by = 0;
while ((by=inputStream.read())!=-1){
      System.out.println((char)by);
}

读到没数据了就返回-1，这个用来判断是否读完。
//读一个字节数组，一般是1024大小
int len = 0 ;
byte[] bys = new byte[1024];
while ((len = inputStream.read(bys)) != -1) {
    System.out.println(new String(bys,0,len));
}

两个read的返回值略有不同，read()返回读取的字节，读到末尾返回-1，read(byte[] b)返回的是读到的字节个数，读到的字节放在了bytes字节数组里，读到末尾没数据了返回-1。
两种读取方式图解：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yv0oyKLy-1603813798619)(http://p5kllyq5h.bkt.clouddn.com/174401.jpg)]
同样的用完了流，也要及时的关闭，以防占用内存。
inputStream.close();

完整示例：
建议以字节数组的方式读取数据。
package io2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * Create by stefan
 * Date on 2018-05-27  23:00
 * Convertion over Configuration!
 */
public class input2 {
    public static void main(String args[]){
        FileInputStream inputStream = null;
        try {
            inputStream = new FileInputStream("a.txt");
//            byte[] bys = new byte[4];
//            int len = inputStream.read(bys);
//            System.out.println(new String(bys));  //bcd
//            System.out.println(len);  //3
//            System.out.println(inputStream.read(bys));  //-1
            int len = 0 ;
            byte[] bys = new byte[1024];
            while ((len = inputStream.read(bys)) != -1) {
                System.out.println(new String(bys,0,len));
            }
            /**
             *    public String(byte bytes[]) {
             this(bytes, 0, bytes.length);
             }
             */

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}


字节流复制文件
利用输入流读取一个文件里的字节，再利用输出流将读取到的字节写出到另一个文件中（不存在会自动创建）
package io2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

/**
 * Create by stefan
 * Date on 2018-05-27  23:19
 * Convertion over Configuration!
 */
public class copy {
    public static void main(String args[]) throws IOException {
        FileInputStream inputStream = new FileInputStream("E:\\huge1.jpg");
        FileOutputStream outputStream = new FileOutputStream("E:\\古月.jpg");
        
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len=inputStream.read(bytes)) != -1) {
            outputStream.write(bytes,0,len);
        }
        inputStream.close();
        outputStream.close();
    }
}


注：复制文本、图片、mp3、视频等的方式一样。
字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果。
java本身在设计的时候，也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流。
字节缓冲输出流
BufferedOutputStream
字节缓冲输入流
BufferedInputStream

BufferedOutputStream
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt",true));
bos.write("hello world".getBytes());
bos.close();

BufferedInputStream
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
byte[] bytes = new byte[1024];
int len = 0;
while ((len=bis.read(bytes)) != -1) {
    System.out.println(new String(bytes,0,len));
}
bis.close();

注：

成员方法与字节流基本一样，字节缓冲流的作用就是提高输入输出的效率。
构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。

复制文件的升级：
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\modern-java.pdf"));
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf"));
int len = 0;
byte[] bytes =new byte[1024];
while ((len=bis.read(bytes)) != -1) {
    bos.write(bytes,0,len);
}
bis.close();
bos.close();

测试：四种复制文件的效率高低
package io2;

import java.io.*;

/**
 *
 * 测试复制的时间
 * Create by stefan
 * Date on 2018-05-28  10:28
 * Convertion over Configuration!
 */
public class copy2 {
    //一个字节一个字节的复制，耗时22697毫秒
    public static  void  fun() throws IOException {
        FileInputStream fis = new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf");
        FileOutputStream fos = new FileOutputStream("E:\\modern-java.pdf");
        int by = 0;
        while ((by=fis.read()) != -1) {
            fos.write(by);
        }
        fis.close();
        fos.close();
    }
    //1024字节数组复制 耗时63毫秒
    public  static void  fun1() throws IOException {
        FileInputStream fis = new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf");
        FileOutputStream fos = new FileOutputStream("E:\\modern-java.pdf");
        int len = 0;
        byte[] bytes =new byte[1024];
        while ((len=fis.read(bytes)) != -1) {
            fos.write(bytes,0,len);
        }
        fis.close();
        fos.close();
    }
    // 一个字节一个字节复制，但是用了缓冲流 耗时64毫秒
    public static   void  fun2() throws IOException {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\modern-java.pdf"));
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf"));
        int by = 0;
        while ((by=bis.read()) != -1) {
            bos.write(by);
        }
        bis.close();
        bos.close();
    }
    // 1024字节数组复制并用了缓冲流 耗时7毫秒
    public  static void  fun3() throws IOException {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\modern-java.pdf"));
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf"));
        int len = 0;
        byte[] bytes =new byte[1024];
        while ((len=bis.read(bytes)) != -1) {
            bos.write(bytes,0,len);
        }
        bis.close();
        bos.close();
    }

    public static void main(String args[]) throws IOException {
        long t1 = System.currentTimeMillis();
        fun3();
        long t2 = System.currentTimeMillis();
        System.out.println(t2-t1);
    }

}


经测试结果显示：

1024字节数组复制并用了缓冲流 的方式效率最高。
以上是本人学习笔记整理，重温java经典，欢迎各位同道中人批评指正。
源码码云地址：

https://gitee.com/stefanpy/java
梦回io流完整目录：
java基础io流——File告白（重温经典）
java基础io流——OutputStream和InputStream的故事（温故知新）
java基础io流——字符流的变革（深入浅出）
java基础io流——配角也风流（不求甚解）