认识流
IO 流总览
字符流
- Writer：字符输出流
- Reader：字符输入流
  - FileReader
    - FileReader 的构造方法
    - FileReader 的具体使用
  - BufferedReader
字节流
- InputStream 字节输入流
  - FileInputStream
- OutputStream 字节输出流
  - FileOutPutStream
File

参考：

https://www.cnblogs.com/wugongzi/p/12092326.html
https://baijiahao.baidu.com/s?id=1659851047751244423&wfr=spider&for=pc
JAVA基础知识之CharArrayWriter流 https://blog.csdn.net/ai_bao_zi/article/details/81334798
认识流
几乎所有的程序都离不开信息的输入和输出，比如从键盘读取数据，从文件中获取或者向文件中存入数据，在显示器上显示数据。这些情况下都会涉及有关输入/输出的处理。

在Java中，把这些不同类型的输入、输出源抽象为流（Stream），其中输入或输出的数据称为数据流（Data Stream），用统一的接口来表示。

IO流的分类

数据流是指一组有顺序的、有起点和终点的字节集合。

输入流与输出流

按照流的流向分，可以分为输入流和输出流。注意：这里的输入、输出是针对程序来说的。
输出：把程序(内存)中的内容输出到磁盘、光盘、显示器等设备中。
输入：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。

字节流与字符流

按处理数据单位不同分为字节流和字符流。
字节流：每次读取(写出)一个字节，当传输的资源文件有中文时，就会出现乱码。
字符流：每次读取(写出)两个字节，有中文时，使用该流就可以正确传输显示中文。

1字符 = 2字节； 1字节(byte) = 8位(bit)；一个汉字占两个字节长度。

节点流与处理流

按照流的角色划分为节点流和处理流。
节点流：从或向一个特定的地方（节点）读写数据。如FileInputStream。
处理流（包装流）：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。

注意：一个IO流可以既是输入流又是字节流又或是以其他方式分类的流类型，是不冲突的。比如FileInputStream，它既是输入流又是字节流还是文件节点流。

字节流与字符流的区别

字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的；而字符流在操作时使用了缓冲区，通过缓冲区再操作文件。

字节流与字符流的使用场景

字节流一般用来处理图像，视频，以及PPT，Word类型的文件。字符流一般用于处理纯文本类型的文件，如TXT文件等。字节流可以用来处理纯文本文件，但是字符流不能用于处理图像视频等非文本类型的文件。

IO 流总览

Java IO 流有4个抽象基类：

	字节流	字符流
输入流	InputStream 字节输入流	Reader 字符输入流
输出流	OutputStream 字节输出流	Writer 字符输出流

其他流都是继承于这四大基类的。下图是Java IO 流的整体架构图：

Java IO流总结 - 图3

字符流

Writer：字符输出流

Java IO流总结 - 图4

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，这个类是可以用于操作文件的。

FileWriter

FileWriter 的构造方法

