Java的学习之路Day11

                                      Day11

一、java中的流

1、java中将流分成了几个类别：高级流、低级流、字节流、字符流。其中低级流是直接和文件打交道的，直接操作文件；高级流操作低级流，对低级流进行封装，方便我们使用；字节流操作字节，一般字节流都会以Stream结尾；字符流操作字符。

字节读写流的爸爸：InputStream 读 爸爸  OutputStream 写 爸爸

字符读写流的爸爸：Reader 读 爸爸  Writer 写 爸爸

常见的字节流：-FileIntputStream；FileOutputStream；

                       -ObjectInputStream；ObjectOutputStream

                       -BufferedInputStream；BufferedOutputStream

常见的字符流：-InputStreamReader；OutputStreamWriter；（可以将这两个看成是一个转换流，他是将字节流转换为字符流）

                        -BufferedReader；PrintWriter；commons-io.jar

二、java流的操作

1、通过低级流来操作文件（FIS,FOS）

@Test
 public void test01() throws Exception {
	FileInputStream fis=new FileInputStream("李**.mp3");
	FileOutputStream fos=new FileOutputStream("李**_02.mp3");
	byte[] data=new byte[1024*10];
	int len=-1;
	System.out.println("开始复制");
	long start= System.currentTimeMillis();
	while((len=fis.read(data))!=-1) {
		fos.write(data,0,len);
	}
	System.out.println("复制结束");
	long end=System.currentTimeMillis();
	System.out.println("耗时："+(end-start));
	fis.close();
	fos.close();

2、高级流通过低级流来实现文件的操作（BOS,BIS）

@Test
 public void test02() throws Exception {
	FileInputStream fis=new FileInputStream("李**_02.mp3");
	FileOutputStream fos=new FileOutputStream("李**_03.mp3");
	BufferedInputStream bis=new BufferedInputStream(fis);
	BufferedOutputStream bos=new BufferedOutputStream(fos);
	int len=-1;
	System.out.println("开始复制");
	while((len=bis.read())!=-1) {
		bos.write(len);
	}
	System.out.println("复制结束");
	
}

3、覆盖写，将文件里面的内容覆盖掉

@Test
public void test03() throws Exception {
	FileOutputStream fos=new FileOutputStream("arr.txt");
	BufferedOutputStream bos=new BufferedOutputStream(fos);
	String str="我爱李**，真的！";
	bos.write(str.getBytes());
	bos.close();
	
}

4、追加写，在文件里面添加内容

@Test
public void test04() throws Exception{
	FileOutputStream fos=new FileOutputStream("arr.txt",true);
	BufferedOutputStream bos=new BufferedOutputStream(fos);
	String str="美女，约吗？";
	bos.write(str.getBytes());
	bos.close();
	
}

5、printWrite 字符流的操作。它非常适合按行输出的文件操作

@Test
public void test05() throws Exception{
 	FileOutputStream fos=new FileOutputStream("李**.txt");
 	PrintWriter pw=new PrintWriter(fos);
 	pw.println("我爱李**");
 	pw.close();



}

想要多行追加则需要如下代码：

@Test
public void test05() throws Exception{
 	FileOutputStream fos=new FileOutputStream("李**.txt",true);
 	//自动行刷新，追加行数据，只有在第一个参数是流的情况下才可以传
 	//布尔类型，在print不是println时，需要手动刷新。
 	PrintWriter pw=new PrintWriter(fos);
 	pw.println("我是某某某");
 	pw.close();

6、按行读取文件的数据

@Test
public void test06() throws Exception{
	FileInputStream fis=new FileInputStream("src/dbConfig.txt");
	//它和OutputStreamReader一起，将字节流转换为字符流
	InputStreamReader isr=new InputStreamReader(fis);
	BufferedReader BR=new BufferedReader(isr);
	/*readLine()读取一行数据，读取到末尾返回值-1，但是有兼容性问题
	 * Windows默认为null
	 * Linux则是空指针异常
	 */
	String line="null";
	while((line=BR.readLine())!=null) {
		System.out.println(line);
	} 

按行读取文件时还可以截取自己想要的文件内容，但是必须要找到每行共有的属性，否则我也不知道

@Test
public void test06() throws Exception{
	FileInputStream fis=new FileInputStream("src/dbConfig.txt");
	//它和OutputStreamReader一起，将字节流转换为字符流
	InputStreamReader isr=new InputStreamReader(fis);
	BufferedReader BR=new BufferedReader(isr);
	/*readLine()读取一行数据，读取到末尾返回值-1，但是有兼容性问题
	 * Windows默认为null
	 * Linux则是空指针异常
	 */
	String line="null";
	while((line=BR.readLine())!=null) {
		//重新定义一个字符串，使用字符串的API来获取想要的字符串内容
		String str=line.substring(line.indexOf("=")+1);
		System.out.println(str);
	} 

三、序列化和反序列化

1、什么是序列化？序列化就是将数据结构转换成字节的过程。

2、什么是反序列化？反序列化就是将字节转化为数据结构的过程。

3、如何实现序列化？如果这个类需要序列化，那么它需要一个空的接口（implements Serializable ），需要给该类添加一个版本号，这个版本号非常重要，它影响着反序列化是否成功。

首先定义一个类：

package javaSEDay16_1;

import java.io.Serializable;

public class student implements Serializable{

	private static final long serialVersionUID = 1L;
     /*这个就是版本号，如果反序列化的时候的版本号和序列化的版本号
      * 不一致，那么反序列化就会失败。
      * 这个属于javaBean的规范
      * 1.属性的私有化
      * 2.对外提供公开的访问和修饰方法
      * 3.重写hashcode和equals方法
      * 4.重写tostring
      * 5.实现Serializable接口
      * 6.给类提供相应的版本号
      * 7.如果属性中有trainsient关键字修饰
      * 那么这个属相在序列化的时候会被排除
      */
	 /*反序列化和版本号的关系
	  * 如果在反序列化的时候，程序会先检查版本号，如果版本号和序列化的版本号不一致
	  * 那么就会抛出异常，如果版本号一直，就会启用兼容模式，在序列化中有属性就输出，
	  * 没有就用默认值替换
	  */
	  private String name;
	  private int age;
	public student() {
		super();
		// TODO Auto-generated constructor stub
	}
	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 int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		student other = (student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	@Override
	public String toString() {
		return "student [name=" + name + ", age=" + age + "]";
	}
	public student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
}

然后进行序列化：

package javaSEDay16_1;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class oos {
	/*
	 * 序列化
	 * 将一个学生对象转为字节，存储到硬盘上
	 */
   public static void main(String[] args) throws Exception {
	student stu=new student("周某人最帅",22);
	System.out.println(stu);
	FileOutputStream fos=new FileOutputStream("帅逼.txt");
	ObjectOutputStream oos=new ObjectOutputStream(fos);
	oos.writeObject(stu);
	oos.close();
	
}
}

接着在进行反序列化：

package javaSEDay16_1;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.ObjectInputStream;
/*
 * 反序列化，将字节转换为数据结构
 */
public class OIS {
	public static void main(String[] args) throws Exception {
		FileInputStream fis=new FileInputStream("帅逼.txt");
		ObjectInputStream ois=new ObjectInputStream(fis);
		/*
		 * 反序列化的方法
		 */
		student stu=(student) ois.readObject();
		System.out.println(stu);
	}
	}