2022-03-29

Day21

编码问题
　　ASCII：美国标准信息交换码，用一个字节的7位可以表示
　　ISO8859-1：拉丁码表。欧洲码表，用一个字节的8位表示
　　GB2312：中国的中文编码表
　　GBK：中国的中文编码表升级，融合了更多的中文文字符号
　　GB18030：GBK的取代版本
　　BIG-5码 ：通行于台湾、香港地区的一个繁体字编码方案，俗称“大五码”
　　Unicode：国际标准码，融合了多种文字，所有文字都用两个字节来表示,Java语言使用的就是unicode
　　UTF-8：最多用三个字节来表示一个字符

String中的编码问题

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

编码:把看得懂的变成看不懂的
　　String -- byte[]
解码:把看不懂的变成看得懂的
　　byte[] -- String

注意：编码和解码的格式要一致

public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String s = "你好";

        // String -- byte[]
        byte[] bys = s.getBytes(); // [-60, -29, -70, -61]
        // byte[] bys = s.getBytes("GBK");// [-60, -29, -70, -61]
        // byte[] bys = s.getBytes("UTF-8");// [-28, -67, -96, -27, -91, -67]
        System.out.println(Arrays.toString(bys));

        // byte[] -- String
        String ss = new String(bys); // 你好
        // String ss = new String(bys, "GBK"); // 你好
        // String ss = new String(bys, "UTF-8"); // ???
        System.out.println(ss);
    }
}

字符流
　　因为字节流操作中文不是特别的方便，所以Java就提供了字符流
字符流=字节流+编码表
写数据
　　OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流
　　OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流
读数据　　
　　InputStreamReader(InputStream is):用默认的编码读取数据
　　InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据

//写数据
public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
        // OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt")); // 默认GBK
        // OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"), "GBK"); // 指定GBK
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                "osw.txt"), "UTF-8"); // 指定UTF-8
        // 写数据
        osw.write("中国");

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

//读数据
public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
        // InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"));

        // InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"), "GBK");

        InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"), "UTF-8");

        // 读取数据
        // 一次读取一个字符
        int ch = 0;
        while ((ch = isr.read()) != -1) {
            System.out.print((char) ch);
        }

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

字符流OutputStreamWriter的方法
　　flush():刷新字符缓冲区，不刷新字符无法写入
　　public void write(int c):写一个字符
　　public void write(char[] cbuf):写一个字符数组
　　public void write(char[] cbuf,int off,int len):写一个字符数组的一部分，从off开始写len个
　　public void write(String str):写一个字符串
　　public void write(String str,int off,int len):写一个字符串的一部分，从off开始写len个

面试题：close()和flush()的区别
close()关闭流对象，但是先刷新一次缓冲区，关闭之后，流对象不可以继续再使用了
flush()仅仅刷新缓冲区,刷新之后，流对象还可以继续使用

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw2.txt"));

        // 写数据
        // public void write(int c):写一个字符
        // osw.write('a');
        // osw.write(97);
        // 为什么数据没有进去呢?
        // 原因是：字符 = 2字节
        // 文件中数据存储的基本单位是字节。
        // void flush()

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

        // public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
        // osw.write(chs,1,3);

        // public void write(String str):写一个字符串
        // osw.write("我爱你中国");

        // public void write(String str,int off,int len):写一个字符串的一部分
        osw.write("我爱你中国", 2, 3);

        // 刷新缓冲区
        osw.flush();
        // osw.write("我爱你中国", 2, 3);

        // 释放资源
        osw.close();
        // java.io.IOException: Stream closed，流已经关闭，无法在使用
        // osw.write("我爱中国", 2, 3);
    }
}

