I/O框架

最新推荐文章于 2024-06-24 16:31:49 发布

一只野良猫w

最新推荐文章于 2024-06-24 16:31:49 发布

阅读量85

点赞数 1

分类专栏：狂神说Java学习文章标签： java

本文链接：https://blog.csdn.net/qq_37933128/article/details/120903740

版权

狂神说Java学习专栏收录该内容

22 篇文章 6 订阅

订阅专栏

一、流的概念

内存与存储设备之间传输数据的通道。

二、流的分类

(1)按流向

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

(2)按单位

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

(3)按功能

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

三、字节流

字节流的父类（抽象类）

//InputStream 字节输入流
public int read(){} //返回下一个数据字节；如果到达流的末尾，则返回-1。
public int read(byte[] b){} //返回读入缓冲区的总字节数；如果因为已经到达流末尾而不再有数据可用，则返回-1。
public int read(byte[] b, int off, int len){} //返回读入缓冲区的总字节数；如果因为已到达流末尾而不再有数据可用，则返回-1。

// OutputStream 字节输出流
public void write(int n){}
public void write(byte[] b){}
public void write(byte[] b, int off, int len){}

四、文件字节流

(1)字节输入流

package com.io;
import java.io.FileInputStream;

public class fileInputStream {
    public static void main(String[] args) throws Exception {
        // 1 创建FileInputStream 并指定文件路径
        FileInputStream fileInputStream = new FileInputStream("D:\\code\\aaa.txt");
        // 2 读取文件
        // fis.read();
        // 2.1单字节读取
        int data=0;
        while ((data=fileInputStream.read())!=-1){
            System.out.println((char)data);
        }
        // 2.2 一次读取多个字节
        byte[] buff=new byte[3]; // 大小为3的缓存区
        int count=fileInputStream.read(buff); //一次读3个
        System.out.println(new String(buff));
        System.out.println(count);
        int count2=fileInputStream.read(buff); //再读3个
        System.out.println(new String(buff));
        System.out.println(count2);
        //上述优化后
        int count3=0;
        while ((count3=fileInputStream.read(buff))!=-1){
            System.out.println(new String(buff,0,count3));
        }
        // 3 关闭
        fileInputStream.close();
    }
}

(2)字节输出流

package com.io;
import java.io.FileOutputStream;

public class fileOutputStream {
    public static void main(String[] args) throws Exception {
        // 1 创建文件字节输出流
        FileOutputStream fos = new FileOutputStream("D:\\code\\aaa.txt", true);// true表示不覆盖 接着写
        // 2 写入文件
        fos.write(97);
        fos.write('a');
        String string = "hello world";
        fos.write(string.getBytes());
        // 3 关闭
        fos.close();
    }
}

(3)复制图片

package com.io;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class copy {
    public static void main(String[] args) throws Exception{
        // 1 创建流
        // 1.1 文件字节输入流
        FileInputStream fis = new FileInputStream("D:\\code\\java学习.jpg");
        // 1.2 文件字节输出流
        FileOutputStream fos = new FileOutputStream("D:\\code\\java学习2.jpg");
        // 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("复制完毕");
    }
}

(4)字节缓冲流

缓冲流：BufferedInputStream/ BufferedOutputStream

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

