I/O（File、字节流、字符流、其他流（特殊操作流）、总结、I/O相关题目、Properties）

1.I/O概述

I/O流的分类

• 按数据流向 (input/output) 针对java程序或内存
  [1] 输入流 ： 读入数据
  [2] 输出流 ： 写出数据
• 按照数据类型
  [1] 字节流：数据是一连串01二进制数据 (1B=8bit,字节是1种单位符号) 0000 0000
  [2] 字符流：数据是字符序列(可以理解为1种文化符号) abcd 张三李四

如何区分使用字节流还是字符流？
文本数据用字符流，如果不确定内容，就用字节流
常用基类：

• 字节流的抽象基类
  [1] InputStream 字节输入流
  [2] OutputStream 字节输出流
• 字符流的抽象基类
  [1] Reader 字符输入流
  [2] Writer 字符输出流

注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream。[xxxx]InputStream
如：Reader的子类FileReader [xxxx]Reader

2.File

File类概述和构造方法

public class FileDemo01 {
    public static void main(String[] args) {
        //File(String pathname)：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
        File f1 = new File("E:\\itcast\\java.txt");
        System.out.println(f1);

        //File(String parent, String child)：从父路径名字符串和子路径名字符串创建新的 File实例。
        File f2 = new File("E:\\itcast","java.txt");
        System.out.println(f2);

        //File(File parent, String child)：从父抽象路径名和子路径名字符串创建新的 File实例。
        File f3 = new File("E:\\itcast");
        File f4 = new File(f3,"java.txt");
        System.out.println(f4);
    }
}

File类创建功能

public boolean createNewFile()：当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
        如果文件不存在，就创建文件，并返回true
        如果文件存在，就不创建文件，并返回false

    public boolean mkdir()：创建由此抽象路径名命名的目录
        如果目录不存在，就创建目录，并返回true
        如果目录存在，就不创建目录，并返回false

    public boolean mkdirs()：创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录
        自己补齐

public class FileDemo02 {
    public static void main(String[] args) throws IOException {
        //需求1：我要在E:\\itcast目录下创建一个文件java.txt
        File f1 = new File("E:\\itcast\\java.txt");
        System.out.println(f1.createNewFile());
        System.out.println("--------");

        //需求2：我要在E:\\itcast目录下创建一个目录JavaSE
        File f2 = new File("E:\\itcast\\JavaSE");
        System.out.println(f2.mkdir());
        System.out.println("--------");

        //需求3：我要在E:\\itcast目录下创建一个多级目录JavaWEB\\HTML
        File f3 = new File("E:\\itcast\\JavaWEB\\HTML");
//        System.out.println(f3.mkdir());
        System.out.println(f3.mkdirs());
        System.out.println("--------");

        //需求4：我要在E:\\itcast目录下创建一个文件javase.txt
        File f4 = new File("E:\\itcast\\javase.txt");
//        System.out.println(f4.mkdir());//创建的是javase.txt目录
        System.out.println(f4.createNewFile());
    }
}

File类判断和获取功能

public class FileDemo04 {
    public static void main(String[] args) {
        //创建一个File对象
        File f = new File("myFile\\java.txt");

//        public boolean isDirectory()：测试此抽象路径名表示的File是否为目录
//        public boolean isFile()：测试此抽象路径名表示的File是否为文件
//        public boolean exists()：测试此抽象路径名表示的File是否存在
        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        System.out.println(f.exists());

//        public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串
//        public String getPath()：将此抽象路径名转换为路径名字符串
//        public String getName()：返回由此抽象路径名表示的文件或目录的名称
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        System.out.println("--------");

//        public String[] list()：返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
//        public File[] listFiles()：返回此抽象路径名表示的目录中的文件和目录的File对象数组
        File f2 = new File("E:\\itcast");

        String[] strArray = f2.list();
        for(String str : strArray) {
            System.out.println(str);
        }
        System.out.println("--------");

        File[] fileArray = f2.listFiles();
        for(File file : fileArray) {
//            System.out.println(file);
//            System.out.println(file.getName());
            if(file.isFile()) {
                System.out.println(file.getName());
            }
        }
    }
}

File类删除功能

public class FileDemo03 {
    public static void main(String[] args) throws IOException {
//        File f1 = new File("E:\\itcast\\java.txt");
        //需求1：在当前模块目录下创建java.txt文件
        File f1 = new File("myFile\\java.txt");
//        System.out.println(f1.createNewFile());

        //需求2：删除当前模块目录下的java.txt文件
        System.out.println(f1.delete());
        System.out.println("--------");

        //需求3：在当前模块目录下创建itcast目录
        File f2 = new File("myFile\\itcast");
//        System.out.println(f2.mkdir());

        //需求4：删除当前模块目录下的itcast目录
        System.out.println(f2.delete());
        System.out.println("--------");

        //需求5：在当前模块下创建一个目录itcast,然后在该目录下创建一个文件java.txt
        File f3 = new File("myFile\\itcast");
//        System.out.println(f3.mkdir());
        File f4 = new File("myFile\\itcast\\java.txt");
//        System.out.println(f4.createNewFile());

        //需求6：删除当前模块下的目录itcast
        System.out.println(f4.delete());
        System.out.println(f3.delete());
    }
}

递归

StackOverflowError:当堆栈溢出发生时抛出一个应用程序递归太深，即没有出口

public class DiGuiDemo {
    public static void main(String[] args) {
        //回顾不死神兔问题，求第20个月兔子的对数
        //每个月的兔子对数：1,1,2,3,5,8，...
        int[] arr = new int[20];

        arr[0] = 1;
        arr[1] = 1;

        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        System.out.println(arr[19]);
        System.out.println(f(20));
    }

    /*
        递归解决问题，首先就是要定义一个方法：
            定义一个方法f(n)：表示第n个月的兔子对数
            那么，第n-1个月的兔子对数该如何表示呢？f(n-1)
            同理，第n-2个月的兔子对数该如何表示呢？f(n-2)

        StackOverflowError:当堆栈溢出发生时抛出一个应用程序递归太深
     */
    public static int f(int n) {
        if(n==1 || n==2) {
            return 1;
        } else {
            return f(n - 1) + f(n - 2);
        }
    }
}

案例，递归求阶乘

public class DiGuiDemo01 {
    public static void main(String[] args) {
        //调用方法
        int result = jc(5);
        //输出结果
        System.out.println("5的阶乘是：" + result);
    }

    //定义一个方法，用于递归求阶乘，参数为一个int类型的变量
    public static int jc(int n) {
        //在方法内部判断该变量的值是否是1
        if(n == 1) {
            //是：返回1
            return 1;
        } else {
            //不是：返回n*(n-1)!
            return n*jc(n-1);
        }
    }
}

遍历目录

public class DiGuiDemo02 {
    public static void main(String[] args) {
        //根据给定的路径创建一个File对象
//        File srcFile = new File("E:\\itcast");
        File srcFile = new File("E:\\itheima");

        //调用方法
        getAllFilePath(srcFile);
    }