读数据InputStreamReader的方法
　　int read():一次读取一个字符
　　int read(char[] chs):一次读取一个字符数组

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "StringDemo.java"));

        // 一次读取一个字符
        // int ch = 0;
        // while ((ch = isr.read()) != -1) {
        // System.out.print((char) ch);
        // }

        // 一次读取一个字符数组
        char[] chs = new char[1024];
        int len = 0;
        while ((len = isr.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }

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

复制文件

/*
 * 需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
 * 
 * 数据源：
 *      a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader
 * 目的地：
 *      b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
        // 封装目的地
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"));

        // 读写数据
        // 方式1
        // int ch = 0;
        // while ((ch = isr.read()) != -1) {
        // osw.write(ch);
        // }

        // 方式2
        char[] chs = new char[1024];
        int len = 0;
        while ((len = isr.read(chs)) != -1) {
            osw.write(chs, 0, len);
            // osw.flush();
        }

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

转换流的简便写法
FileWriter = OutputStreamWriter
　　OutputStreamWriter = FileOutputStream + 编码表(GBK)
　　FileWriter = FileOutputStream + 编码表(GBK)

FileReader = InputStreamReader
　　InputStreamReader = FileInputStream + 编码表(GBK)
　　FileReader = FileInputStream + 编码表(GBK)

 * 需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
 * 
 * 数据源：
 *      a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader
 * 目的地：
 *      b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter
 */
public class CopyFileDemo2 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileReader fr = new FileReader("a.txt");
        //相当于InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
        // 封装目的地
        FileWriter fw = new FileWriter("b.txt");
        //相当于OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"));

        // 一次一个字符
        // int ch = 0;
        // while ((ch = fr.read()) != -1) {
        // fw.write(ch);
        // }

        // 一次一个字符数组
        char[] chs = new char[1024];
        int len = 0;
        while ((len = fr.read(chs)) != -1) {
            fw.write(chs, 0, len);
            fw.flush();
        }

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

字符缓冲流
字符流为了高效读写，也提供了对应的字符缓冲流
　　BufferedWriter:字符缓冲输出流
　　BufferedReader:字符缓冲输入流

字符缓冲流的特殊方法：
BufferedWriter:
　　public void newLine():根据系统来决定换行符
BufferedReader:
　　public String readLine()：一次读取一行数据,包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

BufferedWriter:字符缓冲输出流
　　将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入
　　可以指定缓冲区的大小，或者接受默认的大小，在大多数情况下，默认值就足够大了

public class BufferedWriterDemo {
    public static void main(String[] args) throws IOException {
        // BufferedWriter(Writer out)
        // BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("bw.txt")));
        //new FileWriter("bw.txt")相当于new OutputStreamWriter(new FileOutputStream("bw.txt"))
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

        bw.write("hello");
        bw.write("world");
        bw.write("java");
        bw.flush();

        bw.close();
    }
}

BufferedReader:字符缓冲输入流
　　从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取
　　可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了
子类
　　LineNumberReader
　　　　public int getLineNumber()获得当前行号
　　　　public void setLineNumber(int lineNumber)设置当前行号

public class BufferedReaderDemo {
     public static void main(String[] args) throws IOException {
         // 创建字符缓冲输入流对象
       //  BufferedReader br1 = new BufferedReader(new InputStreamReader(new FileInputStream("bw.txt")));
        //new FileReader("bw.txt")相当于new InputStreamReader(new FileInputStream("bw.txt"))
         BufferedReader br = new BufferedReader(new FileReader("bw.txt"));

         // 方式1
         // int ch = 0;
         // while ((ch = br.read()) != -1) {
         // System.out.print((char) ch);
         // }

         // 方式2
         char[] chs = new char[1024];
         int len = 0;
         while ((len = br.read(chs)) != -1) {
             System.out.print(new String(chs, 0, len));
         }
         // 释放资源
         br.close();
     }
}

字符输入流复制文件

/*
 * 需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
 * 
 * 数据源：
 *      a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader -- BufferedReader
 * 目的地：
 *      b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter -- BufferedWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        // 封装目的地
        BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

        // 两种方式其中的一种一次读写一个字符数组
        char[] chs = new char[1024];
        int len = 0;
        while ((len = br.read(chs)) != -1) {
            bw.write(chs, 0, len);
            bw.flush();
        }

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

字符缓冲流的特殊方法

public class BufferedDemo {
    public static void main(String[] args) throws IOException {
        // write();
        read();
    }

    private static void read() throws IOException {
        // 创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("bw2.txt"));

        // public String readLine()：一次读取一行数据
        // String line = br.readLine();
        // System.out.println(line);
        // line = br.readLine();
        // System.out.println(line);

        // 最终版代码
        String line = null;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
        
        //释放资源
        br.close();
    }

    private static void write() throws IOException {
        // 创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));
        for (int x = 0; x < 10; x++) {
            bw.write("hello" + x);
            // bw.write("\r\n");
            bw.newLine();
            bw.flush();
        }
        bw.close();
    }
}

/*
 * 需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
 * 
 * 数据源：
 *      a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader -- BufferedReader
 * 目的地：
 *      b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter -- BufferedWriter
 */
public class CopyFileDemo2 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        // 封装目的地
        BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

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

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

IO流图解

IO流的主要方法

IO流练习之复制文本文件

/*
 *复制文本文件
 *
 * 分析：
 *      复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流
 *      通过该原理，我们知道我们应该采用字符流更方便一些
 *      而字符流有5种方式
 * 数据源：
 *      a.txt -- FileReader -- BufferdReader
 * 目的地：
 *      b.txt -- FileWriter -- BufferedWriter
 * */
public class CopyFile {
    public static void main(String[] args) throws IOException {
        //字符流复制文件方式一，FileReader一次读取一个字符
        //method1();

        //字符流复制文件方式二，FileReader一次读取一个字符数组
        //method2();

        //字符流复制文件方式三，BufferedWriter一次读取一个字符
        //method3();

        //字符流复制文件方式四，BufferedWriter一次读取一个字符数组
        //method4();

        //字符流复制文件方式五，BufferedWriter的特殊功能，读取和写入一行
        method5();
    }
    //字符流复制文件方式五，BufferedWriter的特殊功能，读取和写入一行
    private static void method5() throws IOException{
        //封装数据源
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        //封装目的地
        BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

        //读写数据
        String line = null;
        while ((line = br.readLine()) != null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //释放资源
        br.close();
        bw.close();
    }

    private static void method4() throws IOException{
        //封装数据源
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        //封装目的地
        BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

        //读写数据
        char []chs = new char[1024];
        int len = 0;
        while ((len = br.read(chs))!= -1){
            bw.write(chs,0,len);
            bw.flush();
        }
        //释放资源
        br.close();
        bw.close();
    }

    //字符流复制文件方式三，BufferedWriter一次读取一个字符
    private static void method3() throws IOException {
        //封装数据源
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        //封装目的地
        BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

        //读写数据
        int  ch = 0;
        while ((ch = br.read())!= -1){
            bw.write(ch);
            bw.flush();
        }
        //释放资源
        br.close();
        bw.close();
    }

    //字符流复制文件方式二，FileReader一次读取一个字节数组
    private static void method2() throws IOException {
        //封装数据源
        FileReader fr = new FileReader("a.txt");
        //封装目的地
        FileWriter fw = new FileWriter("b.txt");

        //读写字符数组
        char[] chs = new char[1024];
        int len = 0;
        while ((len = fr.read(chs)) != -1) {
            fw.write(chs, 0, len);
            fw.flush();
        }
        //释放资源
        fr.close();
        fw.close();
    }

    //字符流复制文件方式一，FileReader一次读取一个字节
    private static void method1() throws IOException {
        //封装数据源
        FileReader fr = new FileReader("a.txt");
        //封装目的地
        FileWriter fw = new FileWriter("b.txt");

        //读写数据
        int ch = 0;
        while ((ch = fr.read()) != -1) {
            fw.write(ch);
            fw.flush();
        }
        //释放资源
        fr.close();
        fw.close();
    }
}

IO流练习之复制图片

/*
 * 复制图片
 *
 * 分析：
 *      复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流。
 *      通过该原理，我们知道我们应该采用字节流。
 *      而字节流有4种方式，所以做这个题目我们有4种方式。推荐掌握第4种。
 *
 * 数据源：
 *      a.jpg -- FileInputStream -- BufferedInputStream
 * 目的地：
 *      b.jpg -- FileOutputStream -- BufferedOutputStream
 * */
public class CopyImage {
    public static void main(String[] args) throws IOException {
        //封装数据源
        File srcFile = new File("a.jpg");
        //封装目的地
        File destFile = new File("b.jpg");
        //复制图片方式一，字节流一次读取一个字节
        //method1(srcFile, destFile);

        //复制图片方式二，字节流一次读取一个字节数组
        //method2(srcFile, destFile);

        //复制图片方式三，字节流一次读取一个字节
        //method3(srcFile, destFile);

        //复制图片方式四，字节流一次读取一个字节数组
        method4(srcFile, destFile);
    }

    //复制图片方式四，字节流一次读取一个字节数组
    private static void method4(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.jpg"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));

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

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

    //复制图片方式三，字节流一次读取一个字节
    private static void method3(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));

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

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

    //复制图片方式一，字节流一次读取一个字节数组
    private static void method2(File srcFile, File destFile) throws IOException {
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

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

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

    //复制图片方式一，字节流一次读取一个字节
    private static void method1(File srcFile, File destFile) throws IOException {
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

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

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

IO流练习ArrayList集合到文本文件

/*
 * 需求：把ArrayList集合中的字符串数据存储到文本文件
 * 
 * 分析：
 *      通过题目的意思我们可以知道如下的一些内容，
 *          ArrayList集合里存储的是字符串
 *          遍历ArrayList集合，把数据获取到
 *          然后存储到文本文件中
 *          文本文件说明使用字符流
 * 
 * 数据源：
 *      ArrayList -- 遍历得到每一个字符串数据
 * 目的地：
 *      a.txt -- FileWriter -- BufferedWriter
 */
public class ArrayListToFileDemo {
    public static void main(String[] args) throws IOException {
        // 封装数据与(创建集合对象)
        ArrayList array = new ArrayList();
        array.add("hello");
        array.add("world");
        array.add("java");

        // 封装目的地
        BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));

        // 遍历集合
        for (String s : array) {
            // 写数据
            bw.write(s);
            bw.newLine();
            bw.flush();
        }

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

IO流练习文本文件到ArrayList集合

/*
 * 需求：从文本文件中读取数据(每一行为一个字符串数据)到集合中，并遍历集合
 * 
 * 分析：
 *      通过题目的意思我们可以知道如下的一些内容，
 *          数据源是一个文本文件。
 *          目的地是一个集合。
 *          而且元素是字符串。
 * 
 * 数据源：
 *      b.txt -- FileReader -- BufferedReader
 * 目的地：
 *      ArrayList
 */
public class FileToArrayListDemo {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        BufferedReader br = new BufferedReader(new FileReader("b.txt"));
        // 封装目的地(创建集合对象)
        ArrayList array = new ArrayList();

        // 读取数据存储到集合中
        String line = null;
        while ((line = br.readLine()) != null) {
            array.add(line);
        }

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

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

IO流练习之获取ArrayList集合随机索引的值

/*
 * 需求：我有一个文本文件中存储了几个名称，请大家写一个程序实现随机获取一个人的名字。
 * 
 * 分析：
 *      把文本文件中的数据存储到集合中
 *      随机产生一个索引
 *      根据该索引获取一个值
 */
public class GetName {
    public static void main(String[] args) throws IOException {
        // 把文本文件中的数据存储到集合中
        BufferedReader br = new BufferedReader(new FileReader("name.txt"));
        ArrayList array = new ArrayList();
        String line = null;
        while ((line = br.readLine()) != null) {
            array.add(line);
        }
        br.close();

        // 随机产生一个索引
        Random r = new Random();
        int index = r.nextInt(array.size());

        // 根据该索引获取一个值
        String name = array.get(index);
        System.out.println("该幸运者是：" + name);
    }
}

IO流练习之复制单级文件夹

/*
 * 需求：复制单极文件夹
 * 
 * 数据源：e:\\demo
 * 目的地：e:\\test
 * 
 * 分析：
 *      封装目录
 *      获取该目录下的所有文本的File数组
 *      遍历该File数组，得到每一个File对象
 *      把该File进行复制
 */
public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
        // 封装目录
        File srcFolder = new File("e:\\demo");
        // 封装目的地
        File destFolder = new File("e:\\test");
        // 如果目的地文件夹不存在，就创建
        if (!destFolder.exists()) {
            destFolder.mkdir();
        }

        // 获取该目录下的所有文本的File数组
        File[] fileArray = srcFolder.listFiles();

        // 遍历该File数组，得到每一个File对象
        for (File file : fileArray) {
            // System.out.println(file);
            // 数据源：e:\\demo\\e.mp3
            // 目的地：e:\\test\\e.mp3
            String name = file.getName(); // e.mp3
            File newFile = new File(destFolder, name); // e:\\test\\e.mp3

            copyFile(file, newFile);
        }
    }

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

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

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

IO流练习之复制指定目录下的指定文件，并修改后缀名

/*
 * 需求：复制指定目录下的指定文件，并修改后缀名。
 * 指定的文件是：.java文件。
 * 指定的后缀名是：.jad
 * 指定的目录是：jad
 * 
 * 数据源：e:\\java\\A.java
 * 目的地：e:\\jad\\A.jad
 * 
 * 分析：
 *      封装目录
 *      获取该目录下的java文件的File数组
 *      遍历该File数组，得到每一个File对象
 *      把该File进行复制
 *      在目的地目录下改名
 */
public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
        // 封装目录
        File srcFolder = new File("e:\\java");
        // 封装目的地
        File destFolder = new File("e:\\jad");
        // 如果目的地目录不存在，就创建
        if (!destFolder.exists()) {
            destFolder.mkdir();
        }

        // 获取该目录下的java文件的File数组
        File[] fileArray = srcFolder.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return new File(dir, name).isFile() && name.endsWith(".java");
            }
        });

        // 遍历该File数组，得到每一个File对象
        for (File file : fileArray) {
            // System.out.println(file);
            // 数据源：e:\java\DataTypeDemo.java
            // 目的地：e:\\jad\DataTypeDemo.java
            String name = file.getName();
            File newFile = new File(destFolder, name);
            copyFile(file, newFile);
        }

        // 在目的地目录下改名
        File[] destFileArray = destFolder.listFiles();
        for (File destFile : destFileArray) {
            // System.out.println(destFile);
            // e:\jad\DataTypeDemo.java
            // e:\\jad\\DataTypeDemo.jad
            String name =destFile.getName(); //DataTypeDemo.java
            String newName = name.replace(".java", ".jad");//DataTypeDemo.jad
            
            File newFile = new File(destFolder,newName);
            destFile.renameTo(newFile);
        }
    }

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

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

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

IO流练习之复制多级文件夹

/*
 * 需求：复制多极文件夹
 * 
 * 数据源：E:\JavaSE\day21\code\demos
 * 目的地：E:\\
 * 
 * 分析：
 *      封装数据源File
 *      封装目的地File
 *      判断该File是文件夹还是文件
 *          是文件夹
 *              就在目的地目录下创建该文件夹
 *              获取该File对象下的所有文件或者文件夹File对象
 *              遍历得到每一个File对象
 *              回到第三步
 *          是文件
 *              就复制(字节流)
 */
public class CopyFoldersDemo {
    public static void main(String[] args) throws IOException {
        // 封装数据源File
        File srcFile = new File("E:\\JavaSE\\day21\\code\\demos");
        // 封装目的地File
        File destFile = new File("E:\\");

        // 复制文件夹的功能
        copyFolder(srcFile, destFile);
    }

    private static void copyFolder(File srcFile, File destFile)throws IOException {
        // 判断该File是文件夹还是文件
        if (srcFile.isDirectory()) {
            // 文件夹
            File newFolder = new File(destFile, srcFile.getName());
            newFolder.mkdir();

            // 获取该File对象下的所有文件或者文件夹File对象
            File[] fileArray = srcFile.listFiles();
            for (File file : fileArray) {
                copyFolder(file, newFolder);
            }
        } else {
            // 文件
            File newFile = new File(destFile, srcFile.getName());
            copyFile(srcFile, newFile);
        }
    }

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

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

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

IO流练习之集合存储学生信息并写入文本文件

/*
 * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低存入文本文件
 * 
 * 分析：
 *      创建学生类
 *      创建集合对象
 *          TreeSet
 *      键盘录入学生信息存储到集合
 *      遍历集合，把数据写到文本文件
 */
public class StudentDemo {
    public static void main(String[] args) throws IOException {
        // 创建集合对象
        TreeSet ts = new TreeSet(new Comparator() {
            @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.getEnglish() - s2.getEnglish() : num3;
                int num5 = num4 == 0 s1.getName().compareTo(s2.getName(): num4;
                return num5;
            }
        });

        // 键盘录入学生信息存储到集合
        for (int x = 1; x <= 5; x++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第" + x + "个的学习信息");
            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);

            // 把学生信息添加到集合
            ts.add(s);
        }

        // 遍历集合，把数据写到文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("students.txt"));
        bw.write("学生信息如下：");
        bw.newLine();
        bw.flush();
        bw.write("姓名,语文成绩,数学成绩,英语成绩");
        bw.newLine();
        bw.flush();
        for (Student s : ts) {
            StringBuilder sb = new StringBuilder();
            sb.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getMath()).append(",").append(s.getEnglish());
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }
        // 释放资源
        bw.close();
        System.out.println("学习信息存储完毕");
    }
}

