简介
对于任何程序设计语言，输入和输出(Input\Output)都是系统非常核心的功能，程序运行需要数据，而数据的获取往往需要跟外部系统进行通信，外部系统可能是文件、数据库、其他程序、网络、IO设备等等，外部系统比较复杂多变，那么我们有必要通过某种手段进行抽象、屏蔽外部的差异，从而实现更加便捷的编程。
1.输入：指的是可以让程序从外部系统取得数据，常见的应用有：
- 读取硬盘上的文件内容到程序
- 读取网络上某个位置内容到程序
- 读取数据库系统的数据到程序
- 读取某些硬件系统的数据到程序
2.输出：指的是程序输出数据给外部系统从而可以操作外部系统，常见的应用有：
- 将数据写到硬盘中
- 将数据写到数据库系统中
- 将数据写到某些硬件系统中
Java中流(Stream)的概念
当程序需要读取数据源的数据时，就会通过IO流对象开启一个通向数据源的流，通过这个IO流对象的相关方法可以顺序读取数据源中的数据。 流对象使用完，必须关闭！不然，总占用系统资源，最终会造成系统崩溃！
import java.io.*;
public class TestIO {
public static void main(String[] args){
FileInputStream fis = null;
try {
fis = new FileInputStream("路径");
StringBuilder sb = new StringBuilder();
int temp =0;
while((temp = fis.read())!=-1){
sb.append((char)temp);
}
System.out.println(sb);
}catch (Exception e){
e.printStackTrace();
}finally {
try {
if(fis!=null){
fis.close();
}
}catch (IOException e){
e.printStackTrace();
}
}
}
}
四大抽象IO类
InputStream/OutputStream和Reader/writer类是所有IO流类的抽象父类，我们有必要简单了解一下这个四个抽象类的作用。然后，通过它们具体的子类熟悉相关的用法。
·InputStream
此抽象类是表示字节输入流的所有类的父类。InputSteam是一个抽象类，它不可以实例化。 数据的读取需要由它的子类来实现。根据节点的不同，它派生了不同的节点流子类 。
继承自InputSteam的流都是用于向程序中输入数据，且数据的单位为字节(8 bit)。
常用方法：
int read()：读取一个字节的数据，并将字节的值作为int类型返回(0-255之间的一个值)。如果未读出字节则返回-1(返回值为-1表示读取结束)。
void close()：关闭输入流对象，释放相关系统资源。
· OutputStream
此抽象类是表示字节输出流的所有类的父类。输出流接收输出字节并将这些字节发送到某个目的地。
常用方法：
void write(int n)：向目的地中写入一个字节。
void close()：关闭输出流对象，释放相关系统资源。
· Reader
Reader用于读取的字符流抽象类，数据单位为字符。
int read(): 读取一个字符的数据，并将字符的值作为int类型返回(0-65535之间的一个值，即Unicode值)。如果未读出字符则返回-1(返回值为-1表示读取结束)。
void close() ： 关闭流对象，释放相关系统资源。
· Writer
Writer用于写入的字符流抽象类，数据单位为字符。
void write(int n)： 向输出流中写入一个字符。
void close() ： 关闭输出流对象，释放相关系统资源。
文件操作
关于文件类的操作。数据存在变量，数组和对象中，但是这些都是临时的，当程序中断了，这些数据都会消失，为了永久的存储这些在程序中创造的数据，你需要将这些数据存在一个文件里面，然后将这些文件放在磁盘或者CD上，文件可以传递，同时这些文件可以被后来的程序所访问。
每个文件都是直接放在文件系统中的，绝对文件名包含了文件的名称和全部路径名，这些都可以在操作系统的层面上看到。从某种角度来看，其实Java的虚拟机也可以看做是某种操作系统。
文件类 File Class
method : +File(pathname: String), +File(parent: String, Child: String), +File(parent: File, Child: String)
+exists(): boolean +canRead():boolean +canRead():boolean +canWrite():boolean
文件的输入和输出
File对象封装了文件的内容或者文件的路径，但是没有包含创建文件的方法，也么有从文件里面读或者写，为了实现输入和输出，你必须要创建对象，然后使用Java IO的类，这些对象包含了对文件读写方法。
使用PrintWriter写数据
Java.io.printWriter 类可以使用来创建文件，并且对文件写入数据，首先创建PrintWriter对象
PrintWriter output = new PrintWriter(filename);
然后你可以使用print ,println和printf的方法。
WriteData.java
public class WriteData {
public static void main(String[] args) throws Exception {
java.io.File file = new java.io.File("scores.txt");
if (file.exists()) {
System.out.println("File already exists");
System.exit(0);
}
// Create a file java.io.PrintWriter output = new java.io.PrintWriter(file);
/ Write formatted output to the file
output.print("John T Smith ");
output.println(90);
output.print("Eric K Jones ");
output.println(85);
// Close the file
output.close();
}
通过Scanner类读取数据：Java.util.Scanner类用于读字符串和最初的值--“从控制台读输入”，
从键盘读入时候的语法 : Scanner input = new Scanner(System.in);
从文件中读入时的语法 : Scanner input = new Scanner(new File(filename));
注意到 new Scanner(string) 创建了一个Scanner来赋予String，为了使得Scanner 能够从文件里面读取数据，你要使用Java.io.File类来创建一个File实例，使用如下的创建方法，new File(filename)，然后使用 Scanner（File）来创建一个Scanner用于文件。
序列化和反序列化
当两个进程之间进行通信时，彼此可以发送各种类型的数据，无论是何种类型的数据，都会以二进制序列的形式进行传送，例如http协议发送字符串信息，也可以支架发送Java对象，发送方需要将这个Java对象转换成字节序列，才能在网络上进行传送，接收方则需要把字符串序列再恢复成Java对象才能正常读取。把Java对象转换为字节序列的的过程称为对象的序列化，把字节序列恢复为Java对象的过程称为对象的反序列化，对象的序列化有如下两种作用：
- 持久化：把对象的字节序列永久地保留在硬盘上，通常存放在一个文件中，比如：休眠的实现，以后服务器session管理，hibernate将对象持久化实现。
- 网络通信：在网络上传送对象的字节序列。例如：服务器时间的数据通信、对象传递。
ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
ObjectInputStream代表兑现输入流，它的readObject(Object obj)方法从一个源输入流中读取字节序列，再把他们反序列化为一个对象，并将其返回
只有实现了Serializable接口的类的对象才能被序列化。Serializable接口是一个空接口，只起到标记作用
import java.io.*;
public class SerializableDemo {
public static void main(String[] args) {
FileOutputStream fos = null;
FileInputStream fis = null;
ObjectInputStream ois = null;
ObjectOutputStream oos = null;
try {
PersonDemo pd = new PersonDemo(18,true,"Ling");
System.out.println("--------------pd-----------");
System.out.println(pd);
fos = new FileOutputStream("d:/fos.txt");
oos = new ObjectOutputStream(fos);
oos.writeObject(pd);
oos.flush();
fis = new FileInputStream("d:/fos.txt");
ois = new ObjectInputStream(fis);
PersonDemo pd2 = (PersonDemo) ois.readObject();
System.out.println("--------------pd-----------");
System.out.println(pd2);
}catch (ClassNotFoundException e){
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}finally {
if(oos!=null){
try {
oos.close();
}catch (Exception e){
e.printStackTrace();
}
}
if(fos!=null){
try {
fos.close();
}catch (IOException e){
e.printStackTrace();
}
}
if(fis!=null){
try {
fis.close();
}catch (IOException e){
e.printStackTrace();
}
}
if(ois!=null){
try {
ois.close();
}catch (IOException e){
e.printStackTrace();
}
}
}
}
}
- static属性不参与序列化
- 对象中的某些属性如果不想被序列化，不能使用static，而是使用transient修饰
- 为了防止读和写的序列化ID不一致，一般指定一个固定的序列化ID
