JavaSE--重新学习_查漏补缺(13)--缓冲字节、字符流_转换流_标准输入输出流、打印流和数据流_对象流_随机存取流--RandomAccessFile 类

一、缓冲字节流

• 缓冲流是基于内存的io，而文件流是基于硬盘的io，所有缓存流比较快，大概比文件流快75000多倍。
  
• 缓冲的字节输入流使用BufferInputStream对象和其read()方法，且BufferedIuputStream的构造函数需要FileInputStream对象作为参数传进去。

/**
	 * 缓冲字节输入流
	 * BufferedInputStream
	 * @throws Exception 
	 */
	public static void testBufferedInputStream() throws Exception{
		//文件字节输入流对象
		FileInputStream in = new FileInputStream("D:\\testdemo\\demo\\src\\day13\\tt.txt");
		
		//把文件字节输入流放到缓冲字节输入流对象
		BufferedInputStream br = new BufferedInputStream(in);
		
		byte[] b = new byte[10];
		
		int len = 0;
		
		while((len = br.read(b)) != -1){
			System.out.println(new String(b,0,len));
		}		
		//关闭流的时候，本着一个最晚开的最早关，依次关
		br.close();
		in.close();
	}

• 缓冲的字节输入流使用BufferedOutputStream对象和其write()方法，且BufferedOutputStream的构造函数需要FileOuputStream对象作为参数传进去。

/**
	 * 缓冲字节输出流
	 * BufferedOutputStream
	 */
	public static void testBufferedOutputStream() throws Exception{
		//创建字节输出流对象
		FileOutputStream out = new FileOutputStream("D:\\testdemo\\demo\\src\\day13\\tt1.txt");
		
		//把字节输出流对象放到缓冲字节输出流中
		BufferedOutputStream bo = new BufferedOutputStream(out);
		
		String s = "hello world";
		
		bo.write(s.getBytes());//写到内存中
		
		bo.flush();//刷到硬盘上
		
		//关闭流的时候，本着一个最晚开的最早关，依次关
		bo.close();
		out.close();
		
	}

• 缓冲字节流流实现文件复制

/**
	 * 缓冲流实现文件的复制
	 */
	public static void copyFile() throws Exception{
		//缓冲输入流
		BufferedInputStream br = new BufferedInputStream(new FileInputStream("D:\\testdemo\\demo\\src\\day13\\tt1.txt"));
		
		//缓冲输出流
		BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream("D:\\testdemo\\demo\\src\\day13\\tt2.txt"));
		
		byte[] b = new byte[1024];
		
		int len = 0;//设置一个没出读取到的数据的长度，直到br.read方法执行到最后（比如说文件中只有hello world，执行到最后一个就读取d的后面，这个时候返回值就是-1）
		
		while((len = br.read(b)) != -1){
			bo.write(b, 0, len);//写到内存
		}
		
		bo.flush();//刷到硬盘
		
		bo.close();
		br.close();
	}

二、缓冲字符流

缓冲字节流和缓冲字符流的关系和 文件字节流和文件字符流的关系一样。

• 缓存的字节输入流使用BufferedReader 对象和其read()方法，且BufferedReader 的构造函数需要FileReader 对象作为参数传进去。

/**
	 * 缓冲字符输入流
	 * BufferedReader
	 */
	public static void testBufferedReader() throws Exception{
		FileReader r = new FileReader("D:\\testdemo\\demo\\src\\day13\\tt.txt");
		
		BufferedReader br = new BufferedReader(r);
		
		char[] c = new char[100];
		
		int len = 0;
		
		while((len = br.read(c)) != -1){//br.read(c)读到文件的最后一个字符的下一位，返回值就是-1
			System.out.println(new String(c, 0, len));
		}
		br.close();
		r.close();
	}

• 缓冲的字节输入流使用BufferedReader 对象和其write()方法，且BufferedReader 的构造函数需要FileReader 对象作为参数传进去。

/**
	 * 缓冲字符输出流
	 * BufferedWriter
	 */
	public static void testBufferedWriter() throws Exception{
		FileWriter fw = new FileWriter("D:\\testdemo\\demo\\src\\day13\\tt3.txt");
		
		BufferedWriter bw = new BufferedWriter(fw);
		
		String s = "hello world!!!!";
		
		bw.write(s);
		
		bw.flush();
		
		bw.close();
		fw.close();
	}

• 缓存字符流流实现文件复制

	/**
	 * 缓冲字符流复制文件
	 */
	public static void copyFile() throws Exception{
		BufferedReader br = new BufferedReader(new FileReader("D:\\testdemo\\demo\\src\\day13\\tt3.txt"));
		
		BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\testdemo\\demo\\src\\day13\\tt4.txt"));
		
		char[] c = new char[100];
		
		int len = 0;
		
		while((len = br.read(c)) != -1){
			bw.write(c, 0, len);
		}
		
		bw.flush();
		
		bw.close();
		br.close();
	}

• 注意：
• 对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush()将会使内存中的数据立刻写出
• 缓冲流是把数据缓冲到内存中

三、转换流

