day18.IO流

  1. 课前回顾:
  2.  1.File:代表的是文件或者文件夹对象
  3.  2.静态成员:
  4.     static String pathSeparator  :路径和其他路径之间的分隔符    ;
  5.     static String separator  :路径中的分隔符      \
  6.  3.构造:
  7.     File(String path)
  8.     File(String parent,String child)
  9.     File(File parent,String child)
  10.  4.相对路径和绝对路径
  11.    绝对路径:从盘符开始写路径
  12.    相对路径:在idea中,从模块名开始写
  13.    如果直接写文件名或者文件夹名,相对路径不带模块名,默认位置在当前project下
  14.  5.获取方法:
  15.    getAbsolutePath()->获取绝对路径
  16.    getPath()->获取的是封装路径
  17.    getName()->获取文件或者文件夹名字
  18.    length()->获取的是文件的字节数
  19.    getParentFile()->获取的是父目录
  20.  6.创建方法:
  21.    createNewFile()->创建新文件
  22.    mkdirs()->创建单击文件夹或者多级文件夹
  23.  7.删除方法:
  24.    delete()->删除文件或者空文件夹->不走回收站
  25.  8.判断方法:
  26.    exists():判断文件或者文件夹是否存在
  27.    isDirectory():判断是否是文件夹
  28.    isFile():判断是否是文件
  29.  9.遍历方法:
  30.    list():获取的是文件或者文件夹,返回String[]
  31.    listFiles():获取的是文件或者文件夹,返回的是File[]
  32.  10.IO流->读写->从一个设备上将数据传输到另一个设备上
  33.  11.流向:内存
  34.     从内存出发,利用代码将数据写到硬盘的文件中->输出->写
  35.     从内存出发,将数据从硬盘的文件中读到内存中->输入->读
  36.  12.分类:
  37.     字节流:万能流,操作一切
  38.           字节输出流:OutputStream
  39.           字节输入流:InputStream
  40.     字符流:专门操作文本文档
  41.           字符输出流:Writer
  42.           字符输入流:Reader
  43.  13.FileOutputStream
  44.     构造:
  45.      FileOutputStream(String path)
  46.      FileOutputStream(File path)
  47.      FileOutputStream(String path,boolean append)->实现续写
  48.     方法:
  49.      write(int b)
  50.      write(byte[] b)
  51.      write(byte[] b,int off,int len)
  52.      close()关闭流对象
  53.     换行: 
  54.        windows:  \r\n
  55.        linux: \n
  56.        os:\r
  57. 今日重点:
  58.    所有

第一章.字节流

六.InputStream子类[FileInputStream]的介绍以及方法的使用

  1. 1.字节输入流:InputStream(抽象类)
  2. 2.子类:FileInputStream(读数据)
  3. 3.构造:
  4.       FileInputStream(File file)
  5.       FileInputStream(String path)
  6. 4.方法:
  7.   int read()->一次读取一个字节  
  8.   int read(byte[] b)->一次读取一个字节数组,返回的是读取个数
  9.   int read(byte[] b, int off, int len) -> 一次读取一个字节数组一部分
  10.           b:读取的数组
  11.           off:从哪个索引开始读取
  12.           len:读取多少个
  13.   void close()  :关闭资源

七.一次读取一个字节

  1. public class Demo01FileInputStream {
  2.     public static void main(String[] args)throws Exception {
  3.         FileInputStream fis = new FileInputStream("day18\\io\\a.txt");
  4.        // method01(fis);
  5.         method02(fis);
  6.     }
  8.     /*
  9.       循环读取
  10.      */
  11.     private static void method02(FileInputStream fis)throws Exception {
  12.        //定义一个变量,接收读取的内容
  13.        int len;
  14.        while((len = fis.read())!=-1){
  15.            //System.out.println(len);
  16.            System.out.println((char) len);
  17.        }
  18.        //关闭资源
  19.         fis.close();
  20.     }
  22.     /*
  23.        int read()->一次读取一个字节
  24.      */
  25.     private static void method01(FileInputStream fis)throws Exception {
  26.         int byte1 = fis.read();
  27.         System.out.println(byte1);
  29.         int byte2 = fis.read();
  30.         System.out.println(byte2);
  32.         int byte3 = fis.read();
  33.         System.out.println(byte3);
  35.         int byte4 = fis.read();
  36.         System.out.println(byte4);
  38.         int byte5 = fis.read();
  39.         System.out.println(byte5);
  40.         fis.close();
  41.     }
  42. }

