百木园-与人分享,
就是让自己快乐。

IO(字符流的使用操作)

OutputStreamWriter(使用)---写数据--(一次写入一个字符)

OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流
 OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流
* 把字节流转换为字符流。
* 字符流 = 字节流 +编码表。

package cn.itcast_02;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/*
 * OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流
 * OutputStreamWriter(OutputStream out,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();
    }
}

 InputStreamReader---读取数据--(一次读取一个字符)

package cn.itcast_02;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 * InputStreamReader(InputStream is):用默认的编码读取数据
 * InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据
 */
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) {
         //此时的ch依然还是int类型--需要进行输出类型的转换
            System.out.print((char) ch);
        }

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

* 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):写一个字符串的一部分
*
* 面试题:close()和flush()的区别?
* A:close()关闭流对象,但是先刷新一次缓冲区。关闭之后,流对象不可以继续再使用了。
* B:flush()仅仅刷新缓冲区,刷新之后,流对象还可以继续使用。
*/

    package cn.itcast_03;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.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):写一个字符串的一部分
 * 
 * 面试题:close()和flush()的区别?
 * A:close()关闭流对象,但是先刷新一次缓冲区。关闭之后,流对象不可以继续再使用了。
 * B: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):一次读取一个字符数组

package cn.itcast_03;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 * 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中

package cn.itcast_04;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

/*
 * 需求:把当前项目目录下的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();
    }
}

 

字符流--- 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中----方式二

package cn.itcast_04;

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

/*
 * 由于我们常见的操作都是使用本地默认编码,所以,不用指定编码。
 * 而转换流的名称有点长,所以,Java就提供了其子类供我们使用。
 * OutputStreamWriter = FileOutputStream + 编码表(GBK)
 * FileWriter = FileOutputStream + 编码表(GBK)
 * 
 * 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\");
        // 封装目的地
        FileWriter fw = new FileWriter(\"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:字符缓冲输出流

package cn.itcast_05;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 字符流为了高效读写,也提供了对应的字符缓冲流。
 * BufferedWriter:字符缓冲输出流
 * BufferedReader:字符缓冲输入流
 * 
 * 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\")));

        BufferedWriter bw = new BufferedWriter(new FileWriter(\"bw.txt\"));

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

        bw.close();
    }
}

 

 * BufferedReader:字符缓冲输入流

package cn.itcast_05;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*
 * BufferedReader
 * 从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。 
 * 可以指定缓冲区的大小,或者可使用默认的大小。大多数情况下,默认值就足够大了。 
 * 
 * BufferedReader(Reader in)
 */
public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        // 创建字符缓冲输入流对象
        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();
    }
}

 

 利用BufferReader和BufferWriter----FileReader---FileWriter----进行文本的复制

package cn.itcast_06;

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

/*
 * 需求:把当前项目目录下的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();
    }
}

 

 字符缓冲流的特殊用法

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

package cn.itcast_05;

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

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

}

 

//利用字符缓冲流的特殊功能复制文本文件---一次复制一行
package cn.itcast_06;

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

/*
 * 需求:把当前项目目录下的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();
    }
}

 

练习版
package Day21;

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

//利用字符缓冲流的特殊功能复制代码---一次复制一行
public class Bufffered2 {
    public static void main(String[] args) throws IOException {
        //创建字符输入缓冲流对象
        BufferedReader file = new BufferedReader(new FileReader(\"zhao.txt\"));
        //创建字符输出缓冲流对象
        BufferedWriter file1 = new BufferedWriter(new FileWriter(\"zhu.txt\"));

        //复制文本文件
        //一次复制一行
        String tt = null;
        while((tt=file.readLine())!=null){
            //复制一行数据
            file1.write(tt);
            //进行换行--复制一行
            file1.newLine();
            //复制一行进行刷新
            file1.flush();
        }

        //释放资源
        file1.close();
        file.close();

    }
}

 

小结

 复制文本文件的5种方式---字符流

package cn.itcast_01;

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

/*
 * 复制文本文件
 * 
 * 分析:
 *         复制数据,如果我们知道用记事本打开并能够读懂,就用字符流,否则用字节流。
 *         通过该原理,我们知道我们应该采用字符流更方便一些。
 *         而字符流有5种方式,所以做这个题目我们有5种方式。推荐掌握第5种。
 * 数据源:
 *         c:\\\\a.txt -- FileReader -- BufferdReader
 * 目的地:
 *         d:\\\\b.txt -- FileWriter -- BufferedWriter
 */
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种方式---字节流
package cn.itcast_01;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

    /*
     * 复制图片
     * 
     * 分析:
     *         复制数据,如果我们知道用记事本打开并能够读懂,就用字符流,否则用字节流。
     *         通过该原理,我们知道我们应该采用字节流。
     *         而字节流有4种方式,所以做这个题目我们有4种方式。推荐掌握第4种。
 * 
 * 数据源:
 *         c:\\\\a.jpg -- FileInputStream -- BufferedInputStream
 * 目的地:
 *         d:\\\\b.jpg -- FileOutputStream -- BufferedOutputStream
 */
public class CopyImageDemo {
    public static void main(String[] args) throws IOException {
        // 使用字符串作为路径
        // String srcString = \"c:\\\\a.jpg\";
        // String destString = \"d:\\\\b.jpg\";
        // 使用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();
    }
}

 



 

 

 


来源:https://www.cnblogs.com/ztg-java-xuexi/p/16089501.html
本站部分图文来源于网络,如有侵权请联系删除。

未经允许不得转载:百木园 » IO(字符流的使用操作)

相关推荐

  • 暂无文章