Java 之IO流（1）

最新推荐文章于 2023-08-17 19:59:59 发布

晓晓晓的打工日记

最新推荐文章于 2023-08-17 19:59:59 发布

阅读量89

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_44553953/article/details/114485430

版权

1.IO流总览

在这里插入图片描述
IO流详细：

IO流分类：按照“流”的数据流向，可分为"输入流“和”输出流“；
按照”流“中处理数据的单位，可分为”字符流“和”字节流“；在java中，字节是占1个Byte，即8位；而字符是占2个Byte，即16位。而且，需要注意的是，java的字节是有符号类型，而字符是无符号类型！
字节流的抽象基类： InputStream，OutputStream
字符流的抽象基类：Reader,Writer

2.字符流

2.1 Writer:字符输出流

在这里插入图片描述
Writer是字符输出流的基类，Writer的主要方法如下：

Writer append(char c) 将指定的字符附加到此作者
Writer append(CharSequence csq) 将指定的字符序列附加到此作者
Writer append(CharSequence csq, int start, int end) 将指定字符序列的子序列附加到此作者 
abstract void close() 关闭流，先刷新
abstract void flush() 刷新流 
void write(char[] cbuf) 写入一个字符数组。 
abstract void write(char[] cbuf, int off, int len) 写入字符数组的一部分 
void write(int c) 写一个字符 
void write(String str) 写一个字符串 
void write(String str, int off, int len) 写一个字符串的一部分

我们知道IO流主要是用于操作文件的，但是从上图中我们发现Writer的直接子类中好像并没有直接操作文件，但是细心的你注意到，在Writer的子类OutputStreamWriter的子类中有一个类叫做FileWriter，File这个单词我们很熟悉——文件，大家可以推测一下这个类是可以用于操作文件的，下面我们来学习一下FileWriter的用法

2.1.1FileWriter

构造方法如下：

OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter
OutputStreamWriter(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter
OutputStreamWriter(OutputStream out, Charset cs) 创建一个使用给定字符集的OutputStreamWriter
OutputStreamWriter(OutputStream out, CharsetEncoder enc) 创建一个使用给定字符集编码器的OutputStreamWriter

方法列表如下：

Writer append(CharSequence csq) 将指定的字符序列附加到此作者。 
Writer append(CharSequence csq, int start, int end) 将指定字符序列的子序列附加到此作者。 
void close() 关闭流，先刷新。 
void flush() 刷新流。 
String getEncoding() 返回此流使用的字符编码的名称。 
void write(char[] cbuf, int off, int len) 写入字符数组的一部分。 
void write(int c) 写一个字符 
void write(String str, int off, int len) 写一个字符串的一部分。

详细用法：

import java.io.IOException;
import java.io.*;

public class FileWriterLearn {
    public static void main(String[] args) throws IOException {
        //创建FileWriter对象，一开始就明确其路径
        FileWriter fw=new FileWriter("C:\\Users\\18811\\Desktop\\fw.txt");
        //调用write方法，将字符串写入流中
        fw.write("abcde");
        //关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
        //将数据刷到目的地中。
        //和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
        fw.close();
    }
}

上面的代码中我们可以看到有异常产生，但是我们并没有处理，而是抛出去了，那么在日常开发中我们不能直接抛出，所以需要对异常进行处理

import java.io.IOException;
import java.io.*;
public class FileWriterLearn {
    public static void main(String[] args) {
        FileWriter fw=null;
        try{fw=new FileWriter("C:\\Users\\18811\\Desktop\\fw.txt");
            //调用write方法，将字符串写入流中
            fw.write("abcde");}
        catch (IOException e){
            System.out.println("catch"+e.toString());
        }
        finally {
            try{
                if(fw!=null){
                    fw.close();
                }
            }
            catch (IOException e){
                System.out.println("catch"+e.toString());
            }
        }
    }
}

上面的那种方式写入文件时，会将之前的文件覆盖了，之前文件中写的内容不存在了，那么如何在已有的文件后面添加内容

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

public class FileWriterLearn1 {
    public static void main(String[] args) throws IOException {
        //传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写
        FileWriter fw=new FileWriter("C:\\Users\\18811\\Desktop\\fw.txt",true);
        fw.write("45678");
        fw.close();
    }
}

2.1.2 BufferedWriter

BufferedWriter 是缓冲字符输出流。它继承于Writer。
BufferedWriter 的作用是为其他字符输出流添加一些缓冲功能，使用BufferedWriter可以提高我们写入文件的效率。

BufferedWriter构造方法如下：

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

BufferedWriter方法列表如下：

void close() 关闭流，先刷新。 
void flush() 刷新流。 
void newLine() 写一行行分隔符。 
void write(char[] cbuf, int off, int len) 写入字符数组的一部分。 
void write(int c) 写一个字符 
void write(String s, int off, int len) 写一个字符串的一部分。

BufferedWriter用例如下：

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

public class BufferReaderLearn {
    public static void main(String[] args) throws IOException {
        FileWriter fw=new FileWriter("fw2.txt");
        //为了提高字符写入流效率，引入数据缓冲技术
        //只需要将需要被提高效率的流对象做为参数传递给缓冲构造函数即可
        BufferedWriter br=new BufferedWriter(fw);
        char[] c={'a','b','c','d'};
        br.write(c,0,3);//写入字符数组的一部分
        br.newLine();//换行
        br.write(c,1,2);//再次写入
        br.flush();//刷新流
        br.close();
    }
}

生成的fw2.txt文件如下：

abc
bc

2.1.3 CharArrayWriter

CharArrayReader 用于写入字符，它继承于Writer。操作的数据是以字符为单位！

CharArrayReader的构造函数：

CharArrayWriter() 创建一个新的CharArrayWriter。 
CharArrayWriter(int initialSize) 用指定的初始大小创建一个新的CharArrayWriter。

CharArrayReader的方法列表：

CharArrayWriter append(char c) 将指定的字符附加到此作者。 
CharArrayWriter append(CharSequence csq) 将指定的字符序列附加到此作者。 
CharArrayWriter append(CharSequence csq, int start, int end) 将指定字符序列的子序列附加到此作者。 
void close() 关闭流。 
void flush() 冲洗流。 
void reset() 重置缓冲区，以便您可以再次使用它，而不会丢弃已经分配的缓冲区。 
int size() 返回缓冲区的当前大小。 
char[] toCharArray() 返回输入数据的副本。 
String toString() 将输入数据转换为字符串。 
void write(char[] c, int off, int len) 将字符写入缓冲区。 
void write(int c) 将一个字符写入缓冲区。 
void write(String str, int off, int len) 将一部分字符串写入缓冲区。 
void writeTo(Writer out) 将缓冲区的内容写入另一个字符流。

2.1.4 FilterWriter

FilterWriter是字符类型的过滤输出流
构造方法：

protected  FilterWriter(Writer out) 创建一个新的过滤输出流对象

方法列表：

void close() 关闭流，先刷新。 
void flush() 刷新流。 
void write(char[] cbuf, int off, int len) 写入字符数组的一部分。 
void write(int c) 写一个字符 
void write(String str, int off, int len) 写一个字符串的一部分。

2.1.5 PrintWriter

PrintWriter 是字符类型的打印输出流，它继承于Writer。
PrintWriter的构造方法：

PrintWriter(File file) 使用指定的文件创建一个新的PrintWriter，而不需要自动的线路刷新。 
PrintWriter(File file, String csn) 使用指定的文件和字符集创建一个新的PrintWriter，而不需要自动进行线条刷新。 
PrintWriter(OutputStream out) 从现有的OutputStream创建一个新的PrintWriter，而不需要自动线路刷新。 
PrintWriter(OutputStream out, boolean autoFlush) 从现有的OutputStream创建一个新的PrintWriter。 
PrintWriter(Writer out) 创建一个新的PrintWriter，没有自动线冲洗。 
PrintWriter(Writer out, boolean autoFlush) 创建一个新的PrintWriter。 
PrintWriter(String fileName) 使用指定的文件名创建一个新的PrintWriter，而不需要自动执行行刷新。 
PrintWriter(String fileName, String csn) 使用指定的文件名和字符集创建一个新的PrintWriter，而不需要自动线路刷新。

PrintWriter 的方法列表：

PrintWriter append(char c) 将指定的字符附加到此作者。 
PrintWriter append(CharSequence csq) 将指定的字符序列附加到此作者。 
PrintWriter append(CharSequence csq, int start, int end) 将指定字符序列的子序列附加到此作者。 
boolean checkError() 如果流未关闭，请刷新流并检查其错误状态。 
protected void clearError() 清除此流的错误状态。 
void close() 关闭流并释放与之相关联的任何系统资源。 
void flush() 刷新流。 
PrintWriter format(String format, Object... args) 使用指定的格式字符串和参数将格式化的字符串写入此写入程序。 
PrintWriter format(Locale l, String format, Object... args) 使用指定的格式字符串和参数将格式化的字符串写入此写入程序。 
void print(boolean b) 打印布尔值。 
void print(char c) 打印一个字符 
void print(char[] s) 打印字符数组。 
void print(double d) 打印双精度浮点数。 
void print(float f) 打印浮点数。 
void print(int i) 打印一个整数。 
void print(long l) 打印一个长整数。 
void print(Object obj) 打印一个对象。 
void print(String s) 打印字符串。 
PrintWriter printf(String format, Object... args) 使用指定的格式字符串和参数将格式化的字符串写入该writer的方便方法。 
PrintWriter printf(Locale l, String format, Object... args) 使用指定的格式字符串和参数将格式化的字符串写入该writer的方便方法。 
void println() 通过写入行分隔符字符串来终止当前行。 
void println(boolean x) 打印一个布尔值，然后终止该行。 
void println(char x) 打印一个字符，然后终止该行。 
void println(char[] x) 打印字符数组，然后终止行。 
void println(double x) 打印双精度浮点数，然后终止行。 
void println(float x) 打印一个浮点数，然后终止该行。 
void println(int x) 打印一个整数，然后终止该行。 
void println(long x) 打印一个长整型，然后终止行。 
void println(Object x) 打印一个对象，然后终止该行。 
void println(String x) 打印一个字符串，然后终止行。 
protected void setError() 表示发生错误。 
void write(char[] buf) 写入一个字符数组。 
void write(char[] buf, int off, int len) 写一个字符数组的一部分。 
void write(int c) 写一个字符 
void write(String s) 写一个字符串 
void write(String s, int off, int len) 写一个字符串的一部分。

2.2 Reader:字符输入流

在这里插入图片描述
有输出流那么当然就有输入流，Reader是字符输入流的基类，Reader的方法列表如下：

abstract void close() 关闭流并释放与之相关联的任何系统资源。 
void mark(int readAheadLimit) 标记流中的当前位置。 
boolean markSupported() 告诉这个流是否支持mark（）操作。 
int read() 读一个字符 
int read(char[] cbuf) 将字符读入数组。 
abstract int read(char[] cbuf, int off, int len) 将字符读入数组的一部分。 
int read(CharBuffer target) 尝试将字符读入指定的字符缓冲区。 
boolean ready() 告诉这个流是否准备好被读取。 
void reset() 重置流。 
long skip(long n) 跳过字符

2.2.1 FileReader

FileReader构造方法如下：

FileReader(File file) 创建一个新的 FileReader ，给出 File读取。 
FileReader(FileDescriptor fd) 创建一个新的 FileReader ，给予 FileDescriptor从中读取。 
FileReader(String fileName) 创建一个新的 FileReader ，给定要读取的文件的名称。

FileReader的具体使用：

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

public class FileReaderlearn {
    public static void main(String[] args) throws IOException {
        //创建一个文件流读取对象，和文件名相关联
        //文件必须是已经存在的
        FileReader fr=new FileReader("fw.txt");
        //调用read方法，一次读取一个字符
        int ch=0;
        char[] ch1=new char[1024];//字符数组存储读取的字符
        int i=0;
        while((ch=fr.read())!=-1){
            ch1[i]=(char)ch;
            i++;
        }
        fr.close();
        //字符数组转化为字符串
        System.out.println(new String(ch1,0,i));
    }
}

2.2.2 BufferedReader

BufferedReader构造方法：

BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。 
BufferedReader(Reader in, int sz) 创建使用指定大小的输入缓冲区的缓冲字符输入流。

BufferedReader方法列表：

void close() 关闭流并释放与之相关联的任何系统资源。 
Stream<String> lines() 返回一个 Stream ，其元素是从这个 BufferedReader读取的行。 
void mark(int readAheadLimit) 标记流中的当前位置。 
boolean markSupported() 告诉这个流是否支持mark（）操作。 
int read() 读一个字符 
int read(char[] cbuf, int off, int len) 将字符读入数组的一部分。 
String readLine() 读一行文字。 
boolean ready() 告诉这个流是否准备好被读取。 
void reset() 将流重置为最近的标记。 
long skip(long n) 跳过字符

BufferedReader使用：

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

public class BufferedReaderLearn {
    public static void main(String[] args) throws IOException {
        //创建一个读取流对象和文件相关联
        FileReader fr=new FileReader("fw.txt");
        //引入缓冲技术，将读取流对象作为参数传递给缓冲对象的构造函数
        BufferedReader br=new BufferedReader(fr);
        String line=null;
        while((line=br.readLine())!=null){
            System.out.println(line);
        }
        br.close();
    }
}

通过缓冲区复制文件：

import java.io.*;

public class CopyBuffer {
    public static void main(String[] args) {
        try {
            BufferedReader br = new BufferedReader(new FileReader("fw.txt"));
            BufferedWriter bw=new BufferedWriter(new FileWriter("bufcopy.txt"));
            String copyLine=null;
            while((copyLine=br.readLine())!=null){
                bw.write(copyLine);
                bw.newLine();
                bw.flush();
            }
        }
        catch(IOException e){
            throw new RuntimeException("读写失败");
        }

    }
}