    //定义一个方法，用于获取给定目录下的所有内容，参数为第1步创建的File对象
    public static void getAllFilePath(File srcFile) {
        //获取给定的File目录下所有的文件或者目录的File数组
        File[] fileArray = srcFile.listFiles();
        //遍历该File数组，得到每一个File对象
        if(fileArray != null) {
            for(File file : fileArray) {
                //判断该File对象是否是目录
                if(file.isDirectory()) {
                    //是：递归调用
                    getAllFilePath(file);
                } else {
                    //不是：获取绝对路径输出在控制台
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
}

3.字节流

• 字节输出流OutputStream
• 字节输入流InputStream

3.1字节输出流OutputStream类

此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。需要定义 OutputStream 子类的应用程序必须始终提供至少一种可写入一个输出字节的方法。输出流中都是（写入）write方法

方法摘要	Value
void	close() 关闭此输出流并释放与此流有关的所有系统资源
void	write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。
void	write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
void abstract	write(int b) 将指定的字节写入此输出流

3.1.1 FileOutputStream类（OutputStream的子类）

FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");//写法一
        //new File(name)//写法一与写法二等价
FileOutputStream fos = new FileOutputStream(new File("myByteStream\\fos.txt"));//写法二

        //FileOutputStream​(File file)：创建文件输出流以写入由指定的 File对象表示的文件
File file = new File("myByteStream\\fos.txt");
FileOutputStream fos2 = new FileOutputStream(file);//写法3
//写法3与写法4等价
FileOutputStream fos2 = new FileOutputStream(new File("myByteStream\\fos.txt"));//写法4

//写法4与写法二等价

FileOutputStream类，即文件输出流，将数据写入File的输出流。
构造方法：

项目	Value
FileOutputStream(File file)	创建一个向指定 File 对象表示的文件中写入数据的文件输出流
FileOutputStream(File file, boolean append)	创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(String name)	创建一个向具有指定名称的文件中写入数据的输出文件流
FileOutputStream(String name, boolean append)	创建一个向具有指定 name 的文件中写入数据的输出文件流。

成员方法：

void	write(byte[] b) 将 b.length 个字节从指定 byte 数组写入此文件输出流中
void	write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流
void	write(int b) 将指定字节写入此文件输出流

使用字节输出流写数据的步骤：
一.创建字节输出流对象：
1.调用系统功能创建了文件
2.创建字节输出流对象
3.让字节输出流对象指向文件
二.调用字节输出流对象的写数据方法：
三.释放资源（关闭此文件输出流并释放于此流相关联的任何系统资源）：

getBytes()：将字符串转化为字节数组
例如：

public class test01 {
    public static void main(String[] args) throws IOException {
// 数据
        String s = "hello world";
// 字节输出流对象
        FileOutputStream out = new FileOutputStream("a.txt");
        byte[] bytes = s.getBytes();
        for (int i = 0; i < bytes.length; i++) {
            out.write(bytes[i]);
        }
        out.write(bytes,2,4);
        out.close();
    }
}

输出：

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //FileOutputStream​(String name)：创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
        /*
            做了三件事情：
                A:调用系统功能创建了文件
                B:创建了字节输出流对象
                C:让字节输出流对象指向创建好的文件
         */

        //void write​(int b)：将指定的字节写入此文件输出流
        fos.write(97);
//        fos.write(57);
//        fos.write(55);

        //最后都要释放资源
        //void close​()：关闭此文件输出流并释放与此流相关联的任何系统资源。
        fos.close();
    }
}

3.1.2 字节流写数据常见问题

1. 创建字节输出流到底做了哪些事情?

[1] 创建FileOutputStream对象的时候，jvm首先到操作系统，查找目标文件.。当发现目标文件不存在的时候， jvm会首先创建该目标文件(内容为空)
[2] 当发现目标文件存在的时候, jvm默认会首先清空目标文件内容，最好准备让FileOutputStream, 从文件头，开始写入数据。
[3]在内存中，创建FileOutputStream对象。在FileOutputStream对象和目标文件之间建立数据传输通道。

2. 数据写成功后，为什么要关闭close

避免资源浪费，io是一种比较宝贵的资源

3. 如何实现数据的换行?

System.lineSeparator() :得到系统换行符
windos:"\r\n"
linux:"\n"
mac:"\r"

4. 如何实现数据的追加写入?

public class test02 {
    public static void main(String[] args) throws IOException {
        // FileOutputStream(String name, boolean append)
// 创建一个向具有指定 name 的文件中写入数据的输出文件流。
//如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处
        FileOutputStream out = new FileOutputStream("a.txt",true);
        out.write("hahahaha".getBytes());
        out.close();
    }
}

输出：

5. 给I/0流操作加上异常处理

public class test03 {
    public static void main(String[] args) {
        FileOutputStream out = null;
        try {
            out = new FileOutputStream("a.txt");
            out.write("hello world".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally { // 为什么finally? 前面代码有问题 开启的io一定要关闭
            try {
// 不等于null才关闭
                if (out != null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3.2字节输入流InputStream类

InputStream是抽象类，是表示所有字节输入流的基类，定义了共性的功能方法。

项目	Value
abstract int	read() 从输入流中读取数据的下一个字节
int	read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b中
int	read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组。

FileInputStream类(InputStream的子类)

构造方法：

FileInputStream(File file)	通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定
FileInputStream(String name)	通过打开一个到实际文件的连接来创建一个
FileInputStream	该文件通过文件系统中的路径名 name 指定。

成员方法：

项目	Value
int	read() 从此输入流中读取一个数据字节
int	read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中
int	read(byte[] b, int off, int len) 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中

读取数据int read()方法：

public class test04 {
    public static void main(String[] args) throws IOException {
        File file = new File("a.txt");
        FileInputStream in = new FileInputStream(file);
        int len;
        while ((len = in.read()) != -1) {
            char c = (char) len;
            System.out.print(c);
        }
    }
}

读取数据int read(byte[] b)方法：

public class test05 {
    public static void main(String[] args) throws IOException {
        File file = new File("a.txt");
        FileInputStream in = new FileInputStream(file);
        byte[] bytes = new byte[1024];
        in.read(bytes);
        String s = new String(bytes);
        System.out.println("s = " + s);
    }
}

一次读取一个字节；
一次读取一个字节数组。
从效率上来讲，肯定是一次读取多个字节的方式效率更高！

复制一张图片 从某路径 到 当前项目目录
思路：
首先创建字节输入流对象，用read方法读取图片数据
再创建字节输出流，用write方法写入新的文件，完成复制
示例：

方式一（每次一个字节）

public class test06 {
    public static void main(String[] args) throws IOException {
        // 创建字节输入流对象
        FileInputStream in = new FileInputStream("E:\\fengjing.jpg");
        // 创建字节输出流对象
        FileOutputStream out = new FileOutputStream("copy1.jpg");
        // 边读边写
// 方式一 耗时 61676ms
        long start = System.currentTimeMillis();
        int len;
        while ((len = in.read()) != -1) {
            out.write(len);
        }
        long end = System.currentTimeMillis();
        System.out.println("复制所耗时间："+(end - start));

    }
}

/*
    需求：把文件fos.txt中的内容读取出来在控制台输出

    使用字节输入流读数据的步骤：
        1:创建字节输入流对象
        2:调用字节输入流对象的读数据方法
        3:释放资源
 */
public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");

        //调用字节输入流对象的读数据方法
        //int read​(byte[] b)：从该输入流读取最多 b.length个字节的数据到一个字节数组

        byte[] bys = new byte[5];

        //第一次读取数据
        int len = fis.read(bys);
        System.out.println(len);
        //String​(byte[] bytes)
//        System.out.println(new String(bys));
        System.out.println(new String(bys,0,len));

        //第二次读取数据
        len = fis.read(bys);
        System.out.println(len);
//        System.out.println(new String(bys));
        System.out.println(new String(bys,0,len));

        //第三次读取数据
        len = fis.read(bys);
        System.out.println(len);
        //String​(byte[] bytes, int offset, int length)
        System.out.println(new String(bys,0,len));

        //再多读取两次
        len = fis.read(bys);
        System.out.println(len);
        len = fis.read(bys);
        System.out.println(len);

        /*
            hello\r\n
            world\r\n

            第一次：hello
            第二次：\r\nwor
            第三次：ld\r\nr

         */

        byte[] byss = new byte[1024]; //1024及其整数倍
        int len2;
        while ((len2=fis.read(byss))!=-1) {
            System.out.print(new String(byss,0,len2));//将byss字节数组转化为对应的字符串
        }

        //释放资源
        fis.close();
    }
}

方式二（每次一个数组）：

public class test06 {
    public static void main(String[] args) throws IOException {
        // 创建字节输入流对象
        FileInputStream in = new FileInputStream("E:\\fengjing.jpg");
        // 创建字节输出流对象
        FileOutputStream out = new FileOutputStream("copy1.jpg");
        // 边读边写
// 方式一 耗时 61676ms
        long start = System.currentTimeMillis();
        byte[] bytes = new byte[1024];//创建一个1024字节的字节数组
        int len;
        while ((len = in.read(bytes)) != -1) {
            out.write(bytes,0,len);//每次写入1024单位的数据
        }
        long end = System.currentTimeMillis();
        System.out.println("复制所耗时间："+(end - start));
        in.close();
        out.close();
    }
}

3.3字节缓冲流

BufferedOutputStream字节缓冲输出流
BufferedInputStream字节缓冲输入流

3.3.1BufferedOutputStream字节缓冲输出流

该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。
构造方法：

项目	Value
BufferedOutputStream(OutputStream out)	创建一个新的缓冲输出流，以将数据写入指定的底层输出流。

要创建缓冲流对象，必须在构造方法中，接收一个普通的相应的输入/输出字节流对象，即缓冲流，是基于一个已有的底层的字节流创建出来的。

• 包装流：缓冲流通过包装了一层底普通字节流得到的
• 包装流会负责自己所包装的底层流：所以关闭流的时候，只需要关闭包装流。

3.3.2BufferedInputStream字节缓冲输入流

项目	Value
BufferedInputStream(InputStream in)	创建一个BufferedInputStream 并保存其参数，即输入流 in，以便将来使用

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        //字节缓冲输出流：BufferedOutputStream​(OutputStream out)
//        FileOutputStream fos = new FileOutputStream("myByteStream\\bos.txt");
//        BufferedOutputStream bos = new BufferedOutputStream(fos);
        /*
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\bos.txt"));
        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        //释放资源
        bos.close();
        */

        //字节缓冲输入流：BufferedInputStream​(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myByteStream\\bos.txt"));

        //一次读取一个字节数据
//        int by;
//        while ((by=bis.read())!=-1) {
//            System.out.print((char)by);
//        }

        //一次读取一个字节数组数据
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1) {
            System.out.print(new String(bys,0,len));
        }

        //释放资源
        bis.close();
    }
}

注意：

• 使用字节缓冲流的时候 如果忘记close，数据就不会刷新到文件当中，必须要使用flush方法强制刷新到底层流
• close方法会自动执行flush方法
• 可以不用flush方法，但是一定要close

3.3.3 案例：字节流复制视频

/*
    需求：
        把E:\\itcast\\字节流复制图片.avi 复制到模块目录下的 字节流复制图片.avi

    思路：
        1:根据数据源创建字节输入流对象
        2:根据目的地创建字节输出流对象
        3:读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
        4:释放资源

    四种方式实现复制视频，并记录每种方式复制视频的时间
        1:基本字节流一次读写一个字节             共耗时：64565毫秒
        2:基本字节流一次读写一个字节数组          共耗时：107毫秒
        3:字节缓冲流一次读写一个字节             共耗时：405毫秒
        4:字节缓冲流一次读写一个字节数组          共耗时：60毫秒
 */
public class CopyAviDemo {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long startTime = System.currentTimeMillis();

        //复制视频
//        method1();
//        method2();
//        method3();
        method4();

        //记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时：" + (endTime - startTime) + "毫秒");
    }

    //字节缓冲流一次读写一个字节数组
    public static void method4() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\字节流复制图片.avi"));

        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1) {
            bos.write(bys,0,len);
        }

        bos.close();
        bis.close();
    }

    //字节缓冲流一次读写一个字节
    public static void method3() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\字节流复制图片.avi"));

        int by;
        while ((by=bis.read())!=-1) {
            bos.write(by);
        }

        bos.close();
        bis.close();
    }