转换输入流InputStreamReader，其构造方法有两个参数参数1是字节流对象，参数2是编码格式。
转换输入流OutputStreamWriter，其构造方法有两个参数参数1是字节流对象，参数2是编码格式。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

/**
 * 转换流
 * 可以把字节流转换为字符流
 * 当字节流中的数据都是字符的时候，使用转换流转为字符流处理效率更高
 * 
 *
 */
public class Test2 {
	public static void main(String[] args) {
		//所有的文件都是有编码格式
		//对于我们来说，TXT和java文件一般来讲有三种编码
		//ISO8859-1，西欧编码，是纯粹英文编码，不适应汉字
		//GBK和UTF-8，这两编码是适用于重要和英文
		//我们一般使用UTF-8编码
		
		try {
//			Test2.testInputStreamReader();
			Test2.testOutputStreamWriter();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 转换字节输入流为字符输入流
	 * 注意，在转换字符流的时候，设置的字符集编码要与读取的文件的数据的编码一致
	 * 不然就会出现乱码
	 * InputStreamReader
	 */
	public static void testInputStreamReader() throws Exception{
		FileInputStream fs = new FileInputStream("D:\\testdemo\\demo\\src\\day13\\tt5.txt");
		
		//把字节流转换为字符流
		InputStreamReader in = new InputStreamReader(fs,"GBK");//参数1是字节流，参数2是编码
//		InputStreamReader in = new InputStreamReader(fs,"UTF-8");//参数1是字节流，参数2是编码
		
		char[] c = new char[100];
		int len = 0;
		
		while((len = in.read(c)) != -1){
			System.out.println(new String(c,0,len));
		}
		
		in.close();
		fs.close();
	}
	
	/**
	 * 转换字节输出流为字符输出流
	 * 注意，在转换字符流的时候，设置的字符集编码要与读取的文件的数据的编码一致
	 * 不然就会出现乱码
	 * OutputStreamWriter
	 */
	public static void testOutputStreamWriter() throws Exception{
		FileOutputStream out = new FileOutputStream("D:\\testdemo\\demo\\src\\day13\\tt6.txt");
		
//		OutputStreamWriter os = new OutputStreamWriter(out, "UTF-8");
		OutputStreamWriter os = new OutputStreamWriter(out, "GBK");
		
		os.write("你好你好");
		os.flush();
		
		os.close();
		out.close();
	}
}

四、标准输入输出流、打印流和数据流

• 标准输入输出流

1. System.in和System.out分别代表了系统标准的输入和输出设备
2. 默认输入设备是键盘，输出设备是显示器
3. System.in的类型是InputStream
4. System.out的类型是PrintStream，其是OutputStream的子类FilterOutputStream 的子类

• 打印流

1. PrintStream(字节打印流)和PrintWriter(字符打印流)提供了一系列重载的print和println方法，用于多种数据类型的输出
2. PrintStream和PrintWriter的输出不会抛出异常
3. PrintStream和PrintWriter有自动flush功能
   System.out返回的是PrintStream的实例

• 数据流

1. 为了方便地操作Java语言的基本数据类型的数据，可以使用数据流。

2. 数据流有两个类：(用于读取和写出基本数据类型的数据）
   DataInputStream 和 DataOutputStream
   分别“套接”在 InputStream 和 OutputStream 节点流上
   DataInputStream中的方法

      boolean readBoolean()		byte readByte()
      char readChar()			float readFloat()
      double readDouble()		short readShort()
      long readLong()			int readInt()
      String readUTF()                                 void readFully(byte[] b)
      DataOutputStream中的方法
   

将上述的方法的read改为相应的write即可。

五、对象流

所使用的类对象ObjectInputStream和OjbectOutputSteam。
用于存储和读取对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
需要思考的问题：
1. 把对象存到电脑硬盘上，硬盘存储的基础是什么?
二进制，那就需要把对象转化为一个二进制的字节流，把这个流保存到电脑上，要使用这个对象，就得流转化为对象再使用。
2. 把对象通过网络传到另一个机器上，网络的通信基础是什么？
二进制，也就是需要把一个对象转化为二进制的数据流，把这个流通过网络进行传输，在接收者如果使用接收的对象就得先把对象得流转化为对象。
3. 基于以上两个问题我们就还要问怎么将 对象->流->对象呢？
这时就需要序列化和反序列化

5.1序列化

• 序列化(Serialize)：用ObjectOutputStream类将一个Java对象写入IO流中

• 反序列化(Deserialize)：用ObjectInputStream类从IO流中恢复该Java对象

• ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

• 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的Java对象

• 序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原

• 序列化是 RMI（Remote Method Invoke – 远程方法调用）过程的参数和返回值都必须实现的机制，而 RMI 是 JavaEE 的基础。因此序列化机制是 JavaEE 平台的基础

• 如果需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：
  Serializable
  Externalizable

5.1.1序列化Serializable接口的serialVersionUID

• 凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：
  private static final long serialVersionUID;
  serialVersionUID用来表明类的不同版本间的兼容性
• 如果类没有显示定义这个静态变量，它的值是Java运行时环境根据类的内部细节自动生成的。若类的源代码作了修改，serialVersionUID 可能发生变化。故建议，显示声明
  显示定义serialVersionUID的用途:

1. 希望类的不同版本对序列化兼容，因此需确保类的不同版本具有相同的serialVersionUID
2. 不希望类的不同版本对序列化兼容，因此需确保类的不同版本具有不同的serialVersionUID

• 创建一个可序列化的对象

import java.io.Serializable;

/**
 * 可以序列化与反序列化的对象
 * 
 *
 */
public class Person implements Serializable{

	/**
	 * 一个表示序列化版本标识符的静态变量
	 * 用来表明类的不同版本间的兼容性
	 */
	private static final long serialVersionUID = 1L;
	
	public String name;
	public int age;

}

• 序列化和反序列化

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

/**
 * 序列化与反序列化
 * 注意：对象的序列化与反序列化使用的类要严格一致，包名，类名，类机构等等所有都要一致
 * 
 *
 */
public class Test5 {
	public static void main(String[] args) {
		try {
//			Test5.testSerialize();
			Test5.testDeserialize();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 对象的序列化
	 */
	public static void testSerialize() throws Exception{
		//定义对象的输出流，把对象的序列化之后的流放到指定的文件中
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:/testdemo/demo/src/day13/tt9.txt"));
		Person p = new Person();
		p.name = "zhangsan";
		p.age = 11;
		out.writeObject(p);
		out.flush();//刷写数据到硬盘
		
		out.close();
	}
	
	/**
	 * 对象的反序列化
	 */
	public static void testDeserialize() throws Exception{
		//创建对象输入流对象，从指定的文件中把对象序列化后的流读取出来
		ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:/testdemo/demo/src/day13/tt9.txt"));
		
		Object obj = in.readObject();
		
		Person p = (Person)obj;
		
		//这个时候序列化与反序列化使用的类不是一个类分别是day13.Person和day13.test.Person
		//这个时候反序列化就有异常day13.Person cannot be cast to day13.test.Person
//		day13.test.Person p = (day13.test.Person)obj;
		
		System.out.println(p.name);
		System.out.println(p.age);
		
		in.close();
		
	}
}

六、随机存取流–RandomAccessFile 类

RandomAccessFile 类支持 “随机访问” 的方式，程序可以直接跳到文件的任意 地方来读、写文件.

1. 支持只访问文件的部分内容
2. 可以向已存在的文件后追加内容
3. RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。
4. RandomAccessFile 类对象可以自由移动记录指针：
   4.1. long getFilePointer()：获取文件记录指针的当前位置
   4.2. void seek(long pos)：将文件记录指针定位到 pos 位置

• 构造器
  public RandomAccessFile(File file, String mode)
  public RandomAccessFile(String name, String mode)

• 创建 RandomAccessFile 类实例需要指定一个 mode 参数，该参数指定 RandomAccessFile 的访问模式：

  1. r: 以只读方式打开
  2. rw：打开以便读取和写入
  3. rwd:打开以便读取和写入；同步文件内容的更新
  4. rws:打开以便读取和写入；同步文件内容和元数据的更新

• RandomAccess流例子

import java.io.RandomAccessFile;
/**
 * 文件的随机读写
 * 程序可以直接跳到文件的任意 地方来读、写文件
 * 
 *
 */
public class Test6 {
	public static void main(String[] args) {
		try {
//			Test6.testRandomAccessFileRead();
			Test6.testRandomAccessFileWrite();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 随机读文件
	 */
	public static void testRandomAccessFileRead() throws Exception{
		//RandomAccessFile的构造有两个参数，参数1是读写的文件的路径
		//参数2是指定 RandomAccessFile 的访问模式
		//r: 以只读方式打开
		//rw：打开以便读取和写入
		//rwd:打开以便读取和写入；同步文件内容的更新
		//rws:打开以便读取和写入；同步文件内容和元数据的更新
		//最常用是r和rw

		RandomAccessFile ra = new RandomAccessFile("D:/testdemo/demo/src/day13/tt10.txt", "r");
		
//		ra.seek(0);//设置读取文件内容的起始点
		ra.seek(8);//通过设置读取文件内容的起始点，来达到从文件的任意位置读取
		
		byte[] b = new byte[1024];
		
		int len = 0;
		
		while((len = ra.read(b)) != -1){
			System.out.println(new String(b, 0, len));
		}
		
		ra.close();
	}
	
	/**
	 * 随机写
	 */
	public static void testRandomAccessFileWrite() throws Exception{
		RandomAccessFile ra = new RandomAccessFile("D:/testdemo/demo/src/day13/tt10.txt", "rw");
		
//		ra.seek(0);//设置写的起始点，0代表从开头写
		//注意：如果是在文件开头或者中间的某个位置开始写的话，就会用写的内容覆盖掉等长度的原内容
		ra.seek(ra.length());//设置写的起始点,ra.length()代表从文件的最后结尾写，也就是文件的追加
		
		ra.write("你好".getBytes());
		
		ra.close();
	}
}