package com.io;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
//使用字节缓冲流读取文件
public class bufferedInputStream {
    public static void main(String[] args) throws Exception{
        // 1 创建BufferedInputStream
        FileInputStream fis = new FileInputStream("D:\\code\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        // 2 读取
        int data = 0;
        while((data = bis.read()) != -1){
            System.out.println(((char) data));
        }
        // 用自己创建的缓冲流
        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 bufferedOutputStream {
    public static void main(String[] args) throws Exception{
        // 1 创建BufferedInputStream
        FileOutputStream fos = new FileOutputStream("路径");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        // 2 写入文件
        for(int i = 0; i < 10; i ++){
            bos.write("hello".getBytes());// 写入8k缓冲区
            bos.flush(); // 刷新到硬盘
        }
        // 3 关闭(内部自动调用flush方法)
        bos.close();
    }
}

(5)对象流

对象流：ObjectOutputStream / ObjectInputStream

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

package com.io.对象流;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
/*
* 使用ObjectOutputStream实现对象序列化
*/
public class objectOutputStream {
    public static void main(String[] args) throws  Exception{
        // 1. 创建对象流
        FileOutputStream fos = new FileOutputStream("D:\\code\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        // 2. 序列化（写入操作）
        Student zhangsan = new Student("zs", 20);
        oos.writeObject(zhangsan);
        // 3. 关闭
        oos.close();
        System.out.println(("序列化完毕"));
    }
}

package com.io.对象流;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
/*
* 使用ObjectInputStream实现对象反序列化
*/
public class objectInputStream {
    public static void main(String[] args) throws Exception{
        // 1. 创建对象流
        FileInputStream fis = new FileInputStream("D:\\code\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        // 2. 读取文件（反序列化）
        Student s = (Student)ois.readObject();
        // 3. 关闭
        ois.close();
        System.out.println("反序列化完毕");
        System.out.println(s.toString());
    }
}

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

五、字符流

(1)FileReader与FileWriter

字符流的父类：

//Reader：字符输入流
public int read(){}
public int read(char[] c){}
public int read(char[] b, int off, int len){}

//Writer：字符输出流
public void write(int n){}
public void write(String str){}
public void write(char[] c){}

package com.io.字符流;
import java.io.FileReader;
//使用FileReader读取文件（中文字符）
public class fileReader {
    public static void main(String[] args) throws Exception{
        //1.创建FileReader 文件字符输入流
        FileReader reader = new FileReader("D:\\code\\hello.txt");
        //2.读取
        //单个字符读取
        int data=0;
        while ((data=reader.read())!=-1){  //无参read()返回是一个int类型的数
            System.out.println((char)data);
        }
        //使用数组读取
        char[] buf = new char[1024];
        int count=0;
        while ((count=reader.read(buf))!=-1){
            System.out.print(new String(buf,0,count));
        }
        //3.关闭
        reader.close();
    }
}

package com.io.字符流;
import java.io.FileWriter;
//使用FileWriter读写文件
public class fileWriter {
    public static void main(String[] args) throws Exception{
        // 1. 创建FileWriter对象
        FileWriter fw = new FileWriter("D:\\code\\write.txt");
        // 2. 写入
        for(int i = 0; i < 10; i ++){
            fw.write("写入的内容\r\n");
            fw.flush();
        }
        // 3. 关闭
        fw.close();
        System.out.println("执行完毕");
    }
}

(2)复制文本文件

不能复制图片或二进制文件，使用字节流可以复制任意文件。

package com.io.字符流;
import java.io.FileReader;
import java.io.FileWriter;

public class copy {
    public static void main(String[] args) throws Exception{
        // 1. 创建FileReader，FileWriter
        FileReader fr = new FileReader("D:\\code\\write.txt");
        FileWriter fw = new FileWriter("D:\\code\\copy_write.txt");
        // 2. 读写
        int data = 0;
        while((data = fr.read()) != -1){
            fw.write(data);
            fw.flush();
        }
        // 3. 关闭
        fw.close();
        fr.close();
    }
}

(3)字符缓冲流

字符缓冲流：BufferedReader,BufferedWriter

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

package com.io.字符缓冲流;
import java.io.BufferedReader;
import java.io.FileReader;

public class bufferedReader {
    public static void main(String[] args) throws Exception{
        // 创建缓冲流
        FileReader fr = new FileReader("D:\\code\\reader.txt");
        BufferedReader br = new BufferedReader(fr);
        // 读取
        // 1. 第一种方式
        char[] buf = new char[1024];
        int count=0;
        while ((count=br.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        // 2. 第二种方式 一行一行读取
        String line = null;
        while ((line=br.readLine())!=null){
            System.out.println(line);
        }
        // 3. 关闭
        br.close();
    }
}

package com.io.字符缓冲流;
import java.io.BufferedWriter;
import java.io.FileWriter;

public class bufferedWriter {
    public static void main(String[] args) throws Exception{
        // 1. 创建BufferedWriter对象
        FileWriter fw = new FileWriter("D:\\code\\writer.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        // 2. 写入
        for(int i = 0; i < 10; i ++){
            bw.write("写入的内容");
            bw.newLine(); // 写入一个换行符
            bw.flush();
        }
        // 3. 关闭
        bw.close(); // 此时会自动关闭fw
    }
}

六、打印流

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

package com.IO.打印流;
import java.io.PrintWriter;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
public class printWriter {
    public static void main(String[] args) throws Exception{
        // 1 创建打印流
        PrintWriter pw = new PrintWriter("D:\\code\\print.txt");
        // 2 打印
        pw.println(12);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        // 3 关闭
        pw.close();
    }
}

七、转换流

桥转换流：InputStreamReader / OutputStreamWriter

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

package com.IO.转换流;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class inputStreamReader {
    public static void main(String[] args) throws Exception{
        // 1 创建InputStreamReader对象
        FileInputStream fis = new FileInputStream("..");
        InputStreamReader isr = new InputStreamReader(fis, "utf-8");
        // 2 读取文件
        int data = 0;
        while((data = isr.read()) != -1){
            System.out.println((char) data);
        }
        // 3 关闭
        isr.close();
    }
}

package com.IO.转换流;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

public class outputStreamWriter {
    public static void main(String[] args) throws Exception{
        // 1 创建OutputStreamReader对象
        FileOutputStream fos = new FileOutputStream("..");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");
        // 2 写入
        for(int i = 0; i < 10; i ++){
            osw.write("写入内容");
            osw.flush();
        }
        // 3 关闭
        osw.close();
    }
}

八、File类

概念：代表物理盘符中的一个文件或者文件夹
常用方法：

方法名	解释
createNewFile()	创建一个新文件
mkdir()	创建一个新目录
delete()	删除文件或空目录
exists()	判断文件或文件夹是否存在
getAbsolutePath()	获取文件的绝对路径
getName()	获取文件名，注意会带文件后缀
getParent()	获取文件/目录所在的目录
isDirectory()	判断是否是目录
isFile()	是否为文件
length()	获取文件的长度
listFiles()	列出目录中的所有内容
renameTo()	修改文件名为
deleteOnExit()	jvm退出后删除文件
canWrite()	判断文件是否可写入

package com.JavaClass.File;
import java.io.File;
import java.util.Date;

/*
* File类的使用
* (1)分隔符
* (2)文件操作
* (3)文件夹操作
* */
public class fileMethod {
    public static void main(String[] args) throws Exception {
        separator();
        fileOpen();
        directoryOpe();
    }
    // 1. 分隔符
    public static void separator(){
        System.out.println("路径分隔符" + File.pathSeparator);
        System.out.println("名称分隔符" + File.separator);
    }
    // 2. 文件操作
    public static void fileOpen() throws Exception{
        // 1. 创建文件
        File file = new File("D:\\code\\file.txt");
        if(!file.exists()){ // 是否存在
            boolean b = file.createNewFile();
            System.out.println("创建结果："+b);
        }

        // 2. 删除文件
        // 2.1 直接删除
        file.delete(); // 成功true
        // 2.2 使用jvm退出时删除
        file.deleteOnExit();

        // 3. 获取文件信息
        System.out.println("获取绝对路径" + file.getAbsolutePath());
        System.out.println("获取路径" + file.getPath());
        System.out.println("获取文件名称" + file.getName());
        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());
    }

    // 文件夹操作
    public static void directoryOpe() throws Exception {
        // 1. 创建文件夹
        File dir = new File("D:\\code\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if (!dir.exists()) {
            //dir.mkdir(); // 只能创建单级目录
            dir.mkdirs(); // 创建多级目录
        }

        // 2. 删除文件夹
        // 2.1 直接删除
        dir.delete(); // 只能删除最底层空目录
        // 2.2 使用jvm删除
        dir.deleteOnExit();

        // 3. 获取文件夹信息
        System.out.println("获取绝对路径" + dir.getAbsolutePath());
        System.out.println("获取路径" + dir.getPath());
        System.out.println("获取文件名称" + dir.getName());
        System.out.println("获取夫目录" + dir.getParent());
        System.out.println("获取文件长度" + dir.length());
        System.out.println("文件夹创建时间" + new Date(dir.lastModified()).toLocaleString());

        // 4. 判断
        System.out.println("是否是文件夹" + dir.isFile());
        System.out.println("是否隐藏" + dir.isHidden());

        // 5. 遍历文件夹
        File dir2 = new File("...");
        String[] files = dir2.list();
        for (String string : files) {
            System.out.println(string);
        }
    }
}

九、FileFilter接口

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

  // FileFilter接口的使用
        File[] files2 = dir2.listFiles(new FileFilter(){
            @Override
            public boolean accept(File pathname){
                if(pathname.getName().endsWith(".jpg")){
                    return true;
                }
                return false;
            }
        });
        for(File file : files2){
            System.out.println(file.getName());
        }

十、递归遍历/删除文件夹

package com.JavaClass.File;
import java.io.File;

public class listFlies {
    public static void main(String[] args) {
        listDir(new File("..."));
        deleteDir(new File("..."));
    }
    //1.递归遍历文件夹
    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());
                }
            }
        }
    }