    //基本字节流一次读写一个字节数组
    public static void method2() throws IOException {
        //E:\\itcast\\字节流复制图片.avi
        //模块目录下的 字节流复制图片.avi
        FileInputStream fis = new FileInputStream("E:\\itcast\\字节流复制图片.avi");
        FileOutputStream fos = new FileOutputStream("myByteStream\\字节流复制图片.avi");

        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1) {
            fos.write(bys,0,len);
        }

        fos.close();
        fis.close();
    }

    //基本字节流一次读写一个字节
    public static void method1() throws IOException {
        //E:\\itcast\\字节流复制图片.avi
        //模块目录下的 字节流复制图片.avi
        FileInputStream fis = new FileInputStream("E:\\itcast\\字节流复制图片.avi");
        FileOutputStream fos = new FileOutputStream("myByteStream\\字节流复制图片.avi");

        int by;
        while ((by=fis.read())!=-1) {
            fos.write(by);
        }

        fos.close();
        fis.close();
    }
}

4.字符流

为什么会出现乱码？
字节流：以字节为单位。
字符流：以字符为单位，两者逻辑单位不一致。
核心问题：编解码的不一致。

4.1字符编码表

• ASCII：美国标准信息交换码：用一个字节的7位，共128字符可以表示。
• ISO8859-1：拉丁码表。欧洲码表：用一个字节的8位表示
• GB2312：中国的中文编码表：
• GBK：中国的中文编码表升级，融合了更多的中文文字符号
• GB18030：GBK的取代版本
• BIG-5码：通行于台湾、香港地区的一个繁体字编码方案，俗称“大五码”
• Unicode：国际标准码，融合了多种文字（理论上）
• UTF-8：可变长度来表示一个字符
  UTF-8定义了一种“区间规则”，这种规则可以和ASCII编码保持最大程度的兼容。（电子邮件、网页及其他存储或传送文字的应用中，优先使用的编码）

它将Unicode编码为00000000-0000007F的字符，用单个字节来表示 0111 1111 = 7F

