一、IO流
数据传输是需要通道的，而IO流就是数据传输的通道。
1、IO流的分类：
1.1、根据操作的数据类型的不同可以分为 ：字节流与字符流。
- 1字符 = 2字节 、 1字节(byte) = 8位(bit) 、 一个汉字占两个字节长度
- 字节流：每次读取一个字节，也就是数据单元是8位的字节；
- 字符流：每次读取两个字节，也就是数据单元是16位的字节；
1.2、根据数据的流向分为：输入流与输出流。
- 程序（内存）作为参照物，程序从外部读取称为输入（Input），程序向外部写数据成为输出（Output）。
2、IO流的结构
IO流
二、字节流
字节流的抽象基类：InputStream，OutputStream
1、字节基础流
1.1、inputStream
InputStream类是字节输入流的抽象类，是所有字节输入流的父类，可以读取字节信息到内存中。
常用方法：
-
public abstract int read()： 从输入流读取数据的下一个字节。 -
public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 -
public void close()：关闭此输入流并释放与此流相关联的任何系统资源。
1.2、outputStream
InputStream类是字节输出流的抽象类，是所有字节输出流的父类，可以写入字节信息到内存中。
常用方法：
-
public void write(byte[] b):将 b.length 个字节从指定的 byte 数组写入此输出流 -
publicvoid write(byte[] b, int off, int len): 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流 -
public void close()：关闭此输入流并释放与此流相关联的任何系统资源。 -
public void flush()：刷新此输出流并强制写出所有缓冲的输出字节.
1.3、总结
InputStream和OutputStream是所有字节流的超类，但它们是抽象类，不能直接使用，需要用它相应的子类来实例化。在Java API中所有以这两个类为后缀名的类均属于字节流。
2、字节文件流
2.1、FileInputStream
public class FileInputStream extends InputStream
FileInputStream从文件系统中的文件中获得输入的字节数据
常用方法：
- FileInputStream(File file)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
//要注意的是123.txt文件必须存在而且要保证是可读的。
FileInputStream fis = new FileInputStream("c:\\123.txt");
2.2、FileOutputStream
public class FileOutputStream extends OutputStream
FileOutputStream是一个向文件(File)中或者文件描述符(FileDescriptor)中写入数据的输出流
常用方法：
- FileOutputStream(File file)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 - FileOutputStream(File file, boolean append)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
//若输出文件已经存在了，那么必须是可以覆盖的，如果不存在，则会创建。
FileOutPutStream fos = new FileOutPutStream("c:\\345.txt");
2.3、案例
使用字节缓冲流实现文件的复制
public class CopyTxt {
public static void main(String[] args) throws IOException {
BufferedInputStream bfin=new FileInputStream("E:\\1.txt");
BufferedOutputStream bfout=new FileOutputStream("E:\\2.txt");
int len=0;
byte[] buff=new byte[1024];
while((len=bfin.read(buff))!=-1) {
bfout.write(buff, 0, len);
}
bfin.close();
bfout.close();
}
3、字节缓冲流
3.1、BufferedInputStream
public class BufferedInputStream extends FilterInputStream
- 字节缓冲输入流，继承了FileInputStream，提高了读取效率。
- 它提供了一个缓冲数组，每次调用read方法的时候，它首先尝试从缓冲区里读取数据，若读取失败（缓冲区无可读数据），则选择从物理数据源（譬如文件）读取新数据（这里会尝试尽可能读取多的字节）放入到缓冲区中，最后再将缓冲区中的内容部分或全部返回给用户.由于从缓冲区里读取数据远比直接从物理数据源（譬如文件）读取速度快。
3.2、BufferedOutputStream
public class BufferedOutputStream extends FilterOutputStream
- 字节缓冲输出流，继承了FileOutPutStream，提高了写出效率。
- 内部通过字节数组进行缓存，也就是数据不直接写入磁盘，而是先写入到内部缓冲区中，借助于内部底层的流进行真正写入缓冲的功能,减少了跟底层磁盘直接交互的io次数，从而提高效率。
3.3、总结
字节缓冲流对处理流进行装饰，增强，内部会有一个缓存区，用来存放字节，每次都是将缓存区存满然后发送，而不是一个字节或两个字节这样发送。效率更高
3.4、案例
例：使用字节缓冲流实现文件的复制
public class CopyTxt {
public static void main(String[] args) throws IOException {
BufferedInputStream bfin=new BufferedInputStream(new FileInputStream("E:\\1.txt"));
BufferedOutputStream bfout=new BufferedOutputStream(new FileOutputStream("E:\\2.txt"));
int len=0;
byte[] buff=new byte[1024];
while((len=bfin.read(buff))!=-1) {
bfout.write(buff, 0, len);
}
bfin.close();
bfout.close();
}
三、字符流
字符流的抽象基类：Reader，Writer
1、字符基础流
1.1、Reader
字符输入流,，是所有的输入字符流的父类，它是一个抽象类。
常用方法：
- int read() //读取单个字符。
- int read(char[] cbuf) //将字符读入数组。
- abstract void close() //关闭该流并释放与之关联的所有资源。
1.2、Writer
字符输出流，是所有的输出字符流的父类，它是一个抽象类。
常用方法：
void write(char[] cbuf)// 写入字符数组
void write(String str)// 写入字符串
Writer append(char c)// 将指定字符添加到此 writer
Writer append(CharSequence csq)// 将指定字符序列添加到此 writer
abstract void close()// 关闭此流，但要先刷新它
abstract void flush()// 刷新该流的缓冲
1.3、总结
Reader和Writer是所有字符流的超类，但它们是抽象类，不能直接使用，需要用它相应的子类来实例化。在Java API中所有以这两个类为后缀名的类均属于字符流。
2、字符文件流
2.1、FileReader
public class FileReader extends InputStreamReader
文件字符输入流。
常用方法：
- FileReader(File file)
在给定从中读取数据的 File 的情况下创建一个新 FileReader。
2.2、FileWriter
public class FileWriter extends OutputStreamWriter
文件字符输出流。
常用方法：
- FileWriter(File file)
根据给定的 File 对象构造一个 FileWriter 对象。
2.3、案例
public static void main(String[] args) throws Excetpion {
FileWriter out = new FileWriter("hello.txt");
out.write ("aaabbbccc"); //在此可以直接写入字符串，不用转化为字节数组
out.close();
char[] buf = new char[1024]; //字符数组
FileReader in = new FileReader("hello.txt");
int len = in.read(buf); //此时的read方法可以读取一个字符或几个字符,len代表实际读取到的字符的个数。
System.out.println(new String(buf,0,1024)); //String构造函数把字符数组转化为字符串。
in.close();
}
3、字符缓冲流
3.1、BufferedReader
public class BufferedReader extends Reader
字符缓冲流，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
案例：
//读取一个文本文件
BufferedReader reader = new BufferedReader(new FileReader("1.txt"));
String str;
//一次性读取一行
while ((str = reader.readLine()) != null) {
System.out.println(str);
}
3.2、BufferedWriter
public class BufferedWriter extends Writer
字符缓冲流，将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
案例：
//创建一个字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("1.txt")) ;
bw.write("abc");
bw.write("de");
bw.flush(); //刷新流
bw.close();//关闭资源
四、转换流
InputStreamReader和OutputStreamWriter是字符和字节的桥梁，也可称之为字符转换流。原理：字节流+编码。
1、InputStreamReader
public class InputStreamReader extends Reader
是字节流通向字符流的桥梁
常用方法
void close() //关闭该流并释放与之关联的所有资源。
String getEncoding() //返回此流使用的字符编码的名称。
int read() //读取单个字符。
int read(char[] cbuf, int offset, int length) //将字符读入数组中的某一部分。
boolean ready() //判断此流是否已经准备好用于读取。
案例
public static void transReadByBuf() throws IOException {
/**
* 使用缓冲区 可以使用缓冲区对象的 read() 和 readLine()方法。
*/
//读取字节流
//InputStream in = System.in;//读取键盘上的数据
InputStream in = new FileInputStream("D:\\demo.txt");//读取文件上的数据。
//将字节流向字符流的转换。
InputStreamReader isr = new InputStreamReader(in);//读取
//创建字符流缓冲区
BufferedReader bufr = new BufferedReader(isr);//缓冲
/*int ch =0;
ch = bufr.read();
System.out.println((char)ch);
*/
String line;
while((line = bufr.readLine())!=null){
System.out.println(line);
}
isr.close();
}
2、OutputStreamWriter
public class OutputStreamWriter extends Writer
是字符流通向字节流的桥梁
常用方法
String getEncoding() //返回此流使用的字符编码的名称。
void write(int c) //写入单个字符。
void write(char cbuf[], int off, int len) //写入字符数组的某一部分。
void write(String str, int off, int len) //写入字符串的某一部分。
void flush() //刷新该流的缓冲。
void close() //关闭此流，但要先刷新它。
案例
private static void testWrite() {
try {
// 创建文件“file.txt”对应File对象
File file = new File(FileName);
// 创建FileOutputStream对应OutputStreamWriter：将字节流转换为字符流，即写入out1的数据会自动由字节转换为字符。
OutputStreamWriter out1 = new OutputStreamWriter(new FileOutputStream(file), CharsetName);
// 写入10个汉字
out1.write("字节流转为字符流示例");
// 向“文件中”写入"0123456789"+换行符
out1.write("0123456789\n");
out1.close();
} catch(IOException e) {
e.printStackTrace();
}
}
3、总结
转换流的作用：文本文件在硬盘中以字节流的形式存储时，通过InputStreamReader读取后转化为字符流给程序处理，程序处理的字符流通过OutputStreamWriter转换为字节流保存。
五、对象操作流
1、ObjectInputStream
public class ObjectInputStream extends InputStream implements ObjectInput,ObjectStreamConstants
- 只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流读取。
- readObject 方法用于从流读取对象。应该使用 Java 的安全强制转换来获取所需的类型。在 Java 中，字符串和数组都是对象，所以在序列化期间将其视为对象。读取时，需要将其强制转换为期望的类型。
2、ObjectOutputStream
public class ObjectOutputStream extends OutputStream implements ObjectOutput,ObjectStreamConstants
ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。
将 Java 对象的基本数据类型和图形写入 OutputStream。只能使用 ObjectInputStream 读取（重构）对象
只能将支持 java.io.Serializable 接口的对象写入流中
writeObject 方法用于将对象写入流中。所有对象（包括 String 和数组）都可以通过 writeObject 写入。可将多个对象或基元写入流中。必须使用与写入对象时相同的类型和顺序从相应 ObjectInputstream 中读回对象。
构造方法：ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream。
3、案例
public static void main(String[] args) throws IOException
{
try
{
FileOutputStream fos = new FileOutputStream("c:\\1.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeInt(666);
oos.writeObject("hello");
oos.writeObject(new Date());
oos.close();
}
catch(Except e)
{}
}
六、打印流
1、PrintWriter
public class PrintWriter extends Writer
向文本输出流打印对象的格式化表示形式
- 它实现在 PrintStream 中的所有 print 方法。它不包含用于写入原始字节的方法，对于这些字节，程序应该使用未编码的字节流进行写入。
2、PrintStream
public class PrintStream extends FilterOutputStream implements Appendable, Closeable
将指定的字节写入此字节数组输出流
- PrintStream.print()也是打印数据，和println差不多，也可以输入java基本类型的数据，只不过是不会自动加上换行符
- PrintStream一般用得比较少，它能做的PrintWriter也都能实现，并且PrintWriter的功能更为强大，所以可以替代。
3、案例
/**
* 测试write(), print(), println(), printf()等接口。
*/
private static void testPrintWriterAPIS() {
final char[] arr={'a', 'b', 'c', 'd', 'e' };
try {
// 创建文件对应FileOutputStream
PrintWriter out = new PrintWriter("1.txt");
// 将字符串“hello PrintWriter”+回车符，写入到输出流中
out.println("hello PrintWriter");
// 将0x41写入到输出流中
// 0x41对应ASCII码的字母'A'，也就是写入字符'A'
out.write(0x41);
// 将字符串"65"写入到输出流中。
// out.print(0x41); 等价于 out.write(String.valueOf(0x41));
out.print(0x41);
// 将字符'B'追加到输出流中
out.append('B').append("CDEF");
// 将"CDE is 5" + 回车 写入到输出流中
String str = "GHI";
int num = 5;
out.printf("%s is %d\n", str, num);
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行结果：hello PrintWriter
A65BCDEFGHI is 5
七、序列化
1、序列化
序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象
- 对象序列化是一个用于将对象状态转换为字节流的过程，可以将其保存到磁盘文件中或通过网络发送到任何其他程序
- 通过实现java.io.Serializable接口，可以在Java类中启用可序列化。
- 一般Java对象的生命周期比Java虚拟机端，而实际开发中如果需要JVM停止后能够继续持有对象，则需要用到序列化技术将对象持久化到磁盘或数据库
- 在多个项目进行RPC调用时，需要在网络上传输JavaBean对象，而网络上只允许二进制形式的数据进行传输，这时则需要用到序列化技术。
2、反序列化
从字节流创建对象的相反的过程称为反序列化。
- 在一个平台上序列化的对象可以在不同的平台上反序列化。
3、transient关键字
transient修饰符可以保证某个成员变量不被序列化
- transient修饰符仅适用于变量，不适用于方法和类。在序列化时，如果我们不想序列化特定变量以满足安全约束，那么我们应该将该变量声明为transient。执行序列化时，JVM会忽略transient变量的原始值并将默认值保存到文件中。因此，transient意味着不要序列化。