JAVA入门—————IO流——字符流——OutputStreamWriter——BufferedWriter_BufferedReader

字符流

字符流写完后必须刷新！！！

• 只能读写文本文件
• 字符流 = 字节流 + 编码表
• Reader 抽象类 字符输入流的父类
• Writer 抽象类 字符输出流的父类

编码——发出

• 概念：把字符串转换成字节数组

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。

使用A型字符集进行编码，则使用A型字符集进行解码 使用同一种编码表 否则会出现乱码

OutputStreamWriter ————字符流输出

• 概念：字符流通向字节流的桥梁 ——使用指定的字符集将写入流中的字符编码成字节

OutputStreamWriter(OutputStream out)——创建使用默认字符编码的 OutputStreamWriter

OutputStreamWriter(OutputStream out, String charsetName)——创建使用指定字符集的 OutputStreamWriter

  OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("b.txt",true), "UTF-8");

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)——写一个字符串的一部分

eg：	OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("b.txt"));
        out.write("123");
        out.write("你好");
        out.write('我');
        char[] chars = {'a','b','c','你'};
        out.write(chars);
        out.write(chars,0,2);
        String s = "你好吗同学";
        out.write(s);
        out.write(s,0,2);
        out.close();————————刷新且释放资源

InputStreamReader————字符流输入

• 概念：字节流通向字符流的桥梁

InputStreamReader(InputStream is)——用默认的编码(GBK)读取数据

InputStreamReader(InputStream is,String charsetName)——用指定的编码读取数据

InputStreamReader(InputStream in)创建一个使用默认字符集的 InputStreamReader

InputStreamReader(InputStream in, String charsetName)——创建使用指定字符集的 InputStreamReader

public int read()——一次读取一个字符

public int read(char[] cbuf)——一次读取一个字符数组 如果没有读到 返回-1

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class demo3 {
    public static void main(String[] args) throws IOException {
        InputStreamReader in = new InputStreamReader(new FileInputStream("b.txt"));
        int read = in.read();
        System.out.println(read);
        char[] chars = new char[1024*8];
        int read1 = in.read(chars);——————返回读取到的有效字符个数
        System.out.println(read1+"个有效字符");
        String s = new String(chars);————————将字节数组转换成字符串
        System.out.println(s);
         System.out.println("----------------------------------");
        InputStreamReader in1 = new InputStreamReader(new FileInputStream("b.txt"));
        char[] chars1 = new char[1024];
        int len = in1.read(chars1, 0, 10);————————选取一部分字符进行读取
        System.out.println(len);
        for (char c : chars1) {
            System.out.println(c);——————10个有效字符  其余为空值null
        }
        in.close();
    }
}

字符流复制文本

import java.io.*;
public class demo4 {
    public static void main(String[] args) throws IOException {
        InputStreamReader in = new InputStreamReader(new FileInputStream("a.txt"));
        OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("C:\\Users\\ZY\\Desktop\\JAVA练习文件\\a.txt"));
        int len = 0;
        while((len = in.read())!=-1){
            out.write(len);
            out.flush();
        }
        in.close();
        out.close();
    }
}

高效读取并复制——创建一个字符数组充当缓冲区

eg：	InputStreamReader in = new InputStreamReader(new FileInputStream("a.txt"));
        OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("C:\\Users\\ZY\\Desktop\\JAVA练习文件\\a2.txt"));
        int len = 0;
        char[] chars = new char[1024];
        while((len = in.read(chars))!= -1){
            System.out.println("读取次数");
            out.write(chars,0,len);
            out.flush();
        }
        System.out.println("复制完成！");
        in.close();
        out.close();

FileWriter——便捷字符输出流

FileReader——便捷字符输入流

• 缺点：不能指定编码表 只能使用平台默认编码表

FileReader(File file)——在给定从中读取数据的 File 的情况下创建一个新 FileReader

FileReader(String fileName)——在给定从中读取数据的文件名的情况下创建一个新 FileReader