它将Unicode编码为00000080-000007FF的字符用两个字节表示

它将Unicode编码为00000800-0000FFFF的字符用3字节表示

1字节 0xxxxxxx
2字节 110xxxxx 10xxxxxx
3字节 1110xxxx 10xxxxxx 10xxxxxx

字符流 = 字节流 + 编码表（根据指定编码表，编解码的过程）

4.1.1字符串中的编码解码问题

public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String s = "中国";

        //byte[] getBytes()：使用平台的默认字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
        byte[] bys = s.getBytes(); //[-28, -72, -83, -27, -101, -67]
        //String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的 String
        String ss = new String(bys);
        System.out.println("平台的默认字符集编码为一系列字节："+Arrays.toString(bys));
        System.out.println("平台的默认字符集解码："+ss);


        //byte[] getBytes(String charsetName)：使用指定的字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
        byte[] bys2 = s.getBytes("UTF-8"); //[-28, -72, -83, -27, -101, -67]
        //String(byte[] bytes, String charsetName)：通过指定的字符集解码指定的字节数组来构造新的 String
        String sss = new String(bys2,"UTF-8");
        System.out.println("平台的默认字符集编码为一系列字节："+Arrays.toString(bys2));
        System.out.println("指定的字符集UTF-8解码："+sss);

        byte[] bys3 = s.getBytes("GBK"); //[-42, -48, -71, -6]
        String ssss = new String(bys3,"GBK");
        System.out.println("平台的默认字符集编码为一系列字节："+Arrays.toString(bys3));
        System.out.println("指定的字符集GBK解码："+ssss);
    }
}

4.1.2字符流中的编码解码问题

4.2字符输出流Writer

写入字符流的抽象超类。多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。
成员方法：

项目	Value
void	write(char[] cbuf) 写入字符数组。
abstract void	write(char[] cbuf, int off, int len) 写入字符数组的某一部分
void	write(int c) 写入单个字符。
void	write(String str) 写入字符串。
void	write(String str, int off, int len) 写入字符串的某一部分

Writer是一个抽象类，不能直接实例化。我们应该利用它的子类

转换流OutputStreamWriter

OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

每次调用 write() 方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区中累积。可以指定此缓冲区的大小。
注意，传递给 write() 方法的字符没有缓冲。
构造方法：

项目	Value
OutputStreamWriter(OutputStream out)	创建使用默认字符编码的 OutputStreamWriter
OutputStreamWriter(OutputStream out, String charsetName)	创建使用指定字符集的OutputStreamWriter。

方法:

项目	Value
void	close() 关闭此流，但要先刷新它。
void	flush() 刷新该流的缓冲,很快且及时。
String	getEncoding() 返回此流使用的字符编码的名称。
void	write(char[] cbuf, int off, int len) 写入字符数组的某一部分。
void	write(int c) 写入单个字符
void	write(String str, int off, int len) 写入字符串的某一部分。

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        //OutputStreamWriter​(OutputStream out)：创建一个使用默认字符编码的OutputStreamWriter
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));

        //void write​(int c)：写一个字符
//        osw.write(97);
//        //void flush()：刷新流
//        osw.flush();
        osw.write(98);
        osw.flush();
//        osw.write(99);

        //void write​(char[] cbuf)：写入一个字符数组
        char[] chs = {'a', 'b', 'c', 'd', 'e'};
//        osw.write(chs);

        //void write​(char[] cbuf, int off, int len)：写入字符数组的一部分
//        osw.write(chs, 0, chs.length);
//        osw.write(chs, 1, 3);

        //void write​(String str)：写一个字符串
//        osw.write("abcde");

        //void write​(String str, int off, int len)：写一个字符串的一部分
//        osw.write("abcde", 0, "abcde".length());
        osw.write("abcde", 1, 3);

        //释放资源
        osw.close();
        //Exception in thread "main" java.io.IOException: Stream closed
//        osw.write(100);
    }
}

FileWriter类

用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在FileOutputStream 上构造一个OutputStreamWriter。

文件是否可用或是否可以被创建取决于底层平台。特别是某些平台一次只允许一个FileWriter（或其他文件写入对象）打开文件进行写入。在这种情况下，如果所涉及的文件已经打开，则此类中的构造方法将失败。

FileWriter 用于写入字符流。要写入原始字节流，请考虑使用 FileOutputStream。
构造方法:

项目	Value
FileWriter(File file)	根据给定的 File 对象构造一个 FileWriter 对象。
FileWriter(File file, boolean append)	根据给定的 File 对象构造一个 FileWriter 对象
FileWriter(String fileName)	根据给定的文件名构造一个 FileWriter 对象
FileWriter(String fileName, boolean append)	根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象

FileWriter VS OutputStreamWriter

• FileWriter创建对象简单，OutputStreamWriter繁琐
• FileWriter只能使用默认字符集，OutputStreamWriter可以指定字符集编码

4.3字符输入流Reader

用于读取字符流的抽象超类多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

成员方法：

转换流InputStreamReader类

InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。

它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

OutputStreamWriter 是从字符流到字节流的桥梁：使用指定的编码将写入的字符编码为字节

它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。

public class ConversionStreamDemo {
    public static void main(String[] args) throws IOException {
//        OutputStreamWriter​(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。
//        OutputStreamWriter​(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter。
//        FileOutputStream fos = new FileOutputStream("myCharStream\\osw.txt");
//        OutputStreamWriter osw = new OutputStreamWriter(fos);
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"),"UTF-8");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"),"GBK");
        osw.write("中国");
        osw.close();

//        InputStreamReader​(InputStream in) 创建一个使用默认字符集的InputStreamReader。
//        InputStreamReader​(InputStream in, String charsetName) 创建一个使用命名字符集的InputStreamReader。
//        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\osw.txt"));
        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\osw.txt"),"GBK");
        //一次读取一个字符数据
        int ch;
        while ((ch=isr.read())!=-1) {
            System.out.print((char)ch);
        }

        isr.close();

    }
}

FileReader类和FileWriter类，简化转换流

• FileReader创建对象简单，OutputStreamReader繁琐
• FileReader只能使用默认字符集，OutputStreamReader可以指定字符集编码

案例：字符流复制Java文件

public class CopyJavaDemo01 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\ConversionStreamDemo.java"));
        //根据目的地创建字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\Copy.java"));

        //读写数据，复制文件
        //一次读写一个字符数据
//        int ch;
//        while ((ch=isr.read())!=-1) {
//            osw.write(ch);
//        }

        //一次读写一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len=isr.read(chs))!=-1) {
            osw.write(chs,0,len);
        }

        //释放资源
        osw.close();
        isr.close();
    }
}

案例：字符流复制Java文件（改进版）

public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对象
        FileReader fr = new FileReader("myCharStream\\ConversionStreamDemo.java");
        //根据目的地创建字符输出流对象
        FileWriter fw = new FileWriter("myCharStream\\Copy.java");

        //读写数据，复制文件
//        int ch;
//        while ((ch=fr.read())!=-1) {
//            fw.write(ch);
//        }

        char[] chs = new char[1024];
        int len;
        while ((len=fr.read(chs))!=-1) {
            fw.write(chs,0,len);
        }

        //释放资源
        fw.close();
        fr.close();
    }
}

