Day25、IO流小结

1.小结1

字节流的祖辈OutputStream和InputStream
字符流的祖辈Writer和Reader

Writer的方法
    - void write(int c) 写入单个字符。
    - void write(char[] cbuf)写入字符数组。
    - abstract  void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
    - void write(String str)写入字符串。
    - void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
    - void flush()刷新该流的缓冲。
    - void close() 关闭此流，但要先刷新它。
这么多你肯定也记不住，反正你只需要知道Writer家族调用write方法时传入的参数可以是String字符串 也可以是 char数组

OutputStream的共性成员方法:
    - public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
    - public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
    - public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
    - public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
    - public abstract void write(int b) ：将指定的字节输出流。
这么多你肯定也记不住，反正你只需要知道OutputStream家族调用write方法时传入的参数只能是byte数组 或 一个int类型的字节

-----------------------------------------------------------------------
Reader的方法
    int read() 读取单个字符并返回。
    int read(char[] cbuf)一次读取多个字符,将字符读入数组。
    void close() 关闭该流并释放与之关联的所有资源。
这么多你肯定也记不住，反正你只需要知道Reader家族调用read方法时传入的参数可以是空参 也可以是 char数组

InputStream的方法:
    int read()从输入流中读取数据的下一个字节。
    int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
    void close() 关闭此输入流并释放与该流关联的所有系统资源。
这么多你肯定也记不住，反正你只需要知道InputStream家族调用read方法时传入的参数可以是空参 也可以是 byte数组

举例：

//OOutputStreamWriter extends Writer是Writer家族的，所以调用write方法就可以传入的参数是String的“你好”
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\gbk.txt"),"GBK");
osw.write("你好");


//BufferedWriter extends Writer是Writer家族的，所以调用write方法就可以传入的参数是String的"传智播客"
BufferedWriter bw = new BufferedWriter(new FileWriter("C:\\abc\\abc.txt"));
bw.write("传智播客");

//BufferedOutputStream extends OutputStream是OutputStream家族的，所以调用write方法就可以传入的参数是字节byte数组
FileOutputStream fos = new FileOutputStream("C:\\abc\\abc.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
bos.write("我把数据写入到内部缓冲区中".getBytes());

//FileWriter extends OutputStreamWriter extends Writer调用write方法就可以传入的参数是String的“你好”，也可以是char数组
FileWriter fw =new FileWriter("C://abc.txt");
char cs={"a","b","c","d","e"};
fw.write(cs);
fw.write("你好");

总说：

总说：
    1.字节流、字符流构造方法的参数是文件地址
    2.缓冲流由于可以是字节缓冲流也可以是字符缓冲流所以构造方法的参数是字节流和字符流
    3.转换流 序列化流 的构造方法的参数只能是字节流
    4.（字符流家族一定含有reader或writer）FileReader extends InputStreamReader extends Reader
    5.不含reader和writer的就是字节流家族（见到InputStream第一反应就是字节流家族的）
    6.必须背的单词：
    字节流----FileInputStream、FileOutputStream
    字符流----FileReader、FileWriter
    缓冲流----BufferedInputStream、BufferReader
	转换流----InputStreamReader、OutputStreamWriter
    序列化流--ObjectOutputStream、ObjectInputStream
	（巧计：InputStream是字节流家族的，Reader是字符流家族的，InputStreamReader既含字节流又含字符流所以就是来回切换的流，就是转换流）

字节输入流、字节输出流
FileInputStream extends InputStream
FileOutputStream extends OutputStream
    
使用：
    FileOutputStream fos = new FileOutputStream("C:\\abc\\b\\b.txt");
    fos.write("你好".getBytes());

    FileInputStream fis = new FileInputStream("C:\\abc\\b\\b.txt");
    int len = 0; //记录读取到的字节
    while((len = fis.read())!=-1){
        System.out.print(len);//979899
    }


字符输入流、字符输出流（字符流家族一定含有reader或writer）
FileReader extends InputStreamReader extends Reader
FileWriter extends OutputStreamWriter extends Writer
    
使用：        
    FileWriter fw = new FileWriter("C:\\abc\\b\\b.txt");
    fw.write("你好");

    FileReader fr = new FileReader("C:\\abc\\b\\b.txt");
	int len = 0;
	while((len = fr.read())!=-1){
	    System.out.print((char)len);
	}


缓冲流：构造方法的参数是字节流和字符流
字节缓冲流：
    BufferedOutputStream extends OutputStream
        FileOutputStream fos = new FileOutputStream("C:\\abc\\abc.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        bos.write("我把数据写入到内部缓冲区中".getBytes());

	BufferedInputStream extends InputStream
        FileInputStream fis = new FileInputStream("10_IO\\a.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        int len = 0;
        while((len = bis.read())!=-1){
            System.out.println(len);
        }
字符缓冲流：
    BufferedWriter extends Writer
       BufferedWriter bw = new BufferedWriter(new FileWriter("C:\\abc\\abc.txt"));
       bw.write("传智播客");

	BufferedReader extends Reader
        BufferedReader br = new BufferedReader(new FileReader("10_IO\\c.txt"));
        String line;
        while((line = br.readLine())!=null){
            System.out.println(line);
        }

    

转换流（用来编码的）----构造方法的参数是字节流
	转化流毕竟是字符流家族的（含有Reader和Writer），它的读和写都是针对字符的
	InputStreamReader extends Reader
        InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\gbk.txt"),"GBK");
        int len = 0;
        while((len = isr.read())!=-1){
            System.out.println((char)len);
        }

	OutputStreamWriter extends Writer
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\gbk.txt"),"GBK");
        osw.write("你好");
    
序列化流：构造方法的参数是字节流
ObjectOutputStream extends OutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("10_IO\\person.txt"));
        oos.writeObject(new Person("小美女",18));
ObjectInputStream extends InputStream    
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("10_IO\\person.txt"));
        Object o = ois.readObject();
        ois.close();
        System.out.println(o);//Person{name="小美女",age=18}
        Person p = (Person)o;//o是Object类型，我们强制转换为person类型，这就可以调用person的方法了
        System.out.println(p.getName()+p.getAge());//小美女18   
   
    
网络编程：
    客户端：
        Socket socket = new Socket("127.0.0.1",8888);
        OutputStream os = socket.getOutputStream();
        os.write("你好服务器".getBytes());

        InputStream is = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes,0,len));

    服务器端：
        ServerSocket server = new ServerSocket(8888);
        Socket socket = server.accept();
        
        InputStream is = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes,0,len));
        
        OutputStream os = socket.getOutputStream();
        os.write("收到谢谢".getBytes());
        
        socket.close();
        server.close();
 

