学习笔记049——Java字符流-CSDN博客

本文链接：https://blog.csdn.net/code__bee/article/details/144209113

文章目录

IO 流

IO 流

1、字符流

字符流是有别于字节流的另一种数据流，两者的区别在于每次处理的数据单位不同，一个是以字节为单位进行处理，另一个是以字符为单位进行处理，相当于用两根不同粗细的管子抽水。

跟字节流类似，字符流也可以按照方向分为输入字符流（Reader）和输出字符流（Writer）。

Reader 和 Writer 都是抽象类，使用的时候需要使用它们的非抽象子类。

1.1、Reader

常用方法

方法	描述
int read()	以字符为单位读取数据
int read(char chars[])	将数据读入 char 数组，并返回数据长度
int read(char chars[],int off,int len)	将数据读入 char 数组的指定区间，并返回数据长度
void close()	关闭数据流
transferTo(Writer out)	将数据直接读入字符输出流

package com.htl.test;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class Test {
    public static void main(String[] args) {
        Reader reader = null;
        try {
            //获取Reader
            reader = new FileReader("D:\\java\\test.txt");
            //开始读取数据
            int temp = 0;
            while ((temp = reader.read())!=-1){
                System.out.println(temp);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e){
            e.printStackTrace();
        } finally {
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

英文字母、数字、标点符号，一个字符就是一个字节，使用字节流和字符流其实没有区别。

在 UTF-8 编码的情况下，一个汉字等于三个字节

package com.htl.test;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class Test {
    public static void main(String[] args) {
        Reader reader = null;
        try {
            //获取Reader
            reader = new FileReader("D:\\java\\test.txt");
            //开始读取数据
            char[] chars = new char[1024];
            int read = reader.read(chars,2,7);
            System.out.println(read);
            for (char aChar : chars) {
                System.out.println(aChar);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e){
            e.printStackTrace();
        } finally {
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

1.2、Writer

方法	描述
void write(int c)	以字符为单位写数据
void write(char chars[])	将 char 数组中的数据写出
void write(char chars[],int off,int len)	将 char 数组中指定区间的数据写出
void write(String str)	将 String 数据写出
void write(String str,int off,int len)	将 String 指定区间的数据写出
void flush()	强制将缓冲区的数据同步到输出流中
void close()	关闭数据流

package com.htl.test;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class Test3 {
    public static void main(String[] args) {
        Writer writer = null;
        try {
            writer = new FileWriter("D:\\java2\\test.txt");
            writer.write(230);
            writer.write(123456);
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.htl.test;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class Test3 {
    public static void main(String[] args) {
        Writer writer = null;
        try {
            writer = new FileWriter("D:\\java2\\test.txt");
            char[] chars = {'好','好','学','习'};
            writer.write(chars,2,2);
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.htl.test;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class Test3 {
    public static void main(String[] args) {
        Writer writer = null;
        try {
            writer = new FileWriter("D:\\java2\\test.txt");
            String str = "好好学习";
            writer.write(str,2,2);
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2、缓冲流

缓冲流属于处理流，不能直接访问文件。

如何区分节点流和处理流？

能直接访问文件的就是节点流（字节流、字符流）

不能直接访问文件的就是处理流（缓冲流），必须基于节点流，构造处理流的时候必须将节点流作为参数传入到处理流中

2.1、字节缓冲流

字节输入缓冲流字节输出缓冲流

2.1、字符缓冲流

字符输入缓冲流字符输出缓冲流

字节输入缓冲流 BufferedInputStream

package com.htl.test;

import java.io.*;

public class Test5 {
    public static void main(String[] args) {
        BufferedInputStream bufferedInputStream = null;
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream("D:\\java\\test.txt");
            bufferedInputStream = new BufferedInputStream(inputStream);
            int temp = 0;
            while ((temp = bufferedInputStream.read())!=-1){
                System.out.println(temp);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                inputStream.close();
                bufferedInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符输入缓冲流 BufferedReader

package com.htl.test;

import java.io.*;

public class Test6 {
    public static void main(String[] args) {
        BufferedReader bufferedReader = null;
        Reader reader = null;
        try {
            reader = new FileReader("D:\\java\\test.txt");
            bufferedReader = new BufferedReader(reader);
            String str = "";
            while ((str = bufferedReader.readLine())!=null){
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                reader.close();
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字节输出缓冲流 BufferedOutputStream

package com.htl.test;

import java.io.*;

public class Test7 {
    public static void main(String[] args) {
        OutputStream outputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        try {
            outputStream = new FileOutputStream("D:\\java2\\test.txt");
            bufferedOutputStream = new BufferedOutputStream(outputStream);
            String str = "由于C++所具有的优势，该项目组的研究人员首先考虑采用C++来编写程序。但对于硬件资源极其匮乏的单片式系统来说，C++程序过于复杂和庞大。";
            bufferedOutputStream.write(str.getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bufferedOutputStream.flush();
                bufferedOutputStream.close();
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符输出缓冲流 BufferedWriter

package com.htl.test;

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

public class Test8 {
    public static void main(String[] args) {
        Writer writer = null;
        BufferedWriter bufferedWriter = null;
        try {
            writer = new FileWriter("D:\\java2\\test.txt");
            bufferedWriter = new BufferedWriter(writer);
            String str = "由于C++所具有的优势，该项目组的研究人员首先考虑采用C++来编写程序。但对于硬件资源极其匮乏的单片式系统来说，C++程序过于复杂和庞大。";
            bufferedWriter.write(str);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bufferedWriter.flush();
                bufferedWriter.close();
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3、文件复制

IO 流实现，文本类型可以使用字符流，除了文本类型之外的其他类型，不能使用字符流，只能使用字节流去处理，因为使用字符流会破坏其内部构成，导致文件无法使用。

package com.htl.test;

import java.io.*;

public class Test10 {
    public static void main(String[] args) {
        InputStream inputStream = null;
        BufferedInputStream bufferedInputStream = null;
        OutputStream outputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        try {
            inputStream = new FileInputStream("D:\\java\\123.png");
            bufferedInputStream = new BufferedInputStream(inputStream);
            outputStream = new FileOutputStream("D:\\java2\\123.png");
            bufferedOutputStream = new BufferedOutputStream(outputStream);
            int temp = 0;
            while ((temp = bufferedInputStream.read())!=-1){
                bufferedOutputStream.write(temp);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bufferedOutputStream.flush();
                bufferedOutputStream.close();
                outputStream.close();
                bufferedInputStream.close();
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}