BufferedWriter———高效输出流

BufferedReader———高效输入流

BufferedReader(Reader in)——创建默认大小输入缓冲区的缓冲字符输入流。

BufferedWriter(Writer out)——创建默认大小输出缓冲区的缓冲字符输出流

eg：	BufferedReader bfr = new BufferedReader(new InputStreamReader(new FileInputStream("c.txt")));
        BufferedWriter bfw = new BufferedWriter(new FileWriter("c2.txt"));

BufferedWriter和BufferedReader独特的方法

BufferedWriter: public void newLine()—— 具有系统兼容性的换行符

BufferedReader: public String readLine()——一次读取一行数据 是以换行符为标记的 读到换行符就换行 没读到数据返回null 包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

eg：	BufferedReader bfr = new BufferedReader(new InputStreamReader(new FileInputStream("c.txt")));
        BufferedWriter bfw = new BufferedWriter(new FileWriter("c3.txt"));
        String line = null;
        char[] chars = new char[1024];
        while ((line = bfr.readLine())!=null){——————字符串不为空时应该是null
            bfw.write(line);——————一次读取一行
            bfw.newLine();
            bfw.flush();
        }

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

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
public class demo7 {
    public static void main(String[] args) throws IOException {
        ————————把集合数组中的数据存储在文本文件中
        ArrayList<String> list = new ArrayList<>();
        list.add("小华");
        list.add("小丽");
        list.add("小张");
        list.add("小明");
        BufferedWriter bfw = new BufferedWriter(new FileWriter("name.txt"));
        for (String s : list) {
            bfw.write(s);
            bfw.newLine();
            bfw.flush();
        }
        bfw.close();
    }
}

需求：从文本文件中读取数据到集合中，并遍历集合

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
public class demo8 {
    public static void main(String[] args) throws IOException {
        //把文本文件中的数据读取储存在集合中
        BufferedReader bfr = new BufferedReader(new FileReader("name.txt"));
        ArrayList<String> list = new ArrayList<>();
        while (true){
            String s = bfr.readLine();
            if(s == null){
                break;
            }
            list.add(s.trim());
        }
        System.out.println("读取完毕");
        System.out.println(list);
        bfr.close();
    }
}

从文本文件中生成随机人名单

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;
public class demo9 {
    public static void main(String[] args) throws IOException {
        BufferedReader bfr = new BufferedReader(new FileReader("name.txt"));
        ArrayList<String> list = new ArrayList<>();
        while (true){
            String s = bfr.readLine();
            if(s==null){
                break;
            }
            list.add(s.trim());
        }
        bfr.close();
        Random random = new Random();
        int i = random.nextInt(list.size());
        System.out.println(list.get(i));
    }
}

复制单级文件夹

import java.io.*;
public class demo10 {
    public static void main(String[] args) throws IOException {
        //复制单级文件夹
        File file = new File("C:\\Users\\ZY\\Desktop\\JAVA练习文件");
        File file1 = new File("E:\\Java练习文件");
        if(!file1.exists()){
            file1.mkdirs();
        }
        //递归判断
        digui(file, file1);
        System.out.println("复制完成");
    }
    private static void digui(File file, File file1) throws IOException {
        File[] files = file.listFiles();
        for (File f : files) {
            if(f.isFile()){
                //复制文件
                copyFile(f, file1);
            }
        }
    }
    private static void copyFile(File file, File file1) throws IOException {
        FileInputStream in = new FileInputStream(file);
        File file2 = new File(file1, file.getName());
         /*String name = file.getName(); ————改后缀名
        if(name.endsWith(".png")){
            name = name.substring(0,name.lastIndexOf("."));
        }
        File file2 = new File(file1, name + ".jpg");*/
        FileOutputStream out = new FileOutputStream(file2);
        int len = 0;
        byte[] bytes = new byte[1024 * 8];
        while((len = in.read(bytes))!=-1){
            out.write(bytes,0,len);
            out.flush();
        }
        in.close();
        out.close();
    }
}