Java I/O流基础总结

前言

1、此篇文章为I/O流基础知识（字节流和字符流）。
2、我们通过了解各个类的定义、构造方法、例子学习。
3、代码没写完还想睡觉吗？

一、 第一部分-----字符流

一、概述

1、什么是Java IO流

  有些存储的数据是暂时的，为了能够永久地保存程序创建的数据，需要将其保存到磁盘文件中，这样就可以在其他程序中使用它们。Java 的 I/O（输入/输出）技术可以将数据保存到文本文件和二进制文件中， 以达到永久保存数据的要求。
   java I/O (输入和输出)：用于处理输入并产生输出。
   流: 流是一个抽象的概念，是值一连串的数据（字符或字节），是以先进先出的方式发送信息的通道。
  流的分类：

2、OutputStream是什么？

​   OutputSream：字节输出流，是一种抽象类，代表字节输出流的所有类的超类。输出流接受输出字节并将其发送到某个接收器上。
​   Java应用程序使用输出流将数据写入目标。它可以是文件，阵列，外围设备或Socket套接字。

3、OutputStream的方法

  关于OutputSteam的方法：

方法	描述
public void write(int)throws IOException	用于将字节写入当前输出流。
public void write(byte[])throws IOException	用于将字节数组写入当前输出流。
public void flush()throws IOException	刷新当前输出流。
public void close()throws IOException	用于关闭当前输出流。

4、关于OutputSteam层次结构

5、InputSteam是什么？

  InputStream类是一个抽象类。它是代表字节输入流的所有类的超类。
  Java应用程序使用输入流从源中读取数据。它可以是文件，阵列，外围设备或Socket套接字。

6、InputSteam的方法

方法	描述
public abstract int read()throws IOException	从输入流中读取下一个数据字节。它在文件末尾返回-1。
public int available()throws IOException	返回可以从当前输入流读取的字节数的估计值。
public void close()throws IOException	用于关闭当前输入流。

7、关于InputStream层次结构

二、FileOutputSream和FileInputSream

1、FileOutputSream是什么？

  FileOutputStream 用于将数据写入文件的输出流。

  如果必须将原始类型数据写入文件，请使用FileOutputStream类。您可以通过FileOutputStream类编写面向字节和面向字符的数据。但是，对于面向字符的数据，首选使用FileWriter而不是FileOutputStream。

2、FileOutputStream方法

方法	描述
void write(byte[] ary)	从指定的字节数组写入ary.length个字节到该文件输出流。
void write(byte[] ary, int off, int len)	方法从指定的字节数组开始到该文件输出流关闭写入len字节。
void write(int b)	用于将指定的字节写入文件输出流。
void close()	用于关闭文件输出流。
void flush()	用于刷新此输出流，并强制将所有缓冲的输出字节写出到该流中。

3、案例

3.1、写入单个字节

创建一个向具有指定名称的文件写入数据的输出文件流，文件为io.txt：

package com.io;

import java.io.FileOutputStream;

public class lesson01 {
    public static void main(String[] args) throws Exception {
        //创建一个向具有指定名称的文件中写入数据的输出文件流
        FileOutputStream fileOutputStream = new FileOutputStream("io.txt");
        //指定的字节写入文件输出流 此时的字节数代表Ascii
        fileOutputStream.write(65);
        // 关闭文件输出流
        fileOutputStream.close();
        System.out.println("success");

    }
}

结果:

3.2、写入字符串

package com.io;

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

