编码与解码

编码就是把字符转换为字节，而解码是把字节重新组合成字符。

如果编码和解码过程使用不同的编码方式那么就出现了乱码。

  • GBK 编码中，中文字符占 2 个字节，英文字符占 1 个字节；
  • UTF-8 编码中，中文字符占 3 个字节，英文字符占 1 个字节；
  • UTF-16be 编码中，中文字符和英文字符都占 2 个字节。

UTF-16be 中的 be 指的是 Big Endian，也就是大端。相应地也有 UTF-16le，le 指的是 Little Endian，也就是小端。

Java 的内存编码使用双字节编码 UTF-16be，这不是指 Java 只支持这一种编码方式，
而是说 char 这种类型使用 UTF-16be 进行编码。char 类型占 16 位，也就是两个字节，
Java 使用这种双字节编码是为了让一个中文或者一个英文都能使用一个 char 来存储。

String 的编码方式

String 可以看成一个字符序列，可以指定一个编码方式将它编码为字节序列，也可以指定一个编码方式将一个字节序列解码为 String。

  1. String str1 = "中文";
  2. byte[] bytes = str1.getBytes("UTF-8");
  3. String str2 = new String(bytes, "UTF-8");
  4. System.out.println(str2);

在调用无参数 getBytes() 方法时，默认的编码方式不是 UTF-16be。
双字节编码的好处是可以使用一个 char 存储中文和英文，
而将 String 转为 bytes[] 字节数组就不再需要这个好处，因此也就不再需要双字节编码
。getBytes() 的默认编码方式与平台有关，一般为 UTF-8。

  1. byte[] bytes = str1.getBytes();
  1. public class StringDemo {
  2.     public static void main(String[] args) throws UnsupportedEncodingException {
  3.         String s = "你好";
  5.         // String -- byte[]
  6.         //byte[] bys = s.getBytes(); // [-28, -67, -96, -27, -91, -67]
  7.         //byte[] bys = s.getBytes("GBK");// [-60, -29, -70, -61]
  8.         //byte[] bys = s.getBytes("UTF-8");// [-28, -67, -96, -27, -91, -67]
  9.         byte[] bys = s.getBytes("UTF-16be");//[79, 96, 89, 125]
  10.         System.out.println(Arrays.toString(bys));
  12.         // byte[] -- String
  13.         //String ss = new String(bys); // 你好
  14.         //String ss = new String(bys, "GBK"); // 你好
  15.         //String ss = new String(bys, "UTF-8"); // 你好
  16.         String ss = new String(bys, "UTF-16be"); //你好
  17.         System.out.println(ss);
  18.     }
  19. }

Reader 与 Writer

不管是磁盘还是网络传输，最小的存储单元都是字节，而不是字符。
但是在程序中操作的通常是字符形式的数据，因此需要提供对字符进行操作的方法。

  • InputStreamReader 实现从字节流解码成字符流；
  • OutputStreamWriter 实现字符流编码成为字节流。

InputStreamReader

  • InputStreamReader的构造方法：
  1. InputStreamReader(InputStream is) //用默认的编码读取数据
  2. InputStreamReader(InputStream is,String charsetName) //用指定的编码读取数据
  1. public class ReaderDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         InputStreamReader isr=new InputStreamReader(
  4.                 new FileInputStream("demo1.txt"),"UTF-8");
  5.         int ch=0;
  6.         while((ch=isr.read())!=-1){
  7.             System.out.print((char)ch);
  8.         }
  10.         isr.close();
  11.     }
  12. }
  • 读入字符
  1. int read() //一次读取一个字符
  2. int read(char[] chs) //一次读取一个字符数组
  1. public class ReaderDemo2 {
  2.     public static void main(String[] args) throws IOException {
  3.         InputStreamReader isr=new InputStreamReader(
  4.                 new FileInputStream("demo1.txt"),"UTF-8");
  6.         // 一次读取一个字符
  7.         // int ch = 0;
  8.         // while ((ch = isr.read()) != -1) {
  9.         // System.out.print((char) ch);
  10.         // }
  12.         // 一次读取一个字符数组
  13.         char[] chs = new char[1024];
  14.         int len = 0;
  15.         while ((len = isr.read(chs)) != -1) {
  16.             System.out.print(new String(chs, 0, len));
  17.         }
  19.         isr.close();
  20.     }
  21. }