经验值:在读取的过程中很容易出现以下问题:不要在循环的时候读,输出时再读

问题代码:

经验值2:如果后面想继续使用流对象,请不要提前close:

day18[IO流] - 图1

经验值3:如果文件中的内容读完了,再读就读不到了,如果想读,新new一个输入流对象

  1. private static void method01(FileInputStream fis)throws Exception {
  2.      //定义一个变量,来接收读取的内容
  3.      int len;
  4.      while((len = fis.read())!=-1){
  5.          /*
  6.           因为len接受的就是读取回来的数据
  7.           所以当len接收的数据不等于-1时,证明没读完,就继续读取
  8.           而读取过来的数据让len接受后,我们直接输出len,那么输出其实就是读取过来的数据
  9.           */
  10.          //System.out.println(len);
  11.          System.out.println((char)(fis.read()));//输出的时候再次读了一个数据
  12.      }
  14.      //关闭资源
  15.      fis.close();
  16.  }

八.读取-1的问题

  1. 每一个文件末尾都有一个结束标记,这个结束标记我们看不见,摸不着的

day18[IO流] - 图2

九.一次读取一个字节数组以及过程

  1. public class Demo03FileInputStream {
  2.     public static void main(String[] args)throws Exception {
  3.         FileInputStream fis = new FileInputStream("day18\\io\\a.txt");
  4.         method01(fis);
  5.     }
  7.     /*
  8.        int read(byte[] bytes)->一次读取一个字节数组,返回的是读取的个数
  9.      */
  10.     private static void method01(FileInputStream fis)throws Exception {
  11.         /*
  12.            创建byte数组:
  13.            作用:相当于是一个中间容器,我们读取的内容先放到数组中,然后从数组中取
  14.          */
  16.         byte[] bytes = new byte[2];
  17.         int read1 = fis.read(bytes);
  18.         //System.out.println(read1);
  19.         //System.out.println(new String(bytes));//ab
  20.         System.out.println(new String(bytes,0,read1));
  22.         int read2 = fis.read(bytes);
  23.         //System.out.println(read2);
  24.         //System.out.println(new String(bytes));//cd
  25.         System.out.println(new String(bytes,0,read2));
  27.         int read3 = fis.read(bytes);
  28.         //System.out.println(read3);
  29.        // System.out.println(new String(bytes));//ed
  30.         System.out.println(new String(bytes,0,read3));
  32.         fis.close();
  33.     }
  34. }
  1. public class Demo04FileInputStream {
  2.     public static void main(String[] args)throws Exception {
  3.         FileInputStream fis = new FileInputStream("day18\\io\\a.txt");
  4.         method01(fis);
  5.     }
  7.     /*
  8.        int read(byte[] bytes)->一次读取一个字节数组,返回的是读取的个数
  9.      */
  10.     private static void method01(FileInputStream fis)throws Exception {
  11.         /*
  12.            定义一个byte数组
  14.            习惯上将数组长度定成1024或者1024的倍数
  15.          */
  16.         //byte[] bytes = new byte[5];
  17.         byte[] bytes = new byte[1024];
  18.         //定义一个变量,接收读取的个数
  19.         int len;
  20.         while((len = fis.read(bytes))!=-1){
  21.             System.out.println(new String(bytes,0,len));
  22.         }
  23.         fis.close();
  24.     }
  25. }

