I/O框架
流
概念:流是内存到硬盘的一个通道,我们执行文件需要持久化存储,所以要将内存中的文件进行持久化存储,这需要借助到流。
流的本质是传输数据。
输入流:通过硬盘传输给内存的流
输出流:通过内存给硬盘存储的文件
字节流
继承关系:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BKReYqtl-1675761904787)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220927195613388.png)]
(1)FileInputStream (文件输入流)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HRy9dSTw-1675761904788)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928164958724.png)]
FileInputStream继承了InputStream抽象类,这个抽象类是所有输入字节流的超类。
FileInputStream的方法(参见jdk1.8Api)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RQh1jQNr-1675761904788)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928165329630.png)]
基本用法
以下代码是File Input Stream的写入数据:
import java.io.FileInputStream;
public class Demo01 {
public static void main(String[] args) throws Exception{
//创建FileInputStream,指定文件路径
String fail = "D:\\Studyjavase\\day01\\基础语法\\src\\com\\zhaozhao\\IO框架\\zz.txt\\";
FileInputStream fil = new FileInputStream(fail);
//读取文件:read()
//只读一个字节,读出的字节是阿斯克码值,要读文件的多个字节需要循环
//read()中如果读到最后一个字节,则会返回-1
//fil.read();
// int data = 0;
// while ((data = fil.read()) != -1){
// System.out.println((char)data);//将data转换成字符串
// }
//2一次读取多个字节
//创建一个数组,用来读取字节
System.out.println("===============");
// byte[] buf= new byte[3];
// int count = fil.read(buf);
// System.out.println(new String(buf));
// System.out.println(count);
// int count2 = fil.read(buf);
// System.out.println(new String(buf));
// System.out.println(count2);
// int count3 = fil.read(buf);
// System.out.println(new String(buf,0,count3));
// System.out.println(count3);
// //以上代码并不是最优解,比较麻烦,我们可以用while循环来操作
byte[] buf = new byte[3];
int count = 0;
while ((count = fil.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
//关闭
fil.close();
System.out.println("执行完毕");
}
}
(2)FileOutputStream的使用
方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WtKPiMZm-1675761904789)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928170140577.png)]
FileOutputStream(输出字节流):使用
import java.io.FileOutputStream;
/***
* FileOutputStream的使用
* 文件输出流
*/
public class Demo02 {
public static void main(String[] args) throws Exception{
//创建文件输出流
//如果没有这个文件,会自动创建
FileOutputStream fos = new FileOutputStream("d:\\b.txt",true);
//单字节写入
// fos.write(97);
// fos.write('c');
// fos.write('d');
//多字节写入
String str = "helloWorld";
//使用String中的getBytes()将字符串转换成byte数组写入文件中
//每次写入文件,都会默认覆盖上一次的文件内容,
// 如果不想,可以在之前new对象的时候,增加一个参数,为true,代表在后面追加写
fos.write(str.getBytes());
//关闭
fos.close();
System.out.println("成功喽!");
}
}
使用字节流完成文件的复制
/***
* 使用文件字节流完成文件复制功能
*/
public class Demo03 {
public static void main(String[] args) throws Exception{
//创建流
//创建文件输入流
FileInputStream fis = new FileInputStream("D:\\爬取文件\\img\\阿古朵\\山林之子.jpg");
//创建文件输出流
FileOutputStream fos = new FileOutputStream("D:\\爬取文件\\img\\阿古朵\\山寨之子.jpg");
//一边读一边写
byte[] buf = new byte[1024];
int count = 0;
while ((count=fis.read(buf))!=-1){
fos.write(buf,0,count);
}
//关闭
fis.close();
fos.close();
System.out.println("复制完毕");
}
}
BufferedInputStream/BufferedOutputStream
构造方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G90hxorx-1675761904789)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928172032861.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-910MQvF8-1675761904789)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928172609978.png)]
方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wLDHfngH-1675761904790)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928172503321.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-16CqDvzs-1675761904790)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928172639698.png)]
介绍和使用
BufferedInputStream(字写缓冲输入流)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x4IMkF12-1675761904790)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928172249211.png)]
BufferedOutputStream(字写缓冲输出流)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HVQXv8m7-1675761904791)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928172538746.png)]
缓冲流就是自己建立一个缓冲区,用来暂时存储数据,这样可以提高I/O的效率
在缓冲流中我们写入或者读取的内容会先存储在缓冲区内,然后通过缓冲区再传给内存或者硬盘中
缓冲区的默认大小是8k,可以通过源码看到
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sKhV4eIs-1675761904791)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928171029346.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U2maxPkv-1675761904791)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928171051849.png)]
代码如下:
import java.io.BufferedInputStream;
import java.io.FileInputStream;
/***
* 字节缓冲流的使用
* BufferedInputStream
* 可以提高IO效率
*/
public class Demo04 {
public static void main(String[] args) throws Exception{
//创建字节缓冲流,里面的参数是输入流的所以也要创建字节输入流
String fail = "D:\\Studyjavase\\day01\\基础语法\\src\\com\\zhaozhao\\IO框架\\zz.txt\\";
FileInputStream fis = new FileInputStream(fail);
//缓冲区的大小默认为8k
BufferedInputStream bis = new BufferedInputStream(fis);
int data;
while ((data=fis.read())!=-1){
System.out.print((char)data);
}
//关闭,可以直接关闭缓冲流,输入流就默人关闭
fis.close();
}
}
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
/***
* 字节输出缓冲流
* BufferedOutputStream
*/
public class Demo05 {
public static void main(String[] args) throws Exception{
//创建输出缓冲流和输出流
FileOutputStream fos = new FileOutputStream("d:\\b.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
for (int i = 0; i < 10; i++) {
fos.write("helloWorld\r\n".getBytes());//写入缓冲区,并没有加载到内存
fos.flush();//刷新缓冲流,将内容刷新到硬盘去
}
//关闭
fos.close();
System.out.println("ok");
}
}
ObjectInputStream/ObjectOutputStream(序列化/反序列化)
概念
对象字节输入/输出流
序列化:把对象转换成可传输的字节序列的过程叫做序列化。
反序列化:把字节序列还原为对象的过程叫反序列化。
序列化的作用:对象随着程序的运行而创建,在创建对象的时候,我们调用完,有些对象就没有用了,最终会被回收,对象的生命周期是短暂的,我们想要持久化存储就需要进行序列化,将对象存储成字节序列在硬盘中。
注意事项:
-
序列化类必须要实现Serializable接口(此接口是没有方法的,只是一个标记接口)
-
序列化类中的对象也必须实现Serializable接口。
-
序列化版本号ID,保证序列化的类和反序列化的是同一个类
-
使用transient(瞬间的)修饰的属性,则这个属性不可以被序列化,(如果序列化,反序列化返回的值会变成0/null)
-
静态属性不能序列化
-
序列化多个对象,可以借助集合完成
实例:
对象类
import java.io.Serializable;
//要想序列化,创建的类需要实现Serializable接口,只是一个标记接口,里面没有任何方法
public class Student implements Serializable {
private String name;
private int age;
//设置版本号ID
private final static long serialVersionUID = 100L;
public Student() {
}
public Student(String name, int age) {
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 +
'}';
}
}
序列化:
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
/***
* 使用ObjectOutputStream实现序列化
*要求:序列化的类必须要实现Serializable的接口
*/
public class Demo06 {
public static void main(String[] args) throws Exception{
//创建对象流
FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//序列化(写入操作)
Student zhangsan = new Student("张三", 18);
Student zz = new Student("昭昭", 22);
ArrayList<Student> list = new ArrayList<>();
list.add(zhangsan);
list.add(zz);
oos.writeObject(list);
// oos.writeObject(zhangsan);
// oos.close();
System.out.println("序列化完毕");
}
}
反序列化:
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;
/***
* 使用ObjectInputStream实现反序列化
*/
public class Demo07 {
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("d:\\stu.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
//反序列化(读取文件)
// Student s1 = (Student) ois.readObject();
ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
//关闭
ois.close();
System.out.println("ok");
System.out.println(list.toString());
}
}
字符流
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-arOYv5MW-1675761904791)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928210447155.png)]
转换流
制定编码格式
import java.io.FileInputStream;
import java.io.InputStreamReader;
/***
* InputStreamReader的使用
* 确定编码形式
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("d:\\writer.txt");
InputStreamReader isr = new InputStreamReader(fis, "utf-8");
int data = 0;
while ((data=isr.read())!=-1) {
System.out.print((char) data);
}
isr.close();
}
}
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
/***
* 使用OutputStreamWriter写入
*/
public class Demo02 {
public static void main(String[] args) throws Exception{
FileOutputStream fos = new FileOutputStream("d:\\writer.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");
for (int i = 0; i < 10; i++) {
osw.write("你真的很厉害\r\n");
osw.flush();
}
osw.close();
System.out.println("ok");
}
}
File类
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ULBm0GfC-1675761904792)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928224249822.png)]
代码实例:
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.Date;
public class Demo01 {
public static void main(String[] args) throws Exception{
separator();
fileOpen();
dirOpn();
}
//分隔符
public static void separator(){
//路径分隔符
System.out.println("路径分隔符:"+File.pathSeparator);
System.out.println("文件分隔符:"+File.separator);
}
//文件操作
public static void fileOpen() throws IOException, InterruptedException {
//创建文件creatNewFile()
//先创建文件类对象
File file = new File("a.txt");//在当前目录下创建
//file.exists()表示判断文件是否创建成功,返回值为Boolean
if (!file.exists()) {
boolean b = file.createNewFile();
System.out.println("创建结果为:"+b);
}
//删除文件
//1.直接删除file.delete()
// System.out.println(file.delete());
//2.使用jvm退出时删除
// file.deleteOnExit();
// Thread.sleep(5000);
//获取文件信息
System.out.println("获取文件绝对路径"+file.getAbsolutePath());
System.out.println("获取文件名字"+file.getName());
System.out.println("获取文件路径"+file.getPath());
System.out.println("获取父目录"+file.getParent());
System.out.println("获取文件长度"+file.length());//获取的是字节数
System.out.println("文件创建时间"+new Date(file.lastModified()).toLocaleString());
//判断
System.out.println("是否可写"+file.canWrite());
System.out.println("是否为文件"+file.isFile());
}
//文件夹操作
public static void dirOpn()throws Exception{
//创建文件夹对象
File dir = new File("D:\\aaa\\bbb\\ccc");
//创建文件夹
if (!dir.exists()){
//mkdir()是创建一级文件夹
//mkdirs()是创建多级文件夹
System.out.println("创建成功:"+dir.mkdirs());
dir.mkdir();
}
//删除文件夹
//1.直接删除 只能删除空文件夹,多级文件夹只能删除最底层的文件夹
dir.delete();
//2.2使用jvm删除
dir.deleteOnExit();
Thread.sleep(5000);
//获取文件夹信息
System.out.println("获取文件夹路径"+dir.getPath());
System.out.println("获取文件夹绝对路径"+dir.getAbsolutePath());
System.out.println("获取文件夹长度"+dir.length());
System.out.println("获取文件夹父目录"+dir.getParent());
System.out.println("获取文件夹名字"+dir.getName());
System.out.println("获取创建时间"+new Date(dir.lastModified()).toLocaleString());
//判断
System.out.println(dir.isDirectory());
System.out.println(dir.isHidden());
//遍历文件夹
File dir2 = new File("D:\\爬取文件\\picLibs");
String[] list = dir2.list();
System.out.println("============================================");
for (String s : list) {
System.out.println(s);
}
System.out.println("====================FileFilter接口的使用==============================");
File[] files = dir2.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.getName().endsWith(".jpg")) {
return true;
}
return false;
}
});
for (File file : files) {
System.out.println(file);
}
}
}
import java.io.*;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
/***
* properties类的使用(跟流有关)
*/
public class Demo2 {
public static void main(String[] args) throws IOException {
//创建集合
Properties properties = new Properties();
//添加数据
properties.setProperty("userName","zhangzhang");
properties.setProperty("age","20");
System.out.println(properties.toString());
//遍历
//1.keySet
// Set<Object> objects = properties.keySet();
// for (Object object : objects) {
// System.out.println(object+"----"+properties.get(object));
// }
//2.entrySet
// Set<Map.Entry<Object, Object>> entries = properties.entrySet();
// for (Map.Entry<Object, Object> entry : entries) {
// System.out.println(entry.getKey()+"---"+entry.getValue());
// }
//3.stringPropertyNames()
Set<String> pronames = properties.stringPropertyNames();
for (String pro : pronames) {
System.out.println(pro+"---"+properties.getProperty(pro));
}
//和流有关的方法
//1.list方法
// PrintWriter pw = new PrintWriter("d://print.txt");
// properties.list(pw);
// pw.close();
//2.store方法 保存
FileOutputStream fos = new FileOutputStream("d:\\store.properties");
properties.store(fos,"a");
fos.close();
//3.load方法 加载
Properties properties1 = new Properties();
FileInputStream fis = new FileInputStream("d:\\store.properties");
properties1.load(fis);
fis.close();
System.out.println(properties1.toString());
}
}
import java.io.File;
import java.io.FileFilter;
public class ListDemo {
public static void main(String[] args) {
listDir(new File("D:\\hahaha"));
deleteDir(new File("D:\\hahaha"));
}
//递归遍历文件夹
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());
}
}
}
}
//递归删除文件夹
public static void deleteDir(File dir){
System.out.println("============================================");
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());
}
}
t.println(file.getAbsolutePath());
}
}
}
}
//递归删除文件夹
public static void deleteDir(File dir){
System.out.println(“============================================”);
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());
}
}