12Java_IO框架

Java_IO框架

---

什么是流？

• 概念：内存与存储设备之间传输数据的通道

流的分类

---

按方向：

• 输入流： 将 存储设备 中的内容读入 内存
• 输出流： 将 内存 中的内容写入到 存储设备

按单位：

• 字节流：以字节为单位，可以读写所有数据
• 字符流：以字符为单位，只能读写文本数据

按功能：

• 节点流：具有实际传输数据的读写功能
• 过滤流：在节点流的基础之上增强功能

字节流

---

• 字节流的父类（抽象类）

  • InputStream:字节输入流

    read()

    FileInputStream:

    • public int read(byte[] b) // 从流中读取多个字节，将读到内存存入 b 数组，返回实际读到的字节数；如果达到文件的尾部，则返回 -1

  • OutputStream: 字节输出流

    write()

    • public int write(byte[] b) // 一次写多个字节，将b数组中所有字节，写入输出流

//创建FileInputStream 并指定文件路径
FileInputStream fis = new FileInputStream("d:\\aaa.txt");
// 读取文件
//fis.read()
//2.1单个字节读取
int data = 0;
while((data = fis.read())!= -1){
	System.out.println((char) data);
}
//
byte[] buf = new byte[1024];
int count = 0;
while((count = fis.read(buf)) != -1){
    new String(buf,0,count);
}
//关闭
fis.close();
//执行完毕

//文件字节输出流 FileOutPutStream
FileOutPutStream fos = new FileOutPutStream("d:\\bbb.txt"); // 若有重复就覆盖
// 文件路径 + true 就继续添加
//写入文件
fos.write(97);  // a 字符对应转换
fos.write();
String string = "helloword";
fos.wirte(string.getBytes); // 获取字符串对应的字节数
//关闭
fos.close();


// 使用文件字节流实现文件的复制
//1.创建文件字节输入流
FileInputStream fis = new FileInputStream("d:\\001.jpg");
//2.文件字节输出流
FileOutputStream fos = new FileOutputStream("d:\\002.jpg");
//一边读， 一边写
byte[] buf = new byte[1024];
int count = 0; // 保存实际读取的字节个数
while((count = fis.read(buf)) != -1){
    fos.write(buf,0,count); // 处理最后的数据
}
// 关闭
fis.close();
fos.close();

字节缓冲流

---

• 缓冲流： BufferedInputStream / BufferedOutputStream
  • 提高IO效率，减少访问磁盘的次数
  • 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close

