io（输入输出流）

字节流：InputStream、OutputStream

字符流：Reader、Writer

InputStream子类：ByteArrayInputStream、FileInputStream、FilterInputStream(子类：BufferedInputStream、DataInputStream)、PipedInputStream、SequenceInputStream、ObjectInputStream

OutPutStream:ByteArrayOutputStream、FileOutStream、FilterOutStream(子类：BufferedOutputStream、PrintStream、DataOutputStream)、PipedOutStream、ObjectInputStream

字节流读写文件：

在操作文件时，最常见的就是从文件中读取数据并将数据写入文件。

读文件：FileInputStream

写文件：FileOutputStream

这两个类可以创建文件字节输入和输出流，然后再利用其他的类对其进行包装使用。

读写文件时是以字节流的形式的，所以输出是以数字的形式显示的。

最后需要调用close()来关闭输入输出流

字节缓冲流：BufferedInputStream、BufferedOutputStream

字符流：FileReader、FileWriter

转换流：InputStreamReader、OutputStreamWriter（用来将字节流转换成字符流）

package io;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class Example05 {
public static void main(String[] args) throws Exception{
FileInputStream in=new FileInputStream("src.txt");
InputStreamReader isr=new InputStreamReader(in);
BufferedReader br=new BufferedReader(isr);
FileOutputStream out=new FileOutputStream("des.txt");
OutputStreamWriter osw=new OutputStreamWriter(out);
BufferedWriter bw=new BufferedWriter(osw);
String line;
while((line=br.readLine())!=null){
bw.write(line);
}
br.close();
bw.close();
}
}

对象的序列化和反序列化：利用ObjectInputStream和ObjectOutStream

当对象序列化时必须保证该对象实现Serializable接口，否则会出现NotSerializableException异常。

当对象序列化在objectStream.txt文件上时，会出现乱码现象

对此网友的解释是：

现在问题来了，好多人会发现，在反序列化程序中运行后能够正常输出Person的相关信息，但是在目录下的文件“person.obj”用文本编辑器打开之后却是乱码的。这是为什么呢？是不是因为写出去的编码和文本编辑器的默认编码采用了不一样的字符集？然后我们就开始想怎么能够将二者的编码格式设为一致的。

其实，这么想一开始就是错误的。为什么这么说呢，因为序列化和反序列化都是基于二进制流的，也就是说，在第二步中，其实就是将person的相关信息转化为二进制存储在了person.obj这个文件中，那么用文本编辑器打开查看的话当然是会出现乱码的。只有通过反序列化才能将存储的二进制读取出来，然后正常显示在控制台上。

（摘自：http://blog.csdn.net/QPC908694753/article/details/71629216）

package io;
import java.io.*;
public class Example06 {
public static void main(String[] args) throws Exception{
Person p=new Person("p1", "zhangsan", 20);
System.out.println("---------写入文件前-----------");
System.out.println("Person对象的id:"+p.getId());
System.out.println("Person对象的name:"+p.getName());
System.out.println("Person对象的age:"+p.getAge());
FileOutputStream fos=new FileOutputStream("objectStream.txt");
// OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("objectStream.txt",true),"UTF-8");
ObjectOutputStream oos=new ObjectOutputStream(fos);
oos.writeObject(p);
oos.close();
}
}
class Person implements Serializable{
private String id;
private String name;
private int age;
public Person(String id, String name, int age) {
super();
this.id = id;
this.name = name;
this.age = age;
}
public String getId() {
return id;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}

PrintStream:提供了一系列用于打印数据的print()和println()方法，被称作打印。

package io;
import java.io.*;
public class Example08 {
public static void main(String[] args) throws Exception{
PrintStream ps=new PrintStream(new FileOutputStream("printStream.txt"));
Student stu=new Student();
ps.print("这是一个数据:");
ps.println(19);
ps.println(stu);
}
}
class Student{
public String toString(){
return "我是一个学生";
}
}

标准输入输出流：

in 标准输入流

out标准输出流

err标准错误流

setIn(InputStream in)对标准输入流重定向

setOut(PrintStream out)对标准输出流重定向

setErr(PrintStream out)对标准错误刘重定向

管道输入流：PipedInputStream

管道输出流：PipedOutputStream

用与多线程间的通信，要先建立连接才能进行彼此间的通信。用connect()进行连接。

package io;
import java.io.*;
public class Example11 {
public static void main(String[] args) throws Exception{
final PipedInputStream pis=new PipedInputStream();
final PipedOutputStream pos=new PipedOutputStream();
pis.connect(pos);//输入管道和输出管道建立连接
new Thread(new Runnable(){
@Override
public void run() {
// TODO Auto-generated method stub
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
PrintStream ps=new PrintStream(pos);
while(true){
try {
System.out.println(Thread.currentThread().getName()+"要求输入内容：");
ps.println(br.readLine());
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
},"发送数据的线程").start();

new Thread(new Runnable(){
@Override
public void run() {
// TODO Auto-generated method stub
BufferedReader br=new BufferedReader(new InputStreamReader(pis));
String line;
while(true){
try {
System.out.println(Thread.currentThread().getName()+"收到的内容："+br.readLine());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
},"接受数据的线程").start();
}
}

对发送数据的线程：先从键盘读取数据，然后写入管道流

对接受数据的线程：从管道流读取数据，然后输出

ByteArrayOnputStream：byte型的字节数组的缓冲区，当向字节数组写数据时，该对象会把所有的数据先写入缓冲区，最后再一次性写入文件。

ByteArrayInputStream:从缓冲区中取数据。

SequenceInputStream:多个流处理数据，然后再将这些流进行合并。

对两个流进行处理：

package io;
import java.io.*;
public class Example12 {
public static void main(String[] args) throws Exception{
FileInputStream in1=new FileInputStream("stream1.txt");
FileInputStream in2=new FileInputStream("Stream2.txt");
SequenceInputStream sis=new SequenceInputStream(in1,in2);
FileOutputStream out=new FileOutputStream("stream.txt");
int len;
byte[] buf=new byte[1024];
while((len=sis.read(buf))!=-1){
out.write(buf,0,len);
out.write("\r\n".getBytes());
}
sis.close();
out.close();
}
}

对多个数据进行处理：

构造方法SequenceInputStream(Enumeration<? extend InputStream> e)

该构造方法接受一个Enumeration类型的对象作为参数，Enumeration对象会返回一系列InputStream类型的对象，以提供SequenceInputStream读取。

package io;
import java.io.*;
import java.util.*;
public class Example13 {
public static void main(String[] args) throws Exception{
Vector vector=new Vector();
FileInputStream fis1=new FileInputStream("1.txt");
FileInputStream fis2=new FileInputStream("2.txt");
FileInputStream fis3=new FileInputStream("3.txt");
FileInputStream fis4=new FileInputStream("4.txt");
vector.addElement(fis1);
vector.addElement(fis2);
vector.addElement(fis3);
vector.addElement(fis4);
Enumeration e=vector.elements();
SequenceInputStream sis=new SequenceInputStream(e);
FileOutputStream out=new FileOutputStream("Stream.txt");
int len;
byte[] buf=new byte[1024];
while((len=sis.read(buf))!=-1){
out.write(buf,0,len);
out.write("\r\n".getBytes());
}
sis.close();
out.close();
}
}