1.字符流

字符流出现的原因:由于字节流操作中文不是特别方便，所以，java就提供了字符流。
字符流: 字符流 = 字节流 + 编码表

2.String类中的编码和解码问题

编码: 就是把字符串转换成字节数组

把一个字符串转换成一个字节数组
 public byte[] getBytes();使用平台的默认字符集将此 String编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
 public byte[] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

解码: 把字节数组转换成字符串

public String(byte[] bytes):	通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
public String(byte[] bytes, String charsetName) 通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。

使用什么字符集进行编码,那么就是使用什么字符集进行解码

String(byte[] bytes, String charsetName):通过指定的字符集解码字节数组
byte[] getBytes(String charsetName):使用指定的字符集合把字符串编码为字节数组
 
编码:把看得懂的变成看不懂的:	String -- byte[]
解码:把看不懂的变成看得懂的:	byte[] -- String

public class Test {
    public static void main(String[] args)  {
        byte[] bytes = {97, 98, 99};
        String string = null;
        try {
            string = new String(bytes, "UTF-8");//指定字符集解码字符数组
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        System.out.println(string);
    }
}

3.转换流OutputStreamWriter

OutputStreamWriter的构造方法
	OutputStreamWriter(OutputStream out):根据默认编码(GBK)把字节流的数据转换为字符流
	OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流

演示代码

public class Test1 {
    public static void main(String[] args) throws IOException {
        //输出流所关联的文件，如果不存在，会自动创建
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("b.txt"));
        outputStreamWriter.write("我爱学Java");
        outputStreamWriter.flush();//字符流，写入数据后，需要刷新
        outputStreamWriter.close();//刷新并关闭
    }
}

字符流的5种写数据的方式

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

4.转换流InputStreamReader

InputStreamReader的构造方法
	InputStreamReader(InputStream is):用默认的编码(GBK)读取数据
	InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据

字符流的2种读数据的方式
public int read() 一次读取一个字符，如果没有读到 返回-1
public int read(char[] cbuf) 一次读取一个字符数组 如果没有读到 返回-1

5.字符流复制文本文件

import java.io.*;

/**
 * GEEK
 * Description:爱学Java
 * @author :LiGer
 */
public class Test2 {
    public static void main(String[] args) {
        InputStreamReader in = null;
        OutputStreamWriter out = null;
        try {
            in = new InputStreamReader(new FileInputStream("a.txt"));
            out = new OutputStreamWriter(new FileOutputStream("c.txt"));
            int len=0;
            char[] chars = new char[1024*8];//定义一个字符数组
            while ((len=in.read(chars))!=-1){
                out.write(chars,0,len);
                out.flush();//刷新后才能写入
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (out != null) {
                    out.close();
                }
                if (in != null) {
                    in.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

6.FileWriter和FileReader

FileReader和FileWriter的出现
	转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，
	所以，为了简化我们的书写，转换流提供了对应的子类。	
	FileWriter
	FileReader

字符流便捷类:	因为转换流的名字太长了,并且在一般情况下我们不需要制定字符集,
                 于是java就给我们提供转换流对应的便捷类
    转换流							便捷类
- OutputStreamWriter	-------	FileWriter
- InputStreamReader	-------		FileReader

import java.io.*;

/**
 * GEEK
 * Description:爱学Java
 * @author :LiGer
 */
public class Test3 {
    public static void main(String[] args) {
        FileReader reader = null;
        FileWriter writer = null;
        try {
            reader = new FileReader("a.txt");
            writer = new FileWriter("d.txt");
            int len = 0;
            char[] chars = new char[1024 * 8];
            while ((len = reader.read(chars)) != -1) {
                writer.write(chars, 0, len);
                writer.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
                if (writer != null) {
                    writer.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

7.字符缓冲流的基本使用

高效的字符流

	 高效的字符输出流:	BufferedWriter
	  		     构造方法:	public BufferedWriter(Writer w)
	 高效的字符输入流:	BufferedReader
	 		     构造方法:   public BufferedReader(Reader e)

字符缓冲流的特殊功能
	BufferedWriter:	public void newLine():根据系统来决定换行符 具有系统兼容性的换行符
	BufferedReader:	public String readLine()：一次读取一行数据  是以换行符为标记的 读到换行符就换行 没读到数据返回null
		包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

文件复制练习

import java.io.*;

/**
 * GEEK
 * Description:爱学Java
 * @author :LiGer
 */
public class Test4 {
    public static void main(String[] args) {
        BufferedReader reader = null;
        BufferedWriter writer = null;
        try {
            reader = new BufferedReader(new FileReader("a.txt"));
            writer = new BufferedWriter(new FileWriter("e.txt"));
            String line=null;
            while ((line=reader.readLine())!=null){//读取不到一行返回null
                writer.write(line);
                writer.newLine();//写出换行符
                writer.flush();//刷新
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (writer != null) {
                    writer.close();
                }
                if (reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

8.把集合中的数据存储到文本文件

需求：把ArrayList集合中的字符串数据存储到文本文件
分析:

• a: 创建一个ArrayList集合
• b: 添加元素
• c: 创建一个高效的字符输出流对象
• d: 遍历集合,获取每一个元素,把这个元素通过高效的输出流写到文本文件中
• e: 释放资源

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

/**
 * GEEK
 * Description:爱学Java
 * @author :LiGer
 */
public class Test5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("好好学习");
        list.add("天天向上");
        list.add("爱学习");
        list.add("爱Java");
        list.add("爱写博客");
        BufferedWriter writer = null;
        try {
            writer = new BufferedWriter(new FileWriter("demo.txt"));
            for (String s : list) {
                writer.write(s);
                writer.newLine();//换行
                writer.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (writer != null) {
                    writer.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

把文本文件中的数据存储到集合中
需求：从文本文件中读取数据(每一行为一个字符串数据)到集合中，并遍历集合
分析:
* a: 创建高效的字符输入流对象
* b: 创建一个集合对象
* c: 读取数据(一次读取一行)
* d: 把读取到的数据添加到集合中
* e: 遍历集合
* f: 释放资源

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class MyTest2 {
    public static void main(String[] args) throws IOException {
        ArrayList<String> list = new ArrayList<>();
        BufferedReader reader = new BufferedReader(new FileReader("name.txt"));
        while (true){
            String name = reader.readLine();
            if (name == null) {
                break;
            }
            list.add(name);
        }
        System.out.println(list);
    }
}

随机获取文本文件中的姓名
需求：我有一个文本文件，每一行是一个学生的名字，请写一个程序，每次允许随机获取一个学生名称
分析:
* a: 创建一个高效的字符输入流对象
* b: 创建集合对象
* c: 读取数据,把数据存储到集合中
* d: 产生一个随机数,这个随机数的范围是 0 - 集合的长度 . 作为: 集合的随机索引
* e: 根据索引获取指定的元素
* f: 输出
* g: 释放资源

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;

public class MyTest3 {
    public static void main(String[] args) throws IOException {
        ArrayList<String> list = new ArrayList<>();
        BufferedReader reader = new BufferedReader(new FileReader("name.txt"));
        while (true) {
            String name = reader.readLine();
            if (name == null) {
                break;
            }
            list.add(name);
        }
        int index = new Random().nextInt(list.size());
        System.out.println(list.get(index));
        //思想：数据跟程序的解耦
    }
}