IO框架（学习笔记）

最新推荐文章于 2023-07-10 08:38:37 发布

昭昭啊

最新推荐文章于 2023-07-10 08:38:37 发布

阅读量135

点赞数

文章标签：学习 java

本文链接：https://blog.csdn.net/weixin_56555958/article/details/128922678

版权

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());
}

}

昭昭啊

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
IO框架（学习笔记）

BufferedInputStream(字写缓冲输入流)[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x4IMkF12-1675761904790)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928172249211.png)]BufferedOutputStream(字写缓冲输出流)
复制链接

扫一扫