IO流练习之读取文件并排序然后写入到新文件中

/*
 * 已知s.txt文件中有这样的一个字符串：“hcexfgijkamdnoqrzstuvwybpl”
 * 请编写程序读取数据内容，把数据排序后写入ss.txt中
 * 
 * 分析：
 *      把s.txt这个文件给做出来
 *      读取该文件的内容，存储到一个字符串中
 *      把字符串转换为字符数组
 *      对字符数组进行排序
 *      把排序后的字符数组转换为字符串
 *      把字符串再次写入ss.txt中
 */
public class StringDemo {
    public static void main(String[] args) throws IOException {
        // 读取该文件的内容，存储到一个字符串中
        BufferedReader br = new BufferedReader(new FileReader("s.txt"));
        String line = br.readLine();
        br.close();

        // 把字符串转换为字符数组
        char[] chs = line.toCharArray();

        // 对字符数组进行排序
        Arrays.sort(chs);

        // 把排序后的字符数组转换为字符串
        String s = new String(chs);

        // 把字符串再次写入ss.txt中
        BufferedWriter bw = new BufferedWriter(new FileWriter("ss.txt"));
        bw.write(s);
        bw.newLine();
        bw.flush();

        bw.close();
    }
}

Day22

用户登录IO文件版

package io.pojo;

