第一課 IO流的概述
IO(Input Output）概述。
1、特點。
1）IO流用來處理數據之間的流通。
2）Java對數據的操作是通過流的方式。
3）Java用於操作流的對象都在IO包中
4）流按操作分爲：字節流和字符流。
5）流按方向分爲：輸入流和輸出流。
2、IO流的常用基類。
1）字節流的抽象基類：InputStream、OutputStream。
2）字符流的抽象基類：Reader、Writer。
注：由這四個類派生出來的子類都是以其父類名作爲後綴、其類的功能作爲前綴。

第二課字符流的讀寫

FileWriter類
一、概述。
1、用來寫入字符文件的便捷類。
2、此類的構造方法假定默認字符編碼和默認字節緩衝區大小都是可接受的。
二、構造方法摘要。
1、FileWriter(File file) 根據給定的 File 對象構造一個 FileWriter 對象。
2、FileWriter(String fileName, boolean append) 根據給定的文件名以及指示是否附加寫入數據的 boolean 值來構造 FileWriter 對象。
三、方法摘要。
1、Writer append(char c) 將指定的字符c添加到輸出流中。
2、void close() 關閉輸出流。
3、void flush() 將輸出流中未輸出的數據強制清除。
4、void write(char[] cbuf) 將字符數組中的字符寫到輸出流中。
5、void write(char[] cbuf,int off,int len) 將字符數組內部分字符寫到輸出流中。off指定了字符數組的其實位置，len指定元素的個數。
6、void write(int i) 向輸出流寫入一個字符。
示例一：

import java.io.*;
/*
 * 字符流和字節流
 * 
 * 字節流的基類。
 * InputStream  OutputStream
 * 
 * 字符流的基類
 * 
 * Reader Writer
 * 
 * 先學習字符流的特點：
 * 既然IO流是操作數據的
 * 那麼最常見體現形式是：文件
 * 
 * 需求：
 * 現在硬盤上創建一個文件，並且寫入一些數據。
 * 
 * 找到一個專門用於操作文件Writer子類的對象.FileWriter。後綴名是父類名，前綴名是功能
 */
public class FileWriteDemo {
    private static final String LINE_SEPARATOR = System.getProperty("line.separator");

    //創建一個可以往文件中寫入字符數據的字符輸出流對象
    /*
     * 既然是往文件中寫入文字數據，那麼在創建對象時，就必須明確該文件，（用於存儲數據的目的地）
     * 
     * 如果文件不存在，則會自動創建
     * 
     * 如果文件存在，則會覆蓋
     * 
     * 如果構造函數中加入true，可以追加。
     * 
     * 注：由於在創建對象時，需要指定創建文件位置，如果指定的位置不存在，就會發生IOException異常，所以在整個步驟中，需要對IO異常進行try處理。
     */
    public static void main(String[] args) 
    {
        FileWriter fw=null;

try {
                    fw=new FileWriter("demo1.txt");
        /*
         * 調用Writer對象中的write（string)方法。寫入數據
         * 
         * 其實數據寫入到臨時存儲緩衝區中，
         * 
         */
//      fw.write("a1b"+LINE_SEPARATOR+"HEHE");
        fw.write("xixi7");
        /*
         * 進行刷新將數據直接寫入到目的地
         * 
         */
        fw.flush();
        /*
         * 關閉前現調用flush（）進行刷新之後關閉。
         */


        } catch (IOException e) {


        }
            finally{
                if(fw!=null)
                try {
                    fw.close();
                } catch (IOException e) {

                    throw  new  RuntimeException("關閉失敗");
                }
                }
            }

}

FileReader類
一、概述。
1、用來讀取字符文件的便捷類。
2、此類的構造方法假定默認字符編碼和默認字節緩衝區大小都是適當的。
二、構造函數摘要。
1、FileReader(File file) 在給定從中讀取數據的 File 的情況下創建一個新 FileReader。
2、FileReader(String fileName)在給定從中讀取的額數據的文件命中創建一個新的FileReader
三、方法的摘要。
1、void close() 關閉字符流。
2、int read() 讀取單個字符。
3、int read(char[] chuf) 將字符讀入數組，並返回讀入的字符數。
示例一：

import java.io.*;
public class FileReadDemo{
    public static void main(String[] args) throws IOException
    {
//      /*
//       * 1，創建讀取字符數據的流對象
//       * 
//       * 2。在創建流對象時必須明確讀取的文件，一定要確定該文件是存在的，如果不在會拋出異常
//       * 
//       * 3.用一個讀取流關聯一個已存的文件
//       * 
//       */
        FileReader fr=new FileReader("demo1.txt");
        //第一種讀取方式。
//      int ch=fr.read();//一次讀一個字符而且會自動向下讀，返回整數，如果讀到末尾返回-1；
//      System.out.println((char)ch);
//  
//      while(true){
//          int ch=fr.read();
//          if(ch==-1)
//              break;
//          System.out.println((char)ch);
//      }
        /*
         * 使用read（char[]）讀取文本中的數據
         * 
         * 先創建字符數組。
         * 
         * 
         */
    //第二中讀取方式。
        char[] bf=new char[10];
        fr.read(bf);
        System.out.println(new String(bf));
        System.out.print(new String(bf,0,bf.length));


        fr.close();
    }
}

文件讀寫操作練習。
示例：

import java.io.*;
import java.nio.CharBuffer;
/*
 * 複製文件。
 * 
 * 原理。
 * 1.先創建一個文件用於讀取數據。
 * 2.定義讀取流和文件關聯。
 * 3.通過不斷的讀取完成數據的存儲。
 * 4.關閉資源。
 * 
 */
public class CopyFileDemo {
        public static void main(String[] args) 
        {
//          FileReader fr=new FileReader("demo.txt");
//          String[] buf=new String[1024];
//          FileWriter fw=new FileWriter("demo1.txt");
//          int ch=0;
//          while(!((ch=fr.read())==-1))
//          fw.write(ch);
//          fr.close();
//          fw.close(); 

            FileReader fr=null;
            FileWriter fw=null;
            try{
                fr=new FileReader("demo.txt");
                char[] bf=new char[1024];
                fw=new  FileWriter("demo2.txt");
                //創建一個字符數組用於緩存讀取的數據

                int leng=0;
                while((leng=fr.read(bf))!=-1)
                    fw.write(bf,0,leng);
            }catch(Exception e){

            }finally{
                if(fr!=null)
                    try {
                        fr.close();
                        fw.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

            }


        }



}

字符流的緩衝區講解。
一、概括。
1、緩衝區的出現爲了提高對數據的讀寫效率。
2、緩衝區只有結合流才能使用。
3、在流的基礎上對流的功能進行增強。
4、對應類：
BufferedReader。
BufferedWriter。
二、構造函數摘要。
1、BufferedReader類的構造函數。
BufferedReader(Reader in) 創建一個使用默認大小輸入緩衝區的緩衝字符輸入流。
2、BufferedWriter類的構造函數：
BufferedWriter(Writer out) 創建一個使用默認大小輸出緩衝區的緩衝字符輸出流。
三、方法摘要。
1、BufferedReader類的方法。
1）close() 關閉該流並釋放與之關聯的所有資源。
2）int read() 讀取單個字符。
3）int read(char[] cbuf, int off, int len) 將字符讀入數組的某一部分。
4）String readLine() 讀取一個文本行。
2、BufferedWriter類的方法。
1）void close() 關閉此流，但要先刷新它。
2）void flush() 刷新該流的緩衝。
3）void newLine() 寫入一個行分隔符。
4）void write(char[] cbuf, int off, int len) 寫入字符數組的某一部分。
5）void write(int c) 寫入單個字符。
示例：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;


public class BufferedWriterDemo {
        public static void main(String[] args) throws IOException
        {
            FileWriter fw=new FileWriter("demo3.txt");
            //爲了提高寫入效率，使用字符流緩衝區。
            //創建一個字符流緩衝區的對像，並和制定要被緩衝的對象相關聯。
            BufferedWriter buf=new BufferedWriter(fw);
            //使用緩衝區寫入的方法，將數據寫入到緩衝區‘
            buf.write("abcd");
            buf.newLine();
            buf.write("xixi");
            //使用緩衝區的刷新方法，將數據刷到目的地。
            buf.flush();

            FileReader fr=new FileReader("demo3.txt");
            BufferedReader bur=new BufferedReader(fr);
            String s=null;
            while((s=bur.readLine())!=null)
             System.out.println(s);
//          關閉緩衝區，其實就是關閉的被緩衝的對象。
            buf.close();
            bur.close();

        }
}

緩衝區知識擴展之自定義緩衝區。

import java.io.FileReader;
import java.io.IOException;

/*
 * 自定義的讀取緩衝區。其實就是模擬一個BufferedReader.
 * 
 * 緩衝區中無非就是封裝一個數組，並對外提供了更多方法對數組進行訪問。
 * 
 * 其實這些方法最終的操作都是數組的角標
 * 
 * 緩衝的原理：
 * 其實就是從源中獲取一批數據裝進緩衝區。
 * 
 * 在從緩衝區中不斷取出一個一個數據
 * 
 * 但此次取完後，再從源中繼續取一批數據進入緩衝區，
 * 當源中的數據光時，用一個-1，做結束標記，
 * 
 */
public class MyBufferedReader {
        private FileReader r;
        //定義一個數組作爲緩衝區
        private char[] buf=new char[1024];
        //定義一個指針用於操作這個數組的中的元素，當操作最後一個元素時，指針應爲零
        private int pos=0;
        //定義一個計數器用於記錄緩衝區的數據個數，當數據減到零，緩衝區繼續從源中獲取數據進入緩衝區
        private int count=0;
        MyBufferedReader(FileReader r)
        {
            this.r=r;
        }
        public int Myread() throws IOException
        {
            if(count==0)
            {   
                count=r.read(buf);
                pos=0;
            }
            if(count<0)
                return -1;
            char ch=buf[pos];
            pos++;
            count--;
            return ch;
            //1.從源中獲取一批數據到緩衝區中.需要先做判斷，只有計數器爲0時，才從源中獲取數據
//          if(count==0)
//          {
//            count=r.read(buf);
//            if(count<0)
//              return -1;
//            pos=0;
//            char ch=buf[pos];
//            pos++;
//            count--;
//          }
//          else if(count>0)
//          {
//                char ch=buf[pos];
//                pos++;
//                count--;
//          }
        }
        public String MyreadLine() throws IOException
        {
            StringBuilder sb=new StringBuilder();
            int ch=0;
            while((ch=Myread())!=-1)
            {   //將從緩衝區讀取的字符，存儲到緩存行中的緩衝區中
                if(ch=='\r')
                    continue;
                if(ch=='\n')
                    return sb.toString();
                sb.append((char)ch);
            }
            if(sb.length()!=0)
                return sb.toString();
            return null;
        }
        public void Myclose() throws IOException
        {
            r.close();
        }

}

根據自定義的緩衝區進行讀取操作。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BufferedReaderDemo {

    public static void main(String[] args) throws IOException
    {

            FileReader fr=new FileReader("demo1.txt");
            MyBufferedReader bur=new MyBufferedReader(fr);
            String s=null;
            while((s=bur.MyreadLine())!=null)
             System.out.println(s);
//          關閉緩衝區，其實就是關閉的被緩衝的對象。
            bur.Myclose();
    }

}

BufferedReader類的知識擴展。
LineNumberReader類簡介：
跟蹤行號的緩衝字符輸入流。此類定義了方法 setLineNumber(int) 和 getLineNumber()，它們可分別用於設置和獲取當前行號。默認情況下，行編號從 0 開始。
此類代碼示例：

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.LineNumberReader;
import java.io.PrintStream;


public class LineNumberReaderDemo {

    private static final String LINE_SEPARATOR = System.getProperty("line separator");

    public static void main(String[] args) throws IOException
    {
        FileWriter fw=new FileWriter("demo4.txt");
        FileReader fr=new FileReader("demo3.txt");
        //獲取對象
        LineNumberReader Ln=new LineNumberReader(fr);
        String s=null;
        Ln.setLineNumber(100);//設置行數從100開始
        while((s=Ln.readLine())!=null)
        {   
            int c=Ln.getLineNumber();//得到行數
            System.out.println(c);

            fw.write(Ln.getLineNumber()+":"+s+ LINE_SEPARATOR);
            System.out.println(Ln.getLineNumber()+":"+s);


        }
        fr.close();
        fw.close();

    }
}

                                       第三課   字節流的讀寫
OutputStreamWriter類
一、概述。
1、字節流與字符流不同的是，字節流不僅可以操作文本文件，還可以操作媒體文件。
2、讀寫字節流：
                  InputStream 輸入流。
                  OutputStreamStream 輸出流。
字節流的讀寫操作示例：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


public class ByteStremDemo {

        public static void main(String[] args) throws IOException
        {
            demo_write();
//          demo_read();
        }
        public static void demo_write() throws IOException
        {
            //創建字節流輸出對象，用於操作文件
            FileOutputStream fs=new FileOutputStream("demo5.txt");

//          寫入數據直接寫入到目的地中。
            fs.write("abcd張愉".getBytes());//獲取字符串的自己數組

            fs.close();
        }
        public static void demo_read() throws IOException{
            //創建一個讀取流對象，和指定的文件關聯
            FileInputStream Is=new FileInputStream("demo5.txt");
            System.out.println(Is.available());//返回字節個數；
//          int ch=0;
//          while((ch=Is.read())!=-1)
//              System.out.println((char)ch);


            byte[] b=new byte[1024];

            int leng=0;
            while((leng=Is.read(b))!=-1)
                System.out.println(new String(b,0,leng));
            Is.close();
        }
}

字節流緩衝區講解。
一、概述。
字節流緩衝區的出現和字符流緩衝區的出現一樣，都是爲了提高讀寫的效率。
二、構造函數摘要。
1、BufferedOutputStream類
BufferedOutputStream(OutputStream out) 創建一個新的緩衝輸出流，以將數據寫入指定的底層輸出流。
2、BufferedInputStream類
BufferedInputStream(InputStream in) 創建一個 BufferedInputStream 並保存其參數，即輸入流 in，以便將來使用
示例：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


public class CopyMp3Text {

    public static void Copy_1() throws IOException {
        FileInputStream fs=new FileInputStream("家家 - 塵埃.mp3");
        FileOutputStream fos=new FileOutputStream("1.mp3");
        byte[] b=new byte[fs.available()];
        int ch=0;
        while((ch=fs.read(b))!=-1)
            fos.write(b,0,ch);
        fos.close();
        fs.close();
    }
    public static void Copy_2() throws IOException
    {
        FileInputStream fs=new FileInputStream("家家 - 塵埃.mp3");
        //字節流緩衝區
        BufferedInputStream bis=new BufferedInputStream(fs);

        FileOutputStream fos=new FileOutputStream("2.mp3");
        //字節流緩衝區
        BufferedOutputStream bos=new BufferedOutputStream(fos);

        byte[] b=new byte[1024];
        int ch=0;
        while((ch=bis.read(b))!=-1)
            {
                bos.write(b,0,ch);
                bos.flush();
            }
        bis.close();
        bos.close();


    }
    public static void Copy_3() throws IOException
    {
        FileInputStream fs=new FileInputStream("家家 - 塵埃.mp3");
        FileOutputStream fos=new FileOutputStream("3.mp3");
        byte[] b=new byte[fs.available()];
        fos.write(b);
        fos.close();
        fs.close();
    }
    public static void Copy_4() throws IOException
    {
        FileInputStream fs=new FileInputStream("家家 - 塵埃.mp3");
        FileOutputStream fos=new FileOutputStream("4.mp3");
        int ch=0;
        while((ch=fs.read())!=-1)
            fos.write(ch);
        fos.close();
        fs.close();
    }
    public static void main(String[] args) throws IOException {
            //Copy_1();
            Copy_2();
            //Copy_3();
            //Copy_4();
    }

}

                                       第四課   IO流的操作規律。
讀取鍵盤錄入
1、標準鍵盤輸入輸出流。
InputStream System.in “標準”輸入流。輸入設備：鍵盤。
PrintStream System.out “標準”輸出流。輸出設備：控制檯。
2、轉化流。
1）字節流與字符流之間的橋樑。
2）方便字節流與字符流之間的操作。
InputStreamReader將字節流通向字符流
      a、獲取鍵盤錄入對象。
            InputStream in=System.in;
      b、將字節流對象轉成字符流對象，使用轉換流。
            InputStreamReaderisr=new InputStreamReader(in);
      c、爲了提高效率，將字符串進行緩衝區技術高效操作。使用BufferedReader
            BufferedReaderbr=new BufferedReader(isr);

示例一：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
public class TransStreamDemo {
    public static void main(String[] args) throws IOException
    {

    /*
    *1.無論從鍵盤讀取還是打印在控制檯上實際上操作的都是字節
    *
    *
    *
    *
    *
    *
    *
    */
        //讀
        //字節流
        InputStream in=System.in;
        //將字節流轉化爲字符流的橋樑
        InputStreamReader Isr=new InputStreamReader(in);
        //字符流
        BufferedReader bur=new BufferedReader(Isr);

        //寫
        //字節流
        OutputStream out=System.out;//控制檯
        //把字節轉化爲字符
        OutputStreamWriter Osw=new OutputStreamWriter(out);

        BufferedWriter bufw=new BufferedWriter(Osw);


        String line=null;
        while((line=bur.readLine())!=null)
        {
            if(line.equals("over"))
                break;
//          else
//            System.out.println(s.toUpperCase());
//          Osw.write(line.toUpperCase()+"\r\n");//把字符流發送給控制檯
//          Osw.flush();
            bufw.write(line.toUpperCase());
            bufw.newLine();
            bufw.flush();
        }
    }
}

示例二：



import java.io.*;

/*讀取鍵盤上的數據，並且打印在控制檯上
 * 
 * 鍵盤本身就是一個標準的輸入設備
 * 
 * 對於java而言，對於這種輸入設備都有對應的對象
 * 
 * 
 */
public class ReadKey {

    public static void readKey1()throws IOException
    {
        InputStream in=System.in;

        int ch=in.read();//堵塞式方法，沒有錄入數據時等待,一直到等有數據時

        System.out.println(ch);
        //回車鍵爲兩個字符
        int ch1=in.read();//堵塞式方法，沒有錄入數據時等待

        System.out.println(ch1);
        int ch2=in.read();//堵塞式方法，沒有錄入數據時等待

        System.out.println(ch2);
    }
    public static void readKey2()throws IOException
    {
    /*
     * 獲取用戶錄入的數據如果
     */
        InputStream in=System.in;//標準輸入流
        int ch=0;
        while((ch=in.read())!=-1)
            System.out.println(ch);

    }
    public static void readKey3()throws IOException
    {
        /*
         * 獲取用戶輸入的數據，
         * 並將數據轉化爲大寫
         * 如果用戶輸入over退出
         * 
         * 1. 因爲鍵盤錄入只讀取一個字節，要判斷是否是over，需要先將讀到的自己拼成字符串
         * 
         * 2，那就需要一個容器，StringBuilder
         * 
         * 在用戶回車之前判斷
         */
        InputStream in=System.in;//標準輸入流
        StringBuilder sb=new StringBuilder();
        int ch=0;
        while((ch=in.read())!=-1)
        {
            System.out.println(ch);
            if(ch=='\r')    
                continue;
            if(ch=='\n')

            {   
                String temp=sb.toString();
                if(temp.equals("over"))
                    break;
                System.out.println(temp.toUpperCase());
                sb.delete(0, sb.length());
            }
            else
              sb.append((char)ch);
        }



    }
    public static void readKey4() throws IOException{
        InputStream in=System.in;//標準輸入流
        byte[] b=new byte[1024];
        int ch=0;
        while((ch=in.read(b))!=-1){
            String s=new String(b,0,ch);
            s=s.substring(0,ch-2);
            if(s.equals("over")){
                break;
            }
            else
                System.out.println(s.toUpperCase());
                }
    }
    public static void main(String[] args) throws IOException
    {
//      readKey1();
//      readKey2();
//      readKey3();
        readKey4();

    }
}

IO流讀寫規律總結：

“`
轉化流：
InputStreamReader:自節到字符的橋樑。解碼。
OutputStreamWriter:字符到字節的橋樑。編碼。
流的操作規律：
之所以要弄清這個規律，是因爲流的對象太多，開發時不知道用那個對象合適

想要知道開發時用那個對象，只要通過四個明確即可。

1，明確源和目的（匯）
源：InputStream Reader
目的： OutputStream Writer

2，明確數據是否是純文本數據

源：是純文本  ：Reader
          否  ：InputStream
目的： 是純文本  ： Writer
             否  ： OutputStream

到這裏就可以明確需求中的具體要用那個體系

3，明確具體的設備

源設備：
+
硬盤（文件）：File
鍵盤：System.in
內存：數組
網絡：Socket流
目地設備：

硬盤： File
控制檯：System.in
內存：  數組
網絡：Socket流

4，是否需要其他額外功能

1,是否需要高效（緩衝區）：
   是就加上 buffer

需求1：複製一個文本文件：
1，明確源和目的。
源：InputStream Reader
目的：OutputStream Writer
2，是否是純文本
是：
源:Reader
目的：Writer
3，明確具體設備

源：
  硬盤：File
 目的
   硬盤：File
 FileReader fr=new  FileReader（“a.txt”）
 FileWriter fw=new FileWriter("b.txt")

4,需要額外的功能嗎？

需要：需要高效
BufferedReader bufr=new   BufferedReader（new  FileReader（“a.txt”））

BufferedWriter bufw=new BufferedWriter（new FileWriter(“b.txt”)）

需求2：讀取鍵盤錄入信息寫入到一個文件中

1，明確源和目的。
     源：InputStream    Reader
    目的：OutputStream   Writer
2，是否是純文本
是：
    源:Reader
    目的：Writer
3，明確設備

    源：鍵盤
    目的：鍵盤
 InputStream in=System.in
 FileWriter fw=new FileWriter("b.txt")
這樣做可以完成但是麻煩，將讀取的字符數據轉化爲字符串，再有字節流操作

4，需要額外的功能嗎？
需要
轉換：
將字節流轉化爲字符流.因爲明確的源是Reader，這樣操作文本數據便捷
所以要把已有的字節流轉化爲字符流，使用字節-》字符的對象InputStreamReader
    InputStreamReader  isr=new  InputStreamReader（System.in）；
    FileWriter  fw=new  FileWriter（“a.txt”）

還需要額外的功能嗎？
 需要 高效
 BufferedReader bufr=new   BufferedReader（new  InputStreamReader（System.in））
 BufferedWriter bufw=new   BufferedWriter（new FileWriter("b.txt")）

需求3：

1，明確源和目的。
     源：InputStream    Reader
    目的：OutputStream   Writer
2，是否是純文本
是：
    源:Reader
    目的：Writer
3，明確設備
    源：
    硬盤：File
    目的：
    控制檯：System.in

     FileWriter fw=new FileWriter("b.txt")
 OutputStream out=System.out
 4，需要額外功能嗎？
 需要：轉化
  FileWriter fw=new FileWriter("b.txt")
 OutputStreamWriter out=System.out
 需要高效
 BufferedReader bufr=new   BufferedReader（new FileWriter("b.txt")）
  BufferedWriter bufw=new   BufferedWriter（new OutputStream（System.out））

需求4：

1，明確源和目的。
     源：InputStream    Reader
    目的：OutputStream   Writer
2，是否是純文本
是：
    源:Reader
    目的：Writer
3，明確設備
    源：
        鍵盤：System.in
    目的
        控制檯：System.out

InputStream in=System.in
OutputStream out=System。out


4，明確額外的功能？

需要轉換，因爲都是字節流，但是操作的又都是文本數據，
所以使用字符流操作起來更爲便捷


InputStreamReader isr=new InputStreamReader（System.in）
OutputStreamWriter isw=new OutputStreamWriter（System.out）

爲了高效

  BufferedReader bufr=new   BufferedReader（new InputStreamReader（System.in））
  BufferedWriter bufw=new   BufferedWriter（new OutputStreamWriter（System.out））
  ==============================================================================================

需求5，
將一箇中文字符串數據按照指定的編碼表寫入到一個文本文件中

1，目的：OutputStream  Writer
2，是 純文本  Writer
3，設備 硬盤 File
FileWriter fw=new FileWriter（“a.txt”）
fw.Writer（“你好”）；

注意需求中已經指定了編碼表，就不能使用FileWriter,因爲FileWriter已經指定了默認的編碼表(系統平臺的碼錶)gbk，
只能使用outputstreamreater，
outputstreamreater接受一個字節輸出流對象，既然是操作文件，那麼對應的對象就應該是Fileoutputstream


OutputStreamReader osr=new OutputStreamReader（new FileoutputStream（“a.txt”），charsetName）

需要高效嗎？

要

BufferWriter buw=new （new OutputStreamReader（new FileoutputStream（“a.txt”），charsetName）


什麼時候用轉化流呢？



1，源或者目的使用的對應的設備是字節流，但是操作的確實文本數據，，可以使用轉換作爲橋樑
提高對文本操作的便捷


2，一旦操作文本涉及到具體的指定編碼表時，也是用！！！！

Java基礎------IO流之字符流、字節流和緩衝區。

BufferedWriter bufw=new BufferedWriter（new FileWriter(“b.txt”)）

Android 自定義Camera + TextureView拍照

java基礎----集合框架知識點總結（一）

Java基礎------IO流之字符流、字節流和緩衝區。

Java基礎-----正則表達式

Java基礎------集合框架知識點總結（二）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結