JAVA基础再回首(二十二)——转换流概述及用法、简化写法FileWriter和 FileReader、字符缓冲流及特殊用法、字节流字符流复制文件方法总结

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/m366917/article/details/52435993

JAVA基础再回首(二十二)——转换流概述及用法、简化写法FileWriter和 FileReader、字符缓冲流及特殊用法、字节流字符流复制文件方法总结

版权声明:转载必须注明本文转自程序员杜鹏程的博客:http://blog.csdn.net/m366917

这篇我们继续IO流的学习。

转换流概述

  • OutputStreamWriter 字符输出流
    • public OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流
    • public OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流
  • InputStreamReader 字符输入流
    • public InputStreamReader(InputStream in):用默认的编码读取数据
    • public InputStreamReader(InputStream in,String charsetName):用指定的编码读取数据

这两个其实很好理解,只要我们保持读取数据和写入数据的编码格式一致就可以了。

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

        // 释放资源
        osw.close();
    }
}
//上面我们写入数据的时候指定了UTF-8的编码格式,那么我们在读取数据的时候也要指定是UTF-8的编码格式,如果我们不指定采用默认的编码格式写入数据,那么在读取数据的时候我们也不用去指定了,代码也会采用默认的编码去读取。
//那么我们就来完成上面文件的读取代码
public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
        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的方法

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

来练习一下吧

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

        // 写数据
        // public void write(int c):写一个字符
         osw.write('a');
         osw.write(97);

        // 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("杭州G20峰会");

        // public void write(String str,int off,int len):写一个字符串的一部分
        osw.write("习近平出席", 0, 3);//这是的0,3意思是从下标为0的字符开始向后写3个

        // 刷新缓冲区
        osw.flush();
        osw.write("平致开幕词", 1, 3);

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

    }
}

运行程序打开osw.txt,我们来看一下
这里写图片描述

我们在用转换流时,它用到了缓冲区,所以我们就需要刷新,调用flush()方法。
但是你细心点就会发现,在刷新缓冲区后还可以写入数据。如果当我们释放资源后就不可以写入数据了,那么这就引出一个问题

close()和flush()的区别?

  • close()关闭流对象,但是先刷新一次缓冲区。关闭之后,流对象不可以继续再使用了。
  • flush()仅仅刷新缓冲区,刷新之后,流对象还可以继续使用。

OutputStreamWriter他有写数据的方法,肯定有读数据的方法,我们来看一下

  • OutputStreamWriter读数据方法
    • public int read():一次读取一个字符
    • public int read(char[] cbuf):一次读取一个字符数组
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);
         }

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

上面是一次读取一个字符,当然我们也可以一次读取一个字符数组

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

转换流的简化写法

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

  • FileWriter
  • FileReader

所以呢,我们就可以得出一下总结

  • OutputStreamWriter = FileOutputStream + 编码表(GBK)
  • FileWriter = FileOutputStream + 编码表(GBK)
  • InputStreamReader = FileInputStream + 编码表(GBK)
  • FileReader = FileInputStream + 编码表(GBK)

那我们就用FileWriter和FileReader来复制一个文件的操作吧

public class CopyFileDemo {
    public static void main(String[] args) 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.close();
        fr.close();
    }
}

或者我们一次读取一个字符数组。

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

很明显这种方法就简单方便了好多。

上篇我们学习了字节缓冲流,那么这篇我们学习的字符它肯定也是有缓冲流的,我们就来学习一下。

字符缓冲流

字符流为了高效读写,也提供了对应的字符缓冲流。

  • BufferedWriter:字符缓冲输出流

  • BufferedReader:字符缓冲输入流

我们先来学习BufferedWriter:字符缓冲输出流

  • 将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。
  • 可以指定缓冲区的大小,或者接受默认的大小。在大多数情况下,默认值就足够大了。
