目录
首先，上一张IO流常用流继承关系图，在接下来的文章中，我会带大家把该图中常用的流一一示例！！
首先，要记住Java.io中最重要的5个类，3个接口！！！
| 类 |
说明 |
| File |
文件类 |
| Inputstream |
字节输入流 |
| Outputstream |
字节输出流 |
| Reader |
字符输入流 |
| Writer |
字符输出流 |
| Closeable |
关闭流接口 |
| Flushable |
刷新流接口 |
| Serializable |
序列化接口 |
一：输入输出的基本概念
对于任何程序设计语言而言，输入输出(Input/Output)系统都是非常核心的功能。
程序运行需要数据，数据的获取往往需要跟外部系统（数据源）进行通信.
| 数据源(data source) |
数据库、文件、其他程序、内存、网络连接、IO设备登等 |
数据源分为：
| 源设备 |
为程序提供数据，一般对应输入流 |
| 目标设备 |
程序数据的目的地，一般对应输出流 |
程序是中心，从程序出去是输出，从外面进来是输入
输入(Input)指的是：可以让程序从外部系统获得数据(核心含义是“读”，读取外部数据)
| 读取硬盘上的文件内容到程序。 |
例如：播放器打开一个视频文件、word打开一个doc文件。 |
| 读取网络上某个位置内容到程序。 |
例如：浏览器中输入网址后，打开该网址对应的网页内容;下载网络上某个网址的文件。 |
| 读取数据库系统的数据到程序。 |
|
| 读取某些硬件系统数据到程序。 |
例如：车载电脑读取雷达扫描信息到程序;温控系统等。 |
输出(Output)指的是：程序输出数据给外部系统从而可以操作外部系统(核心含义是“写”，将数据写出到外部系统)。
| 将数据写到硬盘中 |
例如：我们编辑完一个word文档后，将内容写到硬盘上进行保存。 |
| 将数据写到数据库系统中 |
例如：我们注册一个网站会员，实际就是后台程序向数据库中写入一条记录。 |
| 将数据写到某些硬件系统中 |
例如：导弹系统导航程序将新的路径输出到飞控子系统，飞控子系统根据数据修正飞行路径。 |
二：流的分类
流是一个抽象、动态的概念，是一连串连续动态的数据集合。
按流的方向分类：
| 1. 输入流 |
数据流向是数据源到程序(以InputStream、Reader结尾的流)。 |
| 2. 输出流 |
数据流向是程序到目的地(以OutPutStream、Writer结尾的流)。 |
输入/输出流的划分是相对程序而言的，并不是相对数据源。
按处理的数据单元分类：
| 1. 字节流 |
以字节为单位获取数据，命名上以Stream结尾的流一般是字节流，如FileInputStream、FileOutputStream。 |
| 2. 字符流 |
以字符为单位获取数据，命名上以Reader/Writer结尾的流一般是字符流，如FileReader、FileWriter。 原理：底层还是基于字节流操作，自动搜寻了指定的码表 |
按处理对象不同分类：
| 1. 节点流 |
可以直接从数据源或目的地读写数据，如FileInputStream、FileReader、DataInputStream等。 |
| 2. 处理流 |
不直接连接到数据源或目的地，是“处理流的流”。通过对其他流的处理提高程序的性能，如BufferedInputStream、BufferedReader等。处理流也叫包装流。 |
节点流处于IO操作的第一线，所有操作必须通过它们进行;处理流可以对节点流进行包装，提高性能或提高程序的灵活性。
三：编码与解码的概念
| 字节 |
——> |
字符 |
解码decode |
| 字符 |
——> |
字节 |
编码encode |
四：File类
FIle类是文件和目录路径名的抽象表示。
文件相关操作：
| 1、文件名、路径名 |
getName() 文件名、路径名 getPath()路径名，如果是绝对路径，返回完整路径，否则相对路径 getAbsoluteFile() 绝对路径所对应的File对象 getAbsolutePath() 绝对路径名 getParent() 父目录 ,相对路径的父目录 |
| 2、判断信息 |
exists() canWrite() canRead() isFile() isDirectory() isAbsolute()：消除平台差异，ie以盘符开头，其他以/开头 |
| 3、文件长度 |
length() 字节数 不能读取文件夹的长度 |
| 4、创建、删除 |
createNewFile() 不存在则创建新文件,存在返回false delete() 删除文件 static createTempFile(前缀3个字节长，后缀默认.temp) 默认临时空间 static createTempFile(前缀3个字节长，后缀默认.temp,目录) deleteOnExit() 退出虚拟机删除,常用于删除临时文件 |
目录相关操作：
| mkdir() |
创建目录，必须确保父目录存在，如果不存在，创建失败 |
| mkdirs() |
创建目录，如果父目录链不存在一同创建 |
| list() |
回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录 |
| listFiles() |
下级File |
| static listRoots() |
根路径 |
五：随机流 RandomAccessFile
该类的实例支持读取和写入随机访问文件。
随机访问文件的行为类似于存储在文件系统中的大量字节。 有一种游标，或索引到隐含的数组，称为文件指针 ; RandomAccessFile类的所有读写操作均是基于指针的，指针会随着读或写的操作往后移动。（自动移动）
同时也可以通过方法自由的操作指针的位置，以此更方便的读写文件。文件指针可以通过读取getFilePointer方法和设置seek方法。
构造方法：
| RandomAccessFile(File file, String mode) |
创建一个随机访问文件流从File参数指定的文件中读取，并可选地写入文件。 |
| RandomAccessFile(String name, String mode) |
创建随机访问文件流，以从中指定名称的文件读取，并可选择写入文件。 |
常用方法：（读取的方式和字节流类似）
| void close() |
关闭此随机访问文件流并释放与流相关联的任何系统资源。 |
| FileChannel getChannel() |
返回与此文件关联的唯一的FileChannel对象。 |
| FileDescriptor getFD() |
返回与此流关联的不透明文件描述符对象。 |
| long getFilePointer() |
返回此文件中的当前偏移量。 |
| long length() |
返回此文件的长度。 |
| int read() |
从该文件读取一个字节的数据。 |
| int read(byte[] b) |
从该文件读取最多 b.length字节的数据到字节数组。 |
| int read(byte[] b, int off, int len) |
从该文件读取最多 len个字节的数据到字节数组。 |
| boolean readBoolean() |
从此文件读取一个 boolean 。 |
| byte readByte() |
从此文件中读取一个带符号的八位值。 |
| char readChar() |
从此文件中读取一个字符。 |
| double readDouble() |
从此文件读取 double 。 |
| float readFloat() |
从此文件读取一个 float 。 |
| void readFully(byte[] b) |
从此文件读取 b.length字节到字节数组，从当前文件指针开始。 |
| void readFully(byte[] b, int off, int len) |
从此文件中读取 len个字节到字节数组，从当前文件指针开始。 |
| int readInt() |
从该文件读取一个带符号的32位整数。 |
| String readLine() |
从此文件中读取下一行文本。 |
| long readLong() |
从该文件中读取一个带符号的64位整数。 |
| short readShort() |
从此文件中读取一个已签名的16位数字。 |
| int readUnsignedByte() |
从此文件中读取一个无符号的八位数字。 |
| int readUnsignedShort() |
从该文件中读取一个无符号的16位数字。 |
| String readUTF() |
从该文件读取字符串。 |
| void seek(long pos) |
设置文件指针偏移，从该文件的开头测量，发生下一次读取或写入。 |
| void setLength(long newLength) |
设置此文件的长度。 |
| int skipBytes(int n) |
尝试跳过 n字节的输入丢弃跳过的字节。 |
| void write(byte[] b) |
从指定的字节数组写入 b.length个字节到该文件，从当前文件指针开始。 |
| void write(byte[] b, int off, int len) |
从指定的字节数组写入 len个字节，从偏移量 off开始写入此文件。 |
| void write(int b) |
将指定的字节写入此文件。 |
| void writeBoolean(boolean v) |
将 boolean写入文件作为一个字节值。 |
| void writeByte(int v) |
将 byte写入文件作为单字节值。 |
| void writeBytes(String s) |
将字符串作为字节序列写入文件。 |
| void writeChar(int v) |
将 char写入文件作为两字节值，高字节为先。 |
| void writeChars(String s) |
将一个字符串作为字符序列写入文件。 |
| void writeDouble(double v) |
双参数传递给转换 long使用 doubleToLongBits方法在类 Double ，然后写入该 long值到该文件作为一个八字节的数量，高字节。 |
| void writeFloat(float v) |
浮子参数的转换 int使用 floatToIntBits方法在类 Float ，然后写入该 int值到该文件作为一个四字节数量，高字节。 |
| void writeInt(int v) |
将 int写入文件为四个字节，高字节 int 。 |
| void writeLong(long v) |
将 long写入文件为八个字节，高字节为先。 |
| void writeShort(int v) |
将 short写入文件作为两个字节，高字节优先。 |
| void writeUTF(String str) |
以机器无关的方式使用 modified UTF-8编码将字符串写入文件。 |
示例代码：
package 学习.IO;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* 分块随机读取文件
*/
@SuppressWarnings("all")
public class accessstream {
public static void main(String[] args) throws IOException {
//文件总长度
File file = new File("src/学习/IO/output.java");
long len = file.length();
//每块大小
int blocksize = 200;
//块数
int size = (int) Math.ceil(len * 1.0 / blocksize);
//文件指针起始位置
int beginPos = 0;
//实际读取大小
int actualsize = (int) (blocksize > len ? len : blocksize);
//分块读取
RandomAccessFile rnd = new RandomAccessFile(file, "r");
for (int i = 0; i < size; i++) {
beginPos = i * blocksize;
if (i == size - 1) {//最后一块
rnd.seek(beginPos);
actualsize = (int) len;
byte b[] = new byte[actualsize];
rnd.read(b);
System.out.println(new String(b, 0, actualsize));
} else {
rnd.seek(beginPos);
actualsize = blocksize;
byte b[] = new byte[actualsize];
rnd.read(b);
System.out.println(new String(b, 0, actualsize));
len -= actualsize;
}
System.out.println("第" + (i + 1) + "块" + "->起始地址" + rnd.getFilePointer() + "--->实际大小" + actualsize);
}
rnd.close();
}
}
六：字节流
目录：
文件字节流（节点流）
字节数组流（节点流）
字节缓冲流（包装流）
数据流（包装流）
对象流（包装流）
打印流PrintStream
可以直接处理字节信息的流对象
- 计算机中一切数据都是字节数据，无论是文字、音频、图片、视频、网页等内容，底层都是字节数据
- 字节流可以操作计算机中一切数据
- 所有其他流对象，底层都需要依赖字节流
InputStream(字节，字节数组)
常用方法：
int available()
返回从该输入流中可以读取（或跳过）的字节数的估值，而不会被下一次调用此输入流的方法阻塞。
void close()
关闭此输入流并释放与流相关联的任何系统资源。
abstract int read()
从输入流读取数据的下一个字节。
int read(byte[] b)
从输入流读取一些字节数，并将它们存储到缓冲区 b 。
int read(byte[] b, int off, int len)
从输入流读取从off开始 最多len字节的数据到一个字节数组。
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)
将指定的字节写入此输出流。
6.1 文件字节流（节点流）
FileInputStream
构造方法：
FileInputStream(File file)
通过打开与实际文件的连接创建一个 FileInputStream ，该文件由文件系统中的 File对象file命名。
FileInputStream(String name)
通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
常用方法：
int available()
返回从该输入流中可以读取（或跳过）的字节数的估值，而不会被下一次调用此输入流的方法阻塞。
void close()
关闭此输入流并释放与流相关联的任何系统资源。
abstract int read()
从输入流读取数据的下一个字节。
int read(byte[] b)
从输入流读取一些字节数，并将它们存储到缓冲区 b 。
int read(byte[] b, int off, int len)
从输入流读取从off开始 最多len字节的数据到一个字节数组。
FileOutputStream
构造方法 ：
FileOutputStream(File file)
创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(File file, boolean append)
创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(String name)
创建文件输出流以指定的名称写入文件。
FileOutputStream(String name, boolean append)
创建文件输出流以指定的名称写入文件。
常用方法：
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)
将指定的字节写入此输出流。
示例代码：文件的拷贝
1 package 学习.IO; 2 3 import java.io.*; 4 5 public class Filecopy { 6 public static void main(String[] args) throws Exception { 7 String path1="D:\\学习\\IDEA project\\project\\src\\学习\\IO\\1.jpg"; 8 String path2="D:\\学习\\IDEA project\\project\\src\\学习\\IO\\2.jpg"; 9 copy(path1,path2); 10 } 11 12 public static void copy(String srcPath, String destPath) throws Exception { 13 //创建源 14 File src = new File(srcPath); 15 File dest = new File(destPath); 16 //选择流 17 InputStream in = new FileInputStream(src); 18 OutputStream out = new FileOutputStream(dest); 19 //操作 20 byte b[] = new byte[1024];//1k 21 int len = -1;//接收长度 22 while ((len = in.read(b)) != -1) { 23 out.write(b, 0, len); 24 out.flush(); 25 } 26 //释放资源，先打开的后关闭 27 out.close(); 28 in.close(); 29 } 30 }6.2 字节数组流（节点流）
- FileInputStream是把文件当做数据源，文件存储在硬盘上，JVM不能直接访问，需要借助操作系统，借用完后需要让系统释放资源，需要close
- ByteArrayInputStream则是把内存中的”某个字节数组对象”当做数据源，是一块内存，JVM可以直接访问，与操作系统无关，最后由垃圾回收机制释放，不需要close
- 任何东西都可以转换为字节数组
- 文件可以无限制加内容，而内存量小，不允许字节数组太大
ByteArrayInputStream
构造方法：（数据源为字节数组）
ByteArrayInputStream(byte[] buf)
创建一个 ByteArrayInputStream ，使其使用 buf作为其缓冲区数组。
ByteArrayInputStream(byte[] buf, int offset, int length)
创建 ByteArrayInputStream使用 buf作为其缓冲器阵列。
常用方法：
int available()
返回可从此输入流读取（或跳过）的剩余字节数。
void close()
关闭 ByteArrayInputStream没有任何效果。
int read()
从该输入流读取下一个数据字节。
int read(byte[] b, int off, int len)
将 len字节的数据读入此输入流中的字节数组。
ByteArrayOutputStream
构造方法：（可以不要目的地，数组写入缓冲区，最后要获取数据）
ByteArrayOutputStream()
创建一个新的字节数组输出流。
ByteArrayOutputStream(int size)
创建一个新的字节数组输出流，具有指定大小的缓冲区容量（以字节为单位）。
常用方法：
void close()
关闭 ByteArrayOutputStream没有任何效果。
byte[] toByteArray()
创建一个新分配的字节数组。
void write(byte[] b, int off, int len)
从指定的字节数组写入 len字节，从偏移量为 off开始，输出到这个字节数组输出流。
void write(int b)
将指定的字节写入此字节数组输出流。
void flush()
刷新此输出流并强制任何缓冲的输出字节被写出。
示例代码：读字节数组
package 学习.IO; import java.io.ByteArrayInputStream; import java.io.InputStream; public class bytearrayin { public static void main(String[] args) throws Exception { //创建源,为字节数组 byte a[] = ("还不错").getBytes(); //选择流 InputStream in = new ByteArrayInputStream(a); //操作 byte b[] = new byte[1024]; int len = -1; while ((len = in.read(b)) != -1) { String str = new String(b, 0, len); System.out.println(str); } } }示例代码：写出字节数组
package 学习; import java.io.ByteArrayOutputStream; import java.io.OutputStream; public class bytearrayout { public static void main(String[] args) throws Exception { //创建源 byte arr[] = null; //选择流 OutputStream out = new ByteArrayOutputStream(); //操作 byte a[] = "我".getBytes(); out.write(a, 0, a.length); out.flush(); //获取数据 arr = ((ByteArrayOutputStream) out).toByteArray(); System.out.println(new String(arr, 0, arr.length)); } }
6.3 字节缓冲流（包装流）
- 缓冲流提高了性能
- 任何处理流最底层是节点流
- 只需要释放最外层的处理流，内部会自动释放节点流
BufferedInputStream
构造方法：（处理流的流，处理节点流）
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使用。
BufferedInputStream(InputStream in, int size)
创建 BufferedInputStream具有指定缓冲区大小，并保存其参数，输入流 in ，供以后使用。
常用方法：
int available()
返回从该输入流中可以读取（或跳过）的字节数的估计值，而不会被下一次调用此输入流的方法阻塞。
void close()
关闭此输入流并释放与流相关联的任何系统资源。
int read()
见 read法 InputStream的一般合同。
int read(byte[] b, int off, int len)
从给定的偏移开始，将字节输入流中的字节读入指定的字节数组。
BufferedOutputStream
构造方法：（处理流的流，处理节点流）
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
BufferedOutputStream(OutputStream out, int size)
创建一个新的缓冲输出流，以便以指定的缓冲区大小将数据写入指定的底层输出流。
常用方法
void flush()
刷新缓冲输出流。
void write(byte[] b, int off, int len)
从指定的字节数组写入 len个字节，从偏移 off开始到缓冲的输出流。
void write(int b)
将指定的字节写入缓冲的输出流。
代码示例：
package 学习.IO; import java.io.*; public class bfstream { public static void main(String[] args) throws IOException { InputStream inputStream = new BufferedInputStream(new FileInputStream("abc.txt")); OutputStream outputStream = new BufferedOutputStream(new FileOutputStream("abc-copy.txt")); byte b[] = new byte[1024]; int len = -1; while ((len = inputStream.read(b)) != -1) { outputStream.write(b, 0, len); } inputStream.close(); outputStream.close(); }
6.4：数据流（包装流）
- 写出后读取
- 读取的顺序与写出保持一致
操作基本数据类型与字符串
DataInputStream
数据输入流允许应用程序以独立于机器的方式从底层输入流读取原始Java数据类型。 应用程序使用数据输出流来写入稍后可以被数据输入流读取的数据
构造方法：
DataInputStream(InputStream in)
创建使用指定的底层InputStream的DataInputStream
常用方法：
int read(byte[] b)
从包含的输入流中读取一些字节数，并将它们存储到缓冲区数组 b 。
int read(byte[] b, int off, int len)
从包含的输入流读取最多 len个字节的数据为字节数组。
boolean readBoolean()
见的总承包 readBoolean的方法 DataInput 。
byte readByte()
见的总承包 readByte的方法 DataInput 。
char readChar()
见 readChar方法的总合同 DataInput 。
double readDouble()
见 readDouble方法 DataInput的总体合同。
float readFloat()
见 readFloat法 DataInput的一般合同。
void readFully(byte[] b)
见的总承包 readFully的方法 DataInput 。
void readFully(byte[] b, int off, int len)
见的总承包 readFully的方法 DataInput 。
int readInt()
见 readInt方法 DataInput的一般合同。
long readLong()
见的总承包 readLong的方法 DataInput 。
short readShort()
见 readShort方法 DataInput的一般合同。
int readUnsignedByte()
见的总承包 readUnsignedByte的方法 DataInput 。
int readUnsignedShort()
见 readUnsignedShort法 DataInput的一般合同。
String readUTF()
见 readUTF法 DataInput的一般合同。
static String readUTF(DataInput in)
从流in读取以modified UTF-8格式编码的Unicode字符串的表示; 这个字符串然后作为String返回。
DataOutputStream
数据输出流使应用程序以便携式方式将原始Java数据类型写入输出流。 然后应用程序可以使用数据输入流来读取数据。
构造方法：
DataOutputStream(OutputStream out)
创建一个新的数据输出流，以将数据写入指定的底层输出流。
常用方法：
void flush()
刷新此数据输出流。
int size()
返回计数器的当前值 written ，到目前为止写入此数据输出流的字节数。
void write(byte[] b, int off, int len)
写入 len从指定的字节数组起始于偏移 off基础输出流。
void write(int b)
将指定的字节（参数 b的低8位）写入底层输出流。
void writeBoolean(boolean v)
将 boolean写入底层输出流作为1字节值。
void writeByte(int v)
将 byte作为1字节值写入底层输出流。
void writeBytes(String s)
将字符串作为字节序列写入基础输出流。
void writeChar(int v)
将 char写入底层输出流作为2字节值，高字节优先。
void writeChars(String s)
将字符串写入底层输出流作为一系列字符。
void writeDouble(double v)
双参数传递给转换 long使用 doubleToLongBits方法在类 Double ，然后写入该 long值基础输出流作为8字节的数量，高字节。
void writeFloat(float v)
浮子参数的转换 int使用 floatToIntBits方法在类 Float ，然后写入该 int值基础输出流作为一个4字节的数量，高字节。
void writeInt(int v)
将底层输出流写入 int作为四字节，高位字节。
void writeLong(long v)
将 long写入底层输出流，为8字节，高字节为首。
void writeShort(int v)
将 short写入底层输出流作为两个字节，高字节优先。
void writeUTF(String str)
使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流。
示例代码：
package 学习.IO; import java.io.*; public class datastream { public static void main(String[] args) throws Exception { //写出 ByteArrayOutputStream bao = new ByteArrayOutputStream(); DataOutputStream out = new DataOutputStream(new BufferedOutputStream(bao)); //操作数据类型+数据 out.writeBoolean(true); out.writeChar('c'); out.writeDouble(3.12); out.writeUTF("我喜欢高楚楚"); out.flush(); byte[] dates = bao.toByteArray(); //读取 DataInputStream in = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(dates))); //顺序与写出一致 boolean flag = in.readBoolean(); char c = in.readChar(); double d = in.readDouble(); String str = in.readUTF(); System.out.println(flag + " " + c + " " + d + " " + str); in.close(); out.close(); } }
6.5：对象流（包装流）
可以操作各种类型以及自定义对象
- 不是所有对象都可以序列化，只有支持java.io.Serializable接口的对象才能写入流中
- 必须先写出后读取
- 读取顺序和写出顺序保持一致
ObjectInputStream （反序列化）
反序列化先前使用ObjectOutputStream编写的原始数据和对象。
构造方法：
ObjectInputStream()
为完全重新实现ObjectInputStream的子类提供一种方法，不必分配刚刚被ObjectInputStream实现使用的私有数据。
ObjectInputStream(InputStream in)
创建从指定的InputStream读取的ObjectInputStream
常用方法：
int available()
返回可以读取而不阻塞的字节数。
void close()
关闭输入流。
int read()
读取一个字节的数据。
int read(byte[] buf, int off, int len)
读入一个字节数组。
boolean readBoolean()
读取布尔值。
byte readByte()
读取一个8位字节。
char readChar()
读一个16位字符。
double readDouble()
读64位双倍。
float readFloat()
读32位浮点数。
int readInt()
读取一个32位int。
long readLong()
读64位长。
Object readObject()
从ObjectInputStream读取一个对象。
short readShort()
读取16位短。
int readUnsignedByte()
读取一个无符号的8位字节。
int readUnsignedShort()
读取无符号16位短。
String readUTF()
以 modified UTF-8格式读取字符串。
ObjectOutputStream（序列化）
ObjectOutputStream将Java对象的原始数据类型和对象写入OutputStream
构造方法：
ObjectOutputStream()
为完全重新实现ObjectOutputStream的子类提供一种方法，不必分配刚刚被ObjectOutputStream实现使用的私有数据。
ObjectOutputStream(OutputStream out)
创建一个写入指定的OutputStream的ObjectOutputStream。
常用方法：
void close()
关闭流。
void flush()
刷新流。
void write(byte[] buf)
写入一个字节数组。
void write(byte[] buf, int off, int len)
写入一个子字节数组。
void write(int val)
写一个字节。
void writeBoolean(boolean val)
写一个布尔值。
void writeByte(int val)
写入一个8位字节。
void writeBytes(String str)
写一个字符串作为字节序列。
void writeChar(int val)
写一个16位的字符。
void writeChars(String str)
写一个字符串作为一系列的字符。
void writeDouble(double val)
写一个64位的双倍。
void writeFields()
将缓冲的字段写入流。
void writeFloat(float val)
写一个32位浮点数。
void writeInt(int val)
写一个32位int。
void writeLong(long val)
写一个64位长
void writeObject(Object obj)
将指定的对象写入ObjectOutputStream。
void writeShort(int val)
写一个16位短。
void writeUTF(String str)
此字符串的原始数据写入格式为 modified UTF-8 。
示例代码 ：
package 学习.IO; import java.io.*; import java.util.Date; public class objectstream { public static void main(String[] args) throws IOException, ClassNotFoundException { //写出----》序列化 ByteArrayOutputStream bao = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bao)); //操作数据类型+数据 out.writeBoolean(true); out.writeChar('c'); out.writeDouble(3.12); out.writeUTF("我喜欢高楚楚"); //操作对象 out.writeObject("asdsa"); out.writeObject(new Date()); person p = new person(20, "zsr"); out.writeObject(p); //刷新 out.flush(); //获取对象 byte[] dates = bao.toByteArray(); //读取----》反序列化 ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(new ByteArrayInputStream(dates))); //顺序与写出一致 boolean flag = in.readBoolean(); char c = in.readChar(); double d = in.readDouble(); String str = in.readUTF(); //对象数据的还原 Object string = in.readObject(); Object date = in.readObject(); Object pe = in.readObject(); //判断类型 if (string instanceof String) { String strObj = (String) string; System.out.println(strObj); } if (date instanceof Date) { Date dateObj = (Date) date; System.out.println(dateObj); } if (pe instanceof person) { person personObj = (person) pe; System.out.println(personObj.getName() + " " + personObj.getAge()); } System.out.println(flag + " " + c + " " + d + " " + str); in.close(); out.close(); } } //必须实现可序列化接口 class person implements Serializable { private transient int age;//该数据不需要序列化 private String name; public person(int age, String name) { this.age = age; this.name = name; } public person() { } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } }
6.6 打印流PrintStream
PrintStream为另一个输出流添加了功能，即能够方便地打印各种数据值的表示。
还提供了另外两个功能：
- 与其他输出流不同， PrintStream从不抛出IOException ; 相反，异常情况只是设置一个可以通过checkError方法测试的内部标志。
- 可以选择一个PrintStream ，以便自动刷新; 这意味着flush字节数组写入方法后自动调用，所述一个println方法被调用时，或者一个新行字符或字节（ '\n' ）被写入。
构造方法：
PrintStream(File file)
使用指定的文件创建一个新的打印流，而不需要自动换行。
PrintStream(File file, String csn)
使用指定的文件和字符集创建新的打印流，而不需要自动换行。
PrintStream(OutputStream out)
创建一个新的打印流。
PrintStream(OutputStream out, boolean autoFlush)
创建一个新的打印流。
PrintStream(OutputStream out, boolean autoFlush, String encoding)
创建一个新的打印流。
PrintStream(String fileName)
使用指定的文件名创建新的打印流，无需自动换行。
PrintStream(String fileName, String csn)
创建一个新的打印流，不需要自动换行，具有指定的文件名和字符集。
常用方法：
PrintStream append(char c)
将指定的字符附加到此输出流。
PrintStream append(CharSequence csq)
将指定的字符序列附加到此输出流。
PrintStream append(CharSequence csq, int start, int end)
将指定字符序列的子序列附加到此输出流。
boolean checkError()
刷新流并检查其错误状态。
protected void clearError()
清除此流的内部错误状态。
void close()
关闭流。
void flush()
刷新流。
PrintStream format(Locale l, String format, Object... args)
使用指定的格式字符串和参数将格式化的字符串写入此输出流。
PrintStream format(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)
打印字符串。
PrintStream printf(Locale l, String format, Object... args)
使用指定的格式字符串和参数将格式化的字符串写入此输出流的便利方法。
PrintStream printf(String format, Object... args)
使用指定的格式字符串和参数将格式化的字符串写入此输出流的便利方法。
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()
将流的错误状态设置为 true 。
void write(byte[] buf, int off, int len)
从指定的字节数组写入 len个字节，从偏移 off开始到此流。
void write(int b)
将指定的字节写入此流
示例代码：
package 学习.IO; import java.io.*; public class printstream { public static void main(String[] args) throws FileNotFoundException { //打印流System.out PrintStream ps = System.out; ps.println(1); ps.print(true); ps = new PrintStream(new BufferedOutputStream(new FileOutputStream("print.txt")), true); ps.print("我"); ps.println(1314); //重定向输出端 System.setOut(ps); System.out.println("嘿嘿！"); //重定向回控制台 System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)), true)); System.out.println("我回来了"); ps.close(); } }
七：字符流
目录：
文件字符流（节点流）
字节缓冲流（包装流）
转换流
打印流PrintWriter
字符流用于直接操作字符的流对象
顶层抽象类
Reader
Writer
Reader(字符，字符数组)
用于读取字符流的抽象类.子类必须实现的唯一方法是read(char [],int,int)和close(). 而，大多数子类将覆盖这里定义的一些方法，以便提供更高的效率，附加的功能或两者
常用方法：
int read()
读取一个完整的字符，如果返回-1表示到达文件末尾
int read(char[] chs)
读取一系列字符到一个字符数组中
abstract int read(char[] cbuf, int off, int len)
将字符读入数组的一部分
close()
关闭流并释放与之相关联的任何系统资源
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)
写一个字符串的一部分。
- 字符流是在字节流的基础上实现的，字符流将字节流按照相应的编码方式转化为字符流
- 字节流面向计算机，字符流面向人类
7.1 文件字符流
FileReader
按照字符的方式，从文件读取信息
构造方法：
FileReader(File file)
创建一个新的 FileReader ，给出 File读取。
FileReader(String fileName)
创建一个新的 FileReader ，给定要读取的文件的名称。
常用方法：
int read()
读取一个完整的字符，如果返回-1表示到达文件末尾
int read(char[] chs)
读取一系列字符到一个字符数组中
abstract int read(char[] cbuf, int off, int len)
将字符读入数组的一部分
close()
关闭流并释放与之相关联的任何系统资源
FileWriter
构造方法：
FileWriter(String path)
FileWrtier(File f)
将一个路径封装成字符输出流，如果文件存在，则先清空
FileWriter(String path, boolean append)
FileWriter(File f, boolean append)
将一个路径封装成字符输出流，如果第二个参数为true，则在文件存在的情况下，可以追加
常用方法：
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)
写一个字符串的一部分。
示例代码：读文件
package 学习.IO; import java.io.File; import java.io.FileReader; import java.io.Reader; public class charin { public static void main(String[] args) throws Exception { //创建源 File src = new File("D:/学习/IDEA project/project/src/学习/IO/abc.txt"); //选择流 Reader reader = new FileReader(src); //操作（读取） char b[] = new char[1024]; int len = -1; while ((len = reader.read(b)) != -1) { String string = new String(b, 0, len); System.out.println(string); } //释放资源 reader.close(); } }示例代码：写文件
package 学习.IO; import java.io.*; public class charout { public static void main(String[] args) throws Exception { //创建源 File src = new File("D:/学习/IDEA project/project/src/学习/IO/destination.txt"); //选择流 Writer writer = new FileWriter(src); //操作（写出） writer.write("真不错"); writer.append("我喜欢你").append("高楚楚"); //释放资源 writer.close(); } }
7.2 字符缓冲流（包装流）
BufferedReader
构造方法：
BufferedReader(Reader in)
创建使用默认大小的输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz)
创建使用指定大小的输入缓冲区的缓冲字符输入流。
常用方法：
void close()
关闭流并释放与之相关联的任何系统资源。
int read()
读一个字符
int read(char[] cbuf, int off, int len)
将字符读入数组的一部分。
String readLine()
读一行文字。
BufferedWriter
构造方法 ：
BufferedWriter(Writer out)
创建使用默认大小的输出缓冲区的缓冲字符输出流
BufferedWriter(Writer out, int sz)
创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区
常用方法：
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)
写一个字符串的一部分。
Writer append(char c)
将指定的字符附加到此作者。
Writer append(CharSequence csq)
将指定的字符序列(字符串)附加到此作者。
Writer append(CharSequence csq, int start, int end)
将指定字符序列的子序列附加到此作者。
示例代码：
package 学习.IO; import java.io.*; public class bufferstream { public static void main(String[] args) throws IOException { BufferedReader bufferedReader = new BufferedReader(new FileReader("abc.txt")); BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("abc-1.txt")); String line = null; while ((line=bufferedReader.readLine()) != null) { bufferedWriter.write(line); bufferedWriter.newLine(); } bufferedWriter.close(); bufferedReader.close(); } }
7.3 转换流
- 将字节流转换为字符流（为纯文本）
- 可以指定字符集
InputStreamReader
是从字节流到字符流的桥：它读取字节，并使用指定的charset将其解码为字符 。它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
构造方法：
InputStreamReader(InputStream in)
创建一个使用默认字符集的InputStreamReader。
InputStreamReader(InputStream in, Charset cs)
创建一个使用给定字符集的InputStreamReader。
InputStreamReader(InputStream in, CharsetDecoder dec)
创建一个使用给定字符集解码器的InputStreamReader。
InputStreamReader(InputStream in, String charsetName)
创建一个使用命名字符集的InputStreamReader。
常用方法：
void close()
关闭流并释放与之相关联的任何系统资源。
String getEncoding()
返回此流使用的字符编码的名称。
int read()
读一个字符
int read(char[] cbuf, int offset, int length)
将字符读入数组的一部分。
boolean ready()
告诉这个流是否准备好被读取。
OutputStreamWriter
从字符流到字节流的桥梁：使用指定的charset将写入的字符编码为字节。它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
构造方法：
OutputStreamWriter(OutputStream out)
创建一个使用默认字符编码的OutputStreamWriter。
OutputStreamWriter(OutputStream out, Charset cs)
创建一个使用给定字符集的OutputStreamWriter。
OutputStreamWriter(OutputStream out, CharsetEncoder enc)
创建一个使用给定字符集编码器的OutputStreamWriter。
OutputStreamWriter(OutputStream out, String charsetName)
创建一个使用命名字符集的OutputStreamWriter。
常用方法：
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)
写一个字符串的一部分。
代码示例： 爬取百度的源代码,网络流
package 学习.IO; import java.io.*; import java.net.URL; /** * 爬取百度的源代码,网络流 */ public class convertstream2 { public static void main(String[] args) throws IOException { InputStream inputStream = new URL("http://www.baidu.com").openStream(); InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8"); BufferedReader bufferedReader = new BufferedReader(inputStreamReader); BufferedWriter bufferedWriter = new BufferedWriter( new OutputStreamWriter( new FileOutputStream("baidu.html"), "utf-8")); String str = ""; while ((str = bufferedReader.readLine()) != null) { bufferedWriter.write(str); bufferedWriter.flush(); } bufferedWriter.close(); bufferedReader.close(); } }
7.4 打印流
PrintWriter
- 将对象的格式表示打印到文本输出流。 这个类实现了全部在发现print种方法PrintStream 。 它不包含用于编写原始字节的方法，程序应使用未编码的字节流。
- 不像PrintStream类，如果启用自动刷新，它只会在调用的println，printf，或format方法来完成，而不是当一个换行符恰好是输出。 这些方法使用平台自己的行分隔符而不是换行符。
构造方法：
PrintWriter(File file)
使用指定的文件创建一个新的PrintWriter，而不需要自动刷新。
PrintWriter(File file, String csn)
使用指定的文件和字符集创建一个新的PrintWriter，而不需要自动刷新。
PrintWriter(OutputStream out)
从现有的OutputStream创建一个新的PrintWriter，而不需要自动刷新。
PrintWriter(OutputStream out, boolean autoFlush)
从现有的OutputStream创建一个新的PrintWriter。
PrintWriter(String fileName)
使用指定的文件名创建一个新的PrintWriter，而不需要自动执行刷新。
PrintWriter(String fileName, String csn)
使用指定的文件名和字符集创建一个新的PrintWriter，而不需要自动刷新。
PrintWriter(Writer out)
创建一个新的PrintWriter，没有自动刷新
PrintWriter(Writer out, boolean autoFlush)
创建一个新的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(Locale l, String format, Object... args)
使用指定的格式字符串和参数将格式化的字符串写入此写入程序。
PrintWriter format(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(Locale l, String format, Object... args)
使用指定的格式字符串和参数将格式化的字符串写入该writer的方便方法。
PrintWriter printf(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)
写一个字符串的一部分。
THE END........