OutputStreamWriter

  • OutputStreamWriter的构造方法：
  1. OutputStreamWriter(OutputStream out) //根据默认编码把字节流的数据转换为字符流
  2. OutputStreamWriter(OutputStream out,String charsetName) //根据指定编码把字节流数据转换为字符流
  3.  //字符流 = 字节流 +编码表。
  1. public class WriterDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("demo1.txt"),"UTF-8");
  5.         //直接写字符
  6.         osw.write("你好 hello\r\n");
  8.         osw.close();
  9.     }
  10. }
  • 写出方法：
  1. public void write(int c) //写一个字符
  2. public void write(char[] cbuf) //写一个字符数组
  3. public void write(char[] cbuf,int off,int len) //写一个字符数组的一部分
  4. public void write(String str) //写一个字符串
  5. public void write(String str,int off,int len) //写一个字符串的一部分
  1. public class WriterDemo2 {
  2.     public static void main(String[] args) throws IOException {
  3.         OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("demo1.txt"),"UTF-8");
  5.         // 写数据
  6.         // public void write(int c):写一个字符
  7.         osw.write('a');
  8.         osw.write(97);
  9.         // 为什么数据没有进去呢?
  10.         // 原因是：字符 = 2字节
  11.         // 文件中数据存储的基本单位是字节。
  12.         // void flush()
  14.         // public void write(char[] cbuf):写一个字符数组
  15.         // char[] chs = {'a','b','c','d','e'};
  16.         // osw.write(chs);
  18.         // public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
  19.         // osw.write(chs,1,3);
  21.         // public void write(String str):写一个字符串
  22.         // osw.write("我爱林青霞");
  24.         // public void write(String str,int off,int len):写一个字符串的一部分
  25.         osw.write("我爱林青霞", 2, 3);
  27.         // 刷新缓冲区
  28.         osw.flush();
  29.         // osw.write("我爱林青霞", 2, 3);
  31.         // 释放资源
  32.         osw.close();
  33.         // java.io.IOException: Stream closed
  34.         // osw.write("我爱林青霞", 2, 3);
  35.     }
  36. }

注意：close()和flush()的区别?

  1. close()关闭流对象，但是先刷新一次缓冲区。关闭之后，流对象不可以继续再使用了。
  2. flush()仅仅刷新缓冲区,刷新之后，流对象还可以继续使用。

BufferedReader

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

  1. public class ReaderDemo3 {
  2.     public static void main(String[] args) throws IOException {
  3.         // 创建字符缓冲输入流对象
  4.         BufferedReader br = new BufferedReader(new FileReader("demo1.txt"));
  6.         // 方式1
  7.         // int ch = 0;
  8.         // while ((ch = br.read()) != -1) {
  9.         // System.out.print((char) ch);
  10.         // }
  12.         // 方式2
  13.         char[] chs = new char[1024];
  14.         int len = 0;
  15.         while ((len = br.read(chs)) != -1) {
  16.             System.out.print(new String(chs, 0, len));
  17.         }
  19.         // 释放资源
  20.         br.close();
  21.     }
  22. }

BufferedWriter

  1. public class WriterDemo3 {
  2.     public static void main(String[] args) throws IOException {
  3.         BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
  5.         bw.write("hello");
  6.         bw.write("world");
  7.         bw.write("java");
  8.         bw.flush();
  10.         bw.close();
  11.     }
  12. }

字符缓冲流中的特殊方法

  1. //BufferedWriter:
  2. public void newLine() //根据系统来决定换行符
  3. //BufferedReader:
  4. public String readLine() //一次读取一行数据
  5. //包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
  1. /**
  2.  * 字符缓冲流的特殊方法：
  3.  * BufferedWriter:
  4.  *         public void newLine():根据系统来决定换行符
  5.  * BufferedReader:
  6.  *         public String readLine()：一次读取一行数据
  7.  *         包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
  8.  */
  9. public class BufferDemo {
  10.     public static void main(String[] args) throws IOException {
  11.         //write();
  12.         read();
  13.     }
  15.     public static void write() throws IOException {
  16.         BufferedWriter bw=new BufferedWriter(new FileWriter("demo1.txt"));
  18.         for (int x = 0; x < 3; x++) {
  19.             bw.write("我爱林青霞");
  20.             bw.newLine();
  21.             bw.flush();
  22.         }
  23.         bw.write("重要的事情说三遍");
  25.         bw.close();
  26.     }
  28.     public static void read() throws IOException {
  29.         BufferedReader br=new BufferedReader(new FileReader("demo1.txt"));
  31.         String line=null;
  32.         while((line=br.readLine())!=null){
  33.             System.out.println(line);
  34.         }
  36.         br.close();
  37.     }
  38. }

字符转换流

  1. public class TransferDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         // 封装数据源
  4.         BufferedReader br = new BufferedReader(new FileReader("demo1.txt"));
  5.         // 封装目的地
  6.         BufferedWriter bw = new BufferedWriter(new FileWriter("demo4.txt"));
  8.         // 两种方式其中的一种一次读写一个字符数组
  9.         char[] chs = new char[1024];
  10.         int len = 0;
  11.         while ((len = br.read(chs)) != -1) {
  12.             bw.write(chs, 0, len);
  13.             bw.flush();
  14.         }
  16.         // 释放资源
  17.         bw.close();
  18.         br.close();
  19.     }
  20. }
  1. public class TransferDemo2 {
  2.     public static void main(String[] args) throws IOException {
  3.         // 封装数据源
  4.         BufferedReader br = new BufferedReader(new FileReader("demo1.txt"));
  5.         // 封装目的地
  6.         BufferedWriter bw = new BufferedWriter(new FileWriter("demo4.txt"));
  8.         String line=null;
  9.         while((line=br.readLine())!=null){
  10.             bw.write(line);
  11.             bw.newLine();
  12.             bw.flush();
  13.         }
  15.         // 释放资源
  16.         bw.close();
  17.         br.close();
  18.     }
  19. }