//学生类
public class User {
    // 用户名
    private String username;
    // 密码
    private String password;

    public User() {
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

//功能接口
import io.pojo.User;

public interface UserDao {
    //登录
    public abstract boolean isLogin(String username, String password);

    //注册
    public abstract void regist(User user);
}

package cn.itcast.dao.impl;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import io.dao.UserDao;
import io.pojo.User;

//功能接口的实现类
public class UserDaoImpl implements UserDao {
    // 为了保证文件一加载就创建
    private static File file = new File("user.txt");

    static {
        try {
            file.createNewFile();
        } catch (IOException e) {
            System.out.println("创建文件失败");
            // e.printStackTrace();
        }
    }

    @Override
    public boolean isLogin(String username, String password) {
        boolean flag = false;

        BufferedReader br = null;
        try {
            // br = new BufferedReader(new FileReader("user.txt"));
            br = new BufferedReader(new FileReader(file));
            String line = null;
            while ((line = br.readLine()) != null) {
                // 用户名=密码
                String[] datas = line.split("=");
                if (datas[0].equals(username) && datas[1].equals(password)) {
                    flag = true;
                    break;
                }
            }
        } catch (FileNotFoundException e) {
            System.out.println("用户登录找不到信息所在的文件");
            // e.printStackTrace();
        } catch (IOException e) {
            System.out.println("用户登录失败");
            // e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    System.out.println("用户登录释放资源失败");
                    // e.printStackTrace();
                }
            }
        }

        return flag;
    }

