在I/O類庫中，java.io.InputStream和java.io.OutputStream分別表示位元組輸入流和位元組輸出流，它們都是抽象類，不能例項化，資料流中的最小單位是位元組，所以叫做位元組流。

一、InputStream中的讀取資料的方法如下：

　　1 、int read()

　　功能：讀取一個位元組的資料，並且返回讀到得資料，如果返回-1，則表示讀到輸入流的末尾。

　　2、int read(byte[] b)

　　功能：從輸入流中讀取一定量的位元組，並將其儲存在位元組陣列b中，返回實際讀取的位元組數，如果返回-1，則表示讀到輸入流的末尾。

　　3、int read(byte[] b, int off, int len)

　　功能：將資料讀入一個位元組陣列，同時返回讀取的實際位元組數，如果返回-1，則表示讀到輸入流的末尾。off指定在陣列b中存放資料的起始偏移位置，len指定讀取的最大位元組數。

　　4、available()

　　功能：返回此輸入流下一個方法呼叫可以不受阻塞地從此輸入流讀取或跳過的估計位元組數。

　　5、close()

　　功能：關閉輸入流，釋放這個流的相關資源。

二、OutputStream中寫入資料的方法如下：

　　1 、int write(int b)

　　功能：將b的最低的一個位元組寫入此輸入流，其他三個位元組丟棄。

　　2、int write(byte[] b)

　　功能：將指定的位元組陣列b寫入此輸入流。

　　3、int write(byte[] b, int off, int len)

　　功能：將指定byte陣列中從偏移量off開始的len個位元組寫入輸入流。

　　4、flush()

　　功能：重新整理此輸入流並強制寫出所有緩衝的輸出位元組數。

　　5、close()

　　功能：關閉輸出流，釋放這個流的相關資源。

①位元組陣列輸入流：

 1 package com.iotest;
 2 
 3 import java.io.ByteArrayInputStream;
 4 import java.io.IOException;
 5 public class ByteArryInputStreamDemo {
 
 6     public static void main(String[] args) throws IOException {
 7         String str = "abcdefghijk";
 8         byte[] strBuf = str.getBytes();  //字串轉換成位元組陣列
 9         ByteArrayInputStream bais = new ByteArrayInputStream(strBuf);
10         int data = bais.read();          //從位元組陣列輸入流讀取位元組
11         while(data!=-1){
12             char upper = Character.toUpperCase((char)data);
13             System.out.print(upper+" ");
14             data = bais.read();
15         }
16         bais.close();
17     }
18 }

程式執行結果：A B C D E F G H I J K

②位元組陣列輸出流：

 1 package com.iotest;
 2 
 3 import java.io.ByteArrayOutputStream;
 4 import java.io.IOException;
 5 
 6 public class ByteArrayOutputStreamDemo {
 7     public static void main(String[] args) throws IOException {
 8         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 9         String s = "welcome to use ByteArrayOutputStreamDemo";
10         byte[] buf = s.getBytes();  
11         baos.write(buf); //將指定的byte陣列寫到位元組陣列輸出流中
12         System.out.println(baos.toString());  //將位元組陣列輸出流內容轉換成字串輸出
13         //將位元組陣列輸出流中的內容複製到位元組陣列中
14         byte[] b = baos.toByteArray();
15         for (int i = 0; i < b.length; i++) {
16             System.out.print((char)b[i]);
17         }
18         baos.close();
19     }
20 }

程式執行結果：
welcome to use ByteArrayOutputStreamDemo
welcome to use ByteArrayOutputStreamDemo