public class BufferedWriterDemo {
    public static void main(String[] args) {
        try {
            // 创建一个字符写入流对象
            FileWriter fw = new FileWriter("bw.txt");
            // 为了提高写入流的效率加入了缓冲技术
            BufferedWriter bw = new BufferedWriter(fw);

            //写入数据
            bw.write("hello");
            //换行
            bw.newLine();
            bw.write("world");
            bw.newLine();
            bw.write("java");
            //只要用到了缓冲区,就需要刷新
            bw.flush();
            //释放资源
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行程序在bw.txt文件中可以看到这样的结果
这里写图片描述

下面我们来学习BufferedReader:字符缓冲输入流

  • 从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。
  • 可以指定缓冲区的大小,或者可使用默认的大小。大多数情况下,默认值就足够大了。
public class BufferedReaderDemo {
    public static void main(String[] args) {
        try {
            // 创建字符缓冲输入流对象
            BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
            // 一次读取一个字符
            int ch = 0;
            while ((ch = br.read()) != -1) {
                System.out.print((char) ch);
            }

            // 释放资源
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

当然我们也可以一次读取一个字符数组


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

字符缓冲流的特殊用法

我们在上面讲字符缓冲流输出数据的时候,代码中用到了**换行**newLine()
那么我们下面就来讲一下字符缓冲流的特殊用法

  • BufferedWriter:
    • public void newLine():根据系统来决定换行符
  • BufferedReader:
    • public String readLine():一次读取一行数据

根据系统来决定换行符,这个用法很简单,就不做演示了,我们来看下 BufferedReader的readLine()方法

readLine( ):包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null

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

        try {
            // 创建字符缓冲输入流对象
            BufferedReader br = new BufferedReader(new FileReader("bw.txt"));

            // 一次读取一行数据
            String line = null;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }

            //释放资源
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

练习:字符缓冲流特殊功能复制文本文件

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"));

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

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

我们要切记readLine()和newLine()是BufferedReader和BufferedWriter 的特殊功能。

好了,我们关于字符流就学这么多了,我们来总结一下,上篇学的字节流和这篇学的字符流

字节流复制数据4种方式和字符流复制数据5种方式学习


  • 字节流复制数据
    • 4种方式
  • 字符流复制数据
    • 5种方式

注意:我们除了用windows记事本能读懂的数据用字符流以外,其余的全部使用字节流。
下面我们就来给大家写一个例子总结一下

先总结字符流复制数据的 5种方式推荐掌握第5种。

//我们将c盘根目录下的a.txt文件复制到d盘根目录下并命名为b.txt
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        String srcString = "c:\\a.txt";
        String destString = "d:\\b.txt";
        method1(srcString, destString);//第一种--基本字符流一次读写一个字符
        method2(srcString, destString);//第二种--基本字符流一次读写一个字符数组
        method3(srcString, destString);//第三种--字符缓冲流一次读写一个字符
        method4(srcString, destString);//第四种--字符缓冲流一次读写一个字符数组
        method5(srcString, destString);//第五种-- 字符缓冲流一次读写一个字符串
    }

    // 第五种字符缓冲流一次读写一个字符串
    private static void method5(String srcString, String destString)
            throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(srcString));
        BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

        String line = null;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        bw.close();
        br.close();
    }

    // 第四种字符缓冲流一次读写一个字符数组
    private static void method4(String srcString, String destString)
            throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(srcString));
        BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

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

        bw.close();
        br.close();
    }

    // 第三种字符缓冲流一次读写一个字符
    private static void method3(String srcString, String destString)
            throws IOException {
        BufferedReader br = new BufferedReader(new FileReader(srcString));
        BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

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

        bw.close();
        br.close();
    }

    // 第二种基本字符流一次读写一个字符数组
    private static void method2(String srcString, String destString)
            throws IOException {
        FileReader fr = new FileReader(srcString);
        FileWriter fw = new FileWriter(destString);

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

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

    // 第一种基本字符流一次读写一个字符
    private static void method1(String srcString, String destString)
            throws IOException {
        FileReader fr = new FileReader(srcString);
        FileWriter fw = new FileWriter(destString);

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

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

继续总结一下字节流复制数据的4种方式
我们知道用记事本打开并能够读懂,就用字符流,否则用字节流。
所以我们就来复制图片我们有4种方式。推荐掌握第4种。

public class CopyImageDemo {
    public static void main(String[] args) throws IOException {
        // 使用File对象做为参数
        File srcFile = new File("c:\\a.jpg");
        File destFile = new File("d:\\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(
                srcFile));
        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);
        }

        bos.close();
        bis.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 by = 0;
        while ((by = bis.read()) != -1) {
            bos.write(by);
        }

        bos.close();
        bis.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);
        }

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

    // 第一种基本字节流一次读写一个字节
    private static void method1(File srcFile, File destFile) throws IOException {
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

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

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

好了,我们关于字符流的学习就到这里,关于后面的总结大家可以多做练习就很清楚了。

欢迎有兴趣的同学加我朋友的QQ群:点击直接加群555974449 请备注:java基础再回首我们一起来玩吧。

阅读更多 登录后自动展开
想对作者说点什么? 我来说一句