Java学习：I/O流（2）

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

 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     }

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

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

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

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