I/O框架
什么是流
- 概念:内存与存储设备之间传输数据的通道。
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-72mGHw62-1615108051169)(D:\QQ\378214218\FileRecv\MobileFile\qq_pic_merged_1612340541618.jpg)]
流的分类
-
按方向【重点】:
-
输入流:将<存储设备>中的内容读到<内存>中。
-
输出流:将<内存>中的内容写入到<存储设备>中。
输入流 输出流
-
文件 ---------------------------------->程序--------------------------------------->文件
- 按单位:
- 字节流:以字节为单位,可以读写所有数据。
- 字符流:以字符为单位,只能读写文本数据。
- 按功能:
- 节点流:具有实际传输数据的读写功能。
- 过滤流:再节点流基础之上增强功能。
字节流
- 字节流的父类(抽象类):
- InputStream:字节输入流
- OutputStream:字节输出流
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NyFR0Xdw-1615108051171)(D:\QQ\378214218\FileRecv\MobileFile\qq_pic_merged_1612354878604.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:\\aaa.txt");
//2.读取文件
//fis.read();
//单个字节读取
/*int date = 0;
while ((date = fis.read())!=-1){
System.out.println((char) date);
}
System.out.println("读取完毕");*/
//2.2一次读取多个字节
byte arr[] = new byte[1024];
int count = 0;
while ((count = fis.read(arr))!=-1){
System.out.println((new String(arr,0,count)));
}
//3.关闭
fis.close();
}
}
文件字节输出流使用
package com.io;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;
// 演示文件字节输出流的使用
// FileOutputStream
public class Demo02 {
public static void main(String[] args)throws Exception {
//1.创建一个文件输出流对象
FileOutputStream fos = new FileOutputStream("D:\\bbb.txt");
//2.写入文件
//fos.write(97);
//fos.write('b');
//fos.write('c');
String string = "helloworld";
fos.write(string.getBytes());
//3.关闭
fos.close();
System.out.println("执行完毕");
}
}
案例:复制一个照片
package com.io;
import java.io.FileInputStream;
import java.io.FileOutputStream;
//使用字节流实现文件的复制
public class Demo03 {
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);
}
//3.关闭流
fis.close();
fos.close();
System.out.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.创建BufferedInputStream FileInputStream fis = new FileInputStream("D:\\aaa.txt"); BufferedInputStream bis = new BufferedInputStream(fis); //2.读取 /*int data = 0; while ((data = bis.read())!=-1){ System.out.print((char) data); }*/ //2.1 byte[] buf = new byte[1024]; int count = 0; while ((count = bis.read(buf))!=-1){ System.out.println((new String(buf,0,count))); } //3.关闭 bis.close(); } }
-
字节缓存流输出
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:\\buffer.txt"); BufferedOutputStream bos = new BufferedOutputStream(fos); //2.写入文件 for (int i = 0; i < 10; i++) { bos.write("helloworld\n".getBytes());//写入8k缓存区 bos.flush();//刷新到硬盘 } //3.关闭(内部调用flush方法) bos.close(); } }
对象流
-
对象流: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;//序列化版本号ID
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
=======================
package com.io;
import java.io.*;
//使用ObjectInputStream实现对象的序列化
//注意事项:
// (1).序列化必须实现Serializable的接口
// (2).序列化中对象属性要求实现Serializable接口
// (3).序列化版本号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);
//3.关闭
oos.close();
System.out.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();
//3.关闭
ois.close();
System.out.println("执行完毕");
System.out.println(list.toString());
}
}
字符编码
-
ISO-8859-1收录除了ASCII外,还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
-
UTF-8 针对Unicode码标的可变长度字符编码
-
GB2312 简体中文
-
GBK 简体中文、扩充
-
BIG5台湾 繁体中文
注:当编码方式和解码方式不一致时,会出现乱码。
字符流
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kqONOP9v-1615108051173)(D:\QQ\378214218\FileRecv\MobileFile\Screenshot_20210204_183417.jpg)]
文件字符流
- FileReader:
- public int read (char[] c) //从流中读取多个字符,将读到的内容存入c数组,返回实际读到的字符数;如果达到文件的尾部,则返回-1.
- FileWrite:
- public void write(String str) //一次写多个字符,将b数组中所有字符,写入输出流.
文件字符流读取使用
package com.io.chars;
import java.io.FileReader;
//使用FileReader读取文件
public class Demo01 {
public static void main(String[] args) throws Exception {
//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[1024];
int count = 0;
while ((count = fr.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
//3.关闭
fr.close();
}
}
文件字符流写入文件
package com.io.chars;
import java.io.FileWriter;
//使用FileWrite写入文件
public class Demo02 {
public static void main(String[] args)throws Exception {
//1.创建一个FileWrite对象
FileWriter fw = new FileWriter("D:\\abc.txt");
//2.写入文件
//fw.write("java牛逼");
for (int i = 0; i < 10; i++) {
fw.write("java是世界上最好的语言\n");
fw.flush();
}
//3.关闭
fw.close();
System.out.println("执行完毕");
}
}
案例:字符流复制文件(只能复制文本文件)
package com.io.chars;
import java.io.FileReader;
import java.io.FileWriter;
//使用FileRead和FileWrite复制文本文件,不能复制图片或二进制文件
//使用字节流复制任意文件
public class Demo03 {
public static void main(String[] args) throws Exception{
//1.创建FileRead和FileWrite
FileReader fr = new FileReader("d:\\abc.txt");
FileWriter fw = new FileWriter("d:\\abc2.txt");
//2.读写
int data = 0;
while ((data = fr.read())!=-1){
fw.write(data);
}
fw.flush();
//3.关闭
fw.close();
fr.close();
}
}
字符缓存流
-
缓存流:BufferedReader/BufferedWriter
- 高效读写
- 支持输入换行符
- 可一次写一行、读一行
-
字符缓存流读取
package com.io.chars; 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:\\abc.txt"); BufferedReader br = new BufferedReader(fr); //2.读取 //2.第一种方式 /*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); } //3.关闭 br.close(); } }
-
字符缓存流写入
package com.io.chars; 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:\\buffer1.txt"); BufferedWriter bw = new BufferedWriter(fw); //2.写入 for (int i = 0; i < 10; i++) { bw.write("好好学习,天天向上"); bw.newLine();//写入一个换行符 bw.flush(); } //3.关闭 bw.close(); System.out.println("执行完毕"); } }
打印流
-
PrintWriter:
- 封装了print()/ println()方法,支持写入后换行。
- 支持数据原样打印
package com.io.chars; import java.io.PrintWriter; //演示PrintWrite的使用 public class Demo06 { public static void main(String[] args)throws Exception { //1.创建打印流 PrintWriter pw = new PrintWriter("D:\\print.txt"); //2.打印 pw.println(97);//97 pw.println(true); pw.println(3.14); pw.println('a'); //3.关闭 pw.close(); System.out.println("执行完毕"); } }
转换流
-
桥转换流:InputStreanReader/OutputStreanReader
- 可将字节流转换为字符流
- 可设置字符的编码方式
-
读取文件,指定使用的编码
package com.io.transition; 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:\\abc.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(); } }
-
写入文件,指定编码
package com.io.transition; 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:\\info.txt"); OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk"); //2.写入 for (int i = 0; i < 10; i++) { osw.write("我爱中国,我爱故乡\n"); osw.flush(); } //3.关闭 osw.close(); System.out.println("执行完毕"); } }
File类
-
概念:代表物理盘符中的一个文件或者一个文件夹。
-
方法
- createNewFile() //创建一个新文件
- mkdir () //创建一个新目录
- delete () //删除文件或空目录
- exists() // 判断File对象所对象所代表的对象是否存在
- getAbsolutePath () // 获取文件的绝对路径
- getName () //取得名字
- getParent () //获取文件/目录所在的目录
- isDirectory () //是否是目录
- isFile () //是否是文件
- length () //获得文件的长度
- listFiles () // 列出目录中的所有内容
- renameTo () //修改文件名为
-
文件操作
package com.io.transition; import java.io.File; import java.util.Date; //File类的使用 //(1).分隔符 //(2).文件操作 //(3).文件夹操作 public class Demo03 { public static void main(String[] args)throws Exception { separator(); fileOpe(); } //(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);//休眠五秒钟 //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()); } } ==============在IDEA的输出结果为: 路径分隔符; 名称分隔符\ 文件的绝对路径D:\file.txt 获取路径D:\file.txt 获取文件名称file.txt 获取父目录D:\ 获取文件的长度15 获取文件的创建时间2021-2-5 13:04:54 是否可写true 是不是文件true 是否隐藏false Process finished with exit code 0
-
文件夹操作
package com.io.transition; 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"); System.out.println(file.toString()); if (!file.exists()){ //file.mkdir();//只能创建单级目录 file.mkdirs();//可以创建多级目录 System.out.println("创建结果"+file.mkdirs()); } //(2).删除文件夹 // 2.1直接删除(只能删除空目录)且只删除了ccc目录 //System.out.println("删除结果"+file.delete()); //2.2使用JVM删除 //file.deleteOnExit(); //Thread.sleep(5000); //(3).获取文件夹信息 System.out.println("文件夹的绝对路径"+file.getAbsolutePath()); System.out.println("获取路径"+file.getPath()); System.out.println("获取文件夹名称"+file.getName());//最里面的文件夹名称 System.out.println("获取父目录"+file.getParent()); System.out.println("获取文件的创建时间"+new Date(file.lastModified()).toLocaleString()); //(4).判断 System.out.println("是不是文件夹"+file.isDirectory()); System.out.println("是否隐藏"+file.isHidden()); //(5).遍历文件夹 File file1 = new File("D:\\照片"); String[] files = file1.list(); System.out.println("==========="); for (String string:files) { System.out.println(string); } } } ===========在IDEA的输出结果为: d:\aaa\bbb\ccc 文件夹的绝对路径d:\aaa\bbb\ccc 获取路径d:\aaa\bbb\ccc 获取文件夹名称ccc 获取父目录d:\aaa\bbb 获取文件的创建时间2021-2-5 13: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 () 的返回值中。
System.out.println("=====FileFilter接口的使用=======");
file2[] files1 = file1.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.getName().endsWith(".jpg")){
return true;
}
return false;
}
});
for (File file2: files1) {
System.out.println(file.getName());
}
递归遍历和递归删除
package com.io.transition;
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();
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());
}
}
==============在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删除true
Process finished with exit code 0
补充:Properties
- Properties:属性集合
- 特点:
- 1.存储属性名和属性值
- 2.属性名和属性值都是字符串类型、
- 3.没有泛型
- 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");
System.out.println(properties.toString());
//3.遍历
//3.1keySet
//3.2enerySet
//3.3stringPropertyNames()
Set<String> pronames = properties.stringPropertyNames();
for (String pro:pronames) {
System.out.println(pro+"========"+properties.getProperty(pro));
}
//4.和流有关的方法
//4.1 list方法
//PrintWriter pw = new PrintWriter("d:\\print.txt");
// properties.list(pw);
//pw.close();
//4.2 store方法 保存
//FileOutputStream fos = new FileOutputStream("d:\\store.properties");
//properties.store(fos,"注释");
//fos.close();
//4.3 load方法 加载
Properties properties1 = new Properties();
FileInputStream fis = new FileInputStream("d:\\store.properties");
properties1.load(fis);
fis.close();
System.out.println(properties1.toString());
}
}
总结
- 流的概念:
- 内存与存储设备之间传输数据的通道。
- 流的分类:
- 输入流、输出流; 字节流、字符流; 节点流、过滤流;
- 序列化、反序列化
- 将对象通过流写入到文件,或将对象通过流读取到内存,必须实现Serializable接口。
- File对象
- 代表物理盘符中的一个文件或者文件夹。