③檔案輸入輸出流的使用

 1 package com.iotest;
 2 
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileOutputStream;
 7 import java.io.IOException;
 8 //複製圖片
 9 public class FileInputStreamDemo {
10     public static void main(String[] args) throws IOException {
11         File file = new File("F:\\shar\\test\\logo17.gif");
12         FileInputStream fis = new FileInputStream(file); //建立一個輸入流
13         //建立一個輸出流，後面一個引數true表示追加，原有內容不會被清除,預設為false
14         FileOutputStream fos = new FileOutputStream("F:\\shar\\test\\logo18.gif",false);
15         int ch = 0;
16         //方式一
17         /*while((ch=fis.read()) != -1){
18             fos.write(ch);
19         }*/
20         //方式二
21         /*byte[] b = new byte[1024];
22         while((ch=fis.read(b)) != -1){
23             fos.write(b,0,ch);
24         }*/
25         //方式三
26         byte[] b = new byte[fis.available()];
27         fis.read(b); //首先把fis的內容讀到位元組陣列b裡面
28         fos.write(b);//再把位元組陣列b的內容通過輸出流寫到指定檔案
29         //關閉流
30         fos.close();
31         fis.close();
32     }
33 
34 }

④管道流的使用：
　　一個PipedInputStream物件必須和一個PipedOutputStream物件進行連線從而產生一個通訊管道。通常一個執行緒從管道輸出流寫入資料，另一個執行緒從管道輸入流中讀取資料。當執行緒A執行管道輸入流的read()方法時，如果暫時沒有資料，這個執行緒就會被阻塞，只有當執行緒B想管道輸出流寫了資料後，執行緒A才會恢復執行。

package com.iotest;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
/*
 * 管道流
 */
class Sender extends Thread{
    private PipedOutputStream out = new PipedOutputStream();
    public PipedOutputStream getOut() {
        return out;
    }
    @Override
    public void run() {

        String s = "hello world";
        try {
            out.write(s.getBytes());
            out.close();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
}
public class Receiver extends Thread{
    private PipedInputStream in;
    public Receiver(Sender sender) throws IOException {
        in = new PipedInputStream(sender.getOut());
    }
    @Override
    public void run() {
        try {
            int data;
            while((data=in.read())!=-1){
                System.out.print((char)data);
            }
            in.close();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    public static void main(String[] args) throws IOException {
        Sender sender = new Sender();
        Receiver r = new Receiver(sender);
        sender.start();
        r.start();
    }

}

⑤緩衝流的使用：

 1 package com.iotest;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.BufferedOutputStream;
 5 import java.io.FileInputStream;
 6 import java.io.FileNotFoundException;
 7 import java.io.FileOutputStream;
 8 import java.io.IOException;
 9 
10 public class TestPrime {
11     private BufferedInputStream bis = null;
12     private BufferedOutputStream bos = null;
13     String fileName = "F:\\shar\\test\\test2.txt";
14     static int s,p;
15     //判斷是否是質數
16     public boolean isPrime(int n){
17         for(int i=2;i<=n/2;i++){
18             if(n%i == 0){
19                 return false;
20             }
21         }
22         return true;
23     }
24     void printPrime(int m) throws IOException{
25         //將位元組流轉緩衝流
26         bos = new BufferedOutputStream(new FileOutputStream(fileName));
27         int j = 0;
28         for (int i = 2; i < m; i++) {
29             if(isPrime(i)){
30                 j++;
31                 if(j%s == 0){
32                     String s = String.valueOf(i)+" ";
33                     bos.write(s.getBytes());
34                     bos.write("\r\n".getBytes());
35                 }else{
36                     String s = String.valueOf(i)+" ";
37                     bos.write(s.getBytes());
38                 }
39             }
40         }
41         bos.flush();
42         bos.close();
43     }
44     void getPrime() throws IOException{
45         //將位元組流轉緩衝流
46         bis = new BufferedInputStream(new FileInputStream(fileName));
47         int c = bis.read();
48         while(c != -1){
49             char ch = (char)c;
50             System.out.print(ch);
51             c = bis.read();
52         }
53     }
54     /**
55      * @param args
56      * @throws IOException 
57      */
58     public static void main(String[] args) throws IOException {
59         TestPrime t = new TestPrime();
60         p = 100;
61         s = 10;
62         t.printPrime(p);
63         t.getPrime();
64     }
65 
66 }