20_IO
IO框架
一. 流的概念
- 概念：内存与存储设备之间传输数据的通道
- 水借助管道传输；数据借助流传输
二. 流的分类
- 按方向【重点】
- 输入流：将<存储设备>中的内容读入到<内存>中
- 输出流：将<内存>中的内容读入到<存储设备>中
- 文件——>输入流——>程序——>输出流——>文件
- 按单位
- 字节流：以字节为单位，可以读写所有数据
- 字符流：以字符为单位，只能读写文本数据
- 按功能
- 节点流：具有实际传输数据的读写功能
- 过滤流：在节点流的基础之上增强功能
三. 字节流
1. 字节流的父类（抽象类）
- InputStream：字节输入流
- public int read(){}
- public int read(byte[] b){}
- public int read(byte[] b, int off, int len){}
- OutputStream：字节输出流
- public int write(){}
- public int write(byte[] b){}
- public int write(byte[] b, int off, int len){}
2. 文件字节流
- FileInputStream：
- public int read(byte[] b) //从流中读取多个字节，将读到的内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1
- FileOutputStream
- public void write(byte[] b) //一次写多个字节，将b数组中所有字节，写入输出流
文件字节输入流(FileInputStream)
//1. 创建字节文件输入流对象 FileInputStream
FileInputStream fis = new FileInputStream("d:\\aaa.txt");
//2. 读取文件
//2.1 读取单个字节
// int data = 0;
// while ((data = fis.read()) != -1){
// System.out.print((char) data);
// }
//2.2 一次读取多个字节
byte[] buf = new byte[1024];
int count = 0;
while ((count = fis.read(buf)) != -1){
System.out.print(new String(buf,0,count));
}
//3. 关闭
fis.close();
System.out.println();
System.out.println("执行完毕");
文件字节输出流(FileOutputStream)
//1. 创建字节文件输出流对象 FileOutputStream
FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);//true代表继续往文件里追加数据
//2. 写入文件
fos.write(97);
fos.write('b');
fos.write('c');
String string = "Hello world";
fos.write(string.getBytes());
//3. 关闭
System.out.println("执行完毕");
使用文件字节流实现文件的复制
//1. 创建流
//1.1文件字节输入流
FileInputStream fis = new FileInputStream("D:\\谷歌下载\\4K壁纸.jpg");
//1.2文件字节输出流
FileOutputStream fos = new FileOutputStream("D:\\谷歌下载\\4K壁纸1.jpg");
//2. 一边读，一边写
byte[] buf = new byte[1024];
int count = 0;
while ((count = fis.read(buf)) != -1){
fos.write(buf,0,count);
}
//3. 关闭
fis.close();
fos.close();
System.out.println("复制完成");
3. 字节缓冲流
- 字节缓冲流：BufferedInputStream/BufferedOutputStream
- 提高I/O效率，减少访问磁盘的次数
- 数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close
使用字节缓冲流读取文件
//1. 创建BufferedInputStream
FileInputStream fis = new FileInputStream("d:\\bbb.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
//2.读取
int data = 0;
while ((data = bis.read()) != -1){
System.out.print((char)data);
}
//3. 关闭
bis.close();
使用字节缓冲流启动文件
//1. 创建字节输出缓冲流
FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
//2.写入文件
for (int i = 0; i < 10; i++) {
bos.write("hello world\r\n".getBytes());//写入到8K缓冲区
bos.flush();//刷新到硬盘
}
//3. 关闭(同时内部调用flush方法，一次性刷新所有数据到硬盘)
bos.close();
4. 对象流
- 对象流：ObjectOutputStream/ObjectInputStream
- 增强了缓冲区功能
- 增强了读写8种基本数据类型和字符串功能
- 增强了读写对象的功能
- readObject() 从流中读取一个对象
- writeObject(Object obj) 向流中写入一个对象
- 使用流传输对象的过程称为序列化，反序列化
序列化
//注意：
//(1)序列化的类必须要实现Serializable接口
//(2)序列化类中的对象属性也要实现Serializable接口
//(3)序列化版本号ID,保证序列化的类和反序列化的类是同一个类
//(4)使用transient（瞬间的）修饰属性，这个属性不能序列化
//(5)静态属性不能被序列化
//(6)序列化多个对象，可以借助集合实现
//1. 创建对象流
FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//2. 序列化（写入操作）
Student jay = new Student("杰",22);
oos.writeObject(jay);
//3. 关闭
oos.close();
System.out.println("序列化完毕");
反序列化
//1. 创建对象流
FileInputStream fis = new FileInputStream("d:\\stu.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
//2. 读取文件（反序列化）
Student s = (Student) ois.readObject();
//3. 关闭
ois.close();
System.out.println("执行完毕");
System.out.println(s.toString());
四. 编码方式
- 字符编码
- ISO-8859-1
- 收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号
- UTF-8
- 针对Unicode码表的可变长度字符编码
- GB2312
- 简体中文
- GBK
- 简体中文、扩充
- BIG5
- 台湾，繁体中文
- ISO-8859-1
- 当编码方式和解码方式不一致时，会出现乱码
五. 字符流
1. 字符流的父类（抽象类）
- Reader:字符输入流
- public int read(){}
- public int read(char[] c){}
- public int read(char[] c, int off, int len){}
- Writer:字符输出流
- public int write(){}
- public int write(char[] c){}
- public int write(char[] c, int off, int len){}
2. 文件字符流
- FileReader:
- public int read(char[] c)//从流中读取多个字符。将读到内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1
使用FileReader读取文件
//1. 创建FileReader 文件字符输入流
FileReader fr = new FileReader("d:\\hello.txt");
//2. 读取
//2.1 单个字符读取
// int data = 0;
// while ((data = fr.read()) != -1){
// System.out.print((char) data);
// }
//2.2 多个字符读取
char[] buf = new char[2];
int count = 0;
while ((count = fr.read(buf)) != -1){
System.out.print(new String(buf,0,count));
}
//3. 关闭
fr.close();
- FileWriter:
- public void write(String str)//一次读写多个字符，将b数组中所有字符，写入输出流
使用FileWriter写入文件
//1. 创建FileWriter对象
FileWriter fw = new FileWriter("d:\\hello.txt");
//2. 写入数据
for (int i = 0; i < 5; i++) {
fw.write("java是世界上最好的语言\r\n");
fw.flush();
}
//3. 关闭
fw.close();
使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件
字节流可复制任意文件
//1.创建对象
FileReader fr = new FileReader("d:\\hello.txt");
FileWriter fw = new FileWriter("d:\\hello1.txt");
//2. 边读边写
int count = 0;
char[] ch = new char[2];
while ((count = fr.read(ch)) != -1){
fw.write(ch,0,count);
fw.flush();
}
//3. 关闭
fr.close();
fw.close();
System.out.println("复制完毕");
3. 字符缓冲流
- 字符缓冲流：BufferedReader/BufferedWriter
- 高效读写
- 支持输入换行符
- 可一次写一行、读一行
BufferedReader
//1. 创建缓冲流
FileReader fr = new FileReader("d:\\hello.txt");
BufferedReader br = new BufferedReader(fr);
//2. 读取
//2.1 第一种方法
// char[] buf = new char[1024];
// int count = 0;
// while ((count = br.read(buf)) != -1){
// System.out.println(new String(buf,0,count));
// }
//关闭
//2.2 第二种方法 一次读一行
String line = null;
while ((line = br.readLine()) != null){
System.out.println(line);
}
br.close();
BufferedWriter
//1. 创建字符缓冲流
FileWriter fw = new FileWriter("d:\\hello.txt");
BufferedWriter bw = new BufferedWriter(fw);
//2. 写入数据
for (int i = 0; i < 5; i++) {
bw.write("java天下第一");
bw.newLine();//写入一个换行符 windows \r\n linux \n
bw.flush();
}
//3. 关闭
bw.close();
4. 打印流
- PrintWriter
- 封装了print()/println()方法，支持写入后换行
- 支持数据原样打印
//1. 创建打印流
PrintWriter pw = new PrintWriter("d:\\print.txt");
//2. 打印
pw.println(97);
pw.println(true);
pw.println(3.14);
pw.println('a');
//3. 关闭
pw.close();
System.out.println("打印完毕");
六. 转换流
InputStreamReader读取文件
//1. 创建InputStreamReader对象
FileInputStream fis = new FileInputStream("d:\\hello.txt");
InputStreamReader isr = new InputStreamReader(fis, "utf-8");
//2. 读取 一个一个字符读
int data = 0;
while ((data = isr.read()) != -1){
System.out.print((char) data);
}
//3. 关闭
isr.close();
OutputStreamWriter写入文件，使用指定编码
//1. 创建OutputStreamWriter
FileOutputStream fos = new FileOutputStream("d:\\info.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");
//2. 写入
for (int i = 0; i < 5; i++) {
osw.write("王者再见\r\n");
osw.flush();
}
//3. 关闭
osw.close();
System.out.println("执行完毕");
七. File类
概念：代表物理盘符中的一个文件或者文件夹
1. 方法
createNewFile()//创建一个新文件
mkdir()//创建一个新目录
delete()//删除文件或空目录
exits()//判断File对象所代表的对象是否存在
getAbsolutePath()//获取文件的绝对路径
getName()//取得名字
getParent()//获取文件/目录所在的目录
isDirectory()//是否是目录
isFile()//是否是文件
length()//获得文件的长度
listFiles()//列出目录中的所有内容
renameTo()//修改文件名为
2. FileFilter接口
- public interface FileFilter
- boolean accept(File pathname)
- 当调用File类中的listFiles()方法时，支持传入FileFilter接口j接口实现类，对获取文件进行过滤，只有满足条件的文件才可出现在listFiles()的返回值中
package com.io.demo04;
import java.io.File;
import java.io.FileFilter;
import java.util.Date;
public class Demo01 {
public static void main(String[] args) throws Exception{
separator();
fileOpe();
directoryOpe();
}
//(1) 分隔符
public static void separator() {
System.out.println("路径分隔符：" + File.pathSeparator);// ;
System.out.println("名称分隔符：" + File.separator);// \
}
//(2) 文件操作
public static void fileOpe() throws Exception{
//1. 创建文件
File file = new File("d:\\file.txt");
//System.out.println(file.toString());
if (!file.exists()){
boolean b = file.createNewFile();
System.out.println("创建结果：" + b);
}
//2. 删除文件
//2.1 直接删除
//System.out.println("删除结果：" + file.delete());
//2.2 使用JVM退出时删除
//file.deleteOnExit();
//Thread.sleep(5000);//5秒后删除
//3. 获取文件信息
System.out.println("获取文件绝对路径：" + file.getAbsolutePath());
System.out.println("获取路径：" + file.getPath());
System.out.println("获取文件名称：" + file.getName());
System.out.println("获取父目录：" + file.getParent());
System.out.println("获取文件长度：" + file.length());
System.out.println("获取文件创建时间：" + new Date(file.lastModified()).toLocaleString());
//4. 判断
System.out.println("是否可写：" + file.canWrite());
System.out.println("是否是文件：" + file.isFile());
System.out.println("是否隐藏：" + file.isHidden());
}
//(3) 文件夹操作
public static void directoryOpe() throws Exception{
//1. 创建文件夹
File dir = new File("d:\\aaa\\bbb\\ccc");
System.out.println(dir.toString());
if (!dir.exists()){
//dir.mkdir只能创建单个文件夹
System.out.println("创建结果：" + dir.mkdirs());//mkdirs创建多级目录
}
//2. 删除文件夹
//2.1 直接删除
//System.out.println("删除结果：" + dir.delete());//只删除最底层的空文件夹
//2.2 使用JVM删除
//dir.deleteOnExit();
//Thread.sleep(5000);
//3. 获取文件夹信息
System.out.println("获取绝对路径：" + dir.getAbsolutePath());
System.out.println("获取路径：" + dir.getPath());
System.out.println("获取文件夹名称：" + dir.getName());
System.out.println("获取父目录：" + dir.getParent());
System.out.println("获取文件夹创建时间：" + new Date(dir.lastModified()).toLocaleString());
//4. 判断
System.out.println("是否是文件夹：" + dir.isDirectory());
System.out.println("是否隐藏：" + dir.isHidden());
//5. 遍历文件夹
File dir2 = new File("d:\\文件");
File[] files = dir2.listFiles();
System.out.println("--------------------");
for (File file : files) {
System.out.println(file);
}
//6. FileFilter接口的使用
System.out.println("-----------FileFilter接口的使用-----------");
File[] files2 = dir2.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
return pathname.getName().endsWith(".txt");
}
});
for (File file : files2) {
System.out.println(file.getName());
}
}
}
3. 递归遍历和递归删除
package com.io.demo04;
import java.io.File;
public class ListDemo {
public static void main(String[] args) {
listDir(new File("d:\\aaa"));
deleteDir(new File("d:\\aaa"));
}
//案例1. 递归遍历文件夹
public static void listDir(File dir){
File[] files = dir.listFiles();
System.out.println(dir.getAbsolutePath());
if (files != null && files.length >0){
for (File file : files) {
if (file.isDirectory()){
listDir(file);//递归
}else{
System.out.println(file.getAbsolutePath());
}
}
}
}
//案例2 递归删除文件夹
public static void deleteDir(File dir){
File[] files = dir.listFiles();
if (files != null && files.length > 0){
for (File file : files) {
if (file.isDirectory()){
deleteDir(file);//递归
}else{
//删除
System.out.println(file.getAbsolutePath() + "删除:" + file.delete());
}
}
}
System.out.println(dir.getAbsolutePath() + "删除:" + dir.delete());
}
}
八.Properties集合
- Properties:属性集合
- 特点：
- 存储属性名和属性值
- 属性名和属性值都是字符串类型
- 没有泛型
- 和流有关
//1. 创建集合
Properties properties = new Properties();
//2. 添加数据
properties.setProperty("张三","18");
properties.setProperty("李四","20");
properties.setProperty("王五","19");
System.out.println(properties.toString());
//3. 遍历
//3.1---keySet---
//3.2---entrySet---
//3.3---stringPropertyNames()---
Set<String> proNames = properties.stringPropertyNames();
for (String proName : proNames) {
System.out.println(proName + ":" + properties.getProperty(proName));
}
//4. 和流有关的方法
//------1. list方法------
PrintWriter pw = new PrintWriter("d:\\print.txt");
properties.list(pw);
pw.close();
//------2. store方法------
// FileWriter fw = new FileWriter("d:\\store.properties");
// properties.store(fw,"注释");
// fw.close();
//------3. load方法------
Properties properties1 = new Properties();
FileReader fr = new FileReader("d:\\store.properties");
properties1.load(fr);
System.out.println(properties1.toString());