复制文本文件

  1. public class CopyFile {
  2.     public static void main(String[] args) throws IOException{
  3.         String srcFile="pride-and-prejudice.txt";
  4.         String destFile="demo5.txt";
  5.         long start=System.currentTimeMillis();
  6.         //method(srcFile,destFile);//共耗时191毫秒
  7.         //method2(srcFile,destFile);//共耗时59毫秒
  8.         //method3(srcFile,destFile);//共耗时68毫秒
  9.         //method4(srcFile,destFile);//共耗时38毫秒
  10.         method5(srcFile,destFile);//共耗时177毫秒
  11.         long end=System.currentTimeMillis();
  12.         System.out.println("共耗时"+(end-start)+"毫秒");
  13.     }
  15.     //基本字符流一次读写一个字符
  16.     public static void method(String srcFile,String destFile) throws IOException{
  17.         FileReader fr=new FileReader(srcFile);
  18.         FileWriter fw=new FileWriter(destFile);
  20.         int ch=0;
  21.         while((ch=fr.read())!=-1){
  22.             fw.write(ch);
  23.         }
  25.         fr.close();
  26.         fw.close();
  27.     }
  29.     //基本字符流一次读写一个字符数组
  30.     public static void method2(String srcFile,String destFile) throws IOException{
  31.         FileReader fr=new FileReader(srcFile);
  32.         FileWriter fw=new FileWriter(destFile);
  34.         int len=0;
  35.         char[] chs=new char[1024];
  36.         while((len=fr.read(chs))!=-1){
  37.             fw.write(chs,0,len);
  38.         }
  40.         fr.close();
  41.         fw.close();
  42.     }
  44.     //字符缓冲流一次读写一个字符
  45.     public static void method3(String srcFile,String destFile) throws IOException{
  46.         BufferedReader br=new BufferedReader(new FileReader(srcFile));
  47.         BufferedWriter bw=new BufferedWriter(new FileWriter(destFile));
  49.         int ch=0;
  50.         while((ch=br.read())!=-1){
  51.             bw.write(ch);
  52.         }
  54.         br.close();
  55.         bw.close();
  56.     }
  58.     //字符缓冲流一次读写一个字符数组
  59.     public static void method4(String srcFile,String destFile) throws IOException{
  60.         BufferedReader br=new BufferedReader(new FileReader(srcFile));
  61.         BufferedWriter bw=new BufferedWriter(new FileWriter(destFile));
  63.         int len=0;
  64.         char[] chs=new char[1024];
  65.         while((len=br.read(chs))!=-1){
  66.             bw.write(chs,0,len);
  67.         }
  69.         br.close();
  70.         bw.close();
  71.     }
  73.     public static void method5(String srcFile,String destFile) throws IOException{
  74.         BufferedReader br=new BufferedReader(new FileReader(srcFile));
  75.         BufferedWriter bw=new BufferedWriter(new FileWriter(destFile));
  77.         String line=null;
  78.         while((line=br.readLine())!=null){
  79.             bw.write(line);
  80.             bw.newLine();
  81.             bw.flush();
  82.         }
  84.         br.close();
  85.         bw.close();
  86.     }
  87. }

复制多级文件夹

  1. public class CopyFolders {
  2.     public static void main(String[] args) throws IOException {
  3.         File srcFile=new File("demo2");
  4.         File destFile=new File("demo3");
  5.         copyFolder(srcFile,destFile);
  6.     }
  8.     //复制多级文件夹
  9.     public static void copyFolder(File srcFile,File destFile) throws IOException {
  10.         if(srcFile.isDirectory()){
  11.             //在destFile下创建新文件夹
  12.             File newDirectory=new File(destFile,srcFile.getName());
  13.             newDirectory.mkdir();
  15.             // 获取该File对象下的所有文件或者文件夹
  16.             File[] files=srcFile.listFiles();
  17.             if(files!=null){
  18.                 //将srcFile下的所有文件都复制到新destFile
  19.                 for(File file:files){
  20.                     copyFolder(file,newDirectory);
  21.                 }
  22.             }
  23.         }else{
  24.             File newFile=new File(destFile,srcFile.getName());
  25.             copyFile(srcFile,newFile);
  26.         }
  27.     }
  29.     //复制文件
  30.     public static void copyFile(File srcFile,File destFile) throws IOException {
  31.         BufferedInputStream bis=new BufferedInputStream(new FileInputStream(srcFile));
  32.         BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(destFile));
  34.         int len=0;
  35.         byte[] bys=new byte[1024];
  36.         while((len=bis.read(bys))!=-1){
  37.             bos.write(bys,0,len);
  38.         }
  40.         bos.close();
  41.         bis.close();
  42.     }
  43. }