day18[IO流] - 图3

十.字节流实现图片复制分析

day18[IO流] - 图4

十一.字节流实现图片复制代码实现

  1. public class Demo05Copy {
  2.     public static void main(String[] args)throws Exception {
  3.         //1.创建FileInputStream用于读取图片
  4.         FileInputStream fis = new FileInputStream("E:\\Idea\\io\\1.jpg");
  5.         //2.创建FileOutputStream用于将读取的图片字节写到指定的位置
  6.         FileOutputStream fos = new FileOutputStream("E:\\Idea\\io\\a\\柳岩.jpg");
  7.         //3.定义数组
  8.         byte[] bytes = new byte[1024];
  9.         //4.定义一个变量,接收读取的字节个数
  10.         int len;
  11.         while((len = fis.read(bytes))!=-1){
  12.             fos.write(bytes,0,len);
  13.         }
  15.         //5.关流
  16.         fos.close();
  17.         fis.close();
  18.     }
  19. }

第二章.字符流

1.字节流读取中文的问题

  1. 如果文件中存储中文,每次读取时字节不能组成一个中文字,输出到控制台时,就是乱码
  2.  GBK:一个中文占2个字节
  3.  utf-8:一个中文占3个字节

注意:

字节流可以称之为万能流,但是别边读边看,如果读完之后,能准确的将所有字节数读取到,就没问题

2.FileReader的介绍以及使用

  1. 1.字符输入流:Reader(抽象类)
  2. 2.子类:FileReader
  3. 3.构造:
  4.   FileReader(File file)
  5.   FileReader(String path)
  6. 4.方法:
  7.   int read() -> 一次读取一个字符 , 返回的是int型
  8.   int read(char[] cbuf)  -> 一次读取一个字符数组,返回读取的个数
  9.   int read(char[] cbuf, int off, int len) -> 一次读取一个字符数组一部分
  10.            cbuf:要读取的数组
  11.            off:从哪个索引开始读
  12.            len:读多少个
  13.   void close() -> 关闭资源
  1. public class Demo02FileReader {
  2.     public static void main(String[] args) throws Exception{
  3.         FileReader fileReader = new FileReader("day18\\io\\b.txt");
  4.         method01(fileReader);
  5.     }
  7.     /*
  8.        int read() -> 一次读取一个字符 , 返回的是int型
  9.      */
  10.     private static void method01(FileReader fileReader)throws Exception {
  11.        /* int read = fileReader.read();
  12.         System.out.println((char)read);
  14.         int read01 = fileReader.read();
  15.         System.out.println((char)read01);
  17.         int read03 = fileReader.read();
  18.         System.out.println(read03);*/
  20.         //定义一个变量,接收读取的字符
  21.         int len;
  22.         while((len = fileReader.read())!=-1){
  23.             System.out.println((char) len);
  24.         }
  25.         fileReader.close();
  26.     }
  27. }
  1. /*
  2.      int read(char[] cbuf)  -> 一次读取一个字符数组,返回读取的个数
  3.      */
  4.     private static void method02(FileReader fileReader)throws Exception {
  5.         char[] chars = new char[2];
  6.         /*int read = fileReader.read(chars);
  7.         System.out.println(new String(chars,0,read));*/
  8.         //定义变量,接收读取的个数
  9.         int len;
  10.         while((len = fileReader.read(chars))!=-1){
  11.             System.out.println(new String(chars,0,len));
  12.         }
  13.         fileReader.close();
  14.     }