4.4字符缓冲流

• 字符缓冲输出流BufferedWriter
• 字符缓冲输入流BufferedReader
• 默认缓冲区大小是8kb = 8192B

BufferedWriter
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
该类提供了 newLine() 方法，它使用平台自己的行分隔符概念，此概念由系统属性 line.separator 定义。并非所有平台都使用新行符 (’\n’) 来终止各行。因此调用此方法来终止每个输出行要优于直接写入新行符。
构造方法：

项目	Value
BufferedWriter(Writer out)	创建一个使用默认大小输出缓冲区的缓冲字符输出流
成员方法
void	newLine() 写入一个行分隔符

BufferedReader
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

通常，Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和InputStreamReader）。例如，

BufferedReader in = new BufferedReader(new FileReader("foo.in"));

构造方法	Value
BufferedReader(Reader in)	创建一个使用默认大小输入缓冲区的缓冲字符输入流方法
成员方法
String	readLine() 读取一个文本行。文件末尾，返回null而不是-1

案例：字符缓冲流复制Java文件

public class CopyJavaDemo01 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
        //根据目的地创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Copy.java"));

        //读写数据，复制文件
        //一次读写一个字符数据
//        int ch;
//        while ((ch=br.read())!=-1) {
//            bw.write(ch);
//        }

        //一次读写一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len=br.read(chs))!=-1) {
            bw.write(chs,0,len);
        }

        //释放资源
        bw.close();
        br.close();
    }
}

案例：字符缓冲流特有功能复制Java文件

public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
        //根据目的地创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Copy.java"));

        //读写数据，复制文件
        //使用字符缓冲流特有功能实现
        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();//换行符
            bw.flush();//刷新
        }

        //释放资源
        bw.close();
        br.close();
    }
}

5.其他流（特殊操作流）

标准输入输出流

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Scanner;

/*
    public static final InputStream in：标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
 */
public class SystemInDemo {
    public static void main(String[] args) throws IOException {
        //public static final InputStream in：标准输入流
//        InputStream is = System.in;

/*
//        int by;
//        while ((by=is.read())!=-1) {
//            System.out.print((char)by);
//        }//每次读取一个字符，遇到中文容易出错
*/

        //如何把字节流转换为字符流？用转换流
//        InputStreamReader isr = new InputStreamReader(is);
//        //使用字符流能不能够实现一次读取一行数据呢？可以
//        //但是，一次读取一行数据的方法是字符缓冲输入流的特有方法
//        BufferedReader br = new BufferedReader(isr);

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        System.out.println("请输入一个字符串：");
        String line = br.readLine();
        System.out.println("你输入的字符串是：" + line);

        System.out.println("请输入一个整数：");
        int i = Integer.parseInt(br.readLine());
        System.out.println("你输入的整数是：" + i);

        //自己实现键盘录入数据太麻烦了，所以Java就提供了一个类供我们使用
        Scanner sc = new Scanner(System.in);
    }
}

/*
    public static final PrintStream out：标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标
 */
public class SystemOutDemo {
    public static void main(String[] args) {
        //public static final PrintStream out：标准输出流
        PrintStream ps = System.out;

        //能够方便地打印各种数据值
//        ps.print("hello");
//        ps.print(100);

//        ps.println("hello");
//        ps.println(100);

        //System.out的本质是一个字节输出流
        System.out.println("hello");
        System.out.println(100);

        System.out.println();
//        System.out.print();
    }
}

数据流

DataInputStream/DataOutputStream

数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。

打印流

• 字节打印流 PrintStream
• 字符打印流PrintWriter
  打印流特点：
• 只能操作目的地，不能操作数据来源
• 可以操作任意类型的数据
• 如果启动了自动刷新，能够自动刷新
• 打印流添加输出数据的功能，使它们能够方便地打印各种数据值表示形式.
  方法：
  void print(String str): 输出任意类型的数据，
  void println(String str): 输出任意类型的数据，自动写入换行操作
  自动刷新：
  通过构造方法
• PrintWriter(OutputStream out, boolean autoFlush) 通过现有的 OutputStream 创建新的PrintWriter
• PrintWriter(Writer out, boolean autoFlush) 创建新 PrintWriter

字节打印流

import java.io.IOException;
import java.io.PrintStream;

/*
    打印流的特点：
        只负责输出数据，不负责读取数据
        有自己的特有方法

    字节打印流
        PrintStream​(String fileName)：使用指定的文件名创建新的打印流
 */
public class PrintStreamDemo {
    public static void main(String[] args) throws IOException {
        //PrintStream​(String fileName)：使用指定的文件名创建新的打印流
        PrintStream ps = new PrintStream("myOtherStream\\ps.txt");

        //写数据
        //字节输出流有的方法
//        ps.write(97);//写入a

        //使用特有方法写数据
//        ps.print(97);
//        ps.println();
//        ps.print(98);
        ps.println(97);//写入97
        ps.println(98);//写入98


        //释放资源
        ps.close();
    }
}

字符打印流

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/*
    字符打印流的构造方法：
        PrintWriter​(String fileName) ：使用指定的文件名创建一个新的PrintWriter，而不需要自动执行行刷新

        PrintWriter​(Writer out, boolean autoFlush)：创建一个新的PrintWriter
            out：字符输出流
            autoFlush： 一个布尔值，如果为真，则println ， printf ，或format方法将刷新输出缓冲区
 */
public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        //PrintWriter​(String fileName) ：使用指定的文件名创建一个新的PrintWriter，而不需要自动执行行刷新
//        PrintWriter pw = new PrintWriter("myOtherStream\\pw.txt");

//        pw.write("hello");
//        pw.write("\r\n");
//        pw.flush();
//        pw.write("world");
//        pw.write("\r\n");
//        pw.flush();

//        pw.println("hello");
        /*
            pw.write("hello");
            pw.write("\r\n");
         */
//        pw.flush();
//        pw.println("world");
//        pw.flush();

        //PrintWriter​(Writer out, boolean autoFlush)：创建一个新的PrintWriter
        PrintWriter pw = new PrintWriter(new FileWriter("myOtherStream\\pw.txt"),true);
//        PrintWriter pw = new PrintWriter(new FileWriter("myOtherStream\\pw.txt"),false);

        pw.println("hello");//一步相当于下面的三步
        /*
            pw.write("hello");
            pw.write("\r\n");
            pw.flush();
         */
        pw.println("world");

        pw.close();
    }
}

案例：复制java文件（打印流改进版）

import java.io.*;

/*
    需求：
        把模块目录下的PrintStreamDemo.java 复制到模块目录下的 Copy.java

    思路：
        1:根据数据源创建字符输入流对象
        2:根据目的地创建字符输出流对象
        3:读写数据，复制文件
        4:释放资源
 */