    @Override
    public void regist(User user) {
        /*
         * 为了让注册的数据能够有一定的规则，我就自己定义了一个规则： 用户名=密码
         */
        BufferedWriter bw = null;
        try {
            // bw = new BufferedWriter(new FileWriter("user.txt"));
            // bw = new BufferedWriter(new FileWriter(file));
            // 为了保证数据是追加写入，必须加true
            bw = new BufferedWriter(new FileWriter(file, true));
            bw.write(user.getUsername() + "=" + user.getPassword());
            bw.newLine();
            bw.flush();
        } catch (IOException e) {
            System.out.println("用户注册失败");
            // e.printStackTrace();
        } finally {
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    System.out.println("用户注册释放资源失败");
                    // e.printStackTrace();
                }
            }
        }
    }
}

package io.game;

import java.util.Scanner;
//这是猜数字小游戏，用户登录成功后可以玩
public class GuessNumber {
    private GuessNumber() {
    }

    public static void start() {
        // 产生一个随机数
        int number = (int) (Math.random() * 100) + 1;

        // 定义一个统计变量
        int count = 0;

        while (true) {
            // 键盘录入一个数据
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入数据(1-100)：");
            int guessNumber = sc.nextInt();

            count++;

            // 判断
            if (guessNumber > number) {
                System.out.println("你猜的数据" + guessNumber + "大了");
            } else if (guessNumber < number) {
                System.out.println("你猜的数据" + guessNumber + "小了");
            } else {
                System.out.println("恭喜你，" + count + "次就猜中了");
                break;
            }
        }
    }
}

package cn.itcast.test;

import java.util.Scanner;

import io.dao.UserDao;
import io.dao.impl.UserDaoImpl;
import io.game.GuessNumber;
import io.pojo.User;