// 使用字节缓冲流读取
//1.创建BufferedInputStream  增强节点流
FileInputStream fis = new FileInputStream("d:\\001.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
//读取缓冲区
int data = 0;
while((data = bis.read()) != -1){
    (char)data;
}
//关闭 直接关闭 缓存流就行
bis.clos();

//使用字节缓冲流写入文件
//BufferedOutputStream
// 创建字节输出缓冲流
FileOutputStream fos = new FileOutputStream("d:\\buffer,txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
//写入文本
bos.write("Helloword\r\n".getByte());
// 先写入8K的缓冲区中
bos.flush(); //刷新到硬盘
//关闭 内部会调用flush方法 关闭的时候会把缓冲区刷近硬盘，建议手动操作 因为缓冲区满了就会丢失数据 
bos.close();

对象流

---

• 对象流 ObjectOutputStream / ObjectInputStream
  • 增强了缓冲区功能
  • 增强了读写8种基本数据类型和字符串功能
  • 增强了读写对象的功能
    • readObject() 从流中读取一个对象
    • writeObject(Object obj) 向流中写入一个对象
  • 使用流传输对象的过程称为 序列化、反序列化

序列化

将对象通过流写入到文件，或将对象通过流读取到内存

// 使用objectOutputStream实现对象的序列化
//创建对象流
FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//序列化(写入操作)
Student zhangsan= new Student("张三",20);
// 序列化的类必须要实现 序列化标记 implements Serializable
oos.writeObject(zhangsan); //写入对象
// 关闭
oos.close();

反序列化

// 使用ObjectInputStream 实现反序列化(读取重构成对象)
// 创建对象流
FileInputStream fis = new FileInputStream("d:\\stu.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
// 读取文件(反序列化)
Student s = (Student)ois.readObject();
// 关闭
ois.close();

序列化和反序列化注意事项

1.序列化类必须要实现Serializable接口
2.序列化类中对象属性要求实现Serializable接口
3.SerializableID,版本ID保证序列化的类和反序列化的类是同一个类
4.使用transient修饰属性，这个属性不能序列化
5.静态属性不能序列化
6.序列化多个对象，可以借助集合来实现 ArrayList

字符编码

---

UTF-8 针对Unicode码表的可变长度字符编码

GB2312 简体中文

GBK 简体中文、扩充

BIG5 台湾、繁体中文

当编码方式和解码方式不一致时，会出现乱码

字符流

---

字符流的父类（抽象类）

• Reader: 字符输入流
• Writer: 字符输出流

//使用FileReader 读取文件
//创建FileReader 文件字符输入流
FileReader fr = new FileReader("d:\\111.txt");
//读取一个字符
int data = 0;
while((data = fr.read()) != -1){
    (char)data;
}
char[] buf = char[1024];
int cout = 0;
while((count = fr.read(buf))!= -1){
    new String(buf,0,count);
}
//关闭
fr.close();

//使用FileWriter写入文件
FileWriter fw = new FileWriter("d:\\111.txt");
fw.write();  // 写入
fw.flush(); // 更新
fw.close(); // 关闭

//字符流复制文件  复制文本文件，不能复制图片或二进制文件
//使用 FileWriter 和 FileReader
//创建 FileWriter 和 FileReader
FileReader fr = new FileReader("d:\\111.txt");
FileWriter fw = new FileWriter("d:\\222.txt");
//读写
int data = 0;
while((data = fr,read()) != -1){
    fw.write(data);
}
//关闭
fr.close();
fw.close();
// 字符流都是编码的，二进制转换成字符编码，所以图片 音频信息就不能读取对应信息，只能复制文本文件
//所以使用字节流复制文件

字符缓冲流

---

缓冲流： BufferedReader / BufferedWriter

• 高效读写
• 支持输入换行符
• 可一次写一行，读一行

详细查看API！~

//使用字符缓冲流读取文件
//创建缓冲流
FileReader fr = new FileReader("d:\\111.txt");
BufferedReader br = new BufferedReader(fr);
//1.读取
char[] buf = new char[1024]; 
int count = 0;
while((count = br.read()) != -1){
    new String(buf,0,count);
}
//2.读取 一行一行的读
String line = null;
while((line = br.readLine()) != null){
    line;
} 
//关闭 
br.close();

//BufferedWriter 的使用
//创建
FileWriter fw = new FileWriter("d:\\222.txt");
BufferedWriter bw = new BufferedWriter(fw);
//写入
bw.write();
bw.newLine();  //写入一个换行符 
bw.flush();
bw.close();

打印流

---

PrintWriter:

• 封装了print() / println()方法，支持写入后换行，
• 支持数据原样打印

//创建打印流
PrintWriter pw = new PrintWriter("d:\\111.txt");
//打印
pw.print();
pw.println();
pw.flush();
pw.close();

转换流

---

桥转换流： InputStreamReader / OutputStreamWriter

• 可将字节流转换为字符流
• 可设置字符的编码方式

//InputStreamReader 读取文件，指定使用的编码
//1.创建InputStreamReader 对象
FileInputStream fis = new FileInputStream("d:\\s.txt");
InputStreamReader isr = new InputStreamReader(fis,"utf-8");  //指定读取的编码方式
//2. 读取文件
int data = 0;
while((data = isr.read()) != -1){
    (char)data;
}
isr.close();

//OutputStreamWriter 写入文件，使用指定的编码
// 创建
FileOutputStream fos = new FileOutputStream("d:\\stu.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
osw.write("写入内容");
osw.flush();
osw.close();

File类

---

概念：代变物理盘符中的一个文件夹或文件

createNewFile();// 创建一个新文件
mkdir(); //创建一个新目录
delete(); // 删除
exists(); // 判断File对象所代表的对象是否存在
getAbsolutePath(); //获取文件的绝对路径
getName(); // 取得名字
getParent(); //获取文件 / 目录所在的目录
isDirectory(); //是否是目录
isFile(); //是否是文件
length(); //获得文件的长度
listFiles(); //列出目录中的所有内容
renameTo(); //修改文件名为

//File类的使用
//1.分隔符  2.文件操作  3.文件夹操作
File.pathSeparator;  //路径分隔符 ;
File.separator;    // 名称分隔符 \

//文件操作-------
//1.创建文件
File file = new File("d:\\file.txt"); //指定路径 创建文件对象
file.createNewFile(); //创建文件 布尔值返回 是否成功
file.exists();  // 是否纯在
//2.删除文件
file.delete();
//使用jvm退出时删除
file.deleteOnExit();
//3.获取文件信息
file.getAbsolutePath();   //获取绝对路径
file.getPath(); //获取路径
file.getName(); //获取文件名称
file.getParent(); //获取父目录
file.length(); //获取文件长度
new Date(file.lastMidified()).toLocaleString();//获取文件最后的创建时间
//4.判断
file.canWrite(); // 是否可写？
file.isFile(); // 是否是文件
file.isHidden(); //是否隐藏

//文件夹操作
//1. 创建文件夹
File dir = new File("d:\\aaa\\bbb");
if(!dir.exists()){
    dir.mkdir(); //只能创建单级目录
    dir.mkdirs(); //创建多级目录
}
//2. 删除文件夹
// 直接删除
dir.delete();  //删除必须是一个空目录
//jvm 退出时删除
dir.deleteOnExit();
Thread.sleep(5000); //过五秒
// 3.获取文件夹信息
dir.getAbsolutePath();   //获取绝对路径
dir.getPath(); //获取文件路径
dir.getName(); //获取文件夹名称
dir.getParent(); //获取父目录
new Date(dir.lastMidified()).toLocaleString();//获取文件夹最后的创建时间
// 4.判断
dir.isDirectory(); //是否是文件夹
dir,isHidden(); // 是否是隐藏的
// 5.遍历文件夹
File dir2 = new File("d:\\图片");
String[] files = dir2.list();
for(String s : files){
    s;
}

FileFilter接口

---

boolean accept(File pathname)

• 当调用File类中的ListFiles()方法时，支持传入FileFilter接口 接口实现类，对获取文件进行过滤，只有满足条件的文件才可以出现在ListFiles()的返回值中。

File[] files2 = dir2.listFiles(new FileFilter(){
    
    //匿名定义类
    public boolean accept(File pathname){
        if(pathname.getName().endsWish(".jpg"))
            return true;
        return false;
    }
});

//递归遍历文件夹 file 下所有内容显示出来
public static void listDir(File dir){
    File[] files = dir.listFiles();
    if(files != null && files.length()>0){
        for(File file : files){
            if(file.isDirectory())
                listDir(file);  //递归
            else{
                file.getAbsolutePath();
            }
        }
    }
}

//递归删除文件夹
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{
                file.delete();
            }
        }
    }
    // 最后删除空的文件夹
    dir.delete();
}

补充 Properties

---

属性集合：

• 存储属性名和属性值
• 属性名和属性值都是字符串类型
• 没有泛型
• 和流有关

//创建集合
Properties properties = new Properties();
properties.setProperty();
//遍历
// keySet
// entrySet 方法
Set<String> pronames = properties.stringPropertyNames();
// 对应 .getProperty();
// 和流有关的方法
// ----list 方法
PrintWriter pw = new PrintWriter("d:\\print.txt");
properties.list(pw);
pw.close();
// 保存的方法  store 方法
properties.store();
FileOutputStream fos = new FileOutputStream("d:\\stu.properties");
properties.store(fos,"注释");
fos.close();
// load 加载方法
Properties properties2 = new Properties();
FileInputStream fis = new FileInputStream("d:\\stu.properties");
properties2.load(fis);
fis.close();