public class CopyJavaDemo {
    public static void main(String[] args) throws IOException {
        /*
        //根据数据源创建字符输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myOtherStream\\PrintStreamDemo.java"));
        //根据目的地创建字符输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myOtherStream\\Copy.java"));

        //读写数据，复制文件
        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
        br.close();
        */

        //根据数据源创建字符输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myOtherStream\\PrintStreamDemo.java"));
        //根据目的地创建字符输出流对象
        PrintWriter pw = new PrintWriter(new FileWriter("myOtherStream\\Copy.java"),true);

        //读写数据，复制文件
        String line;
        while ((line=br.readLine())!=null) {
            pw.println(line);
        }

        //释放资源
        pw.close();
        br.close();
    }
}

对象序列化流与对象反序列化流

Student

import java.io.Serializable;

public class Student implements Serializable {
    private static final long serialVersionUID = 42L;
    private String name;
//    private int age;
    private transient int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

//    @Override
//    public String toString() {
//        return "Student{" +
//                "name='" + name + '\'' +
//                ", age=" + age +
//                '}';
//    }
}

ObjectOutputStreamDemo

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

/*
    对象序列化流
        构造方法：
            ObjectOutputStream​(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream

        序列化对象的方法：
            void writeObject​(Object obj)：将指定的对象写入ObjectOutputStream

    NotSerializableException:抛出一个实例需要一个Serializable接口。 序列化运行时或实例的类可能会抛出此异常

    类的序列化由实现java.io.Serializable接口的类启用。 不实现此接口的类将不会使任何状态序列化或反序列化
 */
public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //ObjectOutputStream​(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myOtherStream\\oos.txt"));

        //创建对象
        Student s = new Student("林青霞",30);

        //void writeObject​(Object obj)：将指定的对象写入ObjectOutputStream
        oos.writeObject(s);

        //释放资源
        oos.close();
    }
}

ObjectInputStreamDemo

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

/*
    构造方法：
        ObjectInputStream​(InputStream in)：创建从指定的InputStream读取的ObjectInputStream

    反序列化对象的方法：
        Object readObject​()：从ObjectInputStream读取一个对象
 */
public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //ObjectInputStream​(InputStream in)：创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myOtherStream\\oos.txt"));

        //Object readObject​()：从ObjectInputStream读取一个对象
        Object obj = ois.readObject();

        Student s = (Student) obj;
        System.out.println(s.getName() + "," + s.getAge());

        ois.close();
    }
}

student类中，给年龄age加了transient，不显示年龄信息且默认为0

import java.io.*;

/*
    用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢？
        java.io.InvalidClassException:
            当序列化运行时检测到类中的以下问题之一时抛出。
                类的串行版本与从流中读取的类描述符的类型不匹配
                该类包含未知的数据类型
                该类没有可访问的无参数构造函数

        com.itheima_03.Student; local class incompatible:
        stream classdesc serialVersionUID = -3743788623620386195,
        local class serialVersionUID = -247282590948908173


    如果出问题了，如何解决呢？
        给对象所属的类加一个值：private static final long serialVersionUID = 42L;

    如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？
        private transient int age;
 */
public class ObjectStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//        write();
        read();
    }

    //反序列化
    private static void read() throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myOtherStream\\oos.txt"));
        Object obj = ois.readObject();
        Student s = (Student) obj;
        System.out.println(s.getName() + "," + s.getAge());
        ois.close();
    }

    //序列化
    private static void write() throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myOtherStream\\oos.txt"));
        Student s = new Student("林青霞", 30);
        oos.writeObject(s);
        oos.close();
    }
}

6.总结

集合到文件

public class ArrayListToTxtDemo {
    public static void main(String[] args) throws IOException {
        //创建ArrayList集合
        ArrayList<String> array = new ArrayList<String>();

        //往集合中存储字符串元素
        array.add("hello");
        array.add("world");
        array.add("java");

        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\array.txt"));

        //遍历集合，得到每一个字符串数据
        for(String s : array) {
            //调用字符缓冲输出流对象的方法写数据
            bw.write(s);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
    }
}

集合到文件（改进版）

Student

public class Student {
    private String sid;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public Student(String sid, String name, int age, String address) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

ArrayListToFileDemo

public class ArrayListToFileDemo {
    public static void main(String[] args) throws IOException {
        //创建ArrayList集合
        ArrayList<Student> array = new ArrayList<Student>();

        //创建学生对象
        Student s1 = new Student("itheima001", "林青霞", 30, "西安");
        Student s2 = new Student("itheima002", "张曼玉", 35, "武汉");
        Student s3 = new Student("itheima003", "王祖贤", 33, "郑州");

        //把学生对象添加到集合中
        array.add(s1);
        array.add(s2);
        array.add(s3);

        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\students.txt"));

        //遍历集合，得到每一个学生对象
        for (Student s : array) {
            //把学生对象的数据拼接成指定格式的字符串
            StringBuilder sb = new StringBuilder();
            sb.append(s.getSid()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",").append(s.getAddress());

            //调用字符缓冲输出流对象的方法写数据
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
    }
}

集合到文件（数据排序改进版）

Student

public class Student {
    // 姓名
    private String name;
    // 语文成绩
    private int chinese;
    // 数学成绩
    private int math;
    // 英语成绩
    private int english;

    public Student() {
        super();
    }

    public Student(String name, int chinese, int math, int english) {
        super();
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getEnglish() {
        return english;
    }

    public void setEnglish(int english) {
        this.english = english;
    }

    //计算总分的方法
    public int getSum() {
        return this.chinese + this.math + this.english;
    }
}

TreeSetToFileDemo

public class TreeSetToFileDemo {
    public static void main(String[] args) throws IOException {
        //创建TreeSet集合，通过比较器排序进行排序
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //成绩总分从高到低
                int num = s2.getSum() - s1.getSum();
                //次要条件
                int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
                int num4 = num3 == 0 ? s1.getName().compareTo(s2.getName()) : num3;
                return num4;
            }
        });


        //键盘录入学生数据
        for (int i = 0; i < 5; i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第" + (i + 1) + "个学生信息：");
            System.out.println("姓名：");
            String name = sc.nextLine();
            System.out.println("语文成绩：");
            int chinese = sc.nextInt();
            System.out.println("数学成绩：");
            int math = sc.nextInt();
            System.out.println("英语成绩：");
            int english = sc.nextInt();

            //创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
            Student s = new Student();
            s.setName(name);
            s.setChinese(chinese);
            s.setMath(math);
            s.setEnglish(english);

            //把学生对象添加到TreeSet集合
            ts.add(s);
        }

        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\ts.txt"));

        //遍历集合，得到每一个学生对象
        for (Student s : ts) {
            //把学生对象的数据拼接成指定格式的字符串
            //格式：姓名,语文成绩,数学成绩,英语成绩
            StringBuilder sb = new StringBuilder();
            sb.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getMath()).append(",").append(s.getEnglish()).append(",").append(s.getSum());

//            调用字符缓冲输出流对象的方法写数据
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
    }
}

文件到集合

public class TxtToArrayListDemo {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\array.txt"));

        //创建ArrayList集合对象
        ArrayList<String> array = new ArrayList<String>();

        //调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line=br.readLine())!=null) {
            //把读取到的字符串数据存储到集合中
            array.add(line);
        }

        //释放资源
        br.close();

        //遍历集合
        for(String s : array) {
            System.out.println(s);
        }
    }
}

文件到集合（改进版）

