流的概念
可以理解为数据的流动。就是一个数据流
输入流
输出流
流的概念使得文件、网络、内存等设备可以被统一处理。用来处理设备之间的数据传输
IO流体系
InputStream
字节输入流的抽象类
常用操作 read(): 读入一个字节 read(byte[]): 读入多个字节 close(): 关闭此输入流
示例代码
InputStream in = new FileInputStream("src\\a.txt");
/**
* 通过循环将数据放在b中,此处不可写成以下形式,读取两次
* while((in.read())!=-1){
* System.out.println((char)(in.read()));
* }
*/
byte[] b = new byte[1024];
int len;
//将内容每次按字节数组读取并放在数组b中,len为读取数组的长度
while((len=in.read(b))!=-1){
System.out.println(len);
System.out.println(new String(b,0,b.length));
}
BufferedInputStream
缓冲流
构造方法
BufferedInputStream(InputStream) 默认8kb
BufferedInputStream(InputStream,int)
InputStream is = new FileInputStream("D:/a.txt");
InputStream bis = new BufferedInputStream(is);
// 3、定义一个字节数组转移数据
byte[] buffer = new byte[4];
int len; // 记录每次读取的字节数。
while ((len = bis.read(buffer)) != -1){
System.out.println(len);
System.out.println(new String(buffer, 0 , len));
}
OutputStream
字节输出流的抽象类
常用操作
write(byte[]):向输出流写多个字节
flush(): 清空缓存
close(): 关闭此输出流
常见构造方法
FileOutStream(String filePath)
FileOutStream(String filePath,boolean append)
OutputStream out=new FileOutputStream("d:/3.txt");
OutputStream out=new FileOutputStream("d:/1.txt",true);
示例代码:
InputStream in = new FileInputStream("D:/a.txt");
OutputStream out = new FileOutputStream("d:/a1.txt");
try {
byte[] buffer = new byte[1024];
int b;
// System.out.println(in.read(b));
//将内容每次按字节数组读取并放在数组b中,返回读取的数组长度
while ((b = in.read(buffer)) != -1) {
String inputStr =new String(buffer, 0, b);
//执行写数据操作
out.write(inputStr.getBytes());
out.flush();
}
}
BufferedOutputStream
为输出流提供缓冲区
示例代码,执行拷贝
// 1、创建低级的字节输入流与源文件接通
InputStream is = new FileInputStream("D:/a.txt");
// a.把原始的字节输入流包装成高级的缓冲字节输入流
InputStream bis = new BufferedInputStream(is);
// 2、创建低级的字节输出流与目标文件接通
OutputStream os = new FileOutputStream("D:/a2.txt");
// b.把字节输出流管道包装成高级的缓冲字节输出流管道
OutputStream bos = new BufferedOutputStream(os);
// 3、定义一个字节数组转移数据
byte[] buffer = new byte[1024];
int len; // 记录每次读取的字节数。
while ((len = bis.read(buffer)) != -1) {
bos.write(buffer, 0, len);
bos.flush();
}
bos.close();
os.close();
bis.close();
is.close();
Reader
字符输入流的抽象类
常用操作 read(): 读入一个字符 read(char[]): 读入多个字符 close(): 关闭此输入流
示例代码
// 1、创建一个文件字符输入流与源文件接通
Reader fr = new FileReader("src\\a.txt");
// 2、用循环,每次读取一个字符数组的数据。
char[] buffer = new char[1024]; // 1K字符
int len;
while ((len = fr.read(buffer)) != -1) {
String rs = new String(buffer, 0, len);
System.out.print(rs);
}
BufferedReader
为字符输入流增加缓存
构造方法参数为Reader
新增操作 readLine 读入一行,返回String
示例代码
Reader fr = new FileReader("src\\a.txt");
// a、把低级的字符输入流包装成高级的缓冲字符输入流。
BufferedReader br = new BufferedReader(fr);
char[] ch = new char[1024];
int len;
while ((len = br.read(ch)) != -1) {
String rs = new String(ch, 0, len);
System.out.print(rs);
}
try {
// 1、创建一个文件字符输入流与源文件接通。
Reader fr = new FileReader("src\\a.txt");
// a、把低级的字符输入流包装成高级的缓冲字符输入流。
BufferedReader br = new BufferedReader(fr);
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
Writer
字符输出流,
常用操作
write(int): 向输出流写一个字符
write(char[]):向输出流写多个字符
write(String): 向输出流写入一个字符串
flush(): 清空缓存
close(): 关闭此输出流
BufferedWriter
示例代码,执行拷贝操作
// 1、创建一个文件字符输入流与源文件接通。
Reader fr = new FileReader("src\\a.txt");
// a、把低级的字符输入流包装成高级的缓冲字符输入流。
BufferedReader br = new BufferedReader(fr);
Writer wr = new FileWriter("src\\a1.txt");
// a、把低级的字符输入流包装成高级的缓冲字符输出流。
BufferedWriter bw = new BufferedWriter(wr);
char[] ch = new char[1024];
int len;
while ((len = br.read(ch)) != -1) {
String rs = new String(ch, 0, len);
wr.write(rs);
bw.flush();
}
基本数据类型与对象的输入输出流
基本类型 DataInputStream DataOutputStream,支持类型 8种基本类型 字符串
注意事项 必须配合使用,DataInputStream只能用来读取DataOutputStream写的数据
示例代码
FileOutputStream out = new FileOutputStream("D:/h.txt");
//DataOutputStream可以将各种各样的数据转换为二进制
DataOutputStream dout = new DataOutputStream(out);
String name = "zhangsan";
int num = 100;
float f = 100.8f;
double d = 10088.00d;
//表示这个字符串有多长,8个字节的字符串,还有两个字节的前缀,会写入10个字节
dout.writeUTF(name);
//4个字节
dout.writeInt(num);
//4个字节
dout.writeFloat(f);
//8个字节
dout.writeDouble(d);
FileInputStream in = new FileInputStream("D:/h.txt");
DataInputStream din = new DataInputStream(in);
String readUTF = din.readUTF();
System.out.println(readUTF);
int readInt = din.readInt();
System.out.println(readInt);
float readFloat = din.readFloat();
System.out.println(readFloat);
double readDouble = din.readDouble();
System.out.println(readDouble);
对象类型 ObjectInputStream ObjectOutputStream
与Serializable接口结合使用,
首先定义个实体类:例如person类,包括姓名和年龄两个字段(用transient关键字标志不进行序列化的状态),实体类实现Serializable接口
示例代码,将对象序列化到文件中
File file = new File("d:/"+File.separator+"out.txt");
Person p1 = new Person("jack", 19);
Person p2 = new Person( "mary", 22);
List<Person> list = new ArrayList();
list.add(p1);
list.add(p2);
// 创建文件流
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream os = new ObjectOutputStream(fos);
os.writeObject(list);
os.close();
System.out.println("serialization success");
读取序列化文件
File file = new File("d:/"+File.separator+"out.txt");
FileInputStream fis = new FileInputStream(file);
ObjectInputStream is = new ObjectInputStream(fis);
List<Person> list = new ArrayList<>();
try {
list = (List<Person>)is.readObject();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
is.close();
//遍历list,输出
for (Person person:list){
System.out.println(person.toString());
}
File类
File对象代表磁盘上的文件或目录
常用构造方法
常用方法
文件工具类的使用
将相关jar包导入项目中进行使用
File f = new File("d:"+File.separator+"demo"+File.separator+"1.txt");
// File f1 = new File("d://demo");
//File f = new File("d://demo","1.txt");
Io工具包:
FileUtils.copyFile(new File("D://demo//1.txt"),new File("d://demo1//1.txt"));
FileUtils.deleteDirectory(new File("D://demo"));
FileUtils.copyFile(new File("D://demo//1.txt"),new File("d://demo1//1.txt"));
IOUtils.copy(new FileInputStream("D:\\resources\\hushui.jpeg"),
new FileOutputStream("D:\\resources\\hushui2.jpeg"));
// // 2.完成文件复制到某个文件夹下!
FileUtils.copyFileToDirectory(new File("D:\\resources\\hushui.jpeg"), new File("D:/"));
FileUtils.deleteDirectory(new File("D://demo"));