//这是用户测试类
public class UserTest {
    public static void main(String[] args) {
        // 为了能够回来
        while (true) {
            // 欢迎界面，给出选择项
            System.out.println("--------------欢迎光临--------------");
            System.out.println("1 登录");
            System.out.println("2 注册");
            System.out.println("3 退出");
            System.out.println("请输入你的选择:");
            // 键盘录入选择，根据选择做不同的操作
            Scanner sc = new Scanner(System.in);
            // 为了后面的录入信息的方便，我所有的数据录入全部用字符接收
            String choiceString = sc.nextLine();

            // switch语句的多个地方要使用，我就定义到外面
            UserDao ud = new UserDaoImpl();

            // 经过简单的思考，我选择了switch
            switch (choiceString) {
            case "1":
                // 登录界面，请输入用户名和密码
                System.out.println("--------------登录界面--------------");
                System.out.println("请输入用户名：");
                String username = sc.nextLine();
                System.out.println("请输入密码：");
                String password = sc.nextLine();

                // 调用登录功能
                // UserDao ud = new UserDaomImpl();

                boolean flag = ud.isLogin(username, password);
                if (flag) {
                    System.out.println("登录成功,可以开始玩游戏了");

                    System.out.println("你玩吗?y/n");
                    while (true) {
                        String resultString = sc.nextLine();
                        if (resultString.equalsIgnoreCase("y")) {
                            // 玩游戏
                            GuessNumber.start();
                            System.out.println("你还玩吗?y/n");
                        } else {
                            break;
                        }
                    }
                    System.out.println("谢谢使用，欢迎下次再来");
                    System.exit(0);
                    // break; //这里写break，结束的是switch
                } else {
                    System.out.println("用户名或者密码有误,登录失败");
                }
                break;
            case "2":
                // 欢迎界面，请输入用户名和密码
                System.out.println("--------------注册界面--------------");
                System.out.println("请输入用户名：");
                String newUsername = sc.nextLine();
                System.out.println("请输入密码：");
                String newPassword = sc.nextLine();

                // 把用户名和密码封装到一个对象中
                User user = new User();
                user.setUsername(newUsername);
                user.setPassword(newPassword);

                // 调用注册功能
                // 多态
                // UserDao ud = new UserDaoImpl();
                // 具体类使用
                // UserDaoImpl udi = new UserDaoImpl();

                ud.regist(user);
                System.out.println("注册成功");
                break;
            case "3":
            default:
                System.out.println("谢谢使用，欢迎下次再来");
                System.exit(0);
                break;
            }
        }
    }
}

操作基本数据类型的流
　　可以读写基本数据类型的数据
数据输入流：DataInputStream
　　DataInputStream(InputStream in)
数据输出流：DataOutputStream
　　DataOutputStream(OutputStream out)

public class DataStreamDemo {
    public static void main(String[] args) throws IOException {
        // 写
        // write();

        // 读
        read();
    }

    private static void read() throws IOException {
        // DataInputStream(InputStream in)
        // 创建数据输入流对象
        DataInputStream dis = new DataInputStream(
                new FileInputStream("dos.txt"));

        // 读数据
        byte b = dis.readByte();
        short s = dis.readShort();
        int i = dis.readInt();
        long l = dis.readLong();
        float f = dis.readFloat();
        double d = dis.readDouble();
        char c = dis.readChar();
        boolean bb = dis.readBoolean();

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

        System.out.println(b);
        System.out.println(s);
        System.out.println(i);
        System.out.println(l);
        System.out.println(f);
        System.out.println(d);
        System.out.println(c);
        System.out.println(bb);
    }

    private static void write() throws IOException {
        // DataOutputStream(OutputStream out)
        // 创建数据输出流对象
        DataOutputStream dos = new DataOutputStream(new FileOutputStream(
                "dos.txt"));

        // 写数据了
        dos.writeByte(10);
        dos.writeShort(100);
        dos.writeInt(1000);
        dos.writeLong(10000);
        dos.writeFloat(12.34F);
        dos.writeDouble(12.56);
        dos.writeChar('a');
        dos.writeBoolean(true);

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

内存操作流
　　用于处理临时存储信息的，程序结束，数据就从内存中消失
字节数组(不需要释放资源)
　ByteArrayInputStream
　　　ByteArrayOutputStream()构造方法
　ByteArrayOutputStream
　　　ByteArrayInputStream(byte[] buf)构造方法,需要一个字符数组,但是ByteArrayInputStream没有生成字符数组,所以要用public byte[] toByteArray()转换一下

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        // 写数据
        for (int x = 0; x < 10; x++) {
            baos.write(("hello" + x).getBytes());
        }

        // public byte[] toByteArray()
        byte[] bys = baos.toByteArray();

        // 读数据
        // ByteArrayInputStream(byte[] buf)
        ByteArrayInputStream bais = new ByteArrayInputStream(bys);

        int by = 0;
        while ((by = bais.read()) != -1) {
            System.out.print((char) by);
        }

字符数组(与字节数组用法相同)
　CharArrayReader
　CharArrayWriter
字符串(与字节数组用法相同)
　StringReader
　StringWriter

打印流
　　字节流打印流　PrintStream
　　字符打印流(属于字符流,可以使用父类Writer的方法)　PrintWriter

打印流的特点：
　　只有写数据的，没有读取数据。只能操作目的地，不能操作数据源
　　可以操作任意类型的数据
　　如果启动了自动刷新，能够自动刷新,不需要手动flush刷新
　　该流是可以直接操作文本文件的

可以直接操作文本文件的流对象
　　FileInputStream
　　FileOutputStream
　　FileReader
　　FileWriter
　　PrintStream
　　PrintWriter
　　　看API,查流对象的构造方法，如果同时有File类型和String类型的参数，一般来说就是可以直接操作文件的

流分为两种
　　基本流：就是能够直接读写文件的
　　高级流：在基本流基础上提供了一些其他的功能

字符打印流PrintWriter作为Writer子类使用

public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        // 作为Writer的子类使用
        PrintWriter pw = new PrintWriter("pw.txt");

        pw.write("hello");
        pw.write("world");
        pw.write("java");
        
        pw.close();
    }
}