3.FileWriter的介绍以及使用

  1. 1.字符输出流:Writer(抽象)
  2. 2.子类:FileWriter
  3. 3.构造:
  4.    FileWriter(File file)
  5.    FileWriter(String path)
  6.    FileWriter(String path,boolean append)
  7.               append:false,没有续写效果,每次运行会创建新的文件,覆盖老文件
  8.               append:true,有续写效果,每次运行不会创建新文件了
  9. 4.方法:
  10.   void write(int c) -> 写单个字符 
  11.   void write(String str) -> 直接写字符串 
  12.   void write(String str, int off, int len)->写字符串一部分
  13.              str:写的字符串
  14.              off:从哪个索引开始写
  15.              len:写多少个字符
  16.   void write(char[] cbuf)->一次写一个字符数组  
  18.   void write(char[] cbuf, int off, int len)->一次写一个字符数组一部分
  19.               cbuf:要写的char数组
  20.               off:从哪个索引开始写
  21.               len:写多少个
  22.   void close()  : 关闭资源  先刷新缓冲区,再关闭流对象
  23.   void flush()  : 刷新缓冲区,将数据从缓冲区中刷到文件中
  24. 5.注意:
  25.   字符流自带一个缓冲区,所以我们写数据时,我们写的数据会自动放到缓冲区中,我们需要将数据从缓冲区中刷到文件中
  1. public class Demo01FileWriter {
  2.     public static void main(String[] args)throws Exception {
  3.         FileWriter fw = new FileWriter("day18\\io\\d.txt",true);
  4.         fw.write(97);
  5.         fw.write("你好讨厌呦!\r\n");
  6.         //换行
  7.         fw.write("\r\n");
  8.         fw.write("a");
  9.         //刷新缓冲区
  10.         //fw.flush();
  11.         fw.close();
  12.     }
  13. }
  1. public class Demo02FileWriter {
  2.     public static void main(String[] args)throws Exception {
  3.         FileWriter fw = new FileWriter("day18\\io\\d.txt");
  4.         char[] chars = {'a','b','c'};
  5.         fw.write(chars);
  6.         fw.close();
  7.     }
  8. }

4.FileWriter的刷新功能和关闭功能

  1. flush:刷新,将数据从缓冲区中刷到文件中,如果写完之后,还想继续用字符输出流对象,就用flush
  2. close:先刷新,再关闭流对象,如果写完之后,不想用字符输出流对象,就close
  1. public class Demo03FileWriter {
  2.     public static void main(String[] args)throws Exception {
  3.         FileWriter fw = new FileWriter("day18\\io\\d.txt");
  4.         fw.write("窗前明月光");
  5.         fw.flush();
  6.         fw.write("疑是地上霜");
  7.         fw.flush();
  8.         fw.write("举头望明月");
  9.         fw.close();
  10.         //fw.write("低头思故乡");由于已经被close了,所以流对象使用不了了
  11.     }
  12. }

5.IO异常处理的方式

  1. public class Demo04FileWriter {
  2.     public static void main(String[] args){
  3.         FileWriter fw = null;
  4.         try{
  5.             fw = new FileWriter("day18\\io\\e.txt");
  6.             fw.write("你好");
  7.         }catch (Exception e){
  8.             e.printStackTrace();
  9.         }finally {
  10.             /*
  11.               fw对象有可能创建失败
  12.               如果创建失败,fw就一直是null
  13.               既然是null,就不用手动close了
  14.              */
  15.             if (fw!=null){
  16.                 try {
  17.                     fw.close();
  18.                 } catch (IOException e) {
  19.                     e.printStackTrace();
  20.                 }
  21.             }
  22.         }
  23.     }
  24. }

6.JDK7之后io异常处理方式->(扩展)

  1. 1.格式:
  2.   try(创建IO流对象){
  3.       可能出现异常的代码
  4.   }catch(){
  5.       异常处理
  6.   }
  7. 2.注意:
  8.   关闭资源,刷新缓冲区,不用我们管,java自动管理
  1. public class Demo05FileWriter {
  2.     public static void main(String[] args){
  3.         try(FileWriter fw = new FileWriter("day18\\io\\e.txt");){
  4.             fw.write("你好吗?");
  5.         }catch (Exception e){
  6.             e.printStackTrace();
  7.         }
  8.     }
  9. }

