javaio详解
1. 同学们知道java中的IO是指什么
一般指文件相关的操作。在Java中，使用文件流进行编码时，需要引入对应的JAR包，而其中最主要的类，像File、FileInputStream、FileOutputStream等等，大多都封装在IO这个包里面。所以Java中，说到IO相关的操作，一般情况下都会认为是文件相关的操作。
2. java中处理中文输入,不需要用到的类是
Java把不同类型的输入、输出抽象为流stream，分为输入流和输出流，用统一的接口来表示
Java开发环境中提供了包java.io，其中包括一系列的类来实现输入／输出处理
InputStream是所有字节输入流的祖先，而OutputStream是所有字节输出流的祖先
public abstract class InputStream implements Closeable
public abstract class OutputStream implements Closeable, Flushable
具体子类： ByteArrayInputStream, FileInputStream, FilterInputStream, ObjectInputStream,
PipedInputStream, SequenceInputStream, StringBufferInputStream
InputStream
InputStream类是一个抽象类，方法包括：
int read()
int read(byte[])
int read(byte[],int,int)
void close()关闭流
int available()报告流中直接可读的字节数
skip(long)跳过流中指定的字节
OutputStream
OutputStream也是一个抽象类。它的主要方法包括：
void write(int)
void write(byte[])
void write(byte[],int,int)
其中第一个方法的int型的参数对应要写入的字节，后两个方法的参数与InputStream类似。
void close() 关闭输出流
void flush() 强行将写入缓冲区中剩余的数据写入
File file = new File("d:\\FileTest.java");
if (file.exists()) {
try (InputStream is = new FileInputStream(file);) {
byte[] buffer = new byte[8192];
int len = is.read(buffer);
while (len > 0) {
System.out.write(buffer, 0, len);
len = is.read(buffer);
}
} catch (Exception e) {
e.printStackTrace();
}
}
InputSream 和 OutputStream 中定义了 read() 和 write() 方法，它们被派生流类重载。字节流是字节序
列，它与外部设备中的字节存在着一一对应的关系，不存在字符的转换，被读写字节的个数与外部设备中的字节个数是相同的
基本输入输出方法
System类是Java语言中一个功能强大、非常有用的类，它提供了标准输入/输出及运行时的系统信息
System类不能创建对象，也就是说，System类的所有属性和方法都是静态的，引用时要以System 作为前缀
System.in与System.out是System类的两个静态属性，分别对应了系统的标准输入/输出流 System类管理标准输入输出流和错误流
System.out：把输出送到缺省的显示(通常是显示器)，是PrintStream的对象
System.in：从标准输入获取输入(通常是键盘)，是InputStream的对象
System.err：把错误信息送到缺省的显示，是PrintStream的对象
同时使用System.out和System.err输出信息不能保证显示顺序就是执行顺序，为了避免这种情况在测试代码执行中经常使用System.err输出
FileInputStream、FileOutputStream 顺序读取文件
PipedInputStream、PipedOutputStream 管道
ByteArrayInputStream、ByteArrayOutputStream 内存读写
FilterInputStream、FilterOutputStream 过滤流（有多线程同步）
DataInputStream、DataOutputStream 对数据类型读写，有多线程同步
BufferedInputStream、BufferedOutputStream 缓冲类型读写
1 、使用字节流进行文件的单字节复制
FileInputStream是InputStream的子类，FileInputStream属于节点流，用于按字节读取文件内容
FileOutputStream是OutputStream的子类，FileOutputStream属于节点流，用于按字节输出数据到文件中
//FileInputStream中read方法的定义
/**
从指定的输入流中按字节读取数据，如果读到流的末尾则返回-1,否则返回读取到的数据。如果文件不存
在则异常FileNotFoundException【IOException的子类】
*/
public int read() throws IOException {
return read0();
}
//FileOutputStream中write方法的定义
//属性,用于表示是否进行文件的追加操作而不是覆盖操作
private final boolean append;
//构造器方法的定义，其中name是文件名称，默认采用覆盖操作
public FileOutputStream(String name) throws FileNotFoundException {
this(name != null ? new File(name) : null, false);
}
//按照字节执行写出int数据，自动会去除多余的字节。如果文件不存在则自动创建新文件，如果
文件已经存在则按照append的值决定采用的是追加操作还是覆盖操作
public void write(int b) throws IOException {
write(b, append);
}
private native void write(int b, boolean append) throws IOException; //
由VM采用对等类的方式提供实现
public class Test1 {
public static void main(String[] args) throws IOException {
try (InputStream is = new FileInputStream("c:/面向对象文档.txt");
OutputStream os = new FileOutputStream("test.txt");) {
int kk;
while ((kk = is.read()) != -1) {
os.write(kk);
}
}
}
}
2 、读取 A.java 文件并在控制台上显示
如何使用控制台输出 : System.out 字节流
分析：使用字节流从 A.java 中一个字节一个字节的读取内容，然后再使用 System.out.print 方法输出即可
注意：读取操作返回的 int 的取值范围为 0-255 ，则表示这里不会有符号位，所以 is.read()==-1 不是只适合于文本文件
File ff = new File("T1.java");
if (ff.exists()) {// 如果文件存在则进行拷贝操作，否则提示文件不存在
InputStream is = new FileInputStream(ff);
OutputStream os = new FileOutputStream("t1.bak");
while (true) {
int kk = is.read();// 返回值应该是0-255，如果返回-1表示流已经结束
if (kk < 0)break;
os.write(kk);
}
is.close();
os.close();
} else
System.out.println("T1.java文件不存在");
InputStream基本输入类
InputStream类是基本的输入类。它定义了所有输入流所需的方法。
public abstract int read() throws IOException读取一个字节并以整数的形式返回，0-255。如果 返回-1已到输入流的末尾。
public int read(byte b[]) throws IOException读取一系列字节并存储到一个数组，返回实际读取的 字节数。如果已经读到输入流的末尾则返回-1
public void close() throws IOException 关闭输入流并释放资源
public int read(byte b[],int offset,int length) throws IOException功能为从输入流中读数据。这一 方法有几种重载形式，可以读一个字节或一组字节。当遇到文件尾时，返回-1。最后一种形式中的 offset是指把结果放在b[]中从第offset个字节开始的空间，length为长度
public long skip (long n) throws IOEnception 从输入流跳过几个字节。返回值为实际跳过的字节数
OutputStream基本输出类
三个重载形式都是用来向输出流写数据的
public abstract void write(int b)向输入流写入一个字节数据，该字节为参数的低8位。
public void write(byte b[],int offset,int length)将一个字节类型的数组中的从指定位置offset开始 的length个字节写入到输出流
public void close( ) 关闭输出流，释放资源
public void write(byte b[])将一个字节类型的数组中的数据写入到输出流
public void flush() 清除缓冲区，将缓冲区内尚未写出的数据全部输出
字符流
在顶层有 Reader 和 Writer 两个抽象类。 Reader 和 Writer 中定义了 read() 和 write() 方法，它们被派生流类重载
Reader 抽象类的定义
public abstract class Reader implements Readable, Closeable {
//BIO，读取一个有效的字符，返回值为0到65535的整数，如果到达流的末尾则返回-1
public int read() throws IOException
//BIO,读取字符存储到char数组中，返回读取的字符个数，流结束则返回-1
public int read(char cbuf[]) throws IOException
//关闭流，同时释放资源
abstract public void close() throws IOException;
Writer 抽象类的定义
public abstract class Writer implements Appendable, Closeable, Flushable {
//写出一个字符到字符流，要写的字符包含在给定整数值的16个低位；16个高位被忽略。
public void write(int c) throws IOException
//将字符数组中的指定部分内容压入到字符流，从off开始共len个字符
abstract public void write(char cbuf[], int off, int len) throws
IOException;
/关闭流，同时释放资源
abstract public void close() throws IOException;
相关的子类
InputStreamReader、OutputStreamWriter桥接流，用于自动实现字节流和字符流的转换
FileReader、FileWriter文件流，用于实现针对文本文件的读写操作
CharArrayReader、CharArrayWriter内存流，用于实现针对char数组的读写操作
PipedReader、PipedWriter管道流，用于线程之间的通讯
FilterReader、FilterWriter过滤流的父类
BufferedReader、BufferedWriter缓存流，用于在流中添加缓冲区
StringReader、StringWriter内存流，用于实现针对字符串的读写操作
使用字符流实现 txt 文件的读取显示【其中包含中文】
编写一个程序，读取文件 test.txt 的内容并在控制台输出。如果源文件不存在，则显示相应的错误信息。
字符流 Reader
int read()读取一个字符并以整数的形式返回0-65535，如果返回-1则已到输入流末尾
int read(char[] cbuf)读取一系列字符并存储到一个数组中，返回实际读取的字符数，如果读到输入流末尾则返回-1
void close()关闭输入流并释放内存资源
int read(char[] cbuf, int off, int len) 读取len个字符并存储到一个数组中，从off位置开始，返回实
际读取的字符数，如果读取到输入流末尾则返回-1
long skip(long n)跳过n个字符不读，返回实际跳过的字节数
字符流 Writer
void write(int c) 将字符（int数组的低8位）压入到字符流中
void write(char[] cbuf, int off, int len)将字符数组中的指定部分内容压入到字符流中，从off开始共len个字符
void write(String str) 将字符串中的内容压入到字符流中
void close() 关闭流并释放所占用的资源
void write(String str, int off, int len) 将字符串中的指定部分内容压入到字符流中，从下标off开始共len个字符
void flush()刷新缓冲区，将缓冲区中的数据全部送出到目标地，然后清空缓冲区
void write(char[] cbuf) 将字符数组中的所有数据压入到字符流中
一般来说：一次读写一个字符效率太低，可以引入 char[] 数组提高执行效率
小结
在学些BIO时记忆父类的方法，区分子类的实现不同
InputStream中的方法 read(byte[]):int； Reader中方法read(char[]):int 如果到达流末尾 则-1
OutputStream中的方法 write(byte[],0,len):void；Writer中的方法 write(char[],0,len)/write(String)
一般在使用中，如果读取数据使用字节流，则写出数据采用的也是字节流；不建议混用，除非引入 桥接流
文件流
FileInputStream("file-name") FileInputStream(File) FileNotFoundException
FileReader("file-name") FileReader(File) FileNotFoundException
FileOutputStream("file-name") FileOutputStream("file-name",true) 默认文件覆盖，如果 参数true表示追加
FileWriter("file-name") FileWriter("file-name",true)
一般不使用单字节或者单字符的操作方法，使用数组
注意：try(){}是推荐写法，否则应该使用try{}finally{}结构保证流的关闭
针对二进制文件不建议使用字符流，建议使用字节流进行操作，否则有可能拷贝文件出现问题：
如果针对文本文件则建议使用字符流，因为编码使用比较方便
文章知识点与官方知识档案匹配
Java技能树类和接口类和面向对象
89124 人正在系统学习中
点击阅读全文
打开CSDN，阅读体验更佳
java用于输入输出流的类_java输入输出流_lsgn的博客
java输入输出流 java IO综述 在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader;一个接口指的是Serializable。 Java I/O主要包括如下几个层次,包含三个部分: ...
java常见输入输出类型_3分钟秒懂大数据的博客
输入:每行输入一个数,连续输入n行,遇到0结束输入,然后输出结果。 importjava.util.ArrayList; importjava.util.Scanner; publicclassTest4{ publicstaticvoidmain(String[] args){ Scannersc=newScanner(System.in); ...
25、JAVA进阶——输入输出流
一、认识Java的流 二、使用字节流读写文本文件 1、使用字节流类FileInputStream读文本文件 2、使用字节流类FileOutputStream写文本文件 三、使用字符流读写文本文件 1、使用字符流类BufferedReader和FileReader读文本文件 2、使用字符流类BufferedWrite和FileWrite写文本文件 四、读写二进制文件 1、 使用字节流读二进制文件 2、 使用字节流写二进制文件 五、序列化和反序列化 1、认识序列化 2、序列化保存对
继续访问
java 输入类_java 输入输出类
java中输入输出类如果理不清思路的话就会很混乱!一.File类提供与操作系统无关的文件操作!可以查看api文档了解它的方法二.输出操作:1.把信息输出到屏幕上最简单的操作就是使用标准输出:System.out.println();下面讨论一下流方式的输出,与之相关的类如下OutputStreamWriter:它提供字符流到字节流的转换,换句话说它写入字符数据然后按照指定字符集转换为字节数据Buf...
继续访问
JAVA的输入输出_努力的地球人的博客_java输出
Java的输入 Scanner类 为了使用scanner类,我们首先需要导入java.util.Scanner包 import java.util.Scanner; 1 创建scanner对象,从用户获取输入 //创建scanner对象 Scanner str=new Scanner(System.in); //接受用户输入 int w=str.nextIn...
java输入输出_java中输入输出总结_weixin_39609407的博客
标准输入studin,对象是键盘。 标准输出stdout,对象是屏幕。 标准错误输出stderr,对象也是屏幕。 二、java.io包中的数据流和文件类 字节流:从InputStream和OutputStream派生出来的一系列类。这类流以字节(byte)为基本处理单位。
Java——不同数据类型的输入输出方式与转化方式
java 中不同数据类型的 输入方法 输出格式 与 转化方式
继续访问
Java文本输出常用类
package com.ss.extract; import java.io.*; import org.apache.log4j.Logger; /** * 结果输出类 * @author Shu */ public class ResultOutput { private ...
继续访问
1.Java基础入门 -(2)输入输出类_菜鸟的小虫子的博客
一. Java Scanner 类 java.util.Scanner是 Java5 的新特征,我们可以通过 Scanner 类来获取用户的输入。 Scanner 对象的基本语法: Scanner in= new Scanner(System.in); 示例1: 输入结果: ...
java的输入输出流类型_理解JAVA输入输出流_天接云涛的博客
1、字节流抽象类 InputStream输入流 OutputStream输出流 2、字符流抽象类 Reader 输入字符流 Writer 输出字符流 四、JAVA中流体系架构 有一些对流进行操作的基本的方法,我们以文件输入输出流进行说明: ...
java的输出类
System.out这个类是PrintStream类，定义如下 public class PrintStream extends FilterOutputStream PrintStream都是用print的相关函数输出到控制台上。print的实现都是用write（String s）实现。 而，PrintWriter这个输出类，也同样实现输出：PrintWriter extends ...
继续访问
Java中的各种输出形式
一、Java中的各种输出形式： package cn.jl.lwj; public class Demo00 { public static void main(String[] args) { //标识符定义 区分大小写 int a = 5; int A = 6; //区分大小写 int Class = 6; int age = 5; //定义常量 final int AGE_MAX = 30;...
继续访问
java中的BIO基础-3
java中的io基础
继续访问
Java学习-IO流进阶
缓冲流也称为高效流、或者高级流。之前学习的字节流可以称为原始流。
继续访问
IO进阶之高级IO
高级IO
继续访问
Java中的IO进阶操作
Java中的IO进阶操作 一、序列化和反序列化 常用于多台服务器之间进行java对象的数据传递。 1.概念 序列化 是指程序中准备好的Java对象，永久的保存在磁盘中，这个过程其实是一个out的动作。 ObjectOutputStream：通过在流中使用文件可以实现对象的持久存储。 创建对象：ObjectOutputStream(OutputStream out) 常用方法： void writeObject(Object obj)：将指定的对象写入ObjectOutputStream 反序列化 是指把
继续访问
Java IO最详解，欢迎提出意见
Java IO 详解 初学java，一直搞不懂java里面的io关系，在网上找了很多大多都是给个结构图草草描述也看的不是很懂。而且没有结合到java7 的最新技术，所以自己来整理一下，有错的话请指正，也希望大家提出宝贵意见。 首先看个图：（如果你也是初学者，我相信你看了真个人都不好了，想想java设计者真是煞费苦心啊！） 这是java io 比较基本的一些处理流，除此之外我们还会...
继续访问
java输出类型_java中各种类型的输入输出
import java.lang.Exception;import java.lang.String;import java.util.Scanner;public class test {public static void main(String[] args) {Scanner s = new Scanner(System.in);char ch;System.out.print("Char...
继续访问
java中输入流的类_Java中的输入/输出流类
Java中包含的输入/输出流类 1.java.io包中的接口 (1)处理字节流的有DataInput接口和DataOutput接口，RandomAccessFile同时实现了这两个接口； (2)处理对象流的有ObjectInput接口和ObjectOutput接口，ObjectInputStream类实现了ObjectInput接口，ObjectOutputStream类实现了ObjectOutp...
继续访问
使用java的输入/输出类
1． 什么是IO？ I：input 输入 通常做读取操作(将不同数据源的数据读入到内存中，也叫读取流) O：output 输出通常做写入操作（将内存中的数据写入到不同的数据源，也叫写入流） 2． 理解流的概念。 想象一下自来水公司要把水输到用户家里，应该先把自来水公司到用户家里的连接水管建好，再将水输出去。管道里输送的是水，但IO里输送的是字节。 u流是...
继续访问
Java中的输入/输出流类
Java中包含的输入/输出流类 1.java.io包中的接口 （1）处理字节流的有DataInput接口和DataOutput接口，RandomAccessFile同时实现了这两个接口； （2）处理对象流的有ObjectInput接口和ObjectOutput接口，ObjectInputStream类实现了ObjectInput接口，ObjectOutputStream类实现了ObjectOutp...
继续访问
最新发布 【Java基础】自定义一个格式输出类
在项目实际开发中，后端接口都按照一定的格式输出给前端调用，在返回中包括状态码和接口的主要作用等注释，再包含实际的data。
继续访问
IO流（进阶提高）
本篇文章继上一篇IO流(小试牛刀)继续更新JavaIO流的知识。 常见IO流的结构图解： 回顾一下IO的基本接口知识： ————————————————————我是不起眼的分割线———————————————————————— IO的序列化与反序列化 Java序列化是指把Java对象转换为字节序列的过程；Java反序列化是指把字节序列恢复为Java对象的过...
继续访问
java进阶8——IO流
File类 File概述 File文件和目录路径名的抽象表示形式。即，Java中把文件或者目录（文件夹）都封装成File对象。也就是说如果我们要去操作硬盘上的文件，或者文件夹只要找到File这个类即可。 File类的构造函数 File(String pathname); // 将一个字符串路径封装成File对象 File(String parent,String child);...
继续访问
Java IO流进阶之常用流（一）
请多参考JDK文档：http://www.matools.com/api/java8或https://docs.oracle.com/javase/8/docs/api/ 转换流——OutputStreamWriter类和InputStreamReader类 字节与字符的转换流： OutputStreamWriter：是Writer类的子类，将输出的字符流变为字节流。 InputStreamRe...
继续访问
详解JAVA I/O之二——java.io层次结构
<br />java I/O(Input/Output)学习——java.io层次结构文章分类:Java编程stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。在Java的IO中，所有的stream（包括Inputstream和Out stream）都包括两种类型： <br />(1)字节流 <br /><br /> 表示以字节为单位从stream中读取或往stream中写入信息，即io包中的inputstream类和outputstream类的派生类。通常用来读取二进制数据，
3. java中的import java.io.*是什么意思 io具体又是什么意思
import java.io.* 这个是引用包import java.io.*这个的意思而IO则是输入输出流的意思，也就是inputStream，和outputStream这些类的
4. java io流的典型使用方式有几种
Java中IO流分成两大类，
一种是输入流，所有的输入流都直接或间接继承自InputStream抽象类，输入流作为数据的来源，我们可以通过输入流的read方法读取字节数据；
另一种是输出流，所有的输出流都直接或间接继承自OutputStream抽象类，输出流接收数据，可以通过write方法写入字节数据。
Java的IO流类中，大部分的输入流和输出流都是成对存在的，即如果存在XXXInputStream，那么就存在XXXOutputStream，反之亦然。SequenceInputStream和StringBufferInputStream是特例，没有对应的SequenceOutputStream类和StringBufferOutputStream类，许多IO操作都可能会抛出IOException异常，比如read、write、close操作。
以下是Java的IO流中常见的输入流，由于每个输入流都有其对应的输出流，所以此处就不再列出输出流的继承结构图。
1、ByteArrayInputStream & ByteArrayOutputStream：
ByteArrayInputStream构造函数中需要传入一个byte数组作为数据源，当执行read操作时，就会从该数组中读取数据，正如其名，是一种基于字节数组实现的一种简单输入流，显而易见的是，如果在构造函数中传入了null作为字节数据，那么在执行read操作时就会出现NullPointerException异常，但是在构造函数初始化阶段不会抛出异常；与之相对应的是ByteArrayOutputStream，其内部也有一个字节数组用于存储write操作时写入的数据，在构造函数中可以传入一个size指定其内部的byte数组的大小，如果不指定，那么默认它会将byte数组初始化为32字节，当持续通过write向ByteArrayOutputStream中写入数据时，如果其内部的byte数组的剩余空间不能够存储需要写入的数据，那么那么它会通过调用内部的ensureCapacity
方法对其内部维护的byte数组进行扩容以存储所有要写入的数据，所以不必担心其内部的byte数组太小导致的IndexOutOfBoundsException之类的异常。
2、FileInputStream & FileOutputStream
FileInputStream 能够将文件作为数据源，读取文件中的流，通过File对象或文件路径等初始化，在其构造函数中，如果传入的File对象（或与其相对应的文件路径所表示的File对象）不存在或是一个目录而不是文件或者由于其他原因无法打开读取数据，都会导致在初始化阶段导致抛出FileNotFoundException异常；与FileInputStream 相对应的是FileOutputStream，可以通过FileOutputStream向文件中写入数据，也需要通过File对象或文件路径对其初始化，如同FileInputStream ，如果传入的File对象（或与其相对应的文件路径所表示的File对象）是一个目录而不是文件或者由于其他原因无法创建该文件写入数据，都会导致在初始化阶段抛出FileNotFoundException异常。
3、PipedInputStream & PipedOutputStream
PipedInputStream和PipedOutputStream一般是结合使用的，这两个类用于在两个线程间进行管道通信，一般在一个线程中执行PipedOutputStream 的write操作，而在另一个线程中执行PipedInputStream的read操作。可以在构造函数中传入相关的流将PipedInputStream 和PipedOutputStream 绑定起来，也可以通过二者的connect方法将二者绑定起来，一旦二者进进行了绑定，那么PipedInputStream的read方法就会自动读取PipedOutputStream写入的数据。PipedInputStream的read操作是阻塞式的，当执行PipedOutputStream的write操作时，PipedInputStream会在另一个线程中自动读取PipedOutputStream写入的内容，如果PipedOutputStream一直没有执行write操作写入数据，那么PipedInputStream的read方法会一直阻塞PipedInputStream的read方法所运行的线程直至读到数据。单独使用PipedInputStream或单独使用PipedOutputStream时没有任何意义的，必须将二者通过connect方法（或在构造函数中传入对应的流）进行连接绑定，如果单独使用其中的某一个类，就会触发IOException: Pipe Not Connected.
4、ObjectInputStream & ObjectOutputStream
ObjectOutputStream具有一系列writeXXX方法，在其构造函数中可以掺入一个OutputStream，可以方便的向指定的输出流中写入基本类型数据以及String，比如writeBoolean、writeChar、writeInt、writeLong、writeFloat、writeDouble、writeCharts、writeUTF等，除此之外，ObjectOutputStream还具有writeObject方法。writeObject方法中传入的类型必须实现了Serializable接口，从而在执行writeObject操作时将对象进行序列化成流，并将其写入指定的输出流中。与ObjectOutputStream相对应的是ObjectInputStream，ObjectInputStream有与OutputStream中的writeXXX系列方法完全对应的readXXX系列方法，专门用于读取OutputStream通过writeXXX写入的数据。
5、SequenceInputStream
SequenceInputStream 主要是将两个（或多个）InputStream在逻辑上合并为一个InputStream，比如在构造函数中传入两个InputStream，分别为in1和in2,那么SequenceInputStream在读取操作时会先读取in1，如果in1读取完毕，就会接着读取in2。在我们理解了SequenceInputStream 的作用是将两个输入流合并为一个输入流之后，我们就能理解为什么不存在对应的SequenceOutputStream 类了，因为将一个输出流拆分为多个输出流是没有意义的。
6、StringBufferInputStream
StringBufferInputStream允许通过在构造函数中传入字符串以读取字节，在读取时内部主要调用了String的charAt方法。与SequenceInputStream类似，StringBufferInputStream也没有对应的OutputStream，即不存在StringBufferOutputStream类。Java没有设计StringBufferOutputStream类的理由也很简单，我们假设StringBufferOutputStream存在，那么StringBufferOutputStream应该是内部通过执行write操作写入数据更新其内部的String对象，比如有可能是通过StringBuilder来实现，但是这样做毫无意义，因为一旦我们String的构造函数中可以直接传入字节数组构建字符串，简单明了，所以设计StringBufferOutputStream就没有太大的必要了。StringBufferInputStream这个类本身存在一点问题，它不能很好地将字符数组转换为字节数组，所以该类被Java标记为废弃的（Deprecated），其官方推荐使用StringReader作为代替。
7、FilterInputStream & FilterOutputStream
FilterInputStream包含了其他的输入流，说具体点就是在其构造函数中需要传入一个InputStream并将其保存在其名为in的字段中，FilterInputStream只是简单的覆盖了所有的方法，之所说是简单覆盖是因为在每个覆盖函数中，它只是调用内部的保存在in字段中的InputStream所对应的方法，比如在其覆盖read方法时，内部只是简单调用了in.read()方法。FilterInputStream的子类可以进一步覆盖某些方法以保持接口不变的情况下实现某一特性（比如其子类有的可以通过使用缓存优化读取的效率）或者提供一些其他额外的实用方法。所以在使用时FilterInputStream可以让传入的InputStream具有一些额外的特性，即对构造函数传入的InputStream进行了一层包裹，使用了典型的装饰着模式，如果只看FilterInputStream本身这一个类的话，则该类自己本身意义不大，因为其只是通过内部的字段in简单覆写某些方法。但是如果将FilterInputStream 和其子类结合起来使用话，那么就很有用了。比如FilterInputStream 有两个子类BufferedInputStream和DataInputStream，这两个类在下面还会详细介绍。BufferedInputStream对read操作做了优化，每次读操作时都读取一大块数据，然后将其放入内部维护的一个字节数组缓冲区中。当外面调用BufferedInputStream的read方法时，首先去该缓冲区中读取数据，这样就避免了频繁的实际的读操作，BufferedInputStream对外没有暴露额外的其他方法，但是其内部的read方法已经经过优化了，所以在执行读操作的时候效率更高。DataInputStream与ObjectInputStream有点类似，可以通过一些readXXX方法读取基本类型的数据，这是非常有用的一些方法。
8、BufferedInputStream & BufferedOutputStream
如上面所介绍的那样，在BufferedInputStream的构造函数中需要传入一个InputStream， BufferedInputStream内部有一个字节数组缓冲区，每次执行read操作的时候就从这buf中读取数据，从buf中读取数据没有多大的开销。如果buf中已经没有了要读取的数据，那么就去执行其内部绑定的InputStream的read方法，而且是一次性读取很大一块数据，以便填充满buf缓冲区。缓冲区buf的默认大小是8192字节，也就是8K，在构造函数中我们也可以自己传入一个size指定缓冲区的大小。由于我们在执行BufferedInputStream的read操作的时候，很多时候都是从缓冲区中读取的数据，这样就大大减少了实际执行其指定的InputStream的read操作的次数，也就提高了读取的效率。与BufferedInputStream 相对的是BufferedOutputStream。在BufferedOutputStream的构造函数中我们需要传入一个OutputStream，这样就将BufferedOutputStream与该OutputStream绑定在了一起。BufferedOutputStream内部有一个字节缓冲区buf，在执行write操作时，将要写入的数据先一起缓存在一起，将其存入字节缓冲区buf中，buf是有限定大小的，默认的大小是8192字节，即8KB，当然也可以在构造函数中传入size指定buf的大小。该buf只要被指定了大小之后就不会自动扩容，所以其是有限定大小的，既然有限定大小，就会有被填充完的时刻，当buf被填充完毕的时候会调用BufferedOutputStream的flushBuffer方法，该方法会通过调用其绑定的OutputStream的write方法将buf中的数据进行实际的写入操作并将buf的指向归零（可以看做是将buf中的数据清空）。如果想让缓存区buf中的数据理解真的被写入OutputStream中，可以调用flush方法，flush方法内部会调用flushBuffer方法。由于buf的存在，会大大减少实际执行OutputStream的write操作的次数，优化了写的效率。
5. java中的IO流是什么啊该怎么理解啊
关于你这个方向性的问题我一开始学的时候也觉得反了。后来搞清楚目标对象就懂了。理解Java的IO流，首先要把视角放在内存上，而不是放在文件上。
InputStream是用来写入的没错，但不是写入文件中，而是写入内存中。所以InputStream的作用是从文件中读取数据然后写入内存中或者说写入到正在运行的程序中。
而OutputStream同理，是从内存/程序中将数据推送出去，把数据保存到文件中。
以Java程序作为主视角，你就能懂了。Input读取是为了读给程序用，Output写出是程序把数据输出到硬盘上了。