public class FileWriter extends OutputStreamWriter {
    /**
     * Constructs a FileWriter object given a file name.
     *
     * @param fileName  String The system-dependent filename.
     * @throws IOException  if the named file exists but is a directory rather
     *                  than a regular file, does not exist but cannot be
     *                  created, or cannot be opened for any other reason
     */
    public FileWriter(String fileName) throws IOException {
        super(new FileOutputStream(fileName));
    }
    /**
     * Constructs a FileWriter object given a file name with a boolean
     * indicating whether or not to append the data written.
     *
     * @param fileName  String The system-dependent filename.
     * @param append    boolean if <code>true</code>, then data will be written
     *                  to the end of the file rather than the beginning.
     * @throws IOException  if the named file exists but is a directory rather
     *                  than a regular file, does not exist but cannot be
     *                  created, or cannot be opened for any other reason
     */
    public FileWriter(String fileName, boolean append) throws IOException {
        super(new FileOutputStream(fileName, append));
    }
    /**
     * Constructs a FileWriter object given a File object.
     *
     * @param file  a File object to write to.
     * @throws IOException  if the file exists but is a directory rather than
     *                  a regular file, does not exist but cannot be created,
     *                  or cannot be opened for any other reason
     */
    public FileWriter(File file) throws IOException {
        super(new FileOutputStream(file));
    }
    /**
     * Constructs a FileWriter object given a File object. If the second
     * argument is <code>true</code>, then bytes will be written to the end
     * of the file rather than the beginning.
     *
     * @param file  a File object to write to
     * @param     append    if <code>true</code>, then bytes will be written
     *                      to the end of the file rather than the beginning
     * @throws IOException  if the file exists but is a directory rather than
     *                  a regular file, does not exist but cannot be created,
     *                  or cannot be opened for any other reason
     * @since 1.4
     */
    public FileWriter(File file, boolean append) throws IOException {
        super(new FileOutputStream(file, append));
    }
    /**
     * Constructs a FileWriter object associated with a file descriptor.
     *
     * @param fd  FileDescriptor object to write to.
     */
    public FileWriter(FileDescriptor fd) {
        super(new FileOutputStream(fd));
    }
}

FileWriter 的方法列表

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); //写一个字符串的一部分。

FileWriter 方法使用

例 1：创建一个文件 demo.txt，然后向里面写入字符串 abcde

