26. IO流（2）

缓冲流

缓冲概述

 

字节缓冲流

 

public class Test {
    public static void main(String[] args) {

        try (
                // 定义一个字节输入流管道与原视频接通
                InputStream is = new FileInputStream("Learn\\src\\Picture\\2.txt");
                //把原始的字节输入流包装成高级的缓冲字节输入流
                InputStream bis = new BufferedInputStream(is);

                // 创建一个字节流输出管道与目标文件接通
                OutputStream os = new FileOutputStream("Learn\\src\\Picture\\f1.txt");
                // 把字节输出流管道包装成高级的字节输出流管道
                OutputStream bos = new BufferedOutputStream(os);
                ) {
            // 定义一个字节数组来转移数据
            byte[] buffer = new byte[1024];
            int len; //记录每次读取的字节数
            while ((len = is.read()) != -1) {
                bos.write(buffer , 0 ,len);
            }
            bos.close();
            bis.close();
            System.out.println("复制完成");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字节缓冲流的性能分析

 

public class Test {
    private static final String SRC_FILE = "F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\2.txt";
    private static final String DEST_FILE = "F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\";

    public static void main(String[] args) {
        copy01(); //使用低级的字节流按照一个一个字节的形式复制文件
        copy02(); //使用低级的字节流按照一个一个字节数组的形式复制文件
        copy03(); //缓冲流一个一个字节复制文件
        copy04(); //缓冲流一个一个字节数组复制文件
        
    }

    /**
     * //缓冲流一个一个字节数组复制文件
     */
    private static void copy04() {
        long startTime = System.currentTimeMillis();
        try (
            InputStream bis = new BufferedInputStream(new FileInputStream(SRC_FILE));
            OutputStream bos = new BufferedOutputStream(new FileOutputStream(DEST_FILE + "f2.txt"))
            ){
            byte[] buffer = new byte[1024];
            int len; //记录每次读取字节长度
            if ((len = bis.read()) != -1) {
                bos.write(buffer,0,len);
            }
            bis.close();
            bos.close();

        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("所用时间为：" + (endTime - startTime) / 1000.0 + "s");

    }

    /**
     * //缓冲流一个一个字节复制文件
     */
    private static void copy03() {
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                InputStream bis = new BufferedInputStream(is);

                OutputStream os = new FileOutputStream(DEST_FILE + "f1.txt");
                OutputStream bos = new BufferedOutputStream(os);
            ){
            int b;
            if ((b = bis.read()) != -1) {
                bos.write(b);
            }
            bis.close();
            bos.close();
            is.close();
            os.close();
        }catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("所用时间为：" + (endTime - startTime) / 1000.0 + "s");


    }

    /**
     * //使用低级的字节流按照一个一个字节数组的形式复制文件
     */
    private static void copy02() {
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                OutputStream os = new FileOutputStream(DEST_FILE + "f1.txt");
            ){

            byte[] buffer = new byte[1024];
            int len; //记录每次读取字节数
            while ((len = is.read(buffer)) != -1) {
                os.write(buffer,0,len);
            }
            is.close();
            os.close();

        }catch (Exception e) {
            e.printStackTrace();
        }
            long endTime = System.currentTimeMillis();
            System.out.println("所用时间为：" + (endTime - startTime) / 1000.0 + "s");
    }

    /**
     * 使用低级的字节流按照一个一个字节的形式复制文件
     */
    private static void copy01() {
        long startTime = System.currentTimeMillis();
        try (
                // 创造低级的字节输入流与源文件接通
                InputStream is = new FileInputStream(SRC_FILE);
                // 创建低级的字节输出流与目标文件接通
                OutputStream os = new FileOutputStream(DEST_FILE + "f1.txt");
            ){
            // 定义一个变量记录每次读取的字节（一个一个字节的复制）
            int b;
            while ((b = is.read()) != -1) {
                os.write(b);
            }
            is.close();
            os.close();
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("所用时间为：" + (endTime - startTime) / 1000.0 + "s");
    }
}

字符缓冲流

public class Test {
    private static final String SRC_FILE = "F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\2.txt";
    private static final String DEST_FILE = "F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\f1.txt";

    public static void main(String[] args) throws Exception{
        try (
                Reader fr = new FileReader(DEST_FILE);
                BufferedReader br = new BufferedReader(fr);
            ){
            int b;
            while ((b = br.read()) != -1){
                System.out.println(br.readLine());
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

public class Test {
    private static final String SRC_FILE = "F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\2.txt";
    private static final String DEST_FILE = "F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\f1.txt";

    public static void main(String[] args) throws Exception{
        // shift +F6:用于快速修改变量名
        try (
                Writer fw = new FileWriter(DEST_FILE);
                BufferedWriter bw = new BufferedWriter(fw);
            ){
            bw.write("我");
            bw.newLine();
            bw.write(85);
            bw.newLine();
            bw.write("abc");
            bw.close();
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

public class Test {
    public static void main(String[] args) throws Exception{
        try (
            // 1. 创建缓冲字符输入流管道与源文件接通
            BufferedReader br = new BufferedReader(new FileReader("Learn\\src\\Picture\\csb.txt"));
        ){
            // 2. 定义一个list集合
            List<String> data = new ArrayList<>();
            // 3. 定义循环按照行拷贝
            String line;
            while ((line = br.readLine()) != null) {
                data.add(line);
            }
            // 4. 排序
            // 自定义排序规则
            List<String> size = new ArrayList<>();
            Collections.addAll(size,"一","二","三","四","五","陆","柒","八","九","十","十一");
            Collections.sort(data, (o1 ,o2) -> size.indexOf(o1.substring(0,o1.indexOf("."))) - size.indexOf(o2.substring(0,o2.indexOf("."))));

            //5. 定义缓冲字符输出管道与目标文件接通
            BufferedWriter wr = new BufferedWriter(new FileWriter("Learn\\src\\Picture\\f1.txt"));
            // 遍历集合中的每行文章写出去，且要换行
            for (String datum : data) {
                wr.write(datum);
                wr.newLine();
            }
            wr.close();
            br.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

转换流

不同编码读取乱码问题

字符输入转换流

public class Test {
    public static void main(String[] args) throws Exception{
        //GBK文件
        // 1. 提取GBK文件的原始字节流，并转换成字符输入流
        Reader isr = new InputStreamReader(new FileInputStream("Learn\\src\\Picture\\99.txt") ,"GBK");

        BufferedReader br= new BufferedReader(isr);
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
    }
}

字符输出转换流

public class Test {
    public static void main(String[] args) throws Exception{
        //GBK文件
        // 1. 定义一个字节输出流，并转换成字符输出流
        Writer osw = new OutputStreamWriter(new FileOutputStream("Learn\\src\\Picture\\f1.txt"));
        BufferedWriter bw = new BufferedWriter(osw);
        bw.newLine();
        bw.write("我");
        bw.close();
    }
}

序列化对象

对象序列化

/**
 * 对象要序列化，必须实现 Serializable接口
 */
public class Student implements Serializable {
private transient String passWord; // transient修饰的成员变量不参与序列化了

public class Test {
    public static void main(String[] args) throws Exception{
        // 1.创建学生对象
        Student s = new Student("张三" ,"zhang","123456",20);

        // 2. 对象序列化，使用对象字节输出流包装字节输出流管道
        ObjectOutputStream oos = new ObjectOutputStream(new  FileOutputStream("Learn\\src\\Picture\\2.txt"));

        // 3. 直接调用序列化方法
        oos.writeObject(s);

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


    }
}

对象反序列化

public class Test {
    public static void main(String[] args) throws Exception{
        // 1.创建对象字节输入流管道包装低级的字节输入流管道
        ObjectInputStream is = new ObjectInputStream(new FileInputStream("Learn\\src\\Picture\\2.txt"));

        // 2. 调用对象字节输入流的反序列化方法
        Student s = (Student) is.readObject();
        System.out.println(s);
    }
}

打印流

 

PrintStream、PrintWriter

public class Test {
    public static void main(String[] args) throws Exception{
        // 1.创建一个打印流对象
        PrintStream ps = new PrintStream(new FileOutputStream("Learn\\src\\Picture\\2.txt"));
        ps.println(97);
        ps.println('a');
        ps.println(23.3);
        ps.println(true);
        ps.println("打印字符串");
        ps.close();
    }
}

 

public class Test {
    public static void main(String[] args) throws Exception{
        // 1.创建一个打印流对象
        // 与PrintStream的使用没有区别
        PrintWriter ps = new PrintWriter("Learn\\src\\Picture\\2.txt");
        ps.println(97);
        ps.println('a');
        ps.println(23.3);
        ps.println(true);
        ps.println("打印字符串");
        ps.write("字符串");
        ps.close();
    }
}

 

输出语句的重定向

 

public class Test {
    public static void main(String[] args) throws Exception{
        System.out.println("Java牛逼");

        //改变输出语句的位置（重定向）
        PrintStream ps = new PrintStream("Learn\\src\\Picture\\f1.txt");
        System.setOut(ps); //把系统的打印流改成我们自己的打印流
        System.out.println("打印到文件里了");
    }
}

Properties

 

 

public class Test {
    public static void main(String[] args) throws Exception{
        Properties properties = new Properties();
        properties.setProperty("admin","123456");
        System.out.println(properties);

        /**
         * 参数一：保存管道 字符输出流管道
         * 参数二：添加注释
         */
        properties.store(new FileWriter(("Learn\\src\\Picture\\2.txt")),"");
    }
}

public class Test {
    public static void main(String[] args) throws Exception{
        Properties properties = new Properties();
        System.out.println(properties);

        //  加载属性文件中的键值对数据到属性对象properties中去
        properties.load(new FileReader("Learn\\src\\Picture\\2.txt"));

        System.out.println(properties);

        String rs = (String) properties.get("dlei");
    }
}

IO框架

/**
    目标:Commons-io包的使用介绍。

    什么是Commons-io包？
            commons-io是apache开源基金组织提供的一组有关IO操作的类库，
            可以挺提高IO功能开发的效率。commons-io工具包提供了很多有关io操作的类，

    见下表：
         | 包                                  | 功能描述                                     |
         | ----------------------------------- | :------------------------------------------- |
         | org.apache.commons.io               | 有关Streams、Readers、Writers、Files的工具类 |
         | org.apache.commons.io.input         | 输入流相关的实现类，包含Reader和InputStream  |
         | org.apache.commons.io.output        | 输出流相关的实现类，包含Writer和OutputStream |
         | org.apache.commons.io.serialization | 序列化相关的类

    步骤：
         1. 下载commons-io相关jar包；http://commons.apache.org/proper/commons-io/
         2. 把commons-io-2.6.jar包复制到指定的Module的lib目录中
         3. 将commons-io-2.6.jar加入到classpath中

    小结：
         IOUtils和FileUtils可以方便的复制文件和文件夹！！
 */
public class CommonsIODemo01 {
    public static void main(String[] args) throws Exception {

        // 1.完成文件复制！
//        IOUtils.copy(new FileInputStream("D:\\resources\\hushui.jpeg"),
//                new FileOutputStream("D:\\resources\\hushui2.jpeg"));


        // 2.完成文件复制到某个文件夹下！
//        FileUtils.copyFileToDirectory(new File("D:\\resources\\hushui.jpeg"), new File("D:/"));


          // 3.完成文件夹复制到某个文件夹下！
//          FileUtils.copyDirectoryToDirectory(new File("D:\\resources") , new File("D:\\new"));
//           FileUtils.deleteDirectory(new File("D:\\new"));

         // JDK1.7 自己也做了一些一行代码完成复制的操作:New IO的技术
         // Files.copy(Path.of("D:\\resources\\hushui.jpeg"), Path.of("D:\\resources\\hushui3.jpeg"));

        FileUtils.deleteDirectory(new File("D:\\new"));
    }
}