Java进阶-IO（2）

- 采用GBK编码，占用2个字节
- UTF-8编码，占用3个字节

注：getBytes()方法：得到字符对应的字节数组，如：
String s="abc";
byte[] bys=s.getBytes();
System.out.println(Arrays.toString(bys));  //Arrays工具类的toString方法，打印结果为[97,98,99]

ISO8859-1：属于单字节编码，最多只能表示 0~255 的字符范围。
GBK/GB2312：中文的国标编码，用来表示汉字，属于双字节编码。GBK 可以表示简体中文和繁体中文，而 GB2312 只能表示简体中文（GBK 兼容 GB2312）
Unicode：是一种编码规范，是为解决全球字符通用编码而设计的。UTF-8 和 UTF-16 是这种规范的一种实现，该编码不兼容 ISO8859-1 编码。Java 内部采用此编码。
UTF：UTF 编码兼容了 ISO8859-1 编码，同时也可以用来表示所有的语言字符，但 UTF 编码是不定长编码，每一个字符的长度为 1~6 个字节不等（一般在中文网页中使用此编码，可以节省空间）

byte[] getBytes()：使用平台默认字符集将该String编码为一系列字节，并将结果存储到新的字节数组中。
byte[] getBytes(String charsetName)：通过指定的字符集将该String编码为一系列字节，并将结果存储到新的字节数组中

String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的String
String(bytes,String charsetName)：通过指定的字符集解码指定的字节数组来构造新的String

Reader：字符输入流的抽象类
Writer：字符输出流的抽象类

InputStreamReader（常用构造方法：2个）
- InputStreamReader（InputStream in） // 默认字符集
- InputStreamReader（InputStream in，String charsetName） // 指定字符集

OutputStreamWriter（常用构造方法：2个）
- OutputStreamWriter（OutputStream out）
- OutputStreamWriter（OutputStream out，String charsetName）

import java.io.UnsupportedEncodingException;
import java.util.Arrays; // 导入Arrays操作类

public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String s="中国"; // 创建一个字符串对象
        /*
        编码
        1.byte[] getBytes()
        2.byte[] getBytes(String charsetName)
         */
        byte[] bys = s.getBytes(); // getBytes()方法返回一个字节数组，ctrl+alt+v快捷键：生成左边
        System.out.println(Arrays.toString(bys)); // [-28, -72, -83, -27, -101, -67],一个汉字占3字节，说明是UTF-8编码
        byte[] bys1 = s.getBytes("UTF-8"); // [-28, -72, -83, -27, -101, -67]
        System.out.println(Arrays.toString(bys1)); // 调用Arrays工具类中的toString()方法，返回对象的字符串显示
        byte[] bys2 = s.getBytes("GBK");
        System.out.println(Arrays.toString(bys2)); // [-42, -48, -71, -6], GBK编码，一个汉字占2个字节

        /*
        解码
        1.String(byte[] bytes)
        2.String(bytes,String charsetName)
         */
        String ss= new String(bys);
        String ss1=new String(bys,"UTF-8");
        String ss2=new String(bys,"GBK"); // bys用UTF-8编码,却用GBK解码，所以输出会乱码
        String ss3=new String(bys2,"GBK"); // bys2用GBK编码，也用GBK解码，故不会乱码
        System.out.println(ss); // 中国
        System.out.println(ss1); // 中国
        System.out.println(ss2); // 涓  浗
        System.out.println(ss3); // 中国
        // 重要结论：按哪种编码存储（编码），就必须按该种编码解析（解码），否则会乱码
    }
}

[-28, -72, -83, -27, -101, -67]
[-28, -72, -83, -27, -101, -67]
[-42, -48, -71, -6]
中国
中国
涓  浗
中国

import java.io.*;

public class ConversionStreamDemo {
    public static void main(String[] args) throws IOException {
//        OutputStreamWriter(OutputStream out) 默认字符编码
//        OutputStreamWriter(OutputStream out,String charsetName) 指定字符编码

//        FileOutputStream fos=new FileOutputStream("C:\\Users\\ASUS\\Desktop\\project1\\src\\osw.txt");
//        OutputStreamWriter osw=new OutputStreamWriter(fos);
        // 操作1：写数据
        // 创建对象，默认字符编码
        //OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("C:\\Users\\ASUS\\Desktop\\project1\\src\\osw.txt")); // 平台默认为UTF-8编码
        // 创建对象，第二种构造方法
        OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("C:\\Users\\ASUS\\Desktop\\project1\\src\\osw.txt"),"GBK");
        osw.write("中国"); // 写入数据
        // 释放资源
        osw.close();

