java笔记六

流(Stream)是字节的源或目的。
两种基本的流是：输入流(Input Stream)和输出流(Output Stream)。可从中读出一系列字节的对象称为输入流。而能向其中写入一系列字节的对象称为输出流。

FileInputStream和FileOutputStream
    节点流，用于从文件中读取或往文件中写入字节流。如果在构造FileOutputStream时，文件已经存在，则覆盖这个文件。
BufferedInputStream和BufferedOutputStream
    过滤流，需要使用已经存在的节点流来构造，提供带缓冲的读写，提高了读写的效率。
DataInputStream和DataOutputStream
      过滤流，需要使用已经存在的节点流来构造，提供了读写Java中的基本数据类型的功能。
PipedInputStream和PipedOutputStream
    管道流，用于线程间的通信。一个线程的PipedInputStream对象从另一个线程的PipedOutputStream对象读取输入。要使管道流有用，必须同时构造管道输入流和管道输出流。

java 代码

1.  //用FileInputStream和FileOutputStream文件读写   
2. import java.io.*;   
3. public class StreamTest {   
4.  public static void main(String[] args) throws Exception {   
5.   /*int data;  
6.   while((data=System.in.read())!=-1) {//读用户输入数据  
7.    System.out.write(data);写出用户读入数据*/  
8.      
9.   //写文件   
10.   FileOutputStream fos = new FileOutputStream("1.txt");   
11.   fos.write("http://www.windycool.com".getBytes());   
12.   fos.close();   
13.      
14.   //读文件   
15.   FileInputStream fis = new FileInputStream("1.txt");   
16.   byte[] buf = new byte[100];   
17.   int len = fis.read(buf);   
18.   System.out.println(new String(buf,0,len));   
19.   fis.close();   
20.  }   
21. }   

 

java 代码

 

1.  //用BufferedInputStream和BufferedOutputStream文件读写   
2.   
3. /*  
4. 作为另一种输入流，BufferedInputStream 为添加了功能，即缓冲输入和支持  
5.  mark 和 reset 方法的能力。创建 BufferedInputStream 时即创建了一个  
6.  内部缓冲区数组。读取或跳过流中的各字节时，必要时可根据所包含的输入流再次  
7.  填充该内部缓冲区，一次填充多个字节。mark 操作记录输入流中的某个点，reset  
8. 操作导致在从所包含的输入流中获取新的字节前，再次读取自最后一次 mark 操作  
9. 以来所读取的所有字节。   
10.  */  
11. import java.io.*;   
12. public class StreamTest {   
13.  public static void main(String[] args) throws Exception {   
14.   FileOutputStream fos = new FileOutputStream("1.txt");   
15.   BufferedOutputStream bos = new BufferedOutputStream(fos);   
16.   bos.write("http://www.windycool.com".getBytes());   
17. //  bos.flush();   
18.   bos.close();//将fos流链接到了bos流，关闭只需关闭尾端的bos流   
19.      
20.   FileInputStream fis = new FileInputStream("1.txt");   
21.   BufferedInputStream bis = new BufferedInputStream(fis);   
22.   byte[] buf = new byte[100];   
23.   int len=bis.read(buf);   
24.   System.out.println(new String(buf,0,len));   
25.   bis.close();   
26.      
27.  }   
28. }   
29.   

java 代码

1. /*  
2. public class PipedInputStream  
3.                  extends InputStream  
4. 传送输入流应该连接到传送输出流；传送输入流会提供要写  
5. 入传送输出流的所有数据字节。通常，数据由某个线程从  
6.  PipedInputStream 对象读取，并由其他线程将其写入到相应的  
7.  PipedOutputStream。不建议对这两个对象尝试使用单个线程，  
8. 因为这样可能会死锁该线程。传送输入流包含一个缓冲区，可在缓冲  
9. 区限定的范围内将读操作和写操作分离开。   
10.     
11.     
12. public class PipedOutputStream  
13.                   extends OutputStream  
14. 传送输出流可以连接到传送输入流，以创建通信管道。传送输出流  
15. 是管道的发送端。通常，数据由某个线程写入 PipedOutputStream   
16. 对象，并由其他线程从连接的 PipedInputStream 读取。不建议对  
17. 这两个对象尝试使用单个线程，因为这样可能会死锁该线程。   
18.  */  
19.   
20. import java.io.*;   
21. public class PipedStreamTest {   
22.  public static void main(String[] args) {   
23.   PipedOutputStream pos = new PipedOutputStream();   
24.   PipedInputStream pis = new PipedInputStream();   
25.   try {   
26.    pos.connect(pis);   
27.    new Producer(pos).start();   
28.    new Consumer(pis).start();   
29.   }   
30.   catch(Exception e) {   
31.    e.printStackTrace();   
32.   }   
33.  }   
34. }   
35. class Producer extends Thread {   
36.  private PipedOutputStream pos;   
37.  public Producer(PipedOutputStream pos) {   
38.   this.pos = pos;   
39.  }   
40.  public void run() {   
41.   try {   
42.    pos.write("Hello,welcome you!".getBytes());   
43.    pos.close();   
44.   }   
45.   catch(Exception e) {   
46.    e.printStackTrace();   
47.   }   
48.  }   
49. }   
50.   
51. class Consumer extends Thread {   
52.  private PipedInputStream pis;   
53.  public Consumer(PipedInputStream pis) {   
54.   this.pis=pis;   
55.  }   
56.  public void run() {   
57.   try {   
58.    byte[] buf = new byte[100];   
59.    int len = pis.read(buf);   
60.    System.out.println(new String(buf,0,len));   
61.    pis.close();   
62.   }   
63.   catch(Exception e) {   
64.    e.printStackTrace();   
65.   }    
66.  }   
67. }   
68. //输出 Hello,welcome you!   
69.   

Java的I/O库提供了一个称做链接的机制，可以将一个流与另一个流首尾相接，形成一个流管道的链接。这种机制实际上是一种被称为Decorator(装饰)设计模式的应用。
通过流的链接，可以动态的增加流的功能，而这种功能的增加是通过组合一些流的基本功能而动态获取的。
我们要获取一个I/O对象，往往需要产生多个I/O对象，这也是Java I/O库不太容易掌握的原因，但在I/O库中Decorator模式的运用，给我们提供了实现上的灵活性。

更多孙鑫lesson 7