IO流的总结、 properties双列集合 与 序列化和反序列化

IO流异常处理

JDK1.6前的写法(常用)

举例: 处理复制文件时的异常

File file = new File("/Users/lanou/Desktop/dp.png");
File dest = new File("/Users/lanou/Desktop/lna/ppp.jpg");
FileInputStream fis = null;
FileOutputStream fos = null;
try {
	fis = new FileInputStream(file);
	BufferedInputStream bis = new BufferedInputStream(fis); 
	fos = new FileOutputStream(dest);
	BufferedOutputStream bos = new BufferedOutputStream(fos);
	int len = 0;
	byte[] b = new byte[1024*1024];
	while ((len = bis.read(b)) != -1) {
		bos.write(b,0,len);
	}
} catch (FileNotFoundException e) {
	throw new RuntimeException("找不到文件路径");
} catch (IOException e) {
	e.printStackTrace();
} 
finally {
	if (fis != null) {
		try {
			fis.close();
		} catch (IOException e2) {
			throw new RuntimeException("fis关闭失败");
		} finally {
			if (fos != null) {
				try {
					fos.close();
				} catch (IOException e3) {
					throw new RuntimeException("fos关闭失败");
				}
			}	
		}
	}
}

JDK1.7的异常处理方法

/*
 * JDK1.7的新特性
 * 流的父类 实现AutoCloseable接口
 * 系统可以自动关闭流(不再需要写关闭流)
 */
try(
		// 将需要关闭的流写在此处
		// 该流的类必须实现AutoCloseable这个接口 可自动关闭流
		FileInputStream fis = new FileInputStream("/Users/lanou/Desktop/dp.png");
		FileOutputStream fos = new FileOutputStream("/Users/lanou/Desktop/rename/ppp.png");
		) {
	// 读写
	int len = 0;
	byte[] b = new byte[1024*1024];
	while ((len = fis.read(b)) != -1) {
		fos.write(b,0,len);
	}
} catch (FileNotFoundException e) {
	throw new RuntimeException("找不到文件路径");
} catch (IOException e) {
	e.printStackTrace();
}

字符缓冲流(高效流)

流的前缀标识功能  后缀表示具体是什么流

BufferedWriter(Writer w)  缓冲字符输出流(字符流写文件时 需要刷新 flush() )

BufferedReader(Reader r) 缓冲字符输入流(读完返回null)

InputStream 字节输入流de所有类的父类(抽象类)---读取文件

OutputStream 字节输出流de所有类的父类(抽象类)---写入文件

FileInputStream(File file) 字节输入流

FileOutputStream(File file) 字节输出流

BufferedInputStream(InputStream fis) 缓冲字节输入流

BufferedOutputStream(OutputStream fos) 缓冲字节输出流

ObjectInputStream(InputStream fis) 反序列化流---将文件中的对象读取出来

ObjectOutputStream(OutputStream fos) 序列化流---将对象写入到文件

Reader 读取字符流的抽象类(字符输入流的父类,是一个抽象类)

Writer 写入字符流的抽象类(字符输出流的父类,是一个抽象类)

FileReader(File file) 字符输入流

FileWriter(File file) 字符输出流

BufferedReader(Reader fr) 缓冲字符输入流(特有读取方法 readLine读取一行)

BufferedWriter(Reader fw) 缓冲字符输出流

InputStreamReader(InputStream fis) 字节流转字符流

OutputStreamWriter(OutputStream fos) 字符流转字节流

LineNumberReader(Reader fr) 带行号的缓冲字符输入流(常用方法 readLine读取一行,继承BufferedReader)

********************************************************************************

总结流:

什么时候使用什么流  明确流操作什么

源文件  读  Input   Reader

目标文件  写  Output   Writer

明确要操作的是什么文件 :

文本---使用字节流 或者 字符流 皆可  常用字符流

非文本(图片 视频 音频等)---使用字节流(不能使用字符流)

明确要使用什么功能 :

高效 : 缓冲流

转换 : 转换流

properties双列集合

properties继承自Hashtable

该集合是唯一能与IO流 产生关系的集合

注意 properties的特有添加方法:

setProperties(String , String);   只能添加字符串

枚举器遍历方法 :

propertyNames();

Enumeration names = pro.propertyNames();
while (names.hasMoreElements()) {
	String key = (String)names.nextElement();
	System.out.println(key + "=" + pro.getProperty(key));
}

读取文件的方法(将文件数据在加载集合中) :

注意: 能读取的文件的格式  key = value

Properties pro = new Properties();
// 文件名规范: 一般把Propertise集合
// 可以直接加载文件的后缀名 都使用properties来标识
FileInputStream fis = new FileInputStream("/Users/lna/Desktop/shuang.properties");
// 把数据加载到集合当中
pro.load(fis);
//关闭流资源
fis.close();		System.out.println(pro); //打印集合

集合中的数据写入文件的方法:

store(OutputStream fos , String str)   参数2是添加注释,一般不用写,中文注释会乱码

Properties pro = new Properties();
pro.setProperty("username", "wanglong");
pro.setProperty("password", "123456");
FileOutputStream fos = new FileOutputStream("/Users/lna/pre.properties");
pro.store(fos,"haha");
fos.close();

序列化和反序列化

序列化: 将对象 写入到文件中

  使用的是字节流 

   ObjectOutputStream

反序列化: 将文件中的对象 读取出来

        ObjectInputStream

序列化就是写对象 反序列化就是把对象读出来

写对象的方法

FileOutputStream fos = new FileOutputStream("/Users/lna/吴倩.txt");
// 创建序列化流
ObjectOutputStream oos = new ObjectOutputStream(fos);
// 序列化接口 Serializable  标识性接口
// 如果你这个类想进行序列化 必须实现该接口
// Person类 要实现该接口
oos.writeObject(new Person("吴承恩", 18));
oos.close();

读对象的方法

FileInputStream fis = new FileInputStream("/Users/lanou/Desktop/lna/吴倩.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
// 读取对象
Object object = ois.readObject();
System.out.println(object);
ois.close();

注意:

序列化和反序列化流读取本地的类 序列号不同(每次读写 都会生成不同的序列号) 就会出现 

InvalidClassException

需要给定义的类 生成一个永久的序列号