java学习-day14-IO(二).字节流字符流写出.序列化/反序列化.编码转换流.

字节流输出

package test;
//这个类用来测试  字节输出流
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
//总结：
//1、字节流的写出流：两种普通流FileOutputStream  和高级流BufferedOutputStream
//2、效率上来讲：BufferedOutputStream  >  FileOutputStream
//3、原因： BufferedOutputStream底层维护了一个byte[]  默认大小是8K，减少给磁盘的次数，提高效率 
public class test1 {
	public static void main(String[] args) {
		method();// 普通输出流FileOutputStream
		method2();// 高效输出流BufferedOutputStream
	}
	private static void method2() {
		OutputStream out = null;
		try {
			// 1，创建对象
			// OutputStream out = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\1.txt");// 默认是数据覆盖模式
			out = new BufferedOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\1.txt", true));// 是数据追加模式
			// 2，开始写出
			out.write(47);
			out.write(48);
			out.write(49);
		} catch (IOException e) {// 捕获大异常
			e.printStackTrace();
		} finally {//为了保证资源一定会被释放
			try {
				out.close();// 3，释放资源
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	private static void method() {
		OutputStream out = null;
		OutputStream out2 = null;
		try {
			// 1，创建对象
			out = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\1.txt");// 默认是数据覆盖模式
			out2 = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\1.txt", true);// 是数据追加模式
			// OutputStream out2 = new FileOutputStream( new File("D:\\iotest\\1.txt") );
			// 2，开始写出
			out.write(47);
			out.write(48);
			out.write(49);	
		} catch (IOException e) {// 捕获大异常
			e.printStackTrace();
		}finally{
			// 3，释放资源
			try {
				out.close();
				out2.close();
			} catch (IOException e) {
				e.printStackTrace();
			}	
		}
	}
}

字符流输出

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
//这个类用来测试 字符输出流
//总结
//字符输出流：两种：普通流FileWriter  高效流BufferedWriter
//效率上来讲：BufferedWriter  >   FileWriter
//原因：BufferedWriter底层维护了一个缓冲数组char[] ，默认大小8K，减少给磁盘的次数，提高效率
public class test2 {
	public static void main(String[] args) {
//		method();//普通对象FileWriter
		method2();//高级流
	}
	private static void method2() {
		Writer out = null ;
		try {
			//1，创建对象
			out = new BufferedWriter (  new FileWriter("C:\\Users\\Administrator\\Desktop\\test\\1.txt",true)   )  ;
			//2，开始写出
			out.write(50);
			out.write("信你个鬼啊");//字符流可以写出字符串
			
			out.flush();  //把缓冲区的数据，刷到磁盘里 显示
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				//3，释放资源
				out.close();   //两个功能：先把数据从缓冲区刷出去  后  释放资源
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	private static void method() {
		Writer out = null ;
		try {
			//1，创建对象
			out = new FileWriter("C:\\Users\\Administrator\\Desktop\\test\\1.txt");
			//2，开始写出
			out.write(49);
			out.write("我爱java");//字符流可以写出字符串
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				//3，释放资源
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

文件复制

package test;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
//这个类用来测试  文件复制
		//1、读取源文件
		//2、把数据写出到 目标文件中
		public class test3 {
			public static void main(String[] args) {
				File from = new File("C:\\Users\\Administrator\\Desktop\\test\\1.txt");// 源文件
				File to = new File("C:\\Users\\Administrator\\Desktop\\test\\2.txt");// 目标文件
				// copy(from,to);//完成复制 -- 字节流---什么类型的文件都可以操作
				copy2(from, to);// 完成复制 -- 字符流--只能操作字符文件
			}
			// 字符流操作  --  只能操作字符文件 
			private static void copy2(File from, File to) {
				Reader in = null;
				Writer out = null;
				try {
					// 1、读取源文件 -- 字节流 高效流
					in  = new BufferedReader(new FileReader(from));
					// 2、把数据写出到 目标文件中
					out = new BufferedWriter(new FileWriter(to));
					// 3、边读边写
					int b = 0; // 定义变量，记录读取到的数据
					while ((b = in.read()) != -1) {// 只要有数据就一直读
						out.write(b);// 读一个写一个
					}
				} catch (IOException e) {// 捕获大点的异常
					e.printStackTrace();
				}finally{
					// TODO 4、释放资源
					try {
						out.close();
						in.close();
					} catch (IOException e) {
						e.printStackTrace();
					}					
				}
			}
			// 字节流操作
			private static void copy(File from, File to) {
				try {
					// 1、读取源文件 -- 字节流 高效流
					InputStream in = new BufferedInputStream(new FileInputStream(from));
					// 2、把数据写出到 目标文件中
					OutputStream out = new BufferedOutputStream(new FileOutputStream(to));
					// 3、边读边写
					int b = 0; // 定义变量，记录读取到的数据
					while ((b = in.read()) != -1) {// 只要有数据就一直读
						out.write(b);// 读一个写一个
					}
					// TODO 4、释放资源
					in.close();
					out.close();
				} catch (IOException e) {// 捕获大点的异常
					e.printStackTrace();
				}
			}
		}

批量读写

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
//这个类用来测试  文件复制
//1、读取源文件
		//2、把数据写出到 目标文件中
		public class test4{
			public static void main(String[] args) {
				File from = new File("C:\\Users\\Administrator\\Desktop\\test\\1.txt");// 源文件
				File to = new File("C:\\Users\\Administrator\\Desktop\\test\\2.txt");// 目标文件
				copy2(from, to);// 完成复制 -- 字符流--只能操作字符文件
			}
			// 字符流操作  --  只能操作字符文件 
			private static void copy2(File from, File to) {
				Reader in = null;
				Writer out = null;
				try {
					// 1、读取源文件 -- 字节流 高效流
					in = new BufferedReader(new FileReader(from));
					// 2、把数据写出到 目标文件中
					out = new BufferedWriter(new FileWriter(to));
					//批量读写，数组的容量到底多大是比较合适的？8*1024=8K
					char[] cs = new char[8*1024]  ;
					int b = 0; // 定义变量，记录读取到的数据
					while ((b = in.read(cs)) != -1) {// read(char[]) --按照数组的容量读取数据--批量读取
						out.write(cs,0,b);//write(char[]) --按照数组的容量写出数据-- 批量写出
				//write(m,n,o);--m是你要写出的数组名--n是你要从数组的哪个位置开始向后写出--o是你要写出多少数据(有多少写多少)
					}
				} catch (IOException e) {// 捕获大点的异常
					e.printStackTrace();
				}finally{
					// TODO 4、释放资源
					try {
						in.close();
						out.close();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}

序列化/反序列化

序列化:把 java 程序中的对象,永久存储到磁盘的过程

 ObjectOutputStream

   ObjectOutputStream(OutputStream out) 

   void writeObject(Object obj)

 将指定的对象写入 ObjectUtputStream

反序列化: 把磁盘中的已经 序列化 好 的文件,恢复到 java 程序中

 ObjectInputStream

   ObjectInputStream(InputStream out) 

   void readObject()

		package test;
		import java.io.FileInputStream;
		import java.io.FileNotFoundException;
		import java.io.FileOutputStream;
		import java.io.IOException;
		import java.io.ObjectInputStream;
		import java.io.ObjectOutputStream;
		import java.io.Serializable;

		//这个类用来测试  对象的序列化
		public class test5 {
			public static void main(String[] args) {
				method();  //完成序列化
				method2();  //完成反序列化
			}
			//反序列化：磁盘中 -- > java对象 ---ObjectInputStream
			private static void method2() {
				try {
					ObjectInputStream in = new ObjectInputStream(new FileInputStream("C:\\Users\\Administrator\\Desktop\\test\\1.txt"));
					//反序列化方法
					Object obj = in.readObject();
					//Student [name=皮皮霞, age=18, score=99.9]
					System.out.println(obj);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			//序列化：java对象 -- > 磁盘中---ObjectOutputStream
			private static void method() {
				try {
					//1、创建对象
					Student s = new Student("皮皮霞",18,99.9);
					ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream( "C:\\Users\\Administrator\\Desktop\\test\\1.txt" ) ) ;
					//2、完成序列化，序列化文件我们看不懂！！
					out.writeObject(s);
					//3、释放资源
					out.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}	
		//4、创建学生类  ，如果想要完成序列化，必须实现序列化接口，否则java.io.NotSerializableException
		class Student  implements  Serializable{
			//5、实现序列化接口后，要生成唯一的版本号id值作为文件的标志
			private static final long serialVersionUID = 1L;
			//构造方法
			public Student() {}
			public Student(String name, int age, double score) {
				this.name = name;
				this.age = age;
				this.score = score;
			}
			private String name;
			private int age;
			private double score;

			//set()/get()
			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 double getScore() {
				return score;
			}
			public void setScore(double score) {
				this.score = score;
			}
		//	toString()为了方便查看对象的属性值而不是地址值
			@Override
			public String toString() {
				return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
			}
		}

编码转换流

解决 字符流 读写乱码现象
OutputStreamWriter: 转换流,把字节输出流 转成 字符 输出流
继承自 Writer

 OutputStreamWriter(OutputStream out)

 OutputStreamWriter(OutputStream out,String CharsetName)

InputStreamReader: 转换流,把字节读取流 转成 字符 读取流
继承自 Reader

InputStreamReader(InputStream in)

InputStreamReader(InputStream in, String charsetName)

package test;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class test5 {
	public static void main(String[] args) {
		try {
		 //1、创建字节流
			OutputStream out = new FileOutputStream("D:\\javaStudy\\tedu\\day14\\test\\1.txt");
			//2、创建字符流，OutputStreamWriter 用来把字节输出流 转换成 字符输出流
		    //OutputStreamWriter(m,n)--m是要写出的字节流对象，n是要使用的编码表
			Writer out2 = new OutputStreamWriter(out,"gbk")  ;  
			//3、写出字符串
			out2.write("大家好，我叫渣渣辉");
			//4、释放资源
			out2.close();
					
			System.out.println();
					
			InputStream in = new FileInputStream("D:\\javaStudy\\tedu\\day14\\test\\1.txt");
			//5、读取时乱码，也可以设置编码表来解决乱码现象
			BufferedReader reader = new BufferedReader (new InputStreamReader(in,"gbk")   );
			//打印读取到的一整行数据
			System.out.println(  reader.readLine() );
			} catch (Exception e) {
					e.printStackTrace();
		}
	}
}