IO基础之对象流、打印流、标准的IO和扫描器类的简单说明

对象流：（序列化和反序列化）

序列化：指把堆内存中的Java对象数据，通过某种方式把对象存储到磁盘文件中或者传递给其他的网络节点（在网络上传输）我们把这个过程称之为序列化。
反序列化：把磁盘文件中的对象数据或者把网络节点的对象数据，恢复成Java对象的过程。

为什么需要序列化：

1、在分布式系统中，需要共享数据的JavaBean对象，都得做序列化，此时下需要把对象在网络上传输，此时就得把对象数据转换为二进制形式。

以后存储在HttpSession中的对象，都应该实现序列化接口（只有实现序列化接口的类，才能做序列化操作）。

2、服务钝化：如果服务发现某些对象好久都没有活动了，此时服务器就会把这些内存中的对象，持久化在本地磁盘文件中（Java对象-->二进制文件）。

如果某些对象需要活动的时候，先在内存中去寻找，找到就使用。找不到再去磁盘文件中，反序列化我们的对象数据，恢复成Java对象。

需要做序列化的对象的类，必须实现序列化接口：java.io.Serializable接口（标志接口[没有抽象方法]）

底层会做判断，如果当前对象是Serializable的实例，才允许做序列化：boolean ret = java对象 instanceof Serializable;

在Java中大多数类都已经实现Serializable接口。

使用对象流来完成序列化和反序列化操作：

ObjectOutputStream：通过writeObject方法做序列化操作的；

ObjectInputStream：通过readObject方法做反序列化操作的。

准备一个Person类：

import java.io.Serializable;

/**
* Created by Layne_Yao on 2017-7-29 下午4:49:43.
* CSDN:http://blog.csdn.net/Jsagacity
*/
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private String sex;
private transient String password;//无需序列化
private int age;

public Person(String name, String sex, String password, int age) {
this.name = name;
this.sex = sex;
this.password = password;
this.age = age;
}

@Override
public String toString() {
return "Person [name=" + name + ", sex=" + sex + ", password="
+ password + ", age=" + age + "]";
}
}

对象流序列化操作：

/**
* Created by Layne_Yao on 2017-7-29 下午4:49:25.
* CSDN:http://blog.csdn.net/Jsagacity
*/
public class ObjectStreamDemo {

public static void main(String[] args) throws Exception {
File file = new File("obj.txt");
writeObject(file);
readObject(file);
}

// 序列化操作
private static void writeObject(File file) throws Exception {
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
file));
out.writeObject(new Person("Layne", "man","123456", 20));
out.close();
}

//反序列化操作
private static void readObject(File file) throws Exception {
ObjectInputStream in = new ObjectInputStream(new FileInputStream(
file));
Person person = (Person) in.readObject();
System.out.println(person);
in.close();
}
}

运行结果：



做反序列化操作必须存在对象的字节码对象。

序列化的细节，序列化的版本：

1、如果某些数据不需要做序列化，比如密码，该怎么做？

   理论上说，静态的字段和瞬态的字段是不能做序列化操作的。

   解决方案：给该字段加上一个修饰符：transient

2、序列化的版本问题：

  反序列化Java对象时必须提供该对象的class文件，现在问题是，随着项目的升级，系统的class文件也会升级（增加一个字段，或删除一个字段），

   这是如何保证两个class文件的兼容性？

   Java通过serialVersionUID（序列化版本号）来判断字节码是否发生改变。如果不显示定义serialVersionUID类变量，该类变量的值由JVM根据类相关信息计算，而修改后的类计算方式和之前往往不同。

   解决方案：在类中提供一个固定的serialVersionUID。

           private static final long serialVersionUID = 1L;

打印流：打印数据的，打印流只能是输出流

PrintStream:字节打印流
PrintWriter:字符打印流

对于PrintWriter来说，当启用字段刷新之后，

PrintWriter pw = new PrintWriter(new FileOututStream(new File("file/out")),true);

调用println、或者printf、或者format方法，便会立马刷新操作

如果没有开启自动刷新，则需要手动刷新或者当缓冲区满的时候，再自动刷新

使用打印流作为输出流，此时的输出操作会特别简单因为在打印流中：
提供了print方法：打印不换行
提供了println方法：打印再换行
print和println方法可以支持打印输出各种数据类型的数据，记住void println(Object x)即可。

字节打印流：

public class PrintStreamDemo {
public static void main(String[] args) throws Exception {
PrintStream ps = new PrintStream(new File("file/out.txt"));
ps.write("ABC".getBytes());
ps.print(false);
ps.print(18);
ps.print("layne");

//其实可以不用刷新
ps.close();

}

}

字符打印流：

public class PrintWriterDemo {
public static void main(String[] args) throws Exception {
PrintWriter ps = new PrintWriter(new File("file/out.txt"));
ps.write("ABC");
ps.print(false);
ps.println(18);
ps.print("layne");

//其实可以不用刷新
ps.close();
}
}

打印流中的格式化输出（printf方法）：

System.out.println();其实等价于PrintStream ps = System.out; ps.println();

//Java的格式化输出
public class printfDemo {
public static void main(String[] args) {
//打印一句话，效果：姓名：layne，年龄：18
String name = "layne";
int age = 18;
//传统的打印风格
String str = "姓名："+name+"，年龄："+age;
System.out.println(str);

//格式化输出
String format = "姓名：%s，年龄：%d";
Object[] data = {name,age};
System.out.printf(format,data);
System.out.println();
//简化
System.out.printf("姓名：%s，年龄：%d",name,age);

}

}

运行结果：



标准的IO：

标准的输入：通过键盘录入数据给程序

标准的输出：在屏幕上显示程序的数据

在System类中有两个常量：

InputStream in = System.in;

PrintStream out = System.out;

标准流的重定向操作：
标准的输入：通过键盘录入数据给程序；
重新指定输入的源不再是键盘，而是一个文件。
static void setIn(InputStream in);重新分配“标准”输入流。
此后，System.in数据的来源就是通过setIn指定的源。
标准的输出：在屏幕上显示程序的数据
重新指定输出的目标不再是屏幕，而是一个文件。
static void setOut(PrintStream out);重新分配“标准”输出流。

public class SystemIODemo {
public static void main(String[] args) throws Exception {
// 重定向标准输入流
System.setIn(new FileInputStream("file/123_copy.txt"));
//重定向标准输出流
System.setOut(new PrintStream("file/print.txt"));

System.out.println("...开始...");
int data = System.in.read(); //读取文件123_copy.txt中的第一个字节
System.out.println(data);
System.out.println("...结束...");
}

}

Scanner：扫描类，在java.util包中，表示输入的操作
存在的方法：xxx表示数据类型，如byte，int，boolean等；
boolean hasNextXxx();//判断是否有下一种类型的数据
Xxx nextXxx();//获取下一个该类型的数据。

public class ScannerDemo {
public static void main(String[] args) throws Exception {
//扫描文件中的数据
//Scanner sc = new Scanner(new File("file/ch.txt"),"GBK");
//扫描键盘输入的数据
//Scanner sc = new Scanner(System.in);
//扫描字符串的数据
Scanner sc = new Scanner("这是扫描类，我是即将被扫描的数据！！！");
while(sc.hasNextLine()){
String line = sc.nextLine();
System.out.println(line);
}
}
}