public class FileToArrayListDemo {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\students.txt"));

        //创建ArrayList集合对象
        ArrayList<Student> array = new ArrayList<Student>();

        //调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line = br.readLine()) != null) {
            //把读取到的字符串数据用split()进行分割，得到一个字符串数组
            String[] strArray = line.split(",");

            //创建学生对象
            Student s = new Student();
            //把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
            //itheima001,林青霞,30,西安
            s.setSid(strArray[0]);
            s.setName(strArray[1]);
            s.setAge(Integer.parseInt(strArray[2]));//将字符串转化为整数
            s.setAddress(strArray[3]);

            //把学生对象添加到集合
            array.add(s);
        }

        //释放资源
        br.close();

        //遍历集合
        for (Student s : array) {
            System.out.println(s.getSid() + "," + s.getName() + "," + s.getAge() + "," + s.getAddress());
        }
    }
}

复制单级文件夹

public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
        //创建数据源目录File对象，路径是E:\\itcast
        File srcFolder = new File("E:\\itcast");

        //获取数据源目录File对象的名称(itcast)
        String srcFolderName = srcFolder.getName();

        //创建目的地目录File对象，路径名是模块名+itcast组成(myCharStream\\itcast)
        File destFolder = new File("myCharStream",srcFolderName);

        //判断目的地目录对应的File是否存在，如果不存在，就创建
        if(!destFolder.exists()) {
            destFolder.mkdir();
        }

        //获取数据源目录下所有文件的File数组
        File[] listFiles = srcFolder.listFiles();

        //遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
        for(File srcFile : listFiles) {
            //数据源文件：E:\\itcast\\mn.jpg
            //获取数据源文件File对象的名称(mn.jpg)
            String srcFileName = srcFile.getName();
            //创建目的地文件File对象，路径名是目的地目录+mn.jpg组成(myCharStream\\itcast\\mn.jpg)
            File destFile = new File(destFolder,srcFileName);
            //复制文件
            copyFile(srcFile,destFile);
        }
    }

    private static void copyFile(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));

        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1) {
            bos.write(bys,0,len);
        }
        bos.close();
        bis.close();
    }
}

复制多级文件夹

import java.io.*;

/*
    需求：
        把“E:\\itcast”复制到 F盘目录下

    思路：
        1:创建数据源File对象，路径是E:\\itcast
        2:创建目的地File对象，路径是F:\\
        3:写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
        4:判断数据源File是否是目录
            是：
                A:在目的地下创建和数据源File名称一样的目录
                B:获取数据源File下所有文件或者目录的File数组
                C:遍历该File数组，得到每一个File对象
                D:把该File作为数据源File对象，递归调用复制文件夹的方法
            不是：说明是文件，直接复制，用字节流
 */
public class CopyFoldersDemo {
    public static void main(String[] args) throws IOException {
        //创建数据源File对象，路径是E:\\itcast
        File srcFile = new File("E:\\itcast");
        //创建目的地File对象，路径是F:\\
        File destFile = new File("F:\\");

        //写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
        copyFolder(srcFile,destFile);
    }

    //复制文件夹
    private static void copyFolder(File srcFile, File destFile) throws IOException {
        //判断数据源File是否是目录
        if(srcFile.isDirectory()) {
            //在目的地下创建和数据源File名称一样的目录
            String srcFileName = srcFile.getName();
            File newFolder = new File(destFile,srcFileName); //F:\\itcast
            if(!newFolder.exists()) {
                newFolder.mkdir();
            }

            //获取数据源File下所有文件或者目录的File数组
            File[] fileArray = srcFile.listFiles();

            //遍历该File数组，得到每一个File对象
            for(File file : fileArray) {
                //把该File作为数据源File对象，递归调用复制文件夹的方法
                copyFolder(file,newFolder);
            }
        } else {
            //说明是文件，直接复制，用字节流
            File newFile = new File(destFile,srcFile.getName());
            copyFile(srcFile,newFile);
        }
    }

    //字节缓冲流复制文件
    private static void copyFile(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));

        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        bis.close();
    }

}

复制文件的异常处理

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
    复制文件加入异常处理
 */
public class CopyFileDemo {
    public static void main(String[] args) {

    }