第三章.字节缓冲流

  1. 1.分类:
  2.   字节缓冲输出流:BufferedOutputStream
  3.                构造:
  4.                 BufferedOutputStream(OutputStream out) 
  5.                                      OutputStream为抽象类,所以传递时需要传递子类对象
  6.                用法:
  7.                 和FileOutputStream一样
  8.                 特有方法:flush()刷新缓冲区
  11.   字节缓冲输入流:BufferedInputStream
  12.                构造:
  13.                BufferedInputStream(InputStream in)  
  14.                                    InputStream为抽象类,所以传递时需要传递子类对象
  15.                用法:
  16.                 和FileInputStream一样
  18. 2.缓冲流特点:
  19.   a.缓冲流自带缓冲区,缓冲区大小默认为8192
  20.   b.之前的FileOutputStream和FileInputStream中的读写功能都是本地方法,而本地方法是直接和系统打交道的,所以我们使用缓冲区可以尽量减少直接对系统进行读写的操作,减少了系统资源的占用
  21.   c.使用缓冲区读写都是在内存中进行读写交互的,效率会比较高
  1.  public class Demo01BufferedIn_BufferedOut {
  2.     public static void main(String[] args) throws Exception{
  3.         //method();
  4.         method02();
  5.     }
  7.     private static void method02()throws Exception {
  8.         //获取系统时间毫秒值
  9.         long start = System.currentTimeMillis();
  11.         //1.创建FileInputStream用于读取图片
  12.         FileInputStream fis = new FileInputStream("E:\\Idea\\io\\a.avi");
  14.         BufferedInputStream bis = new BufferedInputStream(fis);
  16.         //2.创建FileOutputStream用于将读取的图片字节写到指定的位置
  17.         FileOutputStream fos = new FileOutputStream("E:\\Idea\\io\\a\\b.avi");
  19.         BufferedOutputStream bos = new BufferedOutputStream(fos);
  21.         int len;
  22.         while((len = bis.read())!=-1){
  23.             bos.write(len);
  24.         }
  26.         //获取系统时间毫秒值
  27.         long end = System.currentTimeMillis();
  29.         System.out.println(end-start);
  31.         bos.close();
  32.         bis.close();
  33.     }
  36.     private static void method()throws Exception {
  37.         //获取系统时间毫秒值
  38.         long start = System.currentTimeMillis();
  40.         //1.创建FileInputStream用于读取图片
  41.         FileInputStream fis = new FileInputStream("E:\\Idea\\io\\a.avi");
  42.         //2.创建FileOutputStream用于将读取的图片字节写到指定的位置
  43.         FileOutputStream fos = new FileOutputStream("E:\\Idea\\io\\a\\b.avi");
  44.         int len;
  45.         while((len = fis.read())!=-1){
  46.             fos.write(len);
  47.         }
  49.         //获取系统时间毫秒值
  50.         long end = System.currentTimeMillis();
  52.         System.out.println(end-start);
  54.         fos.close();
  55.         fis.close();
  56.     }
  57. }

day18[IO流] - 图5

第四章.字符缓冲流

一.字符缓冲输出流_BufferedWriter

  1. 1.构造:
  2.   BufferedWriter(Writer w)
  3.                  Writer是抽象类,所以传递时要传递Writer的子类
  4. 2.方法:
  5.   和FileWriter一样
  6. 3.特有方法:
  7.   void newLine()  -> 换行
  1. public class Demo02BufferedWriter {
  2.     public static void main(String[] args)throws Exception {
  3.         BufferedWriter bw = new BufferedWriter(new FileWriter("day18\\io\\f.txt"));
  4.         bw.write("锄禾日当午");
  5.         //换行
  6.         bw.newLine();
  7.         bw.write("汗滴禾下土");
  8.         bw.newLine();
  9.         bw.write("谁知盘中餐");
  10.         bw.newLine();
  11.         bw.write("粒粒皆辛苦");
  13.         //关闭资源
  14.         bw.close();
  15.     }
  16. }

