Java IO框架

I/O框架

什么是流

• 概念：内存与存储设备之间传输数据的通道。
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-72mGHw62-1615108051169)(D:\QQ\78214218\FileRecv\MobileFile\qq_pic_merged_161240541618.jpg)]

流的分类

• 按方向【重点】：

  • 输入流：将<存储设备>中的内容读到<内存>中。

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

    输入流 输出流

文件 ---------------------------------->程序--------------------------------------->文件

• 按单位：
  • 字节流：以字节为单位，可以读写所有数据。
  • 字符流：以字符为单位，只能读写文本数据。
• 按功能：
  • 节点流：具有实际传输数据的读写功能。
  • 过滤流：再节点流基础之上增强功能。

字节流

• 字节流的父类（抽象类）：
  • InputStream：字节输入流
  • OutputStream：字节输出流

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yFR0Xdw-1615108051171)(D:\QQ\78214218\FileRecv\MobileFile\qq_pic_merged_161254878604.jpg)]

• FileInputStream:
  • public int read(byte[] b) //从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1。
• FileOutputStream:
  • public void write(byte[] b) //一次写多个字节，将b数组中所有字节，写入输出流。

文件字节输入流使用

package com.io;import java.io.FileInputStream;
//演示FileInputStream的使用
//文件字节输入流 
public class Demo01 {public static void main(String[] args) throws Exception{//1.FileInputStream，并指定文件路径FileInputStream fis = new FileInputStream(d:\\);//2.读取文件//fis.read();//单个字节读取/*int date = 0;while ((date = fis.read())!=-1){println((char) date);}println(读取完毕);*///2.2一次读取多个字节byte arr[] = new byte[1024];int count = 0;while ((count = fis.read(arr))!=-1){println((new String(arr,0,count)));}//.关闭();}
}

文件字节输出流使用

package com.io;import java.io.FileInputStream;
import java.io.FileOutputStream;
import StandardCharsets;// 演示文件字节输出流的使用
// FileOutputStream
public class Demo02 {public static void main(String[] args)throws Exception {//1.创建一个文件输出流对象FileOutputStream fos = new FileOutputStream(D:\\);//2.写入文件//fos.write(97);//fos.write(	b	);//fos.write(	c	);String  string = helloworld;fos.write(string.getBytes());//.关闭();println(执行完毕);}
}

案例：复制一个照片

package com.io;import java.io.FileInputStream;
import java.io.FileOutputStream;//使用字节流实现文件的复制
public class Demo0 {public static void main(String[] args) throws Exception{//1.创建流//1.1文件字节输入流FileInputStream fis = new FileInputStream(D:\\001.png);//1.2文件字节输出流FileOutputStream fos = new FileOutputStream(D:\\002.png);//2.一边读一边写byte[] buf = new byte[1024];int count = 0;while ((count = fis.read(buf))!=-1){fos.write(buf,0,count);}//.关闭流();();println(复制完毕);}
}

• 缓冲流：BufferedInputStream/BufferedOutputStream

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

• 字节缓存流输入

  package com.io;import java.io.BufferedInputStream;
  import java.io.FileInputStream;//字节缓存流
  public class Demo04 {public static void main(String[] args) throws Exception{//1.创建BufferedInputStreamFileInputStream fis = new FileInputStream(D:\\);BufferedInputStream bis = new BufferedInputStream(fis);//2.读取/*int data = 0;while ((data = bis.read())!=-1){print((char) data);}*///2.1byte[] buf = new byte[1024];int count = 0;while ((count = bis.read(buf))!=-1){println((new String(buf,0,count)));}//.关闭();}
  }
  

• 字节缓存流输出

  package com.io;import java.io.BufferedOutputStream;
  import java.io.FileOutputStream;//使用字节缓存流写入文件
  public class Demo05 {public static void main(String[] args) throws Exception{//1.创建字节输出缓存流FileOutputStream fos = new FileOutputStream(d:\\);BufferedOutputStream bos = new BufferedOutputStream(fos);//2.写入文件for (int i = 0; i < 10; i) {bos.write(helloworld\n.getBytes());//写入8k缓存区bos.flush();//刷新到硬盘}//.关闭（内部调用flush方法）();}
  }
  

对象流

• 对象流：ObjectOutputStream / ObjectInputStream

  • 增强了缓存区功能

  • 增强了读写8种基本数据类型和字符串功能

  • 增强了读写对象的功能

    • readObject() 从流中读取一个对象
    • writeObject（Object obj）向流中写入一个对象