        // 操作2：读数据
        // 创建对象(两种构造方法)
        //InputStreamReader isr=new InputStreamReader(new FileInputStream("C:\\Users\\ASUS\\Desktop\\project1\\src\\osw.txt")); //以GBK编码，UTF-8解码，会出现乱码
        InputStreamReader isr=new InputStreamReader(new FileInputStream("C:\\Users\\ASUS\\Desktop\\project1\\src\\osw.txt"),"GBK"); //以GBK编码，GBK解码，不乱码
        // 一次读取一个字符数据
        int ch;
        while ((ch= isr.read())!=-1){ // 未到文件末尾，还有数据
            System.out.print((char) ch); // 强转为字符类型，注意不要加ln
        }
        // 释放资源
        isr.close();
    }
}

中国

Reader 类是所有字符流输入类的父类，常用子类：（参考JDK帮助文档）
- CharArrayReader 类：将字符数组转换为字符输入流，从中读取字符。
- StringReader 类：将字符串转换为字符输入流，从中读取字符。
- BufferedReader 类：为其他字符输入流提供读缓冲区。
- PipedReader 类：连接到一个 PipedWriter。
- InputStreamReader 类：将字节输入流转换为字符输入流，可以指定字符编码。
    - 与 InputStream 类相同，在 Reader 类中也包含 close()、mark()、skip() 和 reset() 等方法，可参考 InputStream 类的方法

int read()    从输入流中读取一个字符，并把它转换为 0~65535 的整数。如果返回 -1， 则表示已经到了输入流的末尾。
为了提高 I/O 操作的效率，通常使用以下两种 read()方法
int read(char[] cbuf)    从输入流中读取若干个字符，并把它们保存到参数 cbuf 指定的字符数组中。 该方法返回读取的字符数，如果返回 -1，则表示已经到了输入流的末尾
int read(char[] cbuf,int off,int len)    从输入流中读取若干个字符，并把它们保存到参数 cbuf 指定的字符数组中。其中，off 指定在字符数组中开始保存数据的起始下标，len 指定读取的字符数。该方法返回实际读取的字符数，如果返回 -1，则表示已经到了输入流的末尾

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        // 创建一个默认字符集的InputStreamReader对象
        InputStreamReader isr=new InputStreamReader(new FileInputStream("D:\\Ultimate JavaCode\\src\\test6\\文本复制案例.txt"));
        // 读数据
//        方法1
//        int ch;
//        while ((ch= isr.read())!=-1){ // 是否读到文件末尾，即判断文件数据是否全部读完
//            System.out.print((char) ch); // 强转为字符类型输出显示在控制台上
//        }
//        方法2
        char[] chs=new char[1024]; // 大小为1024的整数倍
        int len;
        while ((len=isr.read(chs))!=-1){ // read(byte[] b)方法
            System.out.print(new String(chs,0,len)); // 转化为字符串对象输出显示在控制台
        }
        // 释放资源
        isr.close();
    }
}

FileReader(File file)：在给定要读取数据的文件的情况下创建一个新的 FileReader 对象。其中，file 表示要从中读取数据的文件。
FileReader(String fileName)：在给定从中读取数据的文件名的情况下创建一个新 FileReader 对象。其中，fileName 表示要从中读取数据的文件的名称，表示的是一个文件的完整路径。

注：在创建 FileReader 对象时若引发 FileNotFoundException 异常，需要使用 try catch 语句捕获该异常。

import java.io.*;

// 实现字符流复制java文件
public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr=new InputStreamReader(new FileInputStream("D:\\Ultimate JavaCode\\ConversionStreamDemo.java"));
        OutputStreamWriter isw=new OutputStreamWriter(new FileOutputStream("D:\\Ultimate JavaCode\\Copy.java"));
        // 1.一次读取一个字符数据
//        int ch;
//        while ((ch=isr.read())!=-1){ // 读数据
//            isw.write(ch); // 复制文件
//        }
        // 2.一次读取一个字符数组数据
        char[] chs=new char[1024]; // 1024的整数倍
        int len;
        while((len=isr.read(chs))!=-1){
            isw.write(chs,0,len);
        }
        // 释放资源
        isw.close();
        isr.close();
    }
}

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
// FileReader和FileWriter类分别为InputStreamReader和OutputStreamWriter的子类(继承)，因此可以调用其方法
public class FileReaderDemo1 {
    public static void main(String[] args) throws IOException {
        // 根据数据源创建字符输入流对象
        FileReader fr=new FileReader("D:\\Ultimate JavaCode\\ConversionStreamDemo.java");
        // 根据目的地创建字符输出流对象
        FileWriter fw=new FileWriter("D:\\Ultimate JavaCode\\Copy1.java");
        // 1.一次读取一个字符数据
//        int ch;
//        while ((ch=fr.read())!=-1){ // 读数据
//            fw.write(ch); // 写入复制
//        }

        // 2.一次读取一个字符数组
        char[] chs=new char[1024]; // 1024的整数倍
        int len;
        while((len=fr.read(chs))!=-1){
            fw.write(chs,0,len);
        }
        // 释放资源
        fw.close();
        fr.close();
    }
}

