二、处理流
2.引用类型，保留数据+类型
序列化：将对象保存到文件或者字节数组中保存起来，叫序列化。输出流：ObjectOutputStream。writeObject().
反序列化：从文件或者字节数组中拿出这个对象叫反序列化，反序列化也是创建对象的一种方式。输入流：ObjectInputStream。readObject().
注意：
1.先序列化后饭序列化
2.不是所有的对象都可以序列化，必须实现java.io.Serializable接口。
不是所有的属性都需要序列化。不序列化的属性使用transient。
**
* 空接口只是标识，告诉JVM这个对象可以序列化。
*/
public class Employee implements java.io.Serializable {
//不需要序列化
private transient String name;
//需要序列化
private double salary;
public Employee() {
}
public Employee(String name, double salary) {
super();
this.name = name;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
/**
* 不是所有的對象都可以序列化 java.io.NotSerializableException
* 不是所有的屬性都需要序列化 transient
*/
public class ObjectDemo01 {
public static void main(String[] args) throws ClassNotFoundException {
try {
seri("e:/xp/test/ser.txt");
read("e:/xp/test/ser.txt");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//反序列化
public static void read(String destPath) throws IOException, ClassNotFoundException{
//创建源
File src =new File(destPath);
//选择流，反序列化对象，所以选择ObjectInputStream这个输入流。输入输出流是以程序为中心，写到程序是输入流，从程序写出去是输出流。
ObjectInputStream dis =new ObjectInputStream(
new BufferedInputStream(
new FileInputStream(src)
)
);
//操作 读取的顺序与写出一致 必须存在才能读取
//不一致，数据存在问题
Object obj =dis.readObject();//先用Object接收，然后强制转换。
if(obj instanceof Employee){
Employee emp=(Employee)obj;
System.out.println(emp.getName());
System.out.println(emp.getSalary());
}
obj =dis.readObject();
int[] arr=(int[])obj;
System.out.println(Arrays.toString(arr));
dis.close();
}
//序列化
public static void seri(String destPath) throws IOException{
String s;
Integer a;//String自己实现了序列化接口，所以可以自动序列化，没有实现java.io.Serializable接口的，手动实现这个接口就可以序列化了。
Employee emp =new Employee("bjsxt",1000000);
int[] arr ={1,2,3,45};//数组也是对象，所以也可以序列化。数组是实现了java.io.Serializable接口，不能序列化的就要手动实现java.io.Serializable接口。
//创建源对象
File dest =new File(destPath);
// 由于是写入对象，所以选择流 ObjectOutputStream
ObjectOutputStream dos =new ObjectOutputStream(
new BufferedOutputStream(
new FileOutputStream(dest)
)
);
//操作 写出的顺序 为读取准备
dos.writeObject(emp);//向文本中写入对象
dos.writeObject(arr);
//释放资源
dos.close();
}
}
流关闭的方法：
1.编写工具类，实现关闭功能。
import java.io.Closeable;
public class FileUtil {
/**
* 工具类关闭流
* 可变参数: ... 只能形参最后一个位置,处理方式与数组一致
* FileUtil.closeAll(os,is);
*/
public static void close(String info, int a , float b,Closeable ... io){//3个点表示可变参数，个数随便，但是类型是Closeable。
for(Closeable temp:io){
try {
if (null != temp) {
temp.close();//凡事实现了Closeable接口的都有close()方法。
}
} catch (Exception e) {
}
}
}
/**
* 使用泛型方法
*/
public static <T extends Closeable> void closeAll(T ... io){
for(Closeable temp:io){
try {
if (null != temp) {
temp.close();
}
} catch (Exception e) {
}
}
}
}
jdk1.7之后的新特性关闭流：
/**
* 1.7新特性 try --with --resource
* @param srcPath
* @param destPath
* @throws FileNotFoundException
* @throws IOException
*/
public static void copyFile2(String srcPath,String destPath) throws FileNotFoundException,IOException {
//1、建立联系 源(存在且为文件) +目的地(文件可以不存在)
// File src =new File(srcPath);
//File dest =new File(destPath);
//if(! src.isFile()){ //不是文件或者为null
/// System.out.println("只能拷贝文件");
// throw new IOException("只能拷贝文件");
//}
//2、选择流
try(//声明的部分加载try里面
InputStream is =new FileInputStream(src);
OutputStream os =new FileOutputStream(dest);
){
//3、文件拷贝 循环+读取+写出
byte[] flush =new byte[1024];
int len =0;
//读取
while(-1!=(len=is.read(flush))){
//写出
os.write(flush, 0, len);
}
os.flush(); //强制刷出
}catch(e){
}
}
/**
* PrintStream 打印流(字节流)，肯定是一个处理流
*/
public class PrintStreamDemo01 {
public static void main(String[] args) throws FileNotFoundException {
System.out.println("test");
PrintStream ps =System.out;
ps.println(false);
//输出到文件
File src = new File("e:/xp/test/print.txt");
ps = new PrintStream(new BufferedOutputStream(new FileOutputStream(src)));//java.io.PrintStream.PrintStream(OutputStream out)
ps.println("io is so easy....啊啊啊啊啊啊啊啊");//这样就写入到文件了。
ps.close();
}
}
/**
* 三个常量
* 1、System.in 输入流 键盘输入
* 2、System.out 输出流 控制台输出
* System.err，通常用于输出错误。
*
* ==>重定向
* setIn()
* setOut()
* setErr()
* FileDescriptor.in
* FileDescriptor.out
*/
public class SystemDemo01 {
public static void main(String[] args) throws FileNotFoundException {
test1();
test2();
//重定向，System.out.println不再向控制台输出，而是向文件中输出。true表示自动刷新。
System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream("e:/xp/test/print.txt")),true));//e:/xp/test/print.txt不存在可以创建
System.out.println("a嗖嗖嗖"); //控制台 -->文件
System.out.println("test柔柔弱弱");
while(true){System.out.println("back..ss嗖嗖嗖.."+i);i++;}//一直往文件中写
//回控制台
System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)),true));//FileDescriptor.out就代表了控制台，控制台也是一个文件。
System.out.println("back..ss嗖嗖嗖..");//
}
public static void test2() throws FileNotFoundException{
InputStream is =System.in; //System.in代表键盘输入
//is = new BufferedInputStream(new FileInputStream("e:/xp/test/print.txt"));//从文件输出到控制台。
Scanner sc = new Scanner(is);//Scanner也是一个处理流。
System.out.println("请输入:");//这是一个阻塞
System.out.println(sc.nextLine());//输出键盘输入的内容
}
public static void test1(){
System.out.println("test");
System.err.println("err");//输出为红色。System.out和System.err是一样的，只是颜色不同，System.err用于输出错误信息，System.out用于输出一般的信息。
}
}
/**
* 自己封装一个输入
*/
public class BuffereIn {
public static void main(String[] args) throws IOException {
InputStream is =System.in;//System.in是一个节点流，并且是一个字节流，也是输入流。
BufferedReader br = new BufferedReader(new InputStreamReader(is));
System.out.println("请输入。。。。");
String msg =br.readLine();//这行执行后程序会阻塞等待输入。
System.out.println(msg);
}
}
