LineNumberReader
跟踪行号的缓冲字符输入流，父类为BufferedReader。
成员方法：
getLineNumber()
获得当前行号。
setLineNumber(int lineNumber)
设置当前行号。
练习代码如下：
1 //创建LineNumberReader对象
2 //public LineNumberReader(Reader in)
3 LineNumberReader lnr = new LineNumberReader(new FileReader("a.txt"));
4
5 //默认起始行号从0开始
6 //设置其实行号为从10开始
7 lnr.setLineNumber(10);
8
9 //一次读取一行
10 String line;
11 while ((line = lnr.readLine())!=null) {
12 //打印每一行的行号和内容
13 System.out.println(lnr.getLineNumber()+":"+line);
14 }
15
16 //关流
17 lnr.close();
获取行号，设置行号
结果如下：
操作基本数据类型的流
DataInputStream:读数据
DataOutputStream:写数据
具体的方法见API
练习代码如下：
1 public static void main(String[] args) throws IOException {
2 //写数据和读数据
3 write();
4 read();
5 }
6
7 private static void read() throws IOException {
8 //DataInputStream:读数据
9 //创建对象：public DataInputStream(InputStream in)
10 DataInputStream dis = new DataInputStream(new FileInputStream("dos.txt"));
11
12 //读数据了,按什么顺序写入就必须按照什么顺序读出来
13 System.out.println(dis.readByte());
14 System.out.println(dis.readShort());
15 System.out.println(dis.readInt());
16 System.out.println(dis.readLong());
17 System.out.println(dis.readChar());
18 System.out.println(dis.readFloat());
19 System.out.println(dis.readDouble());
20 System.out.println(dis.readBoolean());
21
22 //关流
23 dis.close();
24 }
25
26 private static void write() throws IOException {
27 //public DataOutputStream(OutputStream out)
28 DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));
29
30 //给流关联的文件中写入基本类型的数据
31 dos.writeByte(20);
32 dos.writeShort(200);
33 dos.writeInt(2000);
34 dos.writeLong(20000L);
35
36 dos.writeChar(97);
37 dos.writeFloat(12.34F);
38 dos.writeDouble(23.34);
39 dos.writeBoolean(true);
40
41 //关流
42 dos.close();
43 }
写入数据和读数据
结果如下：
内存操作流
解决临时数据存储的问题。
操作字节数组
ByteArrayInputStream
ByteArrayOutputStream
byte[] toByteArray() 将之前写入内存的流转换成字节数组
操作字符数组
CharArrayReader
CharArrayWrite
操作字符串
StringReader
StringWriter
练习代码：
1 //给内存中写数据public ByteArrayOutputStream()
2 ByteArrayOutputStream baos = new ByteArrayOutputStream();
3 //给内存中调用方法写数据
4 baos.write("hello".getBytes());
5 //将写入内存中的数据读取出来
6 byte[] buf = baos.toByteArray();//调用这个方法，将之前写入内存中的数据存储到字节数组中
7 ByteArrayInputStream bais = new ByteArrayInputStream(buf);//将刚才存储到字节数组中的内容关联上bais
8
9 //只有这样之后，我们才可以直接从bais中读取我们想要的内容
10 //一次读取一个字节
11 int by;
12 while ((by=bais.read())!=-1) {
13 System.out.print((char)by);
14 }
15 //关流
16 bais.close();
17 baos.close();
操纵字节流
打印流
字节打印流 PrintStream
字符打印流 PrintWriter
特点：
A:只能操作目的地，不能操作数据源
B:可以操作任意类型的数据
C:如果启动了自动刷新，能够自动刷新
如果启用了自动刷新，则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作
D:可以操作文件的流
注意：什么流可以直接操作文件？
看流对象的API,如果其构造方法同时有File和String类型的参数，就可以直接操作文件。
1 //注意：如果已经开启了自动刷新功能，必须调用则 println、printf 或 format的时候，才可以实现自动刷新
2 pw.println("hello");
3 pw.println("java");
4 pw.println("world");//调用println这个方法给文件中写数据，1.写数据 2.换行 3.刷新
5
6 //可以操作任意类型的数据
7 pw.println(true);
8 pw.println(12.34);
9
10 //关流
11 pw.close();
自动刷新
合并流：
SequenceInputStream类可以将多个输入流串流在一起，合并为一个输入流，因此，该流也被称为合并流。
构造：
SequenceInputStream(InputStream s1, InputStream s2) ：将s1和s2合并成一个输入流，先读取s1后读取s2
联系代码如下：
1 //将两个数据源合而为一
2 SequenceInputStream sis = new SequenceInputStream(new FileInputStream("PrintWriterDemo.java"), new FileInputStream("SystemIn2.java"));
3 //封装目的地
4 FileOutputStream fos = new FileOutputStream("copy2.java");
5
6 //一下读写一个字节数组
7 byte[] buf = new byte[1024];
8 int len;
9 while ((len=sis.read(buf))!=-1) {
10 //读多少写多少
11 fos.write(buf, 0, len);
12 }
13
14 //关流
15 fos.close();
16 sis.close();
将两个文件合并一个
对象的序列化和反序列化
序列化流：把对象按照流一样的方式写到文件或者在网络中传输。
反序列化流：把文件或者网络中的流对象数据还原对象。
ObjectOutputStream：序列化流
writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。
ObjectInputStream：反序列化流
Object readObject() 从 ObjectInputStream 读取对象。
如何实现序列化？
类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
注意：如果一个类不是实现Serializable接口无法把实例化，会报异常java.io.NotSerializableException
1 public class Studnet implements Serializable{
2 //实现这个接口不需要实现任何方法，这个接口说白了就是仅仅给Student类，打上了一个可以被序列化的标示
3 private String name;
4 private int age;
5 public String getName() {
6 return name;
7 }
8 public void setName(String name) {
9 this.name = name;
10 }
11 public int getAge() {
12 return age;
13 }
14 public void setAge(int age) {
15 this.age = age;
16 }
17 public Studnet(String name, int age) {
18 super();
19 this.name = name;
20 this.age = age;
21 }
22 public Studnet() {
23 super();
24 // TODO Auto-generated constructor stub
25 }
26 @Override
27 public String toString() {
28 return "Studnet [name=" + name + ", age=" + age + "]";
29 }
对象类
1 //创建序列化流对象
2 //public ObjectOutputStream(OutputStream out)
3 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));
4
5 //创建一个学生对象，将学生对象写入文件中
6 Studnet s = new Studnet("刘德华", 50);
7 oos.writeObject(s);
8 // java.io.NotSerializableException
9 //类通过实现 java.io.Serializable 接口以启用其序列化功能
10
11 //关流
12 oos.close();
序列化
1 //创建反序列化流对象
2 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));
3
4 //读取文件中存储的对象，以实现反序列化
5 //readObject()
6 Object object = ois.readObject();
7 System.out.println(object);
8
9 //关流
10 ois.close();
反序列化