javaIO流详解--读取，写入文件的所有类与方法
目录
IO流简介：
1 ：InputStream
2：OutputStream
3：FileInputStream
4：FileOutputStream
5：利用FileInputStream和FileOutputStream读写文件
6: BufferedInputStream
6.1:常用方法：
7: BufferedOutputStream
8:BufferedInputStream和BufferedOutputStream读取文件的案例
9: DataInputStream
10: DataOutputStream
11: ObjectInputStream ：对象输入流
12: ObjectOutputStream ：对象输出流
字符流：
13: InputStreamReader
14: OutputStreamWriter
15：使用InputStreamReader 和 OUtputStreamWriter的案例
16: FileReader
17: FileWriter
18: BufferedReader（缓冲流）
19: BufferedWriter （缓冲流）
20:ByteArrayInputStream
21:ByteArrayOutputStream
IO流图解：
IO流简介：
流的定义：流是指一连串流动的字符,是以先进先出方式发送信息的通道。
按流向分：输出流：OutputStream和Writer为基类
输入流：InputStream和Reader为基类
按处理数据单元划分：字节流：字节输入流：InputStream基类
字节输出流：OutputStream基类
字符流：字符输入流：Reader基类
字节输出流：Writer基类
（字节流是 8 位通用字节流，字符流是16位Unicode字符流）
1 ：InputStream
InputStream ins ins =new FileInputStream（new File（path））;操控字节输入流的，所用的方法也是针对字节的。
1.1：常用方法：
| 返回值类型 |
方法名 |
方法简介 |
| abstract int | read( ) | 从此输入流中读取下一个字节(此方法是抽象方法，子类必须实现该方法。 |
| int | read(byte [ ] b ) | 从输入流中读取一定数量的字节，存储在参数指定的字节数组中。 |
| int | read(byte [ ] b ,int off ,int len ) | 读到 len字节从输入流读入字节数组数据。 |
| long | skip( long n ) | 跳过并丢弃 n字节从输入流中的数据。 |
| int | available( ) | 返回此输入流下一个方法可以读取的字节数。 |
| void | close( ) | 关闭流。 |
tips:
关于InputStream.read(byte[] b)和InputStream.read(byte[] b,int off,int len)这两个方法都是用来从流里读取多个字节的，有经验的程序员就会发现，这两个方法经常 读取不到自己想要读取的个数的字节。比如第一个方法，程序员往往希望程序能读取到b.length个字节，而实际情况是，系统往往读取不了这么多。仔细阅读Java的API说明就发现了，这个方法 并不保证能读取这么多个字节，它只能保证最多读取这么多个字节(最少1个)。因此，如果要让程序读取count个字节，最好用以下代码：
byte[] b = new byte[count];
int readCount = 0; // 已经成功读取的字节的个数
while (readCount < count) {
readCount += in.read(bytes, readCount, count - readCount);
}用这段代码可以保证读取count个字节，除非中途遇到IO异常或者到了数据流的结尾(EOFException)
2：OutputStream
常用方法：
| 返回值类型 |
方法名 |
方法简介 |
| void | flush( ) | 刷新输出流，是缓存数据被写出来 |
| void | write(byte [ ] b) | 写b.length 字节从指定的字节数组的输出流 |
| void | write(byte [ ] b, int off, int len) | 写len字节从字节数组数据中到输入流 |
| abstract int | write( int b ) | 将指定的字节写入该输出流中 |
| void | close( ) | 关闭流 |
3：FileInputStream
FileInputStream是读取原始字节的图像数据流。读取字符流，考虑使用FileReader。常用方法见InputStream中的方法
构建输入流：（准备工作）
FIle file =new File（path）;
InputStream ins =null;
ins =new FileInputStream(file); //这里需要try catch3.1：读取文件字符：
int i =0;
while( ( i=ins.read( ) ) ！= -1）{
System.out.println( i );
}
//输出的是自动转化的ASCII值，此处会抛出 IOException，需要try catch
//或者提高效率，使用缓冲数组byte[ ] b,可读取英文文件，需要转化成char字符：int len =0;
byte [ ]b=new byte [ 1024 ];//建立缓冲流数组
while(（len=ins.read( b )）!= -1）{
System.out.println(""+ new String(b,0,len));
}
}
//中间嵌套for循环，读多少输出多少，中文不可用，会输出乱码-->此处会抛出 IOException，需要try //catch4：FileOutputStream
是OutputSTream的子类，主要功能是从源文件写入资料至指定文件中
4.1：构造方法：
1、FileOutputStream( File file )// 创建“File对象”对应的“文件输入流”；默认“追加模式”是false，
即“写到输出的流内容”不是以追加的方式添加到文件中。若要追加则为（File file， true）;
2、FileOutputStream( String path ) // 创建“文件(路径为path)”对应的“文件输入流”； （若没有，自动系统调用方法创建）
默认“追加模式”是false，即“写到输出的流内容”不是以追加的方式添加到文件中。 若要追加则为（String path， true）;
public class Test1 {
public static void main(String[] args) {
try {
// 构造方法1
File file = new File("E:/test.txt");
FileOutputStream fos1 = new FileOutputStream(file);
// 没有该文件会直接创建文件，但不能有多级目录，否则会报错，或者这只是个目录
// -->java.io.FileNotFoundException:E:\java\java48.txt (系统找不到指定的路径。)
// 构造方法2
FileOutputStream fos2 = new FileOutputStream("E:/java/test.txt");// 规则如上
} catch (Exception e) {
e.printStackTrace();
}
}
}
4.2:常用方法：（同OutputStream）
| 返回值类型 |
方法名 |
方法简介 |
| void | flush( ) | 刷新输出流，是缓存数据被写出来 |
| void | write(byte [ ] b) | 写b.length 字节从指定的字节数组的输出流 |
| void | write(byte [ ] b, int off, int len) | 写len字节从字节数组数据中到输入流 |
| abstract int | write( int b ) | 将指定的字节写入该输出流中 |
| void | close( ) | 关闭流 |
应用主要步骤：1、构建字节输出流对象
2、写数据
3、关闭流
5：利用FileInputStream和FileOutputStream读写文件
public class Test2 {
public static void main(String[] args){
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
File file = new File("C:\\Users\\86156\\Desktop\\test.txt");
fileInputStream = new FileInputStream(file);
fileOutputStream = new FileOutputStream(new File("C:\\Users\\86156\\Desktop\\testhello.txt"));
byte[] b =new byte[20];
int i=0;
while ((i=fileInputStream.read(b))!=(-1)){
System.out.println(""+i);
System.out.println(""+ new String(b));
fileOutputStream.write(b,0,i);
fileOutputStream.flush();
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fileInputStream.close();
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}6: BufferedInputStream
带缓冲区的输入流，默认缓冲区大小是8M，能够减少访问磁盘的次数，提高文件读取性能；是 FileInputStream 的子类。 实现了装饰设计模式！BufferedInputStream没有无参构造方法,它必须传入一个InputStream(一般是FileInputStream)，来一起使用，以提高读写效率。
构造方法：1、BufferInputStream（InputStream in）// 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。创建一个内部缓冲区数组并将其存储在 buf 中,该buf的大小默认为8192。
2、BufferedInputStream（InputStream in, int size） //创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。创建一个长度为 size 的内部缓冲区数组并将其存储在 buf 中。
6.1:常用方法：
| 返回值类型 | 方法名 |
方法简介 |
| abstract int | read( ) | 从此输入流中读取下一个字节(此方法是抽象方法，子类必须实现该方法。 |
| int | read(byte [ ] b ) | 从输入流中读取一定数量的字节，存储在参数指定的字节数组中。 |
| int | read(byte [ ] b ,int off ,int len ) | 读到 len字节从输入流读入字节数组数据。 |
7: BufferedOutputStream
带缓冲区的输出流，能够提高文件的写入效率。实现了装饰设计模式！
BufferedOutputStream没有无参构造方法,它必须传入一个OutputStream(一般是FileOutputStream)，来一起使用，以提高读写效率。
构造方法：
1、BufferOutputStream（OutputStream outs）// 创建一个 BufferedInputStream 并保存其参数，即输出流outs，将数据写入指定的基本输入流中。
2、BufferedOutputStream（OutputStream outs, int size） //创建具有指定缓冲区大小的 BufferedOutputStream ，即输出流outs，将数据写入指定的基本输入流中 。
7.1:常用方法：
| 返回值类型 |
方法名 |
方法简介 |
| void | flush( ) | 刷新输出流，是缓存数据被写出来 |
| void | write(byte [ ] b) | 写b.length 字节从指定的字节数组的输出流 |
| void | write(byte [ ] b, int off, int len) | 写len字节从字节数组数据中到输入流 |
tips：为什么要用BufferedInputStream 和 BufferedOutputStream？
优点：效率高
缺点：内存占用多
不带缓冲的操作，每读一个字节就要写入一个字节，由于涉及磁盘的IO操作相比内存的操作要慢很多，所以不带缓冲的流效率很低。
带缓冲的流，可以一次读很多字节，但不向磁盘中写入，只是先放到内存里。等凑够了缓冲区大小的时候一次性写入磁盘，这种方式可以减少磁盘操作次数，速度就会提高很多。
8:BufferedInputStream和BufferedOutputStream读取文件的案例
public class Test2 {
public static void main(String[] args){
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
BufferedInputStream bufferedInputStream = null;
BufferedOutputStream bufferedOutputStream = null;
try {
File file = new File("C:\\Users\\86156\\Desktop\\test.txt");
fileInputStream = new FileInputStream(file);
fileOutputStream = new FileOutputStream(new File("C:\\Users\\86156\\Desktop\\testhello.txt"));
bufferedInputStream = new BufferedInputStream(fileInputStream);
bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
byte[] b =new byte[1024];
int i=0;
while ((i=bufferedInputStream.read(b))!=(-1)){
System.out.println(""+i);
System.out.println(""+ new String(b,0,i));
bufferedOutputStream.write(b,0,i);
//最后刷新一下
bufferedOutputStream.flush();
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fileInputStream.close();
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
9: DataInputStream
数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。 DataInputStream 对于 多线程访问不一定是安全的。 线程安全是可选的，它由此类方法的使用者负责。
构造方法：DataInputStream（InputStream in）;
9.1:常用方法：
| 返回值类型 |
方法名 | 方法简介 |
| int | read(byte [ ] b) | 读取一定数量的字节从包含输入流并存入缓冲区阵列b |
| int | read (byte [ ] b, int off, int len) | 读到 len 从包含输入流读入字节数组数据字节 |
| boolean | readBoolean( ) | 读 true / false |
| byte | readByte( ) | 读取并返回一个输入字节 |
| char | readChar( ) | 读取两个字节返回一个 char 价值 |
| float | readFloat( ) | 四字节读取输入并返回一个 float 价值 |
| double | readDouble( ) | 八字节读取输入并返回一个 double 价值 |
| int | readInt( ) | 四字节读取输入并返回一个 int 价值 |
| String | readLine( ) | 从输入流读取下一行文本 |
| short | readShort( ) | 两字节读取输入并返回一个 short 价值 |
| String | readUTF( ) | 读取一个字符串，一直采用 modified UTF-8 编码格式 |
10: DataOutputStream
数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。 DataInputStream 对于多线程访问不一定是安全的。 线程安全是可选的，它由此类方法的使用者负责。
构造方法： DataOutputStream( OutputStream outs);
10.1:常用方法：
| 返回值类型 |
方法名 |
方法简介 |
| void | flush( ) | 刷新数据输出流 |
| int | size( ) | 返回柜台 written 电流值，这个数据写入输出流的字节数为止 |
| void | write( int b ) | 将指定的字节（论证b的低八位）的底层输出流 |
| void | write( byte [ ] b, int off, int len ) | 写 len 字节指定字节数组中的起始偏移量 off 当前输出流 |
| void | writeBoolean( boolean v ) | 写一个 boolean 当前输出流作为一个字节的值 |
| void | writeByte( int v ) | 写了 byte 当前输出流作为一个字节的值 |
| void | writeBytes( String s ) | 将字符串写入到基础的输出流作为字节序列 |
| void | writeChar( int v ) | 写一个char当前输出流作为一个双字节的值，高字节优先 |
| void | writeChars( String s ) | 将字符串写入底层输出流，作为一个字符序列 |
| void | writeFloat( float v ) | 将浮点型参数的 int使用 floatToIntBits方法在类 Float，然后写道， int值基本为4字节输出流量，高字节优先。 |
| void | writeDouble( double v ) | 将双参数到一个 long使用 doubleToLongBits方法在类 Double，然后写道， long值基本的输出流的字节的数量，高字节优先。 |
| void | writeInt( int v ) | 写一个 int当前输出流为四个字节，高字节优先。 |
| void | writeShort( int v ) | 写一个 short当前输出流的两个字节，高字节优先。 |
| void | writeUTF( String str ) | 一个字符串写入到输出流的潜在使用在一个机器无关的方式 modified UTF-8编码。 |
案例：
public class Test4 {
public static void main(String[] args) {
try {
FileOutputStream fileOutputStream = new FileOutputStream(new File(""));
DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
dataOutputStream.writeDouble(2.00);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}11: ObjectInputStream ：对象输入流
特点 : 可以从输入流中读取java对象，而不需要每次读取一个字节，需要把InputStream包装到ObjectInputStream中，就可以从中读取对象，对象必须实现序列化，对象类实现Serializable接口
例：（实现序列化）
public class Pet implements Serializable {
private static final long serialVersionUID = 1L;
}
构造方法：1、ObjectInputStream( ) ;
2、ObjectInputStream( InputStream ins) ;
10.1:常用方法：
| 返回值类型 |
方法名 |
方法简介 |
| void | close( ) | 关闭输入流 |
| int | read( ) | 读取一个字节的数据 |
| int | read( byte [ ] b, int off, int len ) | 读入一个字节数组 |
| boolean | readBoolean( ) | 在布尔值中读取 |
| byte | readByte( ) | 读取一个8位字节 |
| char | readChar( ) | 读取一个16位字符 |
| double | readDouble( ) | |
| float | readFloat( ) | |
| int | readInt( ) | 读取一个32位的int |
| String | readLine( ) | 过时的 |
| Object | readObject( ) | 读取对象输入流中的对象 |
| String | readUTF( ) | 读modified UTF-8的格式字符串 |
12: ObjectOutputStream ：对象输出流
特点： 能够让你把对象写入到输出流中，而不需要每次写入一个字节。你可以把OutputStream包装到ObjectOutputStream中，然后就可以把对象写入到该输出流中了
对象必须实现序列化，对象类实现Serializable接口
例：（实现序列化）
public class Pet implements Serializable {
private static final long serialVersionUID = 1L;
}
构造方法： 1、ObjectOutputStream( ) ;
2、ObjectOutputStream( OutputStream ins) ;
10.1:常用方法：
| 返回值类型 |
方法名 |
方法简介 |
| void | close( ) | 关闭流 |
| void | flush( ) | 刷新流 |
| protect Object | replaceObject( ) | 这种方法将允许受信任的子类对象来代替一个物体对另一个序列化期间 |
| void | write( byte [ ] b ) | 写入一个字节数组 |
| void | write( byte [ ] b, int off, int len ) | 写入字节数组的字节数 |
| void | write( int val ) | 写一个字节 |
| void | writeBoolean( boolean val ) | 写一个布尔值 |
| void | writeByte( byte val ) | 写入一个8位字节 |
| void | writeChar( int val ) | 写入一个16位字符 |
| void | writeInt( int val ) | 写入一个32位长的int |
| void | writeObject( Object obj ) | 写入指定对象的对象 |
| void | writeUTF( String str ) | 原始数据写在 modified UTF-8格式字符串 |
ObjiectInputStream 和 ObjectOutputStream 案例：（创建一个宠物类，放入一个集合中，使用者两个类进行读写操作）
public class Test3 {
public static void main(String[] args) {
File file = new File("C:\\Users\\86156\\Desktop\\date.txt");
FileOutputStream fileOutputStream = null;
ObjectOutputStream objectOutputStream = null;
try {
fileOutputStream = new FileOutputStream(file);
objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(new Date());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
objectOutputStream.close();
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}字符流：
1、字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串。字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的。字符流操作的是缓冲区（当我们对文件进行读写操作时如果不调用close() 或 flush()方法时不能看到数据的变化）。
2、字符输入流 Reader 基类
字符输出流 Writer 基类
3、Reader 和 Writer都是抽象类
13: InputStreamReader
特点：将字节输入流转换为字符输入流。是字节流通向字符流的桥梁，可以指定字节流转换为字符流的字符集。
构造方法：1、InputStreamReader( InputStream ins) ; 创建一个默认字符集的 InputStreamReader
2、InputStreamReader( InputStream ins ，“ encoding”) ; 创建使用指定字符集的 InputStreamReader
13.1:常用方法：
| 返回值类型 |
方法名 |
方法简介 |
| void | close( ) | 关闭流 |
| String | getEncoding( ) | 返回此流使用的字符编码名称 |
| int | read( ) | 读取单个字符 |
| int | read( char [ ] ch, int off, int len ) | 将字符读入一个数组的一部分 |
| boolean | ready( ) | 告诉是否该流已准备好阅读 |
读文件内容的常用三种方法：
1、int read（）
//public int read() throws IOException
//读取单个字符。在字符可用、发生 I/O 错误或者已到达流的末尾前，此方法一直阻塞。
2、int read( char [ ]ch, int off, in len )
//public int read(char[] cbuf) throws IOException
//将字符读入数组。在某个输入可用、发生 I/O 错误或者已到达流的末尾前，此方法一直阻塞。
3、int read( char [ ] ch)
//public int read(char[] cbuf) throws IOException
//将字符读入数组的某一部分。在某个输入可用、发生 I/O 错误或者到达流的末尾前，此方法一直阻塞。
14: OutputStreamWriter
特点：将字节输出流转为字符输出流，是字符流通向字节流的桥梁，可使用指定的 encoding 要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，
否则将接受平台默认的字符集。
构造方法：1、OutputStreamWriter(OutputStream outs) ; 创建使用默认字符编码的 OutputStreamWriter
2、 OutputStreamWriter(OutputStream outs , “ecoding”) ; 可以设置编码格式
常用方法：
| 返回值类型 |
方法名 |
方法简介 |
| void | close( ) | 关闭流 |
| void | flush( ) | 刷新流 |
| String | getEcoding( ) | 返回此流使用的字符编码格式名称 |
| void | writer( int val ) | 写入一个字符 |
| void | writer( char [ ]ch, int off, int len ) | 写入一个字符数组的一部分 |
| void | writer( String str, int off, int len ) | 写入字符串的一部分 |
用OutputStreamWriter 将内存中的数据写入文件中有5种方式：
1、 void writer( int val )
//public void write(int c)throws IOException
//写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。
2、 void writer( char [ ]ch )
//public void write(char[] cbuf)throws IOException 写入字符数组。
3、 void writer( char [ ]ch, int off, int len)
//public abstract void write(char[] cbuf,int off,int len)throws IOException 写入字符数组的某一部分。
4、 viod writer( String str )
//public void write(String str) throws IOException 写入字符串。
5、 void writer( String str, int off ,int len )
//public void write(String str,int off, int len)throws IOException; 写入字符串的某一部分。
15：使用InputStreamReader 和 OUtputStreamWriter的案例
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.Scanner;
/**
* 包装流设置字符集
*
* @author kuang
*
*/
public class homework_2 {
public static void main(String[] args) {
// 确定源和目标文件
Scanner sc = new Scanner(System.in);
File o = new File("text1.txt");
File t = new File("text2.txt");
//检测没有文件就创建文件
check(o);
check(t);
// 构建流对象
InputStream ins = null;
OutputStream outs = null;
InputStreamReader insr = null;
OutputStreamWriter outsw = null;
try {
outs = new FileOutputStream(o);// 先做为目标文件写入内容
outsw = new OutputStreamWriter(outs, "UTF-8");//编码格式为UTF-8
System.out.println("输入你要写入的内容：");
String msg = sc.next();
// 写入内容
outsw.write(msg);
// 刷新
outsw.flush();
System.out.println("已经完全写入！");
ins = new FileInputStream(o);// 作为源文件
insr = new InputStreamReader(ins, "UTF-8");//编码格式为UTF-8
outs = new FileOutputStream(t);// 作为写入的目标文件
outsw = new OutputStreamWriter(outs, "UTF-8");//编码格式为UTF-8
char[] ch = new char[1024];
int i = 0;
// 执行边读边写
while ((i = insr.read(ch)) != -1) {
outsw.write(ch, 0, i);
}
// 刷新
outsw.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭流
try {
if (outs != null) {
outs.close();
}
if (ins != null) {
ins.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void check(File file) {
try {
if (!file.exists()) {
file.getParentFile().mkdirs();// 创建文件夹
file.createNewFile();// 创建文件
System.out.println("没有该文件！已创建成功！");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
16: FileReader
17: FileWriter
与上面InputStreamReader 和 OutputStreamWriter没啥区别 ，不多说
18: BufferedReader（缓冲流）
特点：字节输入缓冲流，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine。
构造方法：1、BufferedReader( Reader in ) ； 创建一个使用默认大小输入缓冲区的缓冲字符输入流
2、BufferedReader( Reader in, int sz ) ； 创建一个使用指定大小的输入缓冲区的缓冲字符输入流
常用方法：
该类读取文本的方法就是父类Reader提供的read（）系列方法（见上边的 InputStreamReader）。在这里仅介绍他自己特有的方法readLine()
| 返回值类型 |
方法名 |
方法简介 |
| String | readLine( ) | 读一行文本 --> 特有 |
例：
//public String readLine()throws IOException读取一个文本行。通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行。
public static void readLineTest() throws IOException{
BufferedReader br=new BufferedReader(new FileReader("E:\\test\\javaIo\\1.txt"));
String str=null;
while((str=br.readLine())!=null){
System.out.println(str);
}
br.close();
}
19: BufferedWriter （缓冲流）
特点：字节输出缓冲流，将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。 该类提供了 newLine() 方法，它使用平台自己的行分隔符概念，此概念由系统属性 line.separator 定义。
构造方法：1、BufferedWriter( Writer out ) ；创建一个使用默认大小输出缓冲区的缓冲字符输出流
2、BufferedWriter( Writer out, int sz ) ；创建一个新的缓冲字符输出流，该流使用给定大小的输出缓冲区。
常用方法：
该类写入文本的方法就是父类Writer提供的write（）系列方法（见上边的 OutputStreamWriter），在这里仅介绍他特有的newLine( )方法。
| 返回值类型 |
方法名 |
方法简介 |
| void | newLine( ) | 写行分隔符 |
例：
public static void newLineTest() throws IOException{
BufferedWriter bw=new BufferedWriter(new FileWriter("E:\\test\\javaIo\\2.txt"));
bw.write("爱我");
bw.newLine();
bw.write("中华");
bw.flush();
bw.close();
}
//结果:(加入了换行符)
爱我
中华
字符缓冲流 案例：（使用 BufferedReader 和 BufferedWriter）
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.Reader;
import java.io.Writer;
/**
* 字符缓冲流
*
* @author kuang
*
*/
public class Demo2 {
public static void main(String[] args) {
// 1、指明源和目标
File o = new File("F:/text1.txt");
File t = new File("F:/text2.txt");
// 2、构建流的对象
Reader re = null;
Writer wt = null;
BufferedReader bfr = null;
BufferedWriter bfw = null;
try {
re = new FileReader(o);
bfr = new BufferedReader(re);
wt = new FileWriter(t);
bfw = new BufferedWriter(wt);
String msg = null;
// 读取操作
while ((msg = bfr.readLine()) != null) {// 读一行
// System.out.println(msg);
bfw.write(msg);
bfw.write("\r\n");// 执行换行，读一行 写一行 换行
// 或者 ：bfw.newLine();//换行
}
bfw.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭流
try {
if (wt != null) {// 为了避免空指针异常，进行判空
wt.close();
}
if (re != null) {
re.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
20:ByteArrayInputStream
和缓存输入流一样，只不过他的缓冲区可以一直增加；
-
ByteArrayInputStream包含一个内部缓冲区，其中包含可以从流中读取的字节。 内部计数器跟踪read方法要提供的下一个字节。 -
案例：
public static void main(String[] args) {
//当有数据需要读取的时候，获得一个byte数组，或者从别的地方获得了一个byte数组
//就可以用这个方法然后进行读取
ByteArrayInputStream bArray = new ByteArrayInputStream(byte []a,int off,int len)
for(int y = 0 ; y < 1; y++ ) {
while(( c= bInput.read())!= -1) {
System.out.println(Character.toUpperCase((char)c));
}
bInput.reset();
}
}21:ByteArrayOutputStream
-
该类实现了将数据写入字节数组的输出流。 当数据写入缓冲区时，缓冲区会自动增长。 数据可以使用
toByteArray()和toString()。当读取文件中的数值然后不写出去，只需要请求接口传送的时候，需要将全部的数据都读在一起，就用他； -
案例：
public static void main(String[] args) {
try {
//这个content用来盛放数据
byte[] content = new byte[102400];
// 上传附件
try {
int byteread;
byte data[] = new byte[1024];
InputStream input = new FileInputStream(new File("C:\\Users\\liulei\\Desktop\\测.xlsx"));
System.out.println(input);
ByteArrayOutputStream out = new ByteArrayOutputStream();
while ((byteread = input.read(data)) != -1) {
out.write(data, 0, byteread);
out.flush();
}
content = out.toByteArray();
input.close();
System.out.println(input);
out.close();
} catch (Exception e) {
e.printStackTrace();
}
} catch (Exception e) {
// TODO: handle exception
}
}