    //JDK9的改进方案
    private static void method4() throws IOException {
        FileReader fr = new FileReader("fr.txt");
        FileWriter fw = new FileWriter("fw.txt");
        try(fr;fw){
            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //JDK7的改进方案
    private static void method3() {
        try(FileReader fr = new FileReader("fr.txt");
            FileWriter fw = new FileWriter("fw.txt");){
            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //try...catch...finally
    private static void method2() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader("fr.txt");
            fw = new FileWriter("fw.txt");

            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fw!=null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fr!=null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //抛出处理
    private static void method1() throws IOException {
        FileReader fr = new FileReader("fr.txt");
        FileWriter fw = new FileWriter("fw.txt");

        char[] chs = new char[1024];
        int len;
        while ((len = fr.read()) != -1) {
            fw.write(chs, 0, len);
        }

        fw.close();
        fr.close();
    }
}

7.I/O相关题目

1.有这样的一个words数组，数组中每个字符串的格式为“词性:单词”
String[] words = {“verb:eat”,“verb:drink”,“verb:sleep”,“verb:play”,“noun:rice”,“noun:meat”,“noun:hand”,“noun:hair”};
根据单词性质动词verb全部存入verb.txt文件中
根据单词性质名词noun全部存入noun.txt文件中

import java.io.*;

/**
 * @Author:gaoyuan
 * @Description:分离词性和单词
 * @DateTime:2021/1/18 20:19
 **/
public class SpeechWords {
    public static void main(String[] args) throws IOException {
        String[] words = {"verb:eat", "verb:drink", "verb:sleep",
                "verb:play", "noun:rice", "noun:meat", "noun:hand", "noun:hair"};

        File file1 = new File("verb.txt");
        File file2 = new File("noun.txt");

        FileOutputStream verbfileOutputStream = new FileOutputStream(file1);
        FileOutputStream nounfileOutputStream = new FileOutputStream(file2);

        for (String word : words) {
            if (word.substring(0, 4).equals("verb")) {
                //将匹配的动词（5，word.length()）位置的内容写入到输出流中，最后转化成字节数组
                verbfileOutputStream.write((word.substring(5, word.length()) + "\n").getBytes());
            } else {
                nounfileOutputStream.write((word.substring(5, word.length()) + "\n").getBytes());
            }
        }
    }

}

结果输出：
noun.txt
rice
meat
hand
hair

verb.txt
eat
drink
sleep
play

2. 递归查找指定目录中(包括子目录中)，所有的.java文件，并且，把所有这些找到的java文件，复制(是复制不是移动)到一个指定的目录下，目录结构为如下：
   firstLevel目录中，包含一个secondLevel目录和a1.txt和b1.java文件
   secondLevel目录中包含dir1和dir2两个目录，和a2.txt和b2.java文件
   dir1目录中包含a3.txt和b3.java文件
   dir2目录是一个空目录

mport java.io.*;

/**
 * @Author:gaoyuan
 * @Description:复制匹配文件到一个指定的目录下
 * @DateTime:2021/1/18 21:40
 **/
public class copy {

    public static void main(String[] args) throws IOException {
        File file = new File("F:\\firstLevel");
        Copy(file);


    }

    public static void Copy(File file) throws IOException {
        File[] files = file.listFiles();

        if (file.isFile()) {
            String fileName = file.getName();//获得文件名，如：a1.txt，b1.java
            int index = fileName.lastIndexOf(".");//返回文件名字符数组中“.”所在的位置
            String suffix = fileName.substring(index);//返回后缀子字符串
            if (suffix.equals(".java")) {
                FileInputStream in = new FileInputStream(file);//从抽象对象file中获取路径F:\firstLevel中的信息，即输入流
                //创建将fileName放入指定位置的out输出流抽象对象
                FileOutputStream out = new FileOutputStream(new File("F:\\TESTZ\\" + fileName));// "F:TESTZb1.java"
                //"F:TESTZ/b1.java"
                byte[] bytes = new byte[1024];//创建1024个字节单位的字符数组作为转换中介
                int reader;
                while ((reader = in.read(bytes)) != -1) {//in.read(bytes)返回的是单位输入流的长度数字
                    out.write(bytes, 0, reader);//将单位bytes字符数组输入流中的内容从[0,reader],写入输出流
                }
                in.close();
                out.close();
            }
        } else if (file.isDirectory()) {
            for (File file1 : files) {
                Copy(file1);
            }
        }
    }
}

结果输出：

8.Properties

Properties作为Map集合的使用

import java.util.Properties;
import java.util.Set;

/*
    Properties作为Map集合的使用
 */
public class PropertiesDemo01 {
    public static void main(String[] args) {
        //创建集合对象
//        Properties<String,String> prop = new Properties<String,String>(); //错误
        Properties prop = new Properties();

        //存储元素
        prop.put("itheima001", "林青霞");
        prop.put("itheima002", "张曼玉");
        prop.put("itheima003", "王祖贤");

        //遍历集合
        Set<Object> keySet = prop.keySet();
        for (Object key : keySet) {
            Object value = prop.get(key);
            System.out.println(key + "," + value);
        }
    }
}

Properties作为Map集合的特有方法

import java.util.Properties;
import java.util.Set;

/*
    Properties作为集合的特有方法：
        Object setProperty(String key, String value)：设置集合的键和值，都是String类型，底层调用Hashtable方法put
        String getProperty(String key)：使用此属性列表中指定的键搜索属性
        Set<String> stringPropertyNames()：从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
 */
public class PropertiesDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Properties prop = new Properties();

        //Object setProperty(String key, String value)：设置集合的键和值，都是String类型，底层调用Hashtable方法put
        prop.setProperty("itheima001", "林青霞");
        /*
            Object setProperty(String key, String value) {
                return put(key, value);
            }

            Object put(Object key, Object value) {
                return map.put(key, value);
            }
         */
        prop.setProperty("itheima002", "张曼玉");
        prop.setProperty("itheima003", "王祖贤");

        //String getProperty(String key)：使用此属性列表中指定的键搜索属性
        System.out.println(prop.getProperty("itheima001"));
//        System.out.println(prop.getProperty("itheima0011"));//报错

//        System.out.println(prop);

        //Set<String> stringPropertyNames()：从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
        Set<String> names = prop.stringPropertyNames();
        for (String key : names) {
            System.out.println(key);
            String value = prop.getProperty(key);
            System.out.println(key + "," + value);
        }
    }
}

Properties和IO流相结合的方法

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

/*
    Properties和IO流结合的方法：
        void load(Reader reader)：
            从输入字符流读取属性列表（键和元素对）

        void store(Writer writer, String comments)：
            将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式写入输出字符流
 */
public class PropertiesDemo03 {
    public static void main(String[] args) throws IOException {
        //把集合中的数据保存到文件
//        myStore();

        //把文件中的数据加载到集合
        myLoad();

    }

    private static void myLoad() throws IOException {
        Properties prop = new Properties();

        //void load(Reader reader)：
        FileReader fr = new FileReader("myOtherStream\\fw.txt");
        prop.load(fr);
        fr.close();

        System.out.println(prop);
    }

    private static void myStore() throws IOException {
        Properties prop = new Properties();

        prop.setProperty("itheima001","林青霞");
        prop.setProperty("itheima002","张曼玉");
        prop.setProperty("itheima003","王祖贤");

        //void store(Writer writer, String comments)：
        FileWriter fw = new FileWriter("myOtherStream\\fw.txt");
        prop.store(fw,null);
        fw.close();
    }
}

案例：游戏次数

GuessNumber

import java.util.Random;
import java.util.Scanner;

/*
    猜数字小游戏
 */
public class GuessNumber {
    private GuessNumber() {
    }

    public static void start() {
        //要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
        Random r = new Random();
        int number = r.nextInt(100) + 1;

        while (true) {
            //使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
            Scanner sc = new Scanner(System.in);

            System.out.println("请输入你要猜的数字：");
            int guessNumber = sc.nextInt();

            //比较输入的数字和系统产生的数据，需要使用分支语句。这里使用if..else..if..格式，根据不同情况进行猜测结果显示
            if (guessNumber > number) {
                System.out.println("你猜的数字" + guessNumber + "大了");
            } else if (guessNumber < number) {
                System.out.println("你猜的数字" + guessNumber + "小了");
            } else {
                System.out.println("恭喜你猜中了");
                break;
            }
        }
    }
}

PropertiesTest

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

/*
    需求：请写程序实现猜数字小游戏只能试玩3次，如果还想玩，提示：游戏试玩已结束，想玩请充值(www.itcast.cn)

    思路：
        1:写一个游戏类，里面有一个猜数字的小游戏
        2:写一个测试类，测试类中有main方法，main()方法中按照下面步骤完成
            A:从文件中读取数据到Properties集合，用load()方法实现
                文件已经存在：game.txt
                里面有一个数据值：count=0
            B:通过Properties集合获取到玩游戏的次数
            C:判断次数是否到到3次了
                如果到了，给出提示：游戏试玩已结束，想玩请充值(www.itcast.cn)
                如果不到3次：
                    玩游戏
                    次数+1，重新写回文件，用Properties的store()方法实现
 */
public class PropertiesTest {
    public static void main(String[] args) throws IOException {
        //从文件中读取数据到Properties集合，用load()方法实现
        Properties prop = new Properties();

        FileReader fr = new FileReader("myOtherStream\\game.txt");
        prop.load(fr);
        fr.close();

        //通过Properties集合获取到玩游戏的次数
        String count = prop.getProperty("count");
        int number = Integer.parseInt(count);

        //判断次数是否到到3次了
        if(number >= 3) {
            //如果到了，给出提示：游戏试玩已结束，想玩请充值(www.itcast.cn)
            System.out.println("游戏试玩已结束，想玩请充值(www.itcast.cn)");
        } else {
            //玩游戏
            GuessNumber.start();

            //次数+1，重新写回文件，用Properties的store()方法实现
            number++;
            prop.setProperty("count",String.valueOf(number));
            FileWriter fw = new FileWriter("myOtherStream\\game.txt");
            prop.store(fw,null);
            fw.close();
        }
    }
}