打印流的特点之可以操作任意类型的数据
　　print()和println()都可以操作任意类型数据
启动自动刷新
　　PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
启用自动刷新后print()还是不能自动刷新,只能调用println()的方法才可以,这个时候不仅仅自动刷新了，还实现了数据的换行

println()其实等价于于：bw.write(); + bw.newLine(); + bw.flush();

public class PrintWriterDemo2 {
    public static void main(String[] args) throws IOException {
        // 创建打印流对象
        // PrintWriter pw = new PrintWriter("pw2.txt");没有启动自动刷新
        PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);//启动自动刷新

        // write()不能操作基本数据类型
        // 我们就应该看看它的新方法
        // pw.print(true);
        // pw.print(100);
        // pw.print("hello");

        pw.println("hello");
        pw.println(true);
        pw.println(100);

        pw.close();
    }
}

通过打印流复制

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/*
 * 需求：DataStreamDemo.java复制到Copy.java中
 * 数据源：
 *      DataStreamDemo.java -- 读取数据 -- FileReader -- BufferedReader
 * 目的地：
 *      Copy.java -- 写出数据 -- FileWriter -- BufferedWriter -- PrintWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        // 以前的版本
        // 封装数据源
        // BufferedReader br = new BufferedReader(new FileReader("DataStreamDemo.java"));
        // // 封装目的地
        // BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
        //
        // String line = null;
        // while ((line = br.readLine()) != null) {
        // bw.write(line);
        // bw.newLine();
        // bw.flush();
        // }
        //
        // bw.close();
        // br.close();

        // 打印流的改进版
        // 封装数据源
        BufferedReader br = new BufferedReader(new FileReader("DataStreamDemo.java"));
        // 封装目的地
        PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true);
        
        String line = null;
        while((line=br.readLine())!=null){
            pw.println(line);
        }
        
        pw.close();
        br.close();
    }
}

标准输入输出流

System类中的两个成员变量：
　　public static final InputStream in “标准”输入流
　　public static final PrintStream out “标准”输出流

InputStream is 等价于 System.in;
PrintStream ps 等价于 System.out;

public class SystemOutDemo {
    public static void main(String[] args) {
        //这个输出语句其本质是IO流操作，把数据输出到控制台
        System.out.println("helloworld");

        // 获取标准输出流对象
        PrintStream ps = System.out;
        ps.println("helloworld");
        
        ps.println();
        // ps.print();//这个方法不存在
        
        // System.out.println();
        // System.out.print();这个方法不存在
    }
}

标准输入流
　　System.in 获取键盘输入的数据

键盘录入数据：
　main方法的args接收参数
　　　java HelloWorld hello world java
　Scanner(JDK5以后的)
　　　Scanner sc = new Scanner(System.in);
　　　String s = sc.nextLine(); //获取字符串
　　　int x = sc.nextInt(); //获取整数
　通过字符缓冲流包装标准输入流实现
　　　BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

public class SystemInDemo {
    public static void main(String[] args) throws IOException {
        // 获取标准输入流
        // InputStream is = System.in;
        // 一次读取一行的方法
        //readLine()
        //而这个方法在BufferedReader类中
        // 所以，你这次应该创建BufferedReader的对象，但是底层还是的使用标准输入流
        // BufferedReader br = new BufferedReader(is);
        // 按照我们的推想，现在应该可以了，但是却报错了
        // 原因是：字符缓冲流只能针对字符流操作，而你现在是字节流，所以不能使用可以把字节流转换为字符流，然后在通过字符缓冲流操作
        // 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());
        line = br.readLine();
        int i = Integer.parseInt(line);
        System.out.println("你输入的整数是：" + i);
    }
}

/*
 * 转换流的应用。
 */
public class SystemOutDemo2 {
    public static void main(String[] args) throws IOException {
        // 获取标准输入流
        // // PrintStream ps = System.out;
        // // OutputStream os = ps;
        // OutputStream os = System.out; // 多态
        // // 我能不能按照刚才使用标准输入流的方式一样把数据输出到控制台
        // OutputStreamWriter osw = new OutputStreamWriter(os);
        // BufferedWriter bw = new BufferedWriter(osw);
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
                System.out));

        bw.write("hello");
        bw.newLine();
        // bw.flush();
        bw.write("world");
        bw.newLine();
        // bw.flush();
        bw.write("java");
        bw.newLine();
        bw.flush();
        
        bw.close();
    }
}

随机访问流

RandomAccessFile类不属于流，是Object类的子类，但它融合了InputStream和OutputStream的功能。支持对文件的随机访问读取和写入。

构造方法
　　public RandomAccessFile(String name,String mode)：第一个参数是文件路径，第二个参数是操作文件的模式
　　public RandomAccessFile(File file,String mode)：第一个参数是文件路径，第二个参数是操作文件的模式

该文件指针可以通过 getFilePointer方法读取，并通过 seek 方法设置，以字节为单位，整型占四个，字符型占两个等

模式有四种
　　"r" 以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException
　　"rw" 打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件
　　"rws" 打开以便读取和写入，对于 "rw"，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备
　　"rwd" 打开以便读取和写入，对于 "rw"，还要求对文件内容的每个更新都同步写入到底层存储设备