package com.hanliukui.example;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo {
    public static void main(String[] args) {
        FileWriter fileWriter = null;
        try {
            //(1) 创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。
            //(2) 而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
            //(3) 如果不存在，会创建一个新文件。
            //(4) 第二个参数为true时，表示追加写入，默认false
            fileWriter = new FileWriter("D://111.txt",true);
            // 获取流使用的编码格式
            String encoding = fileWriter.getEncoding();
            System.out.println("此FileWriter使用的编码格式是："+encoding);
            // 写入字符串
            fileWriter.write("1111111111");
            fileWriter.flush();
            // 写入字符
            fileWriter.write('c');
            fileWriter.flush();
            // 写入字符数组
            fileWriter.write(new char[]{'1','2','3','4'});
            fileWriter.flush();
            // 写入字符串子串
            fileWriter.write("0123456789",1,6);
            fileWriter.flush();
            // 写入字符数组子数组
            fileWriter.write(new char[]{'1','2','3','4','5','6','7','8','9'},1,6);
            // 刷新缓存区
            // 刷新流对象中的缓冲中的数据。
            // 将数据刷到目的地中
            fileWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (fileWriter!=null) {
                    // 关闭流，但是关闭之前会刷新一次内部的缓冲中的数据。
                    // 将数据刷到目的地中。
                    // 和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
                    fileWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

BufferedWriter

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

BufferedWriter 的构造方法

private static int defaultCharBufferSize = 8192;
// 创建使用默认大小的输出缓冲区的缓冲字符输出流。
public BufferedWriter(Writer out) {
    this(out, defaultCharBufferSize);
}  
// 创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。
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 的方法使用

package com.hanliukui.example.charstream.writer;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriterDemo {
    public static void main(String[] args) {
        FileWriter fileWriter = null;
        BufferedWriter bufferedWriter = null;
        try {
            fileWriter = new FileWriter("D://111.txt");
            // 为了提高字符写入流效率。加入了缓冲技术。
            bufferedWriter = new BufferedWriter(fileWriter);
            char[] c={'a','b','c','d','e'};
            bufferedWriter.append("f");
            bufferedWriter.write(c);
            bufferedWriter.flush();
            bufferedWriter.newLine();
            bufferedWriter.flush();
            bufferedWriter.append("123456789");
            bufferedWriter.flush();
        } catch (IOException exception) {
            exception.printStackTrace();
        }finally {
            if (fileWriter!=null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedWriter!=null){
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

CharArrayWriter

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

该类实现了一个可用作字符输出流的字符缓冲区，当数据写入流时，缓冲区自动增长，请注意在此类上调用close（）无效，并且可以在流关闭后调用此类的方法而不生成IOException。

CharArrayWriter 的构造函数

public class CharArrayWriter extends Writer {
   /**
     * The buffer where data is stored.
     */
    protected char buf[];
    /**
     * The number of chars in the buffer.
     * 这里count = 0, 基本数据类型 int 默认值0
     */
    protected int count;   
    /**
     * 创造默认缓冲区大小的CharArrayWriter对象
     */
    public CharArrayWriter() {
        this(32);
    }
    /**
     *  创造指定缓冲区大小的CharArrayWriter对象
     */
    public CharArrayWriter(int initialSize) {
        if (initialSize < 0) {
            throw new IllegalArgumentException("Negative initial size: "
                                               + initialSize);
        }
        buf = new char[initialSize];
    }
    ......
}

CharArrayWriter 的方法列表

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); 将缓冲区的内容写入另一个字符流。

写一个字符到缓存区 void write(int c)

 /**
  * Writes a character to the buffer.
  */
 public void write(int c) {
     // 加锁
     synchronized (lock) {
         int newcount = count + 1;
         // 判定写入的下个元素是否超出缓冲区长度
         if (newcount > buf.length) {
             // 进行扩容
             buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount));
         }
         buf[count] = (char)c;
         count = newcount;
     }
 }

从字符数组中写len个字符到缓冲区中

/**
  * 将字符数组的一部分写入到缓冲区中，自动扩容增长
  */
 public void write(char c[], int off, int len) {
     if ((off < 0) || (off > c.length) || (len < 0) ||
         ((off + len) > c.length) || ((off + len) < 0)) {
         throw new IndexOutOfBoundsException();
     } else if (len == 0) {
         return;
     }
     synchronized (lock) {
         int newcount = count + len;
         //判定缓冲区写入len个字符后长度是否超出限制
         if (newcount > buf.length) {
             buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount));
         }
         System.arraycopy(c, off, buf, count, len);
         count = newcount;
     }
 }

将字符串的一部分写入缓存区 ```java

/**
- Write a portion of a string to the buffer.
- @param str String to be written from
- @param off Offset from which to start reading characters
- @param len Number of characters to be written */ public void write(String str, int off, int len) { synchronized (lock) {
```
 int newcount = count + len;
 // 判断是否需要扩容
 if (newcount > buf.length) {
     buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount));
 }
 str.getChars(off, off + len, buf, count);
 count = newcount;
```
  } }


4. 将缓存中的内容写入到另一个字符流中
```java
    /**
     * Writes the contents of the buffer to another character stream.
     *
     * @param out       the output stream to write to
     * @throws IOException If an I/O error occurs.
     */
    public void writeTo(Writ
    er out) throws IOException {
        synchronized (lock) 
            //本质理解为将缓冲区的内容给写了出去，给了另外一个输出流
            out.write(buf, 0, count);
        }
    }

/**
     * 将缓冲区中的数据转成字符串
     * @return the string.
     */
    public String toString() {
        synchronized (lock) {
            return new String(buf, 0, count);
        }
    }
    /**
     * 将缓冲区的数据转成字符数组
     */
    public char[] toCharArray()[] {
        synchronized (lock) {
            return Arrays.copyOf(buf, count);
        }
    }

  /**
     * 刷新流--无效
     */
    public void flush() { }
    /**
      *  关闭流--无效
     */
    public void close() { }

FilterWriter

FilterWriter 是字符类型的过滤输出流。

1、FilterWriter 的构造函数：

protected  FilterWriter(Writer out) 创建一个新的过滤的作者。

2、FilterWriter 的方法列表：

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

PrintWriter

PrintWriter 是字符类型的打印输出流，它继承于 Writer。
1、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，而不需要自动线路刷新。

2、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) 写一个字符串的一部分。

Reader：字符输入流

Java IO流总结 - 图5

