摘要：字節流和字符流和和兩個抽象類是所有輸入流的基類本身并不能創建實例來執行輸入但它們將成為所有輸入流的模板他們的方法是所有輸入流都可用的方法中包含如下三個方法從輸入流中讀取單個字節返回所讀取的字節數據字節數據可直接轉換為類型從輸入流中讀取最多個

InputStream和Reader兩個抽象類是所有輸入流的基類,本身并不能創建實例來執行輸入,但它們將成為所有輸入流的模板.他們的方法是所有輸入流都可用的方法.

int read() 從輸入流中讀取單個字節,返回所讀取的字節數據(字節數據可直接轉 換為int類型).

int read(byte[] b) 從輸入流中讀取最多b.lenght個字節數據,并將其存貯在數組b中,返回實際讀取的字節數.

int read(byte[] b,int off,int len) 從輸入流中讀取最多的len個字符的數據,并存在數組b中,放入數組b中時,從off的位置開始,返回實際讀取的字節數.

int read() 從輸入流中讀取單個字符,返回所讀取的字符數據(字符數可以直接轉換為int類型)

int read(char[] cbuf) 從輸入流中讀取最多的cbuf.length個字符數據,并將其存儲在字符數組cbuf中,返回實際讀取的字符數.

int read(char cbuf,int off,int len) 從輸入流中讀取最多len個字符的數據,并將其存在cbuf中,從off位置開始,返回實際的讀取的字符數.

使用FileInputStream讀取自身

javapublic void readFile() throws IOException {
    //創建字節輸入流
    FileInputStream fis = new FileInputStram("FileInputTest.java");
    //創建一個長度為1024的緩沖數組
    byte[] bbuf = new byte[1024];
    //保存實際讀取的字節數
    int hasRead = 0;
    //循環讀取文件內容
    while ((hasRead = fis.read(bbuf)) > 0) {
       System.out.println(new String(bbuf,0,hasRead));
    }
    //文件IO資源不屬于內存資源
    //垃圾回收無法回收該資源
    //必須顯式關閉
    fis.close();
}

public void readFile() throws IOException {
    FileReader fr = new FileReader("FileReaderTest.java");
    char[] cbuf = new char[32];
    int hasRead = 0;
    while ((hasRead = fr.read(cbuf)) > 0) {
        System.out.println(new String(cbuf,0,hasRead));
    }
    fr.clse();
}

javapublic void copyFile() throws IOException {
    FileInputStream fis = null;
    FileOutputStream fos = null;

    try {
        fis = new FileInputStream("outfile.txt");
        fos = new FileOutputStream("newfile.txt");

        byte[] bbuf = new byte[32];
        int hasRead = 0;
        while ((hasRead =fis.read(bbuf)) > 0) {
            fos.write(bbuf,0,hasRead);
        }
    } catch(IOException ioe) {
        ioe.printStatckTrance();
    } finally {
        if (fis != null) {
            fis.close();
        }
        if(fos != null) {
            fos.close();
        }
    }
}

javapublic void out() {
    FileWriter fw = null;
    try {
        fw = new FileWrite("file.txt");
        fw.write("但我不能放歌，
");
        fw.write("悄悄是別離的笙簫；
");
        fw.write("夏蟲也為我沉默，
");
        fw.write("沉默是今晚的康橋！
");
    } catch (IOException ioe) {

    } finally {
        if(null != fw) {
            fw.close();
        }
    }
}

javapublic void StringNodeTest() {

    String src = "軟泥上的青荇，
"
                +"油油的在水底招搖;
"
                +"在康河的柔波里，
"
                +"我甘心做一條水草。";

    StringReader sr = new StringReader(src);
    char[] cbuf = new char[32];
    int hasRead = 0;
    try {
        while((hasRead =sr.read(cbuf)) > 0) {
            System.out.println(new String(cbuf,0,hasRead));
        }
    } catch (IOException ioe) {
        ioe.
    } finally {
        if (null != sr){
            sr.close();
        }
    }
}

javapublic void convInput() {
    BufferedReader br = null;

    try {
        //System.in轉換成Reader對象
        InputStreamReader reader = new InputStreamReader(System.in);
        //將Reader包裝成BufferedReader
        br = new BufferedReader(reader);
        String buffer = null;
        While((buffer = br.readLine()) != null) {
            if("exit".equals(buffer)) {
                System.exit(1);
            }
            System.out.println("輸入內容為:" + buffer);
        }
    } catach (IOException ioe) {

    } finally {
        try {
            if (null != br) {
                br.close();
            }
        } catach (IOException ioe) {

        }
    }
}

java/**省略無數代碼**/

PushbackReader pr = null;

        try {
            pr = new PushbackReader(new FileReader("E:workplace1
eviewsrcioPushbackReaderTest.java"), 64);
            char[] buf = new char[32];
            //保存上次讀取的字符串內容
            String lastContent = "";
            int hasRead = 0;
            while ((hasRead = pr.read(buf)) > 0) {
                //讀取到內容轉換成字符串
                String content = new String(buf,0,hasRead);
                int targetIndex = 0;
                //將上一次內容和本次內容拼起來 檢查是否包含目標字符串
                //如果包含目標字符串
                if ((targetIndex = (lastContent + content).indexOf("new PushbackReader")) > 0) {
                    //將本次內容上次內容一起退回到推回緩沖區
                    pr.unread((lastContent + content).toCharArray());
                    //再次讀取指定程度的內容(目標字符串之前的內容)
                    pr.read(buf,0,targetIndex);
                    //打印讀取內容
                    System.out.println(new String(buf,0,targetIndex));
                    System.exit(0);
                } else {
                    System.out.println(lastContent);
                    lastContent = content;
                }
            }

/**省略無數代碼**/

java/**省略無數代碼**/
        PrintStream ps = null;

        try {
            //創建重定向需要的輸出流
            ps = new PrintStream(new FileOutputStream("out.txt"));
            //將標準輸出流重定向到ps輸出流
            System.setOut(ps);
            //測試輸出
            System.out.println("普通字符串");
            System.out.println(new RedirectOut());
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (null != ps) {
                ps.close();
            }
        }
/**省略無數代碼**/

java/**省略無數代碼**/
        FileInputStream fis = null;

        try {
            fis = new FileInputStream("E:workplace1
eviewsrcioRedirectIn.java");
            //將標準輸入重定向到fis輸入流
            System.setIn(fis);
            //獲取標準輸入
            Scanner sc = new Scanner(System.in);
            //設置只把回車作為分隔符
            sc.useDelimiter("
");
            while (sc.hasNext()) {
                System.out.println("鍵盤輸入內容為:" + sc.next());
            }
/**省略無數代碼**/