我们最常用的一种叫"rw",这种方式表示我既可以写数据，也可以读取数据

public class RandomAccessFileDemo {
    public static void main(String[] args) throws IOException {
        // write();
        read();
    }

    private static void read() throws IOException {
        // 创建随机访问流对象
        RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");

        int i = raf.readInt();
        System.out.println(i);
        // 该文件指针可以通过 getFilePointer方法读取，并通过 seek 方法设置。
        System.out.println("当前文件的指针位置是：" + raf.getFilePointer());

        char ch = raf.readChar();
        System.out.println(ch);
        System.out.println("当前文件的指针位置是：" + raf.getFilePointer());

        String s = raf.readUTF();
        System.out.println(s);
        System.out.println("当前文件的指针位置是：" + raf.getFilePointer());

        // 我不想重头开始了，我就要读取a，可以用seek指定位置
        raf.seek(4);
        ch = raf.readChar();
        System.out.println(ch);
    }

    private static void write() throws IOException {
        // 创建随机访问流对象
        RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");

        raf.writeInt(100);
        raf.writeChar('a');
        raf.writeUTF("中国");

        raf.close();
    }
}

**合并流**
　　 SequenceInputStream(InputStream s1, InputStream s2)：将s1和s2读入，可以写到一个文件中
　　 SequenceInputStream(Enumeration e)将Enumeration读入，可以写到一个文件中，Enumeration是Vector中的一个方法的返回值类型

将a.txt和b.txt一起复制到c.txt

public class SequenceInputStreamDemo {
    public static void main(String[] args) throws IOException {
        // SequenceInputStream(InputStream s1, InputStream s2)
        // 需求：把ByteArrayStreamDemo.java和DataStreamDemo.java的内容复制到Copy.java中
        InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
        InputStream s2 = new FileInputStream("DataStreamDemo.java");
        SequenceInputStream sis = new SequenceInputStream(s1, s2);
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Copy.java"));

        // 如何写读写呢，其实很简单，你就按照以前怎么读写，现在还是怎么读写
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = sis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        sis.close();
    }
}

将多个文件复制到一个文件

public class SequenceInputStreamDemo2 {
    public static void main(String[] args) throws IOException {
        // 需求：把下面的三个文件的内容复制到Copy.java中
        // ByteArrayStreamDemo.java,CopyFileDemo.java,DataStreamDemo.java

        // SequenceInputStream(Enumeration e)
        // Enumeration elements()
        Vector v = new Vector();
        InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
        InputStream s2 = new FileInputStream("CopyFileDemo.java");
        InputStream s3 = new FileInputStream("DataStreamDemo.java");
        v.add(s1);
        v.add(s2);
        v.add(s3);
        Enumeration en = v.elements();
        SequenceInputStream sis = new SequenceInputStream(en);
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("Copy.java"));

        // 如何写读写呢，其实很简单，你就按照以前怎么读写，现在还是怎么读写
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = sis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        sis.close();
    }
}

序列化流
　　序列化流：把对象按照流一样的方式存入文本文件或者在网络中传输。对象 -- 流数据(ObjectOutputStream)
　　反序列化流:把文本文件中的流对象数据或者网络中的流对象数据还原成对象。流数据 -- 对象(ObjectInputStream)

看到类实现了序列化接口的时候，要想解决黄色警告线问题，就可以自动产生一个序列化id值，而且产生这个值以后，我们对类进行任何改动，它读取以前的数据是没有问题的

注意：
　　我一个类中可能有很多的成员变量，有些我不想进行序列化可以使用transient关键字声明不需要序列化的成员变量

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("oos.txt"));

        // 还原对象
        Object obj = ois.readObject();

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

        // 输出对象
        System.out.println(obj);
    }

    private static void write() throws IOException {
        // 创建序列化流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));

        // 创建对象
        Person p = new Person("张三", 27);

        // public final void writeObject(Object obj)
        oos.writeObject(p);

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

public class Person implements Serializable {
    private static final long serialVersionUID = -2071565876962058344L;

    private String name;

    // private int age;

    private transient int age;

    // int age;

    public Person() {
        super();
    }

    public Person(String name, int age) {
        super();
        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 "Person [name=" + name + ", age=" + age + "]";
    }
}

**Properties **
属性集合类，是一个可以和IO流相结合使用的集合类。
　　Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串，是Hashtable的子类，说明是一个Map集合

特殊功能
　　public Object setProperty(String key,String value)：添加元素
　　public String getProperty(String key):获取元素
　　public Set stringPropertyNames():获取所有的键的集合

Properties与IO的结合使用
这里的集合必须是Properties集合
　　public void load(Reader reader):把文件中的数据读取到集合中
　　public void store(Writer writer,String comments):把集合中的数据存储到文件

public class PropertiesDemo {
    public static void main(String[] args) {
        // 作为Map集合的使用
        // 下面这种用法是错误的，一定要看API，如果没有<>，就说明该类不是一个泛型类,在使用的时候就不能加泛型
        // Properties prop = new Properties();

        Properties prop = new Properties();

        // 添加元素
        prop.put("it002", "hello");
        prop.put("it001", "world");
        prop.put("it003", "java");

        // System.out.println("prop:" + prop);

        // 遍历集合
        Set