java9

什么是io流

流（Steam)源于UNIX中(pipe)的概念。在unix中，管道是一条不间断地字节流，用来实现程序或进程间的通信，或读写外围设备，外部文件等

io流分几类

1. 字节流包含InputStream和OutputStream
2. z字符流包含Reader和Writer

什么是字节流？什么是字符流？

字节流是由字节组成的，字节流是最基本的，所有的InputStream和OutputStream的子类都是字节流，主要是用在处理二进制数据，他是按字节来处理的 
字符流是由字符组成的，Java里字符是由两个字节组成的，所有的Reader和Writerd的子类都是字符流，主要是用在处理文本内容或特定内容

字符流和字节流的区别？

1. 读写的时候一个是按字节读写的，一个是按字符
2. 需要对内容按行进行处理，一般会选择字符流
3. 只是读写文件，和文件内容无关的（下载复制等），一般选择字节
4. 1. 读：  
   2. BufferedReader：  
   3. import java.io.BufferedReader;  
   4. import java.io.FileNotFoundException;  
   5. import java.io.FileReader;  
   6. import java.io.IOException;  
   7.   
   8. public class Read2 {  
   9.   
   10.     public static void main(String[] args) {  
   11.         int count = 0;  
   12.         FileReader reader = null;  
   13.         BufferedReader breader = null;  
   14.         try {  
   15.             reader = new FileReader("D:\\lenovo\\info.txt");  
   16.             breader = new BufferedReader(reader);  
   17.             String temp = "";  
   18.         while((temp=breader.readLine())!=null) {  
   19.             System.out.println(temp);  
   20.             count++;  
   21.         }  
   22.         System.out.println("共循环"+count+"次");  
   23.     } catch (FileNotFoundException e) {  
   24.         e.printStackTrace();  
   25.     } catch (IOException e) {  
   26.         e.printStackTrace();  
   27.     }finally {  
   28.         try {  
   29.             breader.close();  
   30.             reader.close();  
   31.         } catch (IOException e) {  
   32.             e.printStackTrace();  
   33.         }  
   34.     }  
   35.   }  
   36. }  
   [java]  view plain  copy

   1.   
   [java]  view plain  copy

   1. 写：  
   2. import java.io.BufferedWriter;  
   3. import java.io.FileWriter;  
   4. import java.io.IOException;  
   5. import java.io.OutputStreamWriter;  
   6.   
   7. public class Write {  
   8.   
   9.     public static void main(String[] args) {  
   10.         BufferedWriter writer = null;  
   11.         try {  
   12.             writer = new BufferedWriter(new FileWriter("D:\\lenovo\\info.txt",true));  
   13.             writer.newLine();  
   14.             writer.write("Hello");  
   15.             writer.newLine();  
   16.             writer.write("中国");  
   17.               
   18.             writer.flush();  
   19.         } catch (IOException e) {  
   20.             e.printStackTrace();  
   21.         }finally {  
   22.             try {  
   23.                 writer.close();  
   24.             } catch (IOException e) {  
   25.                 e.printStackTrace();  
   26.             }  
   27.         }  
   28.   
   29.     }  
   30.   
   31. }  
   
   
   
   [java]  view plain  copy

   1. 文本复制：  
   2. import java.io.BufferedReader;  
   3. import java.io.BufferedWriter;  
   4. import java.io.FileNotFoundException;  
   5. import java.io.FileReader;  
   6. import java.io.FileWriter;  
   7. import java.io.IOException;  
   8.   
   9. public class ReaderWriter {  
   10.   
   11.     public static void main(String[] args) {  
   12.         int count = 0;  
   13.         FileReader reader = null;  
   14.         BufferedReader breader = null;  
   15.         BufferedWriter writer = null;  
   16.         try {  
   17.             reader = new FileReader("D:\\lenovo\\info.txt");  
   18.             breader = new BufferedReader(reader);  
   19.             writer = new BufferedWriter(new FileWriter("D:\\lenovo\\info1.txt"));  
   20.             String temp = "";  
   21.             while((temp=breader.readLine())!=null){  
   22.                 writer.write(temp);  
   23.                 writer.newLine();  
   24.             }  
   25.             writer.flush();  
   26.             System.out.println("共循环"+count+"次");  
   27.         } catch (FileNotFoundException e) {  
   28.             e.printStackTrace();  
   29.         } catch (IOException e) {  
   30.             e.printStackTrace();  
   31.         }finally {  
   32.             try {  
   33.                 breader.close();  
   34.                 reader.close();  
   35.                 writer.close();  
   36.             } catch (IOException e) {  
   37.                 e.printStackTrace();  
   38.             }  
   39.         }  
   40.   
   41.     }  
   42.   
   43. }  
   
   
   

• Input:输入流指的是将数据以字符或字节形式从外部媒介读取到内存中。

  Output:输出流指的是将内存中的数据写入外部媒介。

• 2
• 3

Output:输出流指的是将内存中的数据写入外部媒介。