public class FileOutputSteamTest02 {
    //写入字符串
    public static void main(String[] args) {
        FileOutputStream  fos=null;
        try {
            fos = new FileOutputStream("io.txt");
            String str="Hello Word!";
            byte b[]=str.getBytes();
            //将字符串转换成字节数组

            //写入字节
            fos.write(b);
            System.out.println("success");

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

结果：

4、FileInputStream是什么？

  Java FileInputStream类从文件获取输入字节。它用于读取面向字节的数据（原始字节流），例如图像数据，音频，视频等。您还可以读取字符流数据。但是，为了读取字符流，建议使用FileReader类。

5、FileInputStream方法

方法	描述
int available()	用于返回可以从输入流读取的估计字节数。
int read()	用于从输入流中读取数据字节。
int read(byte[] b)	用于从输入流中读取最多b.length个数据字节。
int read(byte[] b, int off, int len)	用于从输入流中读取最多len字节的数据。
long skip(long x)	用于跳过并丢弃输入流中的x字节数据。
void close()	用于关闭流
void mark(int readlimit)	此方法标记此输入流中的当前位置。
boolean markSupported()	此方法测试此输入流是否支持mark和reset方法。
void reset()	该方法将该流重新定位到在此输入流上最后调用mark方法的位置。

6、FileInputStream例子

6.1、读出单个字节

创建一个向具有指定名称的文件写入数据的输出文件流，文件为io.txt：

package com.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileIntputSteamTest01 {
    public static void main(String[] args) {
        //读取一个字符
        FileInputStream fis=null;
        try {
            //通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
            fis = new FileInputStream("io.txt");
            int i= fis.read();
            System.out.println((char)i);
            System.out.println("Success");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

结果（控制台）:

6.2、读出所有字节

package com.io;

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

public class FileInputStreamTest02 {
    public static void main(String[] args) {
        //读取所有字节流
        FileInputStream fis=null;
        try {
            fis =new FileInputStream("io.txt");
            int i=0;
            while ((i= fis.read())!=-1){
                System.out.print((char)i);

            }
            System.out.println("读取成功");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

结果：

三、BufferedOutputStream和BufferedInputStream

1、BufferedOutputStream是什么？

  BufferedOutputStream类用于缓冲输出流。它在内部使用缓冲区存储数据。与将数据直接写入流相比，它提高了效率，它提高了效率，提高了性能。

2、BufferedOutputStream的构造方法

  通过JDK查看，我们可以看到构造方法有：

构造方法	描述
public BufferedOutputStream(OutputStream out)	创建新的缓冲输出流，该输出流用于将数据写入指定的输出流。
public BufferedOutputStream(OutputStream out, int size)	创建新的缓冲输出流，该缓冲流用于将数据写入具有指定缓冲区大小的指定输出流。

3、BufferedOutputStream的方法

  关于BufferedOutputStream的方法以下：

方法	描述
public void write(int b)	将指定的字节写入缓冲的输出流。
public void write(byte[] b, int off,int len)	将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流。
public void flush()	刷新此缓冲的输出流。这迫使所有缓冲的输出字节被写出到底层输出流中。

4、BufferedOutputStream例子

4.1、例1

  在此示例中，我们将文本信息写入连接到FileOutputStream对象的BufferedOutputStream对象中。flush() 刷新一个流的数据并将其发送到另一流。如果您已将一个流与另一个流连接，则需要这样做。

​

package com.demo02;

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputSteamTest01 {
    public static void main(String[] args) {
        FileOutputStream fos=null;
        BufferedOutputStream bos=null;
        try {
            fos = new FileOutputStream("bufferTest.txt");
            bos = new BufferedOutputStream(fos);
            String str="BufferedOutputStreamTest";
            //将字符串转换成数组
            byte b[]=str.getBytes();
            fos.write(b);
            //写入缓冲区
            bos.flush();
            System.out.println("Success");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                bos.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

我们查看bufferTest.txt的结果：

5、BufferedInputStream是什么？

  Java BufferedInputStream 类用于从Stream读取信息。它在内部使用缓冲机制来提高性能。

  关于BufferedInputStream的要点是：

• 当跳过或读取流中的字节时，内部缓冲区自动从包含的输入流中重新填充，一次填充多个字节。
• 创建BufferedInputStream时，将创建一个内部缓冲区数组。

6、BufferedInputStream的构造方法

  通过JDK查看，我们可以得知有以下的构造方法：

构造方法	描述
public BufferedInputStream(InputStream in)	创建BufferedInputStream并将其参数（输入流in）保存起来以备后用。
public BufferedInputStream(InputStream in, int size)	创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。创建一个长度为 size 的内部缓冲区数组并将其存储在 buf 中。

7、BufferedInputStream的方法

方法	描述
int available()	返回可以从此输入流读取（或跳过）、且不受此输入流接下来的方法调用阻塞的估计字节数。接下来的调用可能是同一个线程，也可能是不同的线程。一次读取或跳过这么多字节将不会受阻塞，但可以读取或跳过数量更少的字节。
int read()	用于从输入流中读取数据字节。
int read(byte[] b, int off, int len)	从此字节输入流中给定偏移量处开始将各字节读取到指定的 byte 数组中。
long skip(long x)	用于跳过并丢弃输入流中的x字节数据。
void close()	用于关闭流。
void mark(int readlimit)	参见 InputStream 的 mark 方法的常规协定。
boolean markSupported()	此方法测试此输入流是否支持mark和reset方法。
void reset()	该方法将该流重新定位到在此输入流上最后调用mark方法的位置。

8、BufferedInputStream例子

8.1、例1

  让我们看一个使用BufferedInputStream 读取文件数据的简单示例：

package com.demo02;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamTest01 {
    public static void main(String[] args) {
        FileInputStream fis=null;
        BufferedInputStream bis=null;
        try {
            fis = new FileInputStream("bufferTest.txt");
            bis = new BufferedInputStream(fis);
            int len;
            while ((len = bis.read()) != -1) {
                System.out.print((char)len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭资源
            try {
                bis.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

结果：

四、ByteArrayOutputStream和ByteArrayInputStream

1、ByteArrayOutputStream是什么？

  Java ByteArrayOutputStream 类用于将公共数据写入多个文件。在此流中，数据被写入一个字节数组，该字节数组以后可以写入多个流，可使用 toByteArray() 和 toString() 获取数据。

  ByteArrayOutputStream保存数据的副本，并将其转发到多个流。

  ByteArrayOutputStream的缓冲区根据数据自动增长。

2、ByteArrayOutputStream的构造方法

​ 通过JDK我们查看有以下构造方法：

方法	描述
public ByteArrayOutputStream()	创建一个新的 byte 数组输出流。缓冲区的容量最初是 32 字节，如有必要可增加其大小。
public ByteArrayOutputStream(int size)	创建一个新的 byte 数组输出流，它具有指定大小的缓冲区容量（以字节为单位）。 如果 size 为负，则会抛出IllegalArgumentException 。

3、ByteArrayOutputStream的方法

​    通过JDK我们可以知道有以下方法：

方法	描述
public void write(int b	将指定的字节写入此 byte 数组输出流。
public void write(byte[] b,int off,int len)	将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此 byte 数组输出流。
public void writeTo(OutputStream out)	将此 byte 数组输出流的全部内容写入到指定的输出流参数中，这与使用 out.write(buf, 0, count) 调用该输出流的 write 方法效果一样。
public void reset()	用于将字节数组输出流的计数字段重置为零值。
public void close()	用于关闭ByteArrayOutputStream。
public byte[] toByteArray()	建一个新分配的 byte 数组。其大小是此输出流的当前大小，并且缓冲区的有效内容已复制到该数组中。
public int size()	返回缓冲区的当前大小。
public String toString()	使用平台默认的字符集，通过解码字节将缓冲区内容转换为字符串。
public String toString(String charsetName)	使用指定的 charsetName，通过解码字节将缓冲区内容转换为字符串。新 String 的长度是字符集的函数，因此可能不等于缓冲区的大小。

4、ByteArrayOutputStream例子

​   现在我们将字符A就是字节数为65写入两个文件中，分别是test1和test2中：

package com.demo3;

import java.io.ByteArrayOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteArrayOutputStreamTest01 {
    public static void main(String[] args) {
        // 将公共数据写入两个文件中
        FileOutputStream fos1=null;
        FileOutputStream fos2=null;
        ByteArrayOutputStream bos=null;
        try {
            fos1 = new FileOutputStream("test1.txt");
            fos2 = new FileOutputStream("test2.txt");
            bos = new ByteArrayOutputStream();
        //将字节写入文件中
            bos.write(65);
            bos.writeTo(fos1);
            bos.writeTo(fos2);
            System.out.println("写入成功");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                bos.close();
                fos2.close();
                fos1.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

结果：

5、ByteArrayInputStream是什么？

  ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。

​   ByteArrayInputStream由两个词组成：ByteArray和InputStream。顾名思义，它可用于读取字节数组作为输入流。

  Java ByteArrayInputStream 类包含一个内部缓冲区，该缓冲区用于读取字节数组作为流。在此流中，从字节数组中读取数据。

  ByteArrayInputStream的缓冲区根据数据自动增长。

6、ByteArrayInputStream的构造方法

​   通过JDK我们查看以下构造方法：

方法	描述
public ByteArrayInputStream(byte[] buf)	创建一个新的字节数组输入流，该输入流使用buf作为其缓冲区数组。
public ByteArrayInputStream(byte[] buf, int offset,int length)	创建一个新的字节数组输入流，该输入流使用buf作为其缓冲区数组，该数组可以从数组中读取指定的len字节数据。

7、ByteArrayInputStream的方法

方法	描述
public int read()	从此输入流中读取下一个数据字节。返回一个 0 到 255 范围内的 int 字节值。 如果因为到达流末尾而没有可用的字节，则返回值 -1。
public int read(byte[] b, int off,int len)	将最多 len 个数据字节从此输入流读入 byte 数组。
public long skip(long n)	用于从输入流中跳过n个输入字节。
public int available()	返回可从此输入流读取（或跳过）的剩余字节数。
public boolean markSupported()	测试此 InputStream 是否支持 mark/reset。 ByteArrayInputStream 的 markSupported 方法始终返回 true。
public void mark(int readAheadLimit)	用于设置流中的当前标记位置。
public void reset()	将缓冲区的位置重置为标记位置。
public void close()	关闭 ByteArrayInputStream 无效。

8、ByteArrayInputStream例子

​ 读取字节数组作为输入流：

package com.demo03;

import java.io.ByteArrayInputStream;

public class ByteArrayInputStreamTest01 {
    public static void main(String[] args) {
        //创建字节数组
        byte b[]={74, 97,118,97};
        ByteArrayInputStream bis = new ByteArrayInputStream(b);
        //创建新的字节输入流
        int len;
        while ((len = bis.read()) != -1) {
            System.out.print((char)len);
        }
    }
}

结果：

五、DataOutputStream和DataInputStream

1、DataOutputStream是什么？

  数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

2、DataOutputStream的构造方法？

  通过JDK我们可以得知只有一个构造方法：

方法	描述
public DataOutputStream(OutputStream out)	创建一个新的数据输出流，将数据写入指定基础输出流。

3、DataOutputStream的方法？

  通过JDK我们可以得到以下方法：

方法	描述
public void write(int b)	将指定字节（参数 b 的八个低位）写入基础输出流。
public void write(byte[] b,int off,int len)	将指定 byte 数组中从偏移量 off 开始的 len 个字节写入基础输出流。
public void flush()	清空此数据输出流。这迫使所有缓冲的输出字节被写出到流中。
public final void writeBoolean(boolean v)	一个 boolean 值以 1-byte 值形式写入基础输出流。值 true 以值 (byte)1 的形式被写出；值 false 以值 (byte)0 的形式被写出。
public final void writeByte(int v)	一个 byte 值以 1-byte 值形式写出到基础输出流中。
public final void writeShort(int v)	将一个 short 值以 2-byte 值形式写入基础输出流中，先写入高字节。
public final void writeChar(int v)	将一个 char 值以 2-byte 值形式写入基础输出流中，先写入高字节。
public final void writeInt(int v)	将一个 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。
public final void writeLong(long v)	将一个 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。
public final void writeFloat(float v)	使用 Float 类中的 floatToIntBits 方法将 float 参数转换为一个 int 值，然后将该 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。如果没有抛出异常，则计数器 written 增加 4。
public final void writeDouble(double v)	使用 Double 类中的 doubleToLongBits 方法将 double 参数转换为一个 long 值，然后将该 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。
public final void writeBytes(String s)	将字符串按字节顺序写出到基础输出流中。按顺序写出字符串中每个字符，丢弃其八个高位。
public final void writeChars(String s)	将字符串按字符顺序写入基础输出流。通过 writeChar 方法将每个字符写入数据输出流。
public final void writeUTF(String str)	以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。
public final int size()	返回计数器 written 的当前值，即到目前为止写入此数据输出流的字节数。

  虽然方法很多，但是请不要放弃！

4、DataInputStream是什么?

  数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。

5、DataInputStream的构造方法?

  通过JDK我们可以得知只有一个构造方法：

方法	描述
public DataInputStream(InputStream in)	使用指定的底层 InputStream 创建一个 DataInputStream。

6、DataInputStream的方法?

  通过JDK我们可以响应的方法：

方法	描述
public final int read(byte[] b)	从包含的输入流中读取一定数量的字节，并将它们存储到缓冲区数组 b 中。以整数形式返回实际读取的字节数。
public final int read(byte[] b,int off,int len)	从包含的输入流中将最多 len 个字节读入一个 byte 数组中。尽量读取 len 个字节，但读取的字节数可能少于 len 个，也可能为零。
public final void readFully(byte[] b)	用于从输入流中读取字节并将其存储到缓冲区数组中。
public final void readFully(byte[] b, int off, int len)	用于从输入流中读取len个字节。
public final int skipBytes(int n)	用于跳过输入流中x个字节的数据。
public final boolean readBoolean()	用于读取一个输入字节，如果字节不为零，则返回true，如果字节为零，则返回false。
public final byte readByte()	用于读取和返回一个输入字节。
public final int readUnsignedByte()	用于读取一个输入字节，将其零扩展以键入int类型，然后返回结果，因此其范围为0到255。
public final short readShort()	用于读取两个输入字节并返回一个short值。
public final int readUnsignedShort()	用于读取两个输入字节，并返回一个介于0到65535之间的int值。
public final char readChar()	用于读取两个输入字节并返回一个char值。
public final int readInt()	用于读取输入字节并返回int值。
public final long readLong()	用于读取八个输入字节，并返回一个long值。
public final float readFloat()	用于读取四个输入字节并返回一个浮点值。
public final double readDouble()	用于读取八个输入字节并返回一个双精度值。
public final String readUTF()	用于读取使用UTF-8格式编码的字符串。
public static final String readUTF(DataInput in)	从流 in 中读取用 UTF-8 修改版格式编码的 Unicode 字符格式的字符串；然后以 String 形式返回此字符串。UTF-8 修改版表示形式的一些细节与 DataInput 的 readUTF 方法完全相同。

7、案例实操

  这里只举例一个writerChar()例子：

package com.demo04;

import java.io.*;

public class DataOutputStreamTest {
    public static void main(String[] args) throws Exception {
        InputStream is = null;
        DataInputStream dis = null;
        FileOutputStream fos = null;
        DataOutputStream dos = null;
        byte b[]={74,97,118,97};

        try {
            //创建文件输出流
            fos = new FileOutputStream("test1.txt");
            //创建数据输出流
            dos = new DataOutputStream(fos);
            // 将字符写入DOS
            for (byte bs : b) {
                dos.writeChar(bs);
            }
            //写入缓冲流
            dos.flush();
            System.out.println("写入成功");
            //创建文件输入流
            is = new FileInputStream("test1.txt");
            //创建数据输入流
            dis = new DataInputStream(is);
            //读到流的末尾
            while (dis.available()>0){
                // 将字节转换成字符且输出到控制台
                char c=dis.readChar();
                System.out.print(c);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(dis!=null)
                dis.close();
            if(is!=null)
                is.close();
            if (dos!=null){
                dos.close();
            }
            if (fos!=null){
                fos.close();
            }
        }
    }
}

结果:

二、 第二部分-----字符流

  在Java中，根据处理的数据单位不同，分为字节流和字符流。
  所有的读操作都继承自一个公共超类java.io.Reader类。所有的写操作都继承自一个公共超类java.io.Writer类，Reader和Writer是抽象类。

一、Writer和Reader

1、Writer是什么？

  Java Writer 用于写入字符流的抽象类，子类必须实现的方法是write(char[],int,int)，flush() 和close()。

2、Writer的层次结构

3、Writer的方法

  通过JDK我们可以得知有以下方法:

public Writer append(char c)	将指定字符添加到此 writer。 以 out.append© 的形式调用此方法，行为与以下调用完全相同： out.write©
public abstract void flush()	刷新该流的缓冲。
public abstract void close()	关闭此流，但要先刷新它。
public Writer append(CharSequence csq,int start, int end)	将指定字符序列的子序列添加到此 writer.Appendable。
public Writer append(CharSequence csq)	将指定字符序列添加到此 writer。
public void write(String str,int off,int len)	写入字符串的某一部分。
public void write(String str)	写入字符串。
public abstract void write(char[] cbuf,int off, int len)	写入字符数组的某一部分。
public void write(char[] cbuf)	写入字符数组。
public void write(int c)	写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。

4、Reader是什么？

  用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。

5、Reader的层次结构

6、Reader的方法

  通过JDK我们可以得知有以下方法:

方法	描述
public int read(CharBuffer target)	试图将字符读入指定的字符缓冲区。
public int read()	读取单个字符。在字符可用、发生 I/O 错误或者已到达流的末尾前，此方法一直阻塞。
public int read(char[] cbuf)	将字符读入数组。
public abstract int read(char[] cbuf, int off, int len)	将字符读入数组的某一部分。
public long skip(long n)	跳过字符。在某个字符可用、发生 I/O 错误或者已到达流的末尾前，此方法一直阻塞。
public boolean ready()	public boolean ready()
public boolean markSupported()	判断此流是否支持 mark() 操作。默认实现始终返回 false。子类应重写此方法。
public void mark(int readAheadLimit)	标记流中的当前位置。
public void reset()	重置该流。
public abstract void close()	关闭该流并释放与之关联的所有资源。

二、FileWriter和FileReader

1、FileWriter是什么？

  用来写入字符文件的便捷类，与FileOutputStream类不同，不需要将字符串转换为字节数组，因为它提供了直接写入字符串的方法。

2、FileWriter的构造方法

  通过JDK我们可以查看以下构造方法：

构造方法	描述
public FileWriter(String fileName)	根据给定的文件名构造一个 FileWriter 对象。
public FileWriter(String fileName,boolean append)	根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。
public FileWriter(File file)	根据给定的 File 对象构造一个 FileWriter 对象。
public FileWriter(File file,boolean append)	根据给定的 File 对象构造一个 FileWriter 对象。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。

3、FileWriter的方法

  从类 java.io.OutputStreamWriter 继承的方法 ：

方法	描述
public void write(int c)	写入单个字符。
public void write(char[] cbuf, int off, int len)	写入字符数组的某一部分。
public void write(String str,int off,int len)	写入字符串的某一部分。
public void flush()	刷新该流的缓冲。
public void close()	关闭此流，但要先刷新它。

4、FileWriter例子

package com.demo05;

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

public class WriteTest {
    public static void main(String[] args) {
        FileWriter fw=null;
        char c[] = {'J','a','v',97};
        int num=65;
        try {
            fw = new FileWriter("test3.txt");
           
            // 写一个字符串
            String str="写入字符流的抽象类\n";
           
            //写入字符串的一部分,off代表下标位置，len代表要写入的字符串长度，并且包含尾。
            fw.write(str);
           
            //写一个字符
            fw.write(num);
           
            //写一个部分字符串
            fw.write(str,2,8);
            
            //写入一个字符数组
            fw.write(c);
           
            // 写入一部分数组
            fw.write(c,2,2);
            fw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(fw !=null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

结果：

5、FileReader是什么？

  用来读取字符文件的便捷类。

6、FileReader的构造方法

  通过JDK我们可以的得知以下构造方法：

方法	描述
public FileReader(String fileName)	在给定从中读取数据的文件名的情况下创建一个新 FileReader。
public FileReader(File file)	在给定从中读取数据的 File 的情况下创建一个新 FileReader

7、FileRead的方法

  从类 java.io.InputStreamWriter 继承的方法 ：

方法	描述
public int read()	读取单个字符。
public int read(char[] cbuf)	将字符读入数组。。
public abstract int read(char[] cbuf,int off, int len)	将字符读入数组的某一部分。
public abstract void close()	关闭该流并释放与之关联的所有资源。

8、FileRead的例子

package com.demo05;

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

public class ReadTest {
    public static void main(String[] args) {
        FileReader fr=null;
        try {
            fr  = new FileReader("test3.txt");
            int read = fr.read();
            while (read!=-1){
                System.out.print((char)read);
                read= fr.read();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

结果：

三、BufferedWriter和BufferedReader

1、BufferedWriter是什么？

  将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。它使性能更快继承了Writer类。

2、BufferedWriter的构造方法

  通过JDK我们可以的得知以下构造方法：

构造方法	描述
public BufferedWriter(Writer out)	创建一个使用默认大小输出缓冲区的缓冲字符输出流。
public BufferedWriter(Writer out)	创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

3、BufferedWriter的方法

  通过JDK我们可以的得知以下方法：

方法	描述
public void write(int c)	写入单个字符。
public void write(char[] cbuf,int off,int len)	写入字符数组的某一部分。
public void write(String s, int off,int len)	写入字符串的某一部分。
public void newLine()	写入一个行分隔符。
public void flush()	刷新该流的缓冲。
public void close()	关闭此流，但要先刷新它。在

4、BufferedWriter例子

  我们通过写入单个字符、字符串、字符数组举例：

package com.demo06;

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

public class BufferedWriterTest {
    public static void main(String[] args) {
        FileWriter fw=null;
        BufferedWriter bw=null;
        String str = "I love java";
        int c = 97;
        char cr[]={'j','a','v','a'};
        try {
            fw = new FileWriter("test3.txt");
            bw = new BufferedWriter(fw);
            //写入字符串
            bw.write(str,0,str.length());
           
            //写入一个行分隔符
            bw.newLine();
           
            //写入单个字符
            bw.write(c);
            
             //写入一个行分隔符
            bw.newLine();
           
            //写入字符数组
            bw.write(cr);
            bw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源
            if(bw!=null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fw!=null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

结果：

5、BufferedReader是什么?

  从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取，通过readLine() 方法逐行读取数据。它使性能更快。它继承了Reader类。

6、BufferedReader的构造方法

  通过JDK我们可以的得知以下构造方法：

构造方法	描述
public BufferedReader(Reader in)	创建一个使用默认大小输入缓冲区的缓冲字符输入流。
public BufferedReader(Reader in,int sz)	创建一个使用指定大小输入缓冲区的缓冲字符输入流。

7、BufferedReader的方法

  通过JDK我们可以的得知以造方法：

方法	描述
public int read()	读取单个字符。
public int read(char[] cbuf,int off, int len)	将字符读入数组的某一部分。
public String readLine()	读取一个文本行。
public long skip(long n)	跳过字符。
public boolean ready()	判断此流是否已准备好被读取。
public boolean markSupported()	判断此流是否支持 mark() 操作（它一定支持）。
public void mark(int readAheadLimit)	标记流中的当前位置。对 reset() 的后续调用将尝试将该流重新定位到此点。
public void reset()	将流重置到最新的标记。
public void close()	关闭该流并释放与之关联的所有资源。

8、BufferedReader例子

  我们将BufferedWriter写入的数据读出来：

package com.demo06;

import java.io.*;

public class BufferedReaderTest {
    public static void main(String[] args) {
        FileReader fr=null;
        BufferedReader br=null;
        String str = null;
        try {
            fr = new FileReader("test3.txt");
            br = new BufferedReader(fr);
            //读取数据的一种方式
            /*
            int len;
            while ((len = br.read())!=-1){
                System.out.print((char) len);
            }
            */

            //读取数据的第二种方式，readline() 用于读取一行文本。
            while((str = br.readLine())!= null){
                System.out.println(str);
          }

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
        //关闭资源
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

四、CharArrarWriter和CharArrayReader

1、CharArrarWriter是什么？

  此类实现一个可用作 Writer 的字符缓冲区。缓冲区会随向流中写入数据而自动增长。

2、CharArrarWriter的构造方法

  通过JDK我们可以找到以下构造方法：

构造方法	描述
public CharArrayWriter()	创建一个新的 CharArrayWriter。
public CharArrayWriter(int initialSize)	创建一个具有指定初始大小的新 CharArrayWriter。

3、CharArrarWriter的方法

  通过JDK我们可以找到以下方法：

方法	描述
public void write(int c)	public void write(int c)
public void write(char[] c,int off,int len)	public void write(char[] c, int off, int len)
public void write(String str,int off,int len)	将字符串的某一部分写入缓冲区
public void writeTo(Writer out)	将缓冲区的内容写入另一个字符流。
public CharArrayWriter append(CharSequence csq)	将指定的字符序列添加到此 writer。
public CharArrayWriter append(CharSequence csq, int start, int end)	将指定字符序列的子序列添加到此 writer。
public CharArrayWriter append(char c)	将指定字符添加到此 writer。
public void reset()	重置该缓冲区，以便再次使用它而无需丢弃已分配的缓冲区。
public int size()	返回缓冲区的当前大小
public String toString()	将输入数据转换为字符串。
public void flush()	刷新该流的缓冲。
public void close()	关闭该流。

4、CharArrarWriter例子

  我们向两个文件写入数据：

package com.demo07;

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

public class CharArrayWriterTest {
    public static void main(String[] args) {
        FileWriter fw1 = null;
        FileWriter fw2 = null;
        java.io.CharArrayWriter caw = null;
        String str = "Java";
        int a=1;
        try {
            fw1 = new FileWriter("test2.txt");
            fw2 = new FileWriter("test3.txt");
            caw = new java.io.CharArrayWriter();
            caw.write(str);
            caw.writeTo(fw1);
            caw.writeTo(fw2);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (caw != null) {
                caw.close();
            }
            if (fw1 != null) {
                try {
                    fw2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (fw1 != null) {
                    try {
                        fw1.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

结果:

5、CharArrayReader是什么？

  此类实现一个可用作字符输入流的字符缓冲区。

6、CharArrayReader的构造方法

  通过JDK我们可以找到以下构造方法：

构造方法	描述
public CharArrayReader(char[] buf)	根据指定的 char 数组创建一个 CharArrayReader
public CharArrayReader(char[] buf,int offset,int length)	根据指定的 char 数组创建一个 CharArrayReader。 得到的 reader 将从给定的 offset 处开始读取。****

7、CharArrayReader的方法

方法	描述
public int read()	读取单个字符。
public int read(char[] b, int off, int len)	将字符读入数组的某一部分。
public long skip(long n)	跳过字符。返回跳过的字符数。
public boolean ready()	判断此流是否已准备好被读取。
public boolean markSupported()	判断此流是否支持 mark() 操作（它一定支持）。
public void mark(int readAheadLimit)	标记流中的当前位置。
public void reset()	将该流重置为最新的标记，如果从未标记过，则将其重置到开头。
public void close()	关闭该流并释放与之关联的所有系统资源。

8、CharArrayReader例子

package com.demo07;

import java.io.IOException;
import java.io.CharArrayReader;

public class CharArrayReaderTest {
    public static void main(String[] args) {
        CharArrayReader car=null;
        char[] c={'J','a','v','a'};

        try {
            // 创建新的字符数组读取器
            car = new CharArrayReader(c);
            int len=0;
            // 读取文件末尾
            while ((len = car.read())!= -1) {
                char cs = (char) len;
                System.out.print(cs+": ");
                System.out.println(len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭流，释放资源
            if(car!=null){
                car.close();
            }
        }

    }
}

结果:

五、OutStreamWriter和InputtStreamWriter

1、OutStreamWriter是什么？

  OutputStreamWriter 是字符流通向字节流的桥梁，可使用指定的 charset 将要写入流中的字符编码成字节。
  为了获得最高效率，可考虑将 OutputStreamWriter 包装到 BufferedWriter 中，以避免频繁调用转换器。例如：

 Writer out = new BufferedWriter(new OutputStreamWriter(System.out));

2、OutStreamWriter的构造方法？

  通过JDK我们可以找到以下构造方法：

构造方法	描述
public OutputStreamWriter(OutputStream out,String charsetName)	创建使用指定字符集的 OutputStreamWriter。
public OutputStreamWriter(OutputStream out)	创建使用默认字符编码的 OutputStreamWriter。
public OutputStreamWriter(OutputStream out,Charset cs)	创建使用给定字符集的 OutputStreamWriter。
public OutputStreamWriter(OutputStream out, CharsetEncoder enc)	创建使用给定字符集编码器的 OutputStreamWriter。

3、OutStreamWriter的方法？

  通过JDK我们可以找到以下方法：

方法	描述
public String getEncoding()	返回此流使用的字符编码的名称。
public void write(int c)	写入单个字符。
public void write(char[] cbuf, int off, int len)	写入字符数组的某一部分。
public void write(String str, int off, int len)	写入字符串的某一部分。
public void flush()	刷新该流的缓冲。
public void close()	关闭此流，但要先刷新它。

4、OutStreamWriter例子

package com.demo08;

import java.io.*;

public class OutStreamWriterTest {
    public static void main(String[] args) {
        OutputStream fos = null;
        Writer osw = null;
        String str="Java";
        try {
            fos = new FileOutputStream("test3.txt");
            osw = new OutputStreamWriter(fos);
            //写入字符串
            osw.write(str);
            osw.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(osw!=null){
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

结果：

5、InputStreamWriter是什么？

&emps; InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。

6、InputStreamWriter的构造方法

  通过JDK我们可以找到以下构造方法：

构造方法	描述
public InputStreamReader(InputStream in)	创建一个使用默认字符集的 InputStreamReader。
public InputStreamReader(InputStream in,String charsetName)	创建使用指定字符集的 InputStreamReader。
public InputStreamReader(InputStream in,Charset cs)	创建使用给定字符集的 InputStreamReader。
public InputStreamReader(InputStream in, CharsetDecoder dec)	创建使用给定字符集解码器的 InputStreamReader。

7、InputStreamWriter方法

  通过JDK我们可以找到以下方法：

方法	描述
public String getEncoding()	返回此流使用的字符编码的名称。
public int read()	读取单个字符。
public int read(char[] cbuf,int offset,int length)	将字符读入数组中的某一部分。
public boolean ready()	判断此流是否已经准备好用于读取。
public void close()	关闭该流并释放与之关联的所有资源。

8、InputStreamWriter例子

  我们把上述写进test3.txt中的数据读出来：

package com.demo08;

import java.io.*;

public class InputStreamReaderTest {
    public static void main(String[] args) {
        InputStream fis = null;
        Reader  inr= null;
        try {
            fis = new FileInputStream("test3.txt");
            inr = new InputStreamReader(fis);
            int len=0;
            while ((len = inr.read()) != -1) {
                System.out.print((char)len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {

            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

结果：