有输出流那么当然就有输入流，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 read() 告诉这个流是否准备好被读取。 
void reset() 重置流。 
long skip(long n) 跳过字符

FileReader

FileReader 的构造方法

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

FileReader 的具体使用

例 1：

import java.io.*;
class  FileReaderDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个文件读取流对象，和指定名称的文件相关联。
        //要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
        FileReader fr = new FileReader("demo.txt");
        //调用读取流对象的read方法。
        //read():一次读一个字符。而且会自动往下读。
        int ch = 0;
        while((ch=fr.read())!=-1)
        {
            System.out.println("ch="+(char)ch);
        }
        //关闭流
        fr.close();
    }
}

例 2：

/*
第二种方式：通过字符数组进行读取。
*/
import java.io.*;
class FileReaderDemo2
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr = new FileReader("demo.txt");
        //定义一个字符数组。用于存储读到字符。
        //该read(char[])返回的是读到字符个数。
        char[] buf = new char[1024];
        int num = 0;
        while((num=fr.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,num));
        }
        fr.close();
    }
}

BufferedReader

BufferedReader 的构造方法

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

BufferedReader 的方法列表

void close() 关闭流并释放与之相关联的任何系统资源。 
Stream 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 的具体使用：

例 1：

/*
字符读取流缓冲区：
该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。
当返回null时，表示读到文件末尾。
readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。
*/
import java.io.*;
class  BufferedReaderDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个读取流对象和文件相关联。
        FileReader fr = new FileReader("buf.txt");
        //为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。
        BufferedReader bufr = new BufferedReader(fr);
        String line = null;
        while((line=bufr.readLine())!=null)
        {
            System.out.print(line);
        }
　　　　　　　　　 //关闭流
        bufr.close();
    }
}

例 2：通过缓冲区复制文件：

/*
通过缓冲区复制一个.java文件。
*/
import java.io.*;
class  CopyTextByBuf
{
    public static void main(String[] args)
    {
        BufferedReader bufr = null;
        BufferedWriter bufw = null;
        try
        {
            bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));
            bufw = new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));
            String line = null;
            while((line=bufr.readLine())!=null)
            {
                bufw.write(line);
                bufw.newLine();
                bufw.flush();
            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("读写失败");
        }
        finally
        {
            try
            {
                if(bufr!=null)
                    bufr.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException("读取关闭失败");
            }
            try
            {
                if(bufw!=null)
                    bufw.close();
            }
            catch (IOException e)
            {
                throw new RuntimeException("写入关闭失败");
            }
        }
    }
}

字节流

字节流的基本操作和字符流类相同，但它不仅可以操作字符，还可以操作其他媒体文件

InputStream 字节输入流

InputStream 类是字节输入流的抽象类，是所有字节输入流的父类，InputStream 类具有层次结构如下图所示：

Java IO流总结 - 图6

InputStream 的常用方法：

int available() 从下一次调用此输入流的方法返回可从该输入流读取（或跳过）的字节数，而不会阻塞。 
void close() 关闭此输入流并释放与流相关联的任何系统资源。 
void mark(int readlimit) 标记此输入流中的当前位置。 
boolean markSupported() 测试此输入流是否支持 mark和 reset方法。 
abstract int read() 从输入流读取数据的下一个字节。 
int read(byte[] b) 从输入流中读取一些字节数，并将它们存储到缓冲器阵列 b 。 
int read(byte[] b, int off, int len) 从输入流读取最多 len个字节的数据到字节数组。 
byte[] readAllBytes() 从输入流读取所有剩余字节。 
int readNBytes(byte[] b, int off, int len) 将所请求的字节数从输入流读入给定的字节数组。 
void reset() 将此流重新定位到最后在此输入流上调用 mark方法时的位置。 
long skip(long n) 跳过并丢弃来自此输入流的 n字节的数据。 
long transferTo(OutputStream out) 从该输入流中读取所有字节，并按读取的顺序将字节写入给定的输出流。

FileInputStream

FileInputStream 的构造方法：