二.字符缓冲输入流_BufferedReader

  1. 1.构造:
  2.   BufferedReader(Reader r)
  3.                  Reader是一个抽象类,传递传递的是子类对象
  4. 2.方法:
  5.   和FileReader一样
  6. 3.特有方法:
  7.   String readLine()->一次读一行
  1. public class Demo03BufferedReader {
  2.     public static void main(String[] args)throws Exception {
  3.         BufferedReader br = new BufferedReader(new FileReader("day18\\io\\f.txt"));
  4.        /* String s1 = br.readLine();
  5.         System.out.println(s1);
  6.         String s2 = br.readLine();
  7.         System.out.println(s2);
  8.         String s3 = br.readLine();
  9.         System.out.println(s3);
  10.         String s4 = br.readLine();
  11.         System.out.println(s4);
  13.         String s5 = br.readLine();
  14.         System.out.println(s5);*/
  16.         System.out.println("============================");
  17.         //定义一个字符串,接收读取的内容
  18.         String line;
  19.         while((line = br.readLine())!=null){
  20.             System.out.println(line);
  21.         }
  22.         br.close();
  23.     }
  24. }

三.字符缓冲流练习

  1. 将in.txt中的内容排好序,写到另外一个新文件中
  1. c.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。
  2. h.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
  3. d.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
  4. b.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
  5. a.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。
  6. i.今当远离，临表涕零，不知所言。
  7. f.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
  8. g.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
  9. e.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。
  1. 步骤:
  2.   1.创建BufferedReader对象用于读取文件中的内容
  3.   2.创建BufferedWriter对象将排好序的文本写到新文件中
  4.   3.创建ArrayList集合
  5.   4.循环读取文件中的内容,存到ArrayList集合中
  6.   5.调用Collections中的sort方法,进行排序
  7.   6.遍历集合,将排好序的文本遍历出来,然后写到文件中
  8.   7.关流
  1. public class Demo04Exam {
  2.     public static void main(String[] args)throws Exception {
  3.         //1.创建BufferedReader对象用于读取文件中的内容
  4.         BufferedReader br = new BufferedReader(new FileReader("day18\\io\\in.txt"));
  5.         //2.创建BufferedWriter对象将排好序的文本写到新文件中
  6.         BufferedWriter bw = new BufferedWriter(new FileWriter("day18\\io\\out.txt"));
  7.         //3.创建ArrayList集合
  8.         ArrayList<String> list = new ArrayList<>();
  9.         //4.循环读取文件中的内容,存到ArrayList集合中
  10.         String line;
  11.         while((line = br.readLine())!=null){
  12.             list.add(line);
  13.         }
  14.         //5.调用Collections中的sort方法,进行排序
  15.         Collections.sort(list);
  16.         //6.遍历集合,将排好序的文本遍历出来,然后写到文件中
  17.         for (String s : list) {
  18.             bw.write(s);
  19.             //换行
  20.             bw.newLine();
  21.         }
  22.         //7.关流
  23.         bw.close();
  24.         br.close();
  25.     }
  26. }

第五章.转换流

一.字符编码

计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。[按照某种规则，将字符存储到计算机中，称为编码] 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本f符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。

  • 字符编码**Character Encoding** : 就是一套自然语言的字符与二进制数之间的对应规则。

二.字符集

  • 字符集 **Charset**：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。

计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。

day18[IO流] - 图6