  • 使用流传输对象的过程称为序列化(Out)、反序列化(In)。

• 序列化必须实现Serializable的接口

package com.io;import java.io.Serializable;//学生类
public class Student implements Serializable {private static final long serialVersionUID = 100L;//序列化版本号IDprivate String name;private int age;public Student() {}public Student(String name, int age) {super(); = name;this.age = age;}public String getame() {return name;}public void setame(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return Student{ name=	  name  	\		 , age=  age 	}	;}
}
=======================
package com.io;import java.io.*;//使用ObjectInputStream实现对象的序列化
//注意事项：
// (1).序列化必须实现Serializable的接口
// (2).序列化中对象属性要求实现Serializable接口
// ().序列化版本号ID，保证序列化的类和反序列化的类是同一个类。
// (4).使用transient(瞬间的)修饰属性，这个属性就不能序列化
// (5).静态属性不能序列化
// (6).序列化多个对象可以使用集合实现
public class Demo06 {public static void main(String[] args) throws Exception{//1.创建对象流FileOutputStream fos = new FileOutputStream(d:\\stu.bin);ObjectOutputStream oos = new ObjectOutputStream(fos);//2.实现序列化（写入操作）Student zhangsan = new Student(zhangsan,24);oos.writeObject(zhangsan);//.关闭();println(序列号完毕);}
}

• 注意事项：
  • 序列化必须实现Serializable的接口
  • 序列化中对象属性要求实现Serializable接口
  • 序列化版本号ID，保证序列化的类和反序列化的类是同一个类。
  • 使用transient(瞬间的)修饰属性，这个属性就不能序列化
  • 静态属性不能序列化
  • 序列化多个对象可以使用集合实现

package com.io;import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;
//使用ObjectInputStream实现反序列化(读取重构成对象)public class Demo07 {public static void main(String[] args) throws Exception{//1.创建一个对象流FileInputStream fis = new FileInputStream(D:\\stu.bin);ObjectInputStream ois = new ObjectInputStream(fis);//2.读取文件(反序列化)//Student s = (Student)ois.readObject();ArrayList<Student> list = (ArrayList<Student>) ois.readObject();//.关闭();println(执行完毕);println(());}
}

字符编码

• ISO-8859-1收录除了ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。

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

• GB212 简体中文

• GBK 简体中文、扩充

• BIG5台湾 繁体中文

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

字符流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kqOOP9v-161510805117)(D:\QQ\78214218\FileRecv\MobileFile\Screenshot_20210204_18417.jpg)]

• FileReader:
  • public int read (char[] c) //从流中读取多个字符，将读到的内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1.
• FileWrite:
  • public void write(String str) //一次写多个字符，将b数组中所有字符，写入输出流.

文件字符流读取使用

package com.;import java.io.FileReader;//使用FileReader读取文件
public class Demo01 {public static void main(String[] args) throws Exception {//1.创建FileReader 文件字符输入流FileReader fr = new FileReader(D:\\);//2.读取//2.1单个读取/*int data = 0;while ((data = fr.read())!=-1){//读取一个字符print((char) data);}*///2.2多个读取char[] buf = new char[1024];int count = 0;while ((count = fr.read(buf))!=-1){println(new String(buf,0,count));}//.关闭();}
}

文件字符流写入文件

package com.;import java.io.FileWriter;//使用FileWrite写入文件
public class Demo02 {public static void main(String[] args)throws Exception {//1.创建一个FileWrite对象FileWriter fw = new FileWriter(D:\\);//2.写入文件//fw.write(java牛逼);for (int i = 0; i < 10; i) {fw.write(java是世界上最好的语言\n);fw.flush();}//.关闭();println(执行完毕);}
}

案例：字符流复制文件（只能复制文本文件）

package com.;import java.io.FileReader;
import java.io.FileWriter;//使用FileRead和FileWrite复制文本文件，不能复制图片或二进制文件
//使用字节流复制任意文件
public class Demo0 {public static void main(String[] args) throws Exception{//1.创建FileRead和FileWriteFileReader fr = new FileReader(d:\\);FileWriter fw = new FileWriter(d:\\);//2.读写int data = 0;while ((data = fr.read())!=-1){fw.write(data);}fw.flush();//.关闭();();}
}

• 缓存流：BufferedReader/BufferedWriter

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

• 字符缓存流读取

