Java-IO(字符流)

OutputStreamWriter

字符流 = 字节流 + 编码表

字符输出流：Writer --OutputStreamWriter
字符输入流：Reader

构造方法

public OutputStreamWriter(OutputStream out)

public OutputStreamWriter(OutputStream out,String charsetName)

OutputStream的写方法：

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)

package com.bigdat.java.day25;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/*
        字符流= 字节流 + 编码表
        字符输出流：Write -- OutputStreamWrite
        字符输入流：

        OutputStreamWriter 的构造方法
                    public OutputStreamWriter(OutputStream out)
                    public OutputStreamWriter(OutputStream out,String charsetName)

        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 OutputStreamWriteDemo1 {
    public static void main(String[] args) {
        //创建字符输出流对象
        //方式一：
//        FileOutputStream fos = null;
//        OutputStreamWriter osw = null;
//        try {
//            fos = new FileOutputStream("D:\\out.txt");
//            osw = new OutputStreamWriter(fos);
//        } catch (FileNotFoundException e) {
//            e.printStackTrace();
//        } finally {
//            try {
//                osw.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        }
        //由于方式一太过于繁琐，可以使用方式二简化
        OutputStreamWriter osw = null;
        try {
            //在文件输出流的路径后面，加上 true 可以实现追加
            osw = new OutputStreamWriter(new FileOutputStream("D:\\out.txt",true));

            //开始调用方法向流中写入数据
            //public void write(int c)
            osw.write(89);
            osw.write(84);
            osw.write(99);
            osw.write(123);


            //public void write(char[] cbuf)
            //向文件中写入字符数组
            char[] chars = {'我','爱','中','国','!'};
            osw.write(chars);


            //public void write(char[] cbuf,int off,int len)
            //写入字符数组的一部分
            osw.write(chars, 2, 2);
            osw.write("\t\n");

            //public void write(String str)
            //可以直接写入字符串
            osw.write("我是阿涛，阿涛要加油。纵使身处低谷，更要仰望星空！！");

            //public void write(String str,int off,int len)
            //输出一部分的字符串长度
            osw.write("\t\n");
            osw.write("我是阿涛，阿涛要加油。纵使身处低谷，更要仰望星空！！",5,5);

            //调用flush方法后，可以将缓冲区中的数据刷到文件中，并且字符输出流对象不会关闭
            osw.flush();
            System.out.println("写入完毕！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //释放资源，
                //包含的刷新操作，但是刷新之后，流对象关闭，后续就无法在进行操作了
                osw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

字符输入流：Reader -- InputStreamReader

构造方法

InputStreamReader(InputStream in)创建一个使用默认字符集的InputStreamReader。

InputStreamReader(InputStream in, String charsetName)
创建一个使用命名字符集的InputStreamReader。

两种读数据的方式：

1、public int read()

2、public int read(char[] cbuf)

package com.bigdat.java.day25;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
/*
    字符输入流：Reader -- InputStreamReader
      InputStreamReader的构造方法：
            InputStreamReader(InputStream in)
                创建一个使用默认字符集的InputStreamReader。
            InputStreamReader(InputStream in, String charsetName)
                创建一个使用命名字符集的InputStreamReader。

        InputStreamReader读取数据的两种方式：
            1、public int read()
            2、public int read(char[] cbuf)
 */