BufferedReader(Reader in)：创建一个 BufferedReader 来修饰参数 in 指定的字符输入流
BufferedReader(Reader in,int size)：创建一个 BufferedReader 来修饰参数 in 指定的字符输入流，参数 size 则用于指定缓冲区的大小，单位为字符。

import java.io.*;

public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        // 创建字符缓冲输出流对象
//        BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\Ultimate JavaCode\\src\\test6\\bw.txt"));
//        // 写数据
//        bw.write("hello\n"); // 添加换行符换行
//        bw.write("javaee\n");
//        // 释放资源
//        bw.close();

        // 创建字符缓冲输入流对象
        BufferedReader br=new BufferedReader(new FileReader("D:\\Ultimate JavaCode\\src\\test6\\bw.txt"));
        // 一次读取一个字符数据
//        int ch;
//        while((ch=br.read())!=-1){
//            System.out.print((char) ch); // 强转为字符类型输出显示在控制台上
//        }

        // 一次读取一个字符数组
        char[] chs=new char[1024];
        int len;
        while((len=br.read(chs))!=-1){
            System.out.println(new String(chs,0,len)); // 转换为字符串类型输出显示在控制台上
        }
        // 释放资源
        br.close();
    }
}

hello
javaee

Writer 类是所有字符输出流的父类，常用子类：
- CharArrayWriter 类：向内存缓冲区的字符数组写数据。
- StringWriter 类：向内存缓冲区的字符串（StringBuffer）写数据。
- BufferedWriter 类：为其他字符输出流提供写缓冲区。
- PipedWriter 类：连接到一个 PipedReader。
- OutputStreamWriter 类：将字节输出流转换为字符输出流，可以指定字符编码。
    - 与 OutputStream 类相同，Writer 类也包含 close()、flush() 等方法，可参考 OutputStream 类的方法

FileWriter(File file)：在指定 File 对象的情况下构造一个 FileWriter 对象。
FileWriter(File file,boolean append)：在指定 File 对象的情况下构造一个 FileWriter 对象，如果 append 的值为 true，则将字节写入文件末尾，而不是写入文件开始处。
FileWriter(String fileName)：在指定文件名的情况下构造一个 FileWriter 对象。其中，fileName 表示要写入字符的文件名，表示的是完整路径。
FileWriter(String fileName,boolean append)：在指定文件名以及要写入文件的位置的情况下构造 FileWriter 对象。其中，append 是一个 boolean 值，如果为 true，则将数据写入文件末尾，而不是文件开始处

BufferedWriter(Writer out)：创建一个 BufferedWriter 来修饰参数 out 指定的字符输出流，默认大小。
BufferedWriter(Writer out,int size)：创建一个 BufferedWriter 来修饰参数 out 指定的字符输出流，参数 size 则用于指定缓冲区的大小，单位为字符。
- BufferedWriter 类的使用与 FileWriter 类相同，不再重述。

write(int c)  写一个字符
write(char[] cbuf)  写入一个字符数组
write(char[] cbuf,int off,int len)  写入字符数组的一部分
write(String str)  写一个字符串
write(String str,int off,int len)  写一个字符串的一部

flush()：刷新流，还能继续写数据
close()：关闭流之前先刷新流，一旦关闭后不能再写数据

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
// OutputStreamWrite类：将字节输出流转换为字符输出流，可以指定字符编码。
public class OutputStreamWriteDemo {
    public static void main(String[] args) throws IOException {
        // 创建OutputStreamWriter对象(使用默认字符编码)
        OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("D:\\Ultimate JavaCode\\src\\test6\\osw_2_12"));
        /* 写入数据(5种方式，重载)
        write(int c)  写一个字符
        write(char[] cbuf)  写入一个字符数组
        write(char[] cbuf，int off，int len)  写入字符数组的一部分
        write(String str)  写一个字符串
        write(String str，int off，int len)  写一个字符串的一部
         */

//        osw.write(97);
//        // 字符流写数据不能直接写到文件中，因为最终要通过字节流FileOutputStream来写，还存储在缓冲区里面
//        osw.flush(); // 刷新流，将数据从缓冲区刷新入文件，还能继续写数据
//        osw.write(98);
//        osw.flush();
//        osw.write(99);
//        osw.close(); // 关闭流之前先刷新流，一旦关闭后不能再写数据。整个结果：abc

//        char[] chs={'a','b','c','d','e'};
//        osw.write(chs); // abcde
//        osw.write(chs,0,chs.length); // abcde
//        osw.write(chs,1,3); // bcd

//        osw.write("abcdef"); // abcdef
        osw.write("abcdef",1,3); // bcd
        // 释放资源
        osw.close();
    }
}