  package com.;import java.io.BufferedReader;
  import java.io.FileReader;//使用字符缓存流读取文件
  public class Demo04 {public static void main(String[] args) throws Exception{//1.创建一个缓冲流FileReader fr = new FileReader(D:\\);BufferedReader br = new BufferedReader(fr);//2.读取//2.第一种方式/*char[] buf = new char[1024];int count = 0;while ((count = br.read(buf))!=-1){println(new String(buf,0,count));}*///2.2一行一行的读取String line = null;while ((line = br.readLine())!=null){println(line);}//.关闭();}
  }
  

• 字符缓存流写入

  package com.;import java.io.BufferedWriter;
  import java.io.FileWriter;//使用字符缓存流
  public class Demo05 {public static void main(String[] args)throws Exception {//1.创建一个BufferedWriter对象FileWriter fw = new FileWriter(d:\\);BufferedWriter bw = new BufferedWriter(fw);//2.写入for (int i = 0; i < 10; i) {bw.write(好好学习，天天向上);();//写入一个换行符bw.flush();}//.关闭();println(执行完毕);}
  }
  

打印流

• PrintWriter：

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

  package com.;import java.io.PrintWriter;//演示PrintWrite的使用
  public class Demo06 {public static void main(String[] args)throws Exception {//1.创建打印流PrintWriter pw = new PrintWriter(D:\\);//2.打印pw.println(97);//97pw.println(true);pw.println(.14);pw.println(	a	);//.关闭();println(执行完毕);}
  }
  

转换流

• 桥转换流：InputStreanReader/OutputStreanReader

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

• 读取文件，指定使用的编码

  package com.;import java.io.FileInputStream;
  import java.io.InputStreamReader;//使用InputStreamReader读取文件，指定使用的编码
  public class Demo01 {public static void main(String[] args)throws Exception {//1.创建一个InputStreamReader对象FileInputStream fis = new FileInputStream(D:\\);InputStreamReader isr = new InputStreamReader(fis,utf-8);//2.读取文件int data = 0;while ((data = isr.read())!=-1){print((char) data);}//.关闭();}
  }
  

• 写入文件，指定编码

  package com.;import java.io.FileOutputStream;
  import java.io.OutputStreamWriter;//使用OutputStreamWriter写入文件，指定编码
  public class Demo02 {public static void main(String[] args)throws Exception{//1.创建OutputStreamReader对象FileOutputStream fos = new FileOutputStream(d:\\);OutputStreamWriter osw = new OutputStreamWriter(fos,gbk);//2.写入for (int i = 0; i < 10; i) {osw.write(我爱中国，我爱故乡\n);osw.flush();}//.关闭();println(执行完毕);}
  }
  

File类

• 概念：代表物理盘符中的一个文件或者一个文件夹。

• 方法

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

• 文件操作

  package com.;import java.io.File;
  import java.util.Date;//File类的使用
  //(1).分隔符
  //(2).文件操作
  //().文件夹操作
  public class Demo0 {public static void main(String[] args)throws Exception {separator();fileOpe();}//(1).分隔符public static void separator(){println(路径分隔符 File.pathSeparator);println(名称分隔符File.separator);}//(2).文件操作public static void fileOpe()throws Exception{//1.创建文件File file = new File(D:\\);//println(());if (!()) {//如果不存在就创建boolean b = ();println(创建结果：  b);}//2.删除文件//2.1直接删除//println(file.delete());//2.2使用JVM退出时删除//file.deleteOnExit();//Thread.sleep(5000);//休眠五秒钟//.获取文件信息println(文件的绝对路径file.getAbsolutePath());println(获取路径file.getPath());println(获取文件名称file.getame());println(获取父目录file.getParent());println(获取文件的长度file.length());println(获取文件的创建时间new Date(file.lastModified()).toLocaleString());//4.判断println(是否可写());println(是不是文件file.isFile());//还可能是文件夹println(是否隐藏file.isHidden());}
  }
  ==============在IDEA的输出结果为：路径分隔符;
  名称分隔符\
  文件的绝对路径D:\
  获取路径D:\
  获取文件名称
  获取父目录D:\
  获取文件的长度15
  获取文件的创建时间2021-2-5 1:04:54
  是否可写true
  是不是文件true
  是否隐藏falseProcess finished with exit code 0

• 文件夹操作