public class InputStreamReaderDemo1 {
    public static void main(String[] args) {
        //创建字符输入流
        //方式一
//        FileInputStream fim = null;
//        InputStreamReader isr = null;
//        try {
//            fim = new FileInputStream("D:\\out.txt");
//            isr = new InputStreamReader(fim);
//        } catch (FileNotFoundException e) {
//            e.printStackTrace();
//        } finally {
//            try {
//                isr.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        }
        //创建字符输入流的方式二: (由于方式一太过于麻烦)
        InputStreamReader isr = null;
        try {
           isr = new InputStreamReader(new FileInputStream("D:\\out.txt"));

           //调用方法读取数据
            //方式一：一次读取一个字符   public int read()
//            int length = 0;
//            while ((length = isr.read()) != -1){
//                System.out.print((char)length);
//            }

            System.out.println("=====================================================");
            //方式二: 按照字符数组来读取  public int read(char[] cbuf)
            int len = 0;
            char[] chars = new char[1024];
            while((len = isr.read(chars)) != -1){
                System.out.println(new String(chars, 0,len));
            }

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


    }
}

FileWriter

我们知道字符转换流是基于字节流诞生的，
字符流 = 字节流 + 编码表
但是呢，我们在正常写程序的过程中并没有刻意地传入编码，而是使用java默认地编码去操作
OutputStreamWriter = FileOutputStream + 编码表（Unicode编码）
InputStreamReader = FileIntputStream + 编码表（Unicode编码）

上面的过程中，在创建对象时，名字有点长，所以java提供了一个字符流的简化写法

字符输出流：FileWriter

字符输入流：FilerReader

public class FileWriteDemo1 {
    public static void main(String[] args) {
        //以前写法
        //OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("D:\\out1.txt"));
        //现在写法
        FileWriter fileWriter = null;
        try {
            //如果目标文件不存在，就会自动建
            fileWriter = new FileWriter("D:\\out1.txt");

            //向 out1 中写入数据、
            fileWriter.write("好像我从来都没有把一件事情给做的很好！");

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

字符输入流：FilerReade

package com.bigdat.java.day25;
import java.io.*;
public class FileReaderDemo1 {
    public static void main(String[] args) {
        //InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("D:\\out1.txt"));
        //简化的写法
        FileReader fileReader = null;
        try {
            fileReader = new FileReader("D:\\out1.txt");

            //开始读取数据
            //方式一： 单个字符的读取
//            int len = 0;
//            while((len = fileReader.read()) != -1){
//                System.out.print((char)len);
//            }
            //方式二： 按照字符数组进行读取
            char[] chars = new char[1024];
            int length = 0;
            while((length = fileReader.read(chars)) != -1){
                String str = new String(chars,0,length);
                System.out.println(str);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭资源
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

字符缓冲流输出流 BufferedWriter

类比之前学习字节流的时候有缓冲流存在，
字符流也有相对应的缓冲流

字符缓冲输出流：BufferedWriter

字符缓冲输入流：BufferedReader

构造方法

BufferedWriter(Writer out)
创建使用默认大小的输出缓冲区的缓冲字符输出流。

BufferedWriter(Writer out, int sz)
创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。

public class BufferedWriterDemo1 {
    public static void main(String[] args) {
        //繁琐写法
        // BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\out2.txt")));
        // 创建字符缓冲流输出对象
        BufferedWriter bw = null;
        try {
             bw = new BufferedWriter(new FileWriter("D:\\out4.txt",true));

             //调用方法写入数据
            bw.write("天上人间，有谁值得被歌颂！");
            bw.write("不是所有感情都会有始有终，");
            bw.write("\t\n");
            bw.write("不是所有的事情都有结果");
            bw.newLine();
            bw.write("也不是所有的结果都有对错！！！");
            bw.newLine();

            System.out.println("数据录入完毕！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //释放资源
            try {
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符缓冲输入流 BufferedReader

public class BufferedReaderDemo1 {
    public static void main(String[] args) throws IOException {
//        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("d.txt")));
        BufferedReader br = new BufferedReader(new FileReader("d.txt"));
        //一次读一个字符
//        int ch = 0;
//        while ((ch=br.read())!=-1){
//            System.out.print((char) ch);
//        }
        System.out.println("===============================");
        //一次读取一个字符数组
        char[] chars = new char[1024];
        int length = 0;
        while ((length=br.read(chars))!=-1){
            String s = new String(chars, 0, length);
            System.out.println(s);
        }
        //释放资源
        br.close();
    }
}

字符缓冲流特有的方法

BufferedWriter:
public void newLine() throws IOException写一行行分隔符。
行分隔符字符串由系统属性line.separator定义，并不一定是单个换行符（'\ n'）字符。

BufferedReader:
public String readLine() throws IOException读一行文字。
一行被视为由换行符（'\ n'），回车符（'\ r'）中的任何一个或随后的换行符终止。

public class BufferedReaderDemo2 {
    public static void main(String[] args) {
           // reader();
           writer();
    }
    public static void reader(){
        //创建字符输出流对象
        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader("D:\\out4.txt"));
            // 按行读入数据
            String len = null;
            while((len = br.readLine()) != null){
                System.out.println(len);
            }

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


    }
    public static void writer(){
        //创建字符输出流
        BufferedWriter br = null;
        try {
           br = new BufferedWriter(new FileWriter("D:\\out4.txt", true));

           //向文件中写入数据
            br.newLine();
            br.write("在人间，有谁活着不像是一场炼狱。");
            System.out.println("数据写入成功！！！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭资源
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

posted @ 2022-04-10 12:06 a-tao必须奥利给阅读(38) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

atao-BigData

人生如逆旅，你我亦行人。

Java-IO(字符流)

OutputStreamWriter

构造方法

OutputStream的写方法：

字符输入流：Reader -- InputStreamReader

构造方法

两种读数据的方式：

FileWriter

上面的过程中，在创建对象时，名字有点长，所以java提供了一个字符流的简化写法

字符输入流：FilerReade

字符缓冲流输出流 BufferedWriter

构造方法

字符缓冲输入流 BufferedReader

字符缓冲流特有的方法

公告