2.关于字节流字符流写入读出的问题

对于字符流：

1.字符输出流和字符输入流，你写东西的时候new FileWriter("C:\\abc\\b\\b.txt").write(97)  你写入字节，那么你打开文件看到的是字符，你用new FileReader("C:\\abc\\b\\b.txt").read()读的时候读到的是字节

“字节---字符-----字节”（写入和读出的都是字节，打开文件看到的却是字符）


2.当然，那你会问，我能不能调用new FileWriter("C:\\abc\\b\\b.txt").write("你好".getBytes())  你写入“你好”的字节，那么你打开文件看到的是字符“你好”，你用new FileReader("C:\\abc\\b\\b.txt").read()读的时候读到的是“你好”的字节   
不可以！   为什么？  我觉得“字节---字符-----字节”可能仅适用于ASCALL编码里面有的那些字符

因为像上面的那种你直接调用new FileWriter("C:\\abc\\b\\b.txt").write("你好") 就可以


3.字符输出流和字符输入流，你写东西的时候new FileWriter("C:\\abc\\b\\b.txt").write(“97”)  你写入的是字符“97”，那么你打开文件看到的是字符“97”，你用new FileReader("C:\\abc\\b\\b.txt").read()读的时候读到的也是字符“97”

你写东西的时候new FileWriter("C:\\abc\\b\\b.txt").write(“你好”)  你写入的是字符“你好”，那么你打开文件看到的是字符“你好”，你用new FileReader("C:\\abc\\b\\b.txt").read()读的时候读到的也是字符“你好”


4.总结下来就是，对于字符输入流和输出流：

“字节---字符-----字节”（写入的是字节，打开文件看到的却是字符，读出的是字节）

“字符----字符-----字符”（写入的是字节，打开文件看到的是字符，读出的也是字符）

对于字节流：
“字节---字符-----字节”（写入的是字节，打开文件看到的却是字符，读出的是字节）


你如果打开文件想看到“你好”，那么你写的时候就是
new FileOutputStream("C:\\abc\\abc.txt").write("你好".getBytes());你写入“你好”的字节，那么你打开文件看到的是字符“你好”，你用new FileInputStream("C:\\abc\\b\\b.txt").read()读的时候读到的是“你好”的字节   

你如果想要让控制台显示的是“你好”，那就只能FileInputStream("C:\\abc\\b\\b.txt").read()读到字节以后，使用“String(byte[] bytes) 或(char)bytes 将字节转为字符