Java学习：I/O流

Posted 2020-09-18 少放辣子

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();

反序列化