FileInputStream(File file) 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。 
FileInputStream(FileDescriptor fdObj) 通过使用文件描述符 fdObj创建 FileInputStream ，该文件描述符表示与文件系统中的实际文件的现有连接。 
FileInputStream(String name) 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

FileInputStream 的方法列表：

int available() 返回从此输入流中可以读取（或跳过）的剩余字节数的估计值，而不会被下一次调用此输入流的方法阻塞。 
void close() 关闭此文件输入流并释放与流相关联的任何系统资源。 
protected void finalize() 已过时。
finalize方法已被弃用。 为了执行清理而覆盖finalize子类应该修改为使用替代清理机制，并删除覆盖的finalize方法。 当覆盖finalize方法时，其实现必须明确确保按照super.finalize()所述调用super.finalize() 。 有关迁移选项的更多信息，请参阅Object.finalize()的规范。 
FileChannel getChannel() 返回与此文件输入流相关联的唯一的FileChannel对象。 
FileDescriptor getFD() 返回表示与此 FileInputStream正在使用的文件系统中的实际文件的连接的 FileDescriptor对象。 
int read() 从该输入流读取一个字节的数据。 
int read(byte[] b) 从该输入流读取最多 b.length个字节的数据到一个字节数组。 
int read(byte[] b, int off, int len) 从该输入流读取最多 len个字节的数据到字节数组。 
long skip(long n) 跳过并从输入流中丢弃 n字节的数据。

FileInputStream 的具体使用：

import java.io.*;
class  FileStream
{
    public static void main(String[] args) throws IOException
    {
        readFile_3();
    }
    //打开文件，一次读取刚刚好内容的字节
    public static void readFile_3()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");
        //available()返回从此输入流中可以读取（或跳过）的剩余字节数的估计值，而不会被下一次调用此输入流的方法阻塞。
        byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区。不用在循环了。
        fis.read(buf);java
        System.out.println(new String(buf));
        fis.close();
    }
    //打开文件，一次读取多个字节
    public static void readFile_2()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");
        byte[] buf = new byte[1024];
        int len = 0;
        while((len=fis.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,len));
        }
        fis.close();
    }
    //打开文件，一次读取一个字节
    public static void readFile_1()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");
        int ch = 0;
        while((ch=fis.read())!=-1)
        {
            System.out.println((char)ch);
        }
        fis.close();
    }
}

OutputStream 字节输出流

Java IO流总结 - 图7

OutputStream 字节输出流的方法：

void close() 关闭此输出流并释放与此流相关联的任何系统资源。 
void flush() 刷新此输出流并强制任何缓冲的输出字节被写出。 
void write(byte[] b) 将 b.length字节从指定的字节数组写入此输出流。 
void write(byte[] b, int off, int len) 从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。 
abstract void write(int b) 将指定的字节写入此输出流。

FileOutPutStream

FileOutPutStream 的构造方法：

FileOutputStream(File file) 创建文件输出流以写入由指定的 File对象表示的文件。 
FileOutputStream(FileDescriptor fdObj) 创建文件输出流以写入指定的文件描述符，表示与文件系统中实际文件的现有连接。 
FileOutputStream(File file, boolean append) 创建文件输出流以写入由指定的 File对象表示的文件。 
FileOutputStream(String name) 创建文件输出流以指定的名称写入文件。 
FileOutputStream(String name, boolean append) 创建文件输出流以指定的名称写入文件。

FileOutPutStream 的方法列表：

void close() 关闭此文件输出流并释放与此流相关联的任何系统资源。 
protected void finalize() 已过时。
finalize方法已被弃用。 为了执行清理，覆盖finalize子类应被修改为使用替代的清理机制，并删除覆盖的finalize方法。 当覆盖finalize方法时，其实现必须明确确保按照super.finalize()中所述调用super.finalize() 。 有关迁移选项的更多信息，请参阅Object.finalize()的规范。 
FileChannel getChannel() 返回与此文件输出流相关联的唯一的FileChannel对象。 
FileDescriptor getFD() 返回与此流相关联的文件描述符。 
void write(byte[] b) 将 b.length字节从指定的字节数组写入此文件输出流。 
void write(byte[] b, int off, int len) 将 len字节从指定的字节数组开始，从偏移量 off开始写入此文件输出流。 
void write(int b) 将指定的字节写入此文件输出流。

