文章目录
一、缓冲字节流
- 缓冲流是基于内存的io,而文件流是基于硬盘的io,所有缓存流比较快,大概比文件流快75000多倍。
- 缓冲的字节输入流使用BufferInputStream对象和其read()方法,且BufferedIuputStream的构造函数需要FileInputStream对象作为参数传进去。
/**
* 缓冲字节输入流
* BufferedInputStream
* @throws Exception
*/
public static void testBufferedInputStream() throws Exception{
//文件字节输入流对象
FileInputStream in = new FileInputStream("D:\\testdemo\\demo\\src\\day13\\tt.txt");
//把文件字节输入流放到缓冲字节输入流对象
BufferedInputStream br = new BufferedInputStream(in);
byte[] b = new byte[10];
int len = 0;
while((len = br.read(b)) != -1){
System.out.println(new String(b,0,len));
}
//关闭流的时候,本着一个最晚开的最早关,依次关
br.close();
in.close();
}
- 缓冲的字节输入流使用BufferedOutputStream对象和其write()方法,且BufferedOutputStream的构造函数需要FileOuputStream对象作为参数传进去。
/**
* 缓冲字节输出流
* BufferedOutputStream
*/
public static void testBufferedOutputStream() throws Exception{
//创建字节输出流对象
FileOutputStream out = new FileOutputStream("D:\\testdemo\\demo\\src\\day13\\tt1.txt");
//把字节输出流对象放到缓冲字节输出流中
BufferedOutputStream bo = new BufferedOutputStream(out);
String s = "hello world";
bo.write(s.getBytes());//写到内存中
bo.flush();//刷到硬盘上
//关闭流的时候,本着一个最晚开的最早关,依次关
bo.close();
out.close();
}
- 缓冲字节流流实现文件复制
/**
* 缓冲流实现文件的复制
*/
public static void copyFile() throws Exception{
//缓冲输入流
BufferedInputStream br = new BufferedInputStream(new FileInputStream("D:\\testdemo\\demo\\src\\day13\\tt1.txt"));
//缓冲输出流
BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream("D:\\testdemo\\demo\\src\\day13\\tt2.txt"));
byte[] b = new byte[1024];
int len = 0;//设置一个没出读取到的数据的长度,直到br.read方法执行到最后(比如说文件中只有hello world,执行到最后一个就读取d的后面,这个时候返回值就是-1)
while((len = br.read(b)) != -1){
bo.write(b, 0, len);//写到内存
}
bo.flush();//刷到硬盘
bo.close();
br.close();
}
二、缓冲字符流
缓冲字节流和缓冲字符流的关系和 文件字节流和文件字符流的关系一样。
- 缓存的字节输入流使用BufferedReader 对象和其read()方法,且BufferedReader 的构造函数需要FileReader 对象作为参数传进去。
/**
* 缓冲字符输入流
* BufferedReader
*/
public static void testBufferedReader() throws Exception{
FileReader r = new FileReader("D:\\testdemo\\demo\\src\\day13\\tt.txt");
BufferedReader br = new BufferedReader(r);
char[] c = new char[100];
int len = 0;
while((len = br.read(c)) != -1){//br.read(c)读到文件的最后一个字符的下一位,返回值就是-1
System.out.println(new String(c, 0, len));
}
br.close();
r.close();
}
- 缓冲的字节输入流使用BufferedReader 对象和其write()方法,且BufferedReader 的构造函数需要FileReader 对象作为参数传进去。
/**
* 缓冲字符输出流
* BufferedWriter
*/
public static void testBufferedWriter() throws Exception{
FileWriter fw = new FileWriter("D:\\testdemo\\demo\\src\\day13\\tt3.txt");
BufferedWriter bw = new BufferedWriter(fw);
String s = "hello world!!!!";
bw.write(s);
bw.flush();
bw.close();
fw.close();
}
- 缓存字符流流实现文件复制
/**
* 缓冲字符流复制文件
*/
public static void copyFile() throws Exception{
BufferedReader br = new BufferedReader(new FileReader("D:\\testdemo\\demo\\src\\day13\\tt3.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\testdemo\\demo\\src\\day13\\tt4.txt"));
char[] c = new char[100];
int len = 0;
while((len = br.read(c)) != -1){
bw.write(c, 0, len);
}
bw.flush();
bw.close();
br.close();
}
- 注意:
- 对于输出的缓冲流,写出的数据会先在内存中缓存,使用flush()将会使内存中的数据立刻写出
- 缓冲流是把数据缓冲到内存中
三、转换流
转换输入流InputStreamReader,其构造方法有两个参数参数1是字节流对象,参数2是编码格式。
转换输入流OutputStreamWriter,其构造方法有两个参数参数1是字节流对象,参数2是编码格式。
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
/**
* 转换流
* 可以把字节流转换为字符流
* 当字节流中的数据都是字符的时候,使用转换流转为字符流处理效率更高
*
*
*/
public class Test2 {
public static void main(String[] args) {
//所有的文件都是有编码格式
//对于我们来说,TXT和java文件一般来讲有三种编码
//ISO8859-1,西欧编码,是纯粹英文编码,不适应汉字
//GBK和UTF-8,这两编码是适用于重要和英文
//我们一般使用UTF-8编码
try {
// Test2.testInputStreamReader();
Test2.testOutputStreamWriter();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 转换字节输入流为字符输入流
* 注意,在转换字符流的时候,设置的字符集编码要与读取的文件的数据的编码一致
* 不然就会出现乱码
* InputStreamReader
*/
public static void testInputStreamReader() throws Exception{
FileInputStream fs = new FileInputStream("D:\\testdemo\\demo\\src\\day13\\tt5.txt");
//把字节流转换为字符流
InputStreamReader in = new InputStreamReader(fs,"GBK");//参数1是字节流,参数2是编码
// InputStreamReader in = new InputStreamReader(fs,"UTF-8");//参数1是字节流,参数2是编码
char[] c = new char[100];
int len = 0;
while((len = in.read(c)) != -1){
System.out.println(new String(c,0,len));
}
in.close();
fs.close();
}
/**
* 转换字节输出流为字符输出流
* 注意,在转换字符流的时候,设置的字符集编码要与读取的文件的数据的编码一致
* 不然就会出现乱码
* OutputStreamWriter
*/
public static void testOutputStreamWriter() throws Exception{
FileOutputStream out = new FileOutputStream("D:\\testdemo\\demo\\src\\day13\\tt6.txt");
// OutputStreamWriter os = new OutputStreamWriter(out, "UTF-8");
OutputStreamWriter os = new OutputStreamWriter(out, "GBK");
os.write("你好你好");
os.flush();
os.close();
out.close();
}
}
四、标准输入输出流、打印流和数据流
- 标准输入输出流
- System.in和System.out分别代表了系统标准的输入和输出设备
- 默认输入设备是键盘,输出设备是显示器
- System.in的类型是InputStream
- System.out的类型是PrintStream,其是OutputStream的子类FilterOutputStream 的子类
- 打印流
- PrintStream(字节打印流)和PrintWriter(字符打印流)提供了一系列重载的print和println方法,用于多种数据类型的输出
- PrintStream和PrintWriter的输出不会抛出异常
- PrintStream和PrintWriter有自动flush功能
System.out返回的是PrintStream的实例
- 数据流
-
为了方便地操作Java语言的基本数据类型的数据,可以使用数据流。
-
数据流有两个类:(用于读取和写出基本数据类型的数据)
DataInputStream 和 DataOutputStream
分别“套接”在 InputStream 和 OutputStream 节点流上
DataInputStream中的方法boolean readBoolean() byte readByte() char readChar() float readFloat() double readDouble() short readShort() long readLong() int readInt() String readUTF() void readFully(byte[] b) DataOutputStream中的方法
将上述的方法的read改为相应的write即可。
五、对象流
所使用的类对象ObjectInputStream和OjbectOutputSteam。
用于存储和读取对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中,也能把对象从数据源中还原回来。
需要思考的问题:
1. 把对象存到电脑硬盘上,硬盘存储的基础是什么?
二进制,那就需要把对象转化为一个二进制的字节流,把这个流保存到电脑上,要使用这个对象,就得流转化为对象再使用。
2. 把对象通过网络传到另一个机器上,网络的通信基础是什么?
二进制,也就是需要把一个对象转化为二进制的数据流,把这个流通过网络进行传输,在接收者如果使用接收的对象就得先把对象得流转化为对象。
3. 基于以上两个问题我们就还要问怎么将 对象->流->对象呢?
这时就需要序列化和反序列化
5.1序列化
-
序列化(Serialize):用ObjectOutputStream类将一个Java对象写入IO流中
-
反序列化(Deserialize):用ObjectInputStream类从IO流中恢复该Java对象
-
ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
-
对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流,从而允许把这种二进制流持久地保存在磁盘上,或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流,就可以恢复成原来的Java对象
-
序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据,使其在保存和传输时可被还原
-
序列化是 RMI(Remote Method Invoke – 远程方法调用)过程的参数和返回值都必须实现的机制,而 RMI 是 JavaEE 的基础。因此序列化机制是 JavaEE 平台的基础
-
如果需要让某个对象支持序列化机制,则必须让其类是可序列化的,为了让某个类是可序列化的,该类必须实现如下两个接口之一:
Serializable
Externalizable
5.1.1序列化Serializable接口的serialVersionUID
- 凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量:
private static final long serialVersionUID;
serialVersionUID用来表明类的不同版本间的兼容性 - 如果类没有显示定义这个静态变量,它的值是Java运行时环境根据类的内部细节自动生成的。若类的源代码作了修改,serialVersionUID 可能发生变化。故建议,显示声明
显示定义serialVersionUID的用途:
- 希望类的不同版本对序列化兼容,因此需确保类的不同版本具有相同的serialVersionUID
- 不希望类的不同版本对序列化兼容,因此需确保类的不同版本具有不同的serialVersionUID
- 创建一个可序列化的对象
import java.io.Serializable;
/**
* 可以序列化与反序列化的对象
*
*
*/
public class Person implements Serializable{
/**
* 一个表示序列化版本标识符的静态变量
* 用来表明类的不同版本间的兼容性
*/
private static final long serialVersionUID = 1L;
public String name;
public int age;
}
- 序列化和反序列化
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* 序列化与反序列化
* 注意:对象的序列化与反序列化使用的类要严格一致,包名,类名,类机构等等所有都要一致
*
*
*/
public class Test5 {
public static void main(String[] args) {
try {
// Test5.testSerialize();
Test5.testDeserialize();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 对象的序列化
*/
public static void testSerialize() throws Exception{
//定义对象的输出流,把对象的序列化之后的流放到指定的文件中
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:/testdemo/demo/src/day13/tt9.txt"));
Person p = new Person();
p.name = "zhangsan";
p.age = 11;
out.writeObject(p);
out.flush();//刷写数据到硬盘
out.close();
}
/**
* 对象的反序列化
*/
public static void testDeserialize() throws Exception{
//创建对象输入流对象,从指定的文件中把对象序列化后的流读取出来
ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:/testdemo/demo/src/day13/tt9.txt"));
Object obj = in.readObject();
Person p = (Person)obj;
//这个时候序列化与反序列化使用的类不是一个类分别是day13.Person和day13.test.Person
//这个时候反序列化就有异常day13.Person cannot be cast to day13.test.Person
// day13.test.Person p = (day13.test.Person)obj;
System.out.println(p.name);
System.out.println(p.age);
in.close();
}
}
六、随机存取流–RandomAccessFile 类
RandomAccessFile 类支持 “随机访问” 的方式,程序可以直接跳到文件的任意 地方来读、写文件.
- 支持只访问文件的部分内容
- 可以向已存在的文件后追加内容
- RandomAccessFile 对象包含一个记录指针,用以标示当前读写处的位置。
- RandomAccessFile 类对象可以自由移动记录指针:
4.1. long getFilePointer():获取文件记录指针的当前位置
4.2. void seek(long pos):将文件记录指针定位到 pos 位置
-
构造器
public RandomAccessFile(File file, String mode)
public RandomAccessFile(String name, String mode) -
创建 RandomAccessFile 类实例需要指定一个 mode 参数,该参数指定 RandomAccessFile 的访问模式:
- r: 以只读方式打开
- rw:打开以便读取和写入
- rwd:打开以便读取和写入;同步文件内容的更新
- rws:打开以便读取和写入;同步文件内容和元数据的更新
-
RandomAccess流例子
import java.io.RandomAccessFile;
/**
* 文件的随机读写
* 程序可以直接跳到文件的任意 地方来读、写文件
*
*
*/
public class Test6 {
public static void main(String[] args) {
try {
// Test6.testRandomAccessFileRead();
Test6.testRandomAccessFileWrite();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 随机读文件
*/
public static void testRandomAccessFileRead() throws Exception{
//RandomAccessFile的构造有两个参数,参数1是读写的文件的路径
//参数2是指定 RandomAccessFile 的访问模式
//r: 以只读方式打开
//rw:打开以便读取和写入
//rwd:打开以便读取和写入;同步文件内容的更新
//rws:打开以便读取和写入;同步文件内容和元数据的更新
//最常用是r和rw
RandomAccessFile ra = new RandomAccessFile("D:/testdemo/demo/src/day13/tt10.txt", "r");
// ra.seek(0);//设置读取文件内容的起始点
ra.seek(8);//通过设置读取文件内容的起始点,来达到从文件的任意位置读取
byte[] b = new byte[1024];
int len = 0;
while((len = ra.read(b)) != -1){
System.out.println(new String(b, 0, len));
}
ra.close();
}
/**
* 随机写
*/
public static void testRandomAccessFileWrite() throws Exception{
RandomAccessFile ra = new RandomAccessFile("D:/testdemo/demo/src/day13/tt10.txt", "rw");
// ra.seek(0);//设置写的起始点,0代表从开头写
//注意:如果是在文件开头或者中间的某个位置开始写的话,就会用写的内容覆盖掉等长度的原内容
ra.seek(ra.length());//设置写的起始点,ra.length()代表从文件的最后结尾写,也就是文件的追加
ra.write("你好".getBytes());
ra.close();
}
}