缓冲流和对象流

缓冲流实例：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;


//BufferedReader/BufferedWriter
public class Learn1 {
public static void main(String[] args) {
FileReader in = null;
BufferedReader bufferedReader = null;

FileWriter fileWriter = null;
BufferedWriter bufferedWriter = null;


//现在将读取的内容存到磁盘中没有的路径上
File file = new File("e:/j151");

File file2 = new File(file, "B.txt");

if(!file2.exists()) {
file.mkdirs();//创建目录--只创建目录，不应该包含文件
try {
file2.createNewFile();//创建文档
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

try {
in = new FileReader("E:/A.txt");
bufferedReader = new BufferedReader(in);

fileWriter = new FileWriter(file2);
bufferedWriter = new BufferedWriter(fileWriter);

String str = null;
while((str=bufferedReader.readLine())!=null) {
bufferedWriter.write(str);//输出一行
bufferedWriter.newLine();//新的一行
}
bufferedWriter.write("你结束了~");//可以自行书写

fileWriter.flush();
bufferedWriter.flush();

} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(in!=null) {
in.close();
}
if(bufferedReader!=null) {
bufferedReader.close();
}
if(fileWriter!=null) {
fileWriter.close();
}
if(bufferedWriter!=null) {
bufferedWriter.close();
}
} catch (Exception e2) {
System.out.println("错了");
}
}
}

}

————————————————————————————————

对象流实例：

import java.io.Serializable;


//Serializable接口没有需要实现的方法，其作为标记接口存在
//什么是标记接口？--具有特殊含义但不需要重写方法的接口
//实现了Serializable接口表示已经可以序列化
public class Student implements Serializable{
private String name;
private int age;

public Student() {
}


public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}


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 "Student [name=" + name + ", age=" + age + "]";
}
}

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.util.ArrayList;
import java.util.List;

//对象流
//对象流也有输入输出流--
public class Learn {
public static void main(String[] args) {
Student stu =  new Student("小强",18);
Student stu1 =  new Student("校花",17);

FileOutputStream out = null;
ObjectOutputStream objOut = null;

FileInputStream in = null;
ObjectInputStream objIn = null;
try {
in = new FileInputStream("use/user.txt");//当前工程中的存储路径
objIn = new ObjectInputStream(in);

out = new FileOutputStream("use/user.txt");//从源文件中读取
objOut = new ObjectOutputStream(out);
//如果要输出一个对象，则需要将其类进行序列化
//什么是序列化呢？--让类实现Serializable接口
//否则出现异常java.io.NotSerializableException
   //objOut.writeObject(stu);

//现在有个疑问，如何存多个对象？
List<Student> list =  new ArrayList<Student>();
list.add(stu);
list.add(stu1);
//如果是使用集合存入，则需要注意一点，里面的对象所对应的类都需要序列化
objOut.writeObject(list);//写入
//如何将存入的序列化的内容取出？--反序列化(创建对象的第二种方式)
List<Student> list1 = (List<Student>) objIn.readObject();
System.out.println(list1.get(0).getName());
out.flush();
objOut.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}finally {
try {
if(objOut!=null) {
objOut.close();
}
if(out!=null) {
out.close();
}
} catch (Exception e2) {
System.out.println("错了");
}
}
}
}