FileOutPutStream 的具体使用

import java.io.*;
public class FileStreamTest {
    private static final String FileName = "file.txt";
    public static void main(String[] args) {
        testWrite();
    }
    /**
     * FileOutputStream 演示函数
     *
     * 运行结果：
     * 在源码所在目录生成文件"file.txt"，文件内容是“abcdefghijklmnopqrstuvwxyz0123456789”
     *
     * 加入，我们将 FileOutputStream fileOut2 = new FileOutputStream(file, true);
     *       修改为 FileOutputStream fileOut2 = new FileOutputStream(file, false);
     * 然后再执行程序，“file.txt”的内容变成"0123456789"。
     * 原因是：
     * (01) FileOutputStream fileOut2 = new FileOutputStream(file, true);
     *      它是以“追加模式”将内容写入文件的。即写入的内容，追加到原始的内容之后。
     * (02) FileOutputStream fileOut2 = new FileOutputStream(file, false);
     *      它是以“新建模式”将内容写入文件的。即删除文件原始的内容之后，再重新写入。
     */
    public static void testWrite() {
        try {
            // 创建文件“file.txt”对应File对象
            File file = new File(FileName);
            // 创建文件“file.txt”对应的FileOutputStream对象，默认是关闭“追加模式”
            FileOutputStream fileOut1 = new FileOutputStream(file);
            // 创建FileOutputStream对应的PrintStream，方便操作。PrintStream的写入接口更便利
            PrintStream out1 = new PrintStream(fileOut1);
            // 向“文件中”写入26个字母
            out1.print("abcdefghijklmnopqrstuvwxyz");
            out1.close();
            // 创建文件“file.txt”对应的FileOutputStream对象，打开“追加模式”
            FileOutputStream fileOut2 = new FileOutputStream(file, true);
            // 创建FileOutputStream对应的PrintStream，方便操作。PrintStream的写入接口更便利
            PrintStream out2 = new PrintStream(fileOut2);
            // 向“文件中”写入"0123456789"+换行符
            out2.println("0123456789");
            out2.close();
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
}

File

JavaIo 流中还有一个非常常用的类：File。

File 是 “文件” 和 “目录路径名” 的抽象表示形式。
File 直接继承于 Object，实现了 Serializable 接口和 Comparable 接口。实现 Serializable 接口，意味着 File 对象支持序列化操作。而实现 Comparable 接口，意味着 File 对象之间可以比较大小；File 能直接被存储在有序集合 (如 TreeSet、TreeMap 中)。

File 的构造方法

File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例。 
File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。 
File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 File实例。 
File(URI uri) 通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。

File 的方法列表

boolean canExecute() 测试应用程序是否可以执行此抽象路径名表示的文件。 
boolean canRead() 测试应用程序是否可以读取由此抽象路径名表示的文件。 
boolean canWrite() 测试应用程序是否可以修改由此抽象路径名表示的文件。 
int compareTo(File pathname) 比较两个抽象的路径名字典。 
boolean createNewFile() 当且仅当具有该名称的文件尚不存在时，原子地创建一个由该抽象路径名命名的新的空文件。 
static File createTempFile(String prefix, String suffix) 在默认临时文件目录中创建一个空文件，使用给定的前缀和后缀生成其名称。 
static File createTempFile(String prefix, String suffix, File directory) 在指定的目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。 
boolean delete() 删除由此抽象路径名表示的文件或目录。 
void deleteOnExit() 请求在虚拟机终止时删除由此抽象路径名表示的文件或目录。 
boolean equals(Object obj) 测试此抽象路径名与给定对象的相等性。 
boolean exists() 测试此抽象路径名表示的文件或目录是否存在。 
File getAbsoluteFile() 返回此抽象路径名的绝对形式。 
String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。 
File getCanonicalFile() 返回此抽象路径名的规范形式。 
String getCanonicalPath() 返回此抽象路径名的规范路径名字符串。 
long getFreeSpace() 通过此抽象路径名返回分区 named中未分配字节的数量。 
String getName() 返回由此抽象路径名表示的文件或目录的名称。 
String getParent() 返回此抽象路径名的父目录的路径名字符串，如果此路径名未命名为父目录，则返回 null 。 
File getParentFile() 返回此抽象路径名的父目录的抽象路径名，如果此路径名不指定父目录，则返回 null 。 
String getPath() 将此抽象路径名转换为路径名字符串。 
long getTotalSpace() 通过此抽象路径名返回分区 named的大小。 
long getUsableSpace() 通过此抽象路径名返回分区 named上此虚拟机可用的字节数。 
int hashCode() 计算此抽象路径名的哈希码。 
boolean isAbsolute() 测试这个抽象路径名是否是绝对的。 
boolean isDirectory() 测试此抽象路径名表示的文件是否为目录。 
boolean isFile() 测试此抽象路径名表示的文件是否为普通文件。 
boolean isHidden() 测试此抽象路径名命名的文件是否为隐藏文件。 
long lastModified() 返回此抽象路径名表示的文件上次修改的时间。 
long length() 返回由此抽象路径名表示的文件的长度。 
String[] list() 返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录。 
String[] list(FilenameFilter filter) 返回一个字符串数组，命名由此抽象路径名表示的目录中满足指定过滤器的文件和目录。 
File[] listFiles() 返回一个抽象路径名数组，表示由该抽象路径名表示的目录中的文件。 
File[] listFiles(FileFilter filter) 返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。 
File[] listFiles(FilenameFilter filter) 返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。 
static File[] listRoots() 列出可用的文件系统根。 
boolean mkdir() 创建由此抽象路径名命名的目录。 
boolean mkdirs() 创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录。 
boolean renameTo(File dest) 重命名由此抽象路径名表示的文件。 
boolean setExecutable(boolean executable) 为此抽象路径名设置所有者的执行权限的便利方法。 
boolean setExecutable(boolean executable, boolean ownerOnly) 设置该抽象路径名的所有者或每个人的执行权限。 
boolean setLastModified(long time) 设置由此抽象路径名命名的文件或目录的最后修改时间。 
boolean setReadable(boolean readable) 一种方便的方法来设置所有者对此抽象路径名的读取权限。 
boolean setReadable(boolean readable, boolean ownerOnly) 设置此抽象路径名的所有者或每个人的读取权限。 
boolean setReadOnly() 标记由此抽象路径名命名的文件或目录，以便只允许读取操作。 
boolean setWritable(boolean writable) 一种方便的方法来设置所有者对此抽象路径名的写入权限。 
boolean setWritable(boolean writable, boolean ownerOnly) 设置此抽象路径名的所有者或每个人的写入权限。 
Path toPath() 返回从此抽象路径构造的一个java.nio.file.Path对象。 
String toString() 返回此抽象路径名的路径名字符串。 
URI toURI() 构造一个表示此抽象路径名的 file: URI。 
URL toURL() 已过时。 此方法不会自动转义URL中非法的字符。 建议在新的代码转换的抽象路径到URL通过先转换成URI，经由toURI方法，然后经由转换URI为URL URI.toURL方法。

1|_0_3、File 的具体使用：

例 1：

import java.io.*;
/*
File类常见方法：
1，创建。
    boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
                        和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
    boolean mkdir():创建文件夹。
    boolean mkdirs():创建多级文件夹。
2，删除。
    boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。
    void deleteOnExit();在程序退出时删除指定文件。
3，判断。
    boolean exists() :文件是否存在.
    isFile():
    isDirectory();
    isHidden();
    isAbsolute();
4，获取信息。
    getName():
    getPath():
    getParent():
    getAbsolutePath()
    long lastModified()
    long length()
*/
class FileDemo
{
    public static void main(String[] args) throws IOException
    {
        method_5();
    }
    public static void method_5()
    {
        File f1 = new File("c:\\Test.java");
        File f2 = new File("d:\\hahah.java");
        sop("rename:"+f2.renameTo(f1));
    }
    public static void method_4()
    {
        File f = new File("file.txt");
        sop("path:"+f.getPath());
        sop("abspath:"+f.getAbsolutePath());
        //该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。
        //如果相对路径中有上一层目录那么该目录就是返回结果。
        sop("parent:"+f.getParent());                      
    }
    public static void method_3()throws IOException
    {
        File f = new File("d:\\java1223\\day20\\file2.txt");
        //f.createNewFile();
        //f.mkdir();
        //记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在。
        //通过exists判断。
        sop("dir:"+f.isDirectory());
        sop("file:"+f.isFile());
        sop(f.isAbsolute());
    }
    public static void method_2()
    {
        File f = new File("file.txt");
        //sop("exists:"+f.exists());
        //sop("execute:"+f.canExecute());
        //创建文件夹
        File dir = new File("abc\\kkk\\a\\a\\dd\\ee\\qq\\aaa");
        sop("mkdir:"+dir.mkdirs());
    }
    public static void method_1()throws IOException
    {
        File f = new File("file.txt");
        sop("create:"+f.createNewFile());
        //sop("delete:"+f.delete());
    }
    //创建File对象
    public static void consMethod()
    {
        //将a.txt封装成file对象。可以将已有的和为出现的文件或者文件夹封装成对象。
        File f1 = new File("a.txt");
        File f2 = new File("c:\\abc","b.txt");
        File d = new File("c:\\abc");
        File f3 = new File(d,"c.txt");
        sop("f1:"+f1);
        sop("f2:"+f2);
        sop("f3:"+f3);
        File f4 = new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

例 2：递归列出指定目录下的文件或者文件夹

/*
列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容。
因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现的还是目录的话，还可以再次调用本功能。
也就是函数自身调用自身。
这种表现形式，或者编程手法，称为递归。
递归要注意：
1，限定条件。
2，要注意递归的次数。尽量避免内存溢出。
*/
import java.io.*;
class FileDemo3
{
    public static void main(String[] args)
    {
        File dir = new File("E:\\Book");
        showDir(dir,0);
    }
    public static String getLevel(int level)
    {
        StringBuilder sb = new StringBuilder();
        sb.append("|--");
        for(int x=0; x

Java IO流总结

认识流

IO流的分类

输入流与输出流

字节流与字符流

节点流与处理流

字节流与字符流的区别

字节流与字符流的使用场景

IO 流总览

字符流

Writer：字符输出流

FileWriter

FileWriter 的构造方法

FileWriter 的方法列表

FileWriter 方法使用

BufferedWriter

BufferedWriter 的构造方法

BufferedWriter 的方法列表

BufferedWriter 的方法使用

CharArrayWriter

CharArrayWriter 的构造函数

CharArrayWriter 的方法列表

FilterWriter

PrintWriter

Reader：字符输入流

FileReader

FileReader 的构造方法

FileReader 的具体使用

BufferedReader

BufferedReader 的构造方法

BufferedReader 的方法列表

BufferedReader 的具体使用：

字节流

InputStream 字节输入流

FileInputStream

FileInputStream 的构造方法：

FileInputStream 的方法列表：

FileInputStream 的具体使用：

OutputStream 字节输出流

FileOutPutStream

FileOutPutStream 的构造方法：

FileOutPutStream 的方法列表：

FileOutPutStream 的具体使用

File

File 的构造方法

File 的方法列表

1|_0_3、File 的具体使用：