可见，当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们最终要关心的。

  • ASCII字符集 ：
    • ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显示字符（英文大小写字符、阿拉伯数字和西文符号）。
    • 基本的ASCII字符集，使用7位（bits）表示一个字符，共128字符。ASCII的扩展字符集使用8位（bits）表示一个字符，共256字符，方便支持欧洲常用字符。
  • ISO-8859-1字符集：
    • 拉丁码表，别名Latin-1，用于显示欧洲使用的语言，包括荷兰、丹麦、德语、意大利语、西班牙语等。
    • ISO-8859-1使用单字节编码，兼容ASCII编码。
  • GBxxx字符集：
    • GB就是国标的意思，是为了显示中文而设计的一套字符集。
    • GB2312：简体中文码表。一个小于127的字符的意义与原来相同。但两个大于127的字符连在一起时，就表示一个汉字，这样大约可以组合了包含7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名们都编进去了，连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这就是常说的”全角”字符，而原来在127号以下的那些就叫”半角”字符了。
    • GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等。
    • GB18030：最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等。
  • Unicode字符集 ：
    • Unicode编码系统为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。
    • 它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码。
    • UTF-8编码，可以用来表示Unicode标准中任何字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。所以，我们开发Web应用，也要使用UTF-8编码。它使用一至四个字节为每个字符编码，编码规则：
      1. 128个US-ASCII字符，只需一个字节编码。
      2. 拉丁文等字符，需要二个字节编码。
      3. 大部分常用字（含中文），使用三个字节编码。
      4. 其他极少使用的Unicode辅助字符，使用四字节编码。
  1. 总结:
  2.   1.编码:存   解码:取
  3.   2.编码和解码如果遵循的规则不一样,就会乱码
  4.     想要不乱码,编码和解码规则就要一样
  5.   3.GBK中一个汉字占2个字节
  6.     UTF-8中一个汉字占3个字节

三.用字符输入流对本地上的文件中的中文问题

  1. 如果存储的时候是以UTF-8去存的
  2.           那么读取的时候也是以UTF-8去读的,那么就不会出现乱码
  4.           但是存储的时候是GBK去存的,读取以UTF-8去读的,就会出现乱码
  1. public class Test01 {
  2.     public static void main(String[] args)throws Exception {
  3.         /*
  4.           如果存储的时候是以UTF-8去存的
  5.           那么读取的时候也是以UTF-8去读的,那么就不会出现乱码
  7.           但是存储的时候是GBK去存的,读取以UTF-8去读的,就会出现乱码
  8.          */
  9.         FileReader fr = new FileReader("E:\\Idea\\io\\g.txt");
  10.         int read = fr.read();
  11.         System.out.println((char) read);
  12.         fr.close();
  13.     }
  14. }

day18[IO流] - 图7

四.转换流_InputStreamReader

  1. 1.InputStreamReader:用于读数据
  2. 2.构造:
  3.   InputStreamReader(InputStream in, String charsetName) 
  4.                     in:抽象类,需要传递InputStream的子类
  5.                     charsetName:指定的编码(以什么编码去读)->不区分大小写
  6.                                 默认UTF-8
  7. 3.用法和FileReader一样
  1. public class Test02_InputStreamReader {
  2.     public static void main(String[] args) throws Exception{
  3.         InputStreamReader isr = new InputStreamReader(new FileInputStream("E:\\Idea\\io\\g.txt"),"GBK");
  4.         int read = isr.read();
  5.         System.out.println((char) read);
  6.         isr.close();
  7.     }
  8. }

五.转换流_OutputStreamWriter

  1. 1.构造:
  2.   OutputStreamWriter(OutputStream out, String charsetName) 
  3.                      out:抽象类,传递需要传递子类
  4.                      charsetName:指定编码->指定什么编码去写,那么就以什么编码去存这个数据
  5.                      默认UTF-8
  6. 2.用法:
  7.   和FileWriter一样
  1. public class Test03_OutputStreamWriter {
  2.     public static void main(String[] args) throws Exception{
  3.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("E:\\Idea\\io\\haha.txt"),"GBK");
  4.         osw.write("你好");
  5.         osw.close();
  6.     }
  7. }