  package com.;import java.io.File;
  import java.util.Date;//文件夹操作
  public class Demo04 {public static void main(String[] args)throws Exception {directpryope();}//文件夹操作public static void directpryope()throws Exception {//(1).创建文件夹File file = new File(d:\\aaa\\bbb\\ccc);println(());if (!()){//();//只能创建单级目录s();//可以创建多级目录println(创建结果s());}//(2).删除文件夹// 2.1直接删除（只能删除空目录）且只删除了ccc目录//println(删除结果file.delete());//2.2使用JVM删除//file.deleteOnExit();//Thread.sleep(5000);//().获取文件夹信息println(文件夹的绝对路径file.getAbsolutePath());println(获取路径file.getPath());println(获取文件夹名称file.getame());//最里面的文件夹名称println(获取父目录file.getParent());println(获取文件的创建时间new Date(file.lastModified()).toLocaleString());//(4).判断println(是不是文件夹file.isDirectory());println(是否隐藏file.isHidden());//(5).遍历文件夹File file1 = new File(D:\\照片);String[] files = file1.list();println(===========);for (String string:files) {println(string);}}
  }
  ===========在IDEA的输出结果为：d:\aaa\bbb\ccc
  文件夹的绝对路径d:\aaa\bbb\ccc
  获取路径d:\aaa\bbb\ccc
  获取文件夹名称ccc
  获取父目录d:\aaa\bbb
  获取文件的创建时间2021-2-5 1:27:59
  是不是文件夹true
  是否隐藏false
  ===========
  doc.png
  QQ图片20201219010226.jpg
  QQ截图20201219110718.png
  命令行传递参数.png
  屏幕截图 2020-12-18 151657.png

FileFilter接口

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

println(=====FileFilter接口的使用=======);
file2[] files1 = file1.listFiles(new FileFilter() {@Overridepublic boolean accept(File pathname) {if (pathname.getame().endsWith(.jpg)){return true;}return false;}
});
for (File file2: files1) {println(file.getame());
}

package com.;import javax.jws.soap.SOAPBinding;
import java.io.File;
import java.util.Arrays;//案例1：递归遍历文件夹
//案例2：递归删除文件夹
public class ListDemo {public static void main(String[] args) {//listDir(new File(D:\\myfiles));deleteDir(new File(D:\\myfiles));}public static void listDir(File dir){File[] files = dir.listFiles();println(dir.getAbsolutePath());if (files!=null&&files.length!=0){for (File file:files) {if (file.isDirectory()){listDir(file);//递归}elseprintln(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 {//删除文件println(file.getAbsolutePath()删除file.delete());}}}println(dir.getAbsolutePath()删除dir.delete());}
}
==============在IDEA的输出结果为：D:\myfiles\新建 XLSX 工作表.xlsx删除true
D:\myfiles\新建文件夹\新建 PPT 演示文稿.ppt删除true
D:\myfiles\新建文件夹\新建文本文档.txt删除true
D:\myfiles\新建文件夹删除true
D:\myfiles\新建文件夹 (2)\新建 DOC 文档.doc删除true
D:\myfiles\新建文件夹 (2)\新建文本文档.txt删除true
D:\myfiles\新建文件夹 (2)删除true
D:\myfiles\新建文本文档.txt删除true
D:\myfiles删除trueProcess finished with exit code 0

补充：Properties

• Properties:属性集合
• 特点：
  • 1.存储属性名和属性值
  • 2.属性名和属性值都是字符串类型、
  • .没有泛型
  • 4.和流有关

package com.io.properties;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;//演示Properties的使用
public class Demo01 {public static void main(String[] args) throws Exception{//1。创建集合Properties properties = new Properties();//2.添加数据properties.setProperty(username,zhangsan);properties.setProperty(age,20);println(());//.遍历//.1keySet//.2enerySet//.stringPropertyames()Set<String> pronames = properties.stringPropertyames();for (String pro:pronames) {println(pro========properties.getProperty(pro));}//4.和流有关的方法//4.1  list方法//PrintWriter pw = new PrintWriter(d:\\);// properties.list(pw);//();//4.2  store方法  保存//FileOutputStream fos = new FileOutputStream(d:\\store.properties);//properties.store(fos,注释);//();//4.  load方法    加载Properties properties1 = new Properties();FileInputStream fis = new FileInputStream(d:\\store.properties);properties1.load(fis);();println(());}
}

总结

• 流的概念:
  • 内存与存储设备之间传输数据的通道。
• 流的分类:
  • 输入流、输出流; 字节流、字符流; 节点流、过滤流;
• 序列化、反序列化
  • 将对象通过流写入到文件，或将对象通过流读取到内存，必须实现Serializable接口。
• File对象
  • 代表物理盘符中的一个文件或者文件夹。