Java学习笔记4——I/O框架

Bug一号质检员

已于 2022-01-26 01:12:50 修改

阅读量70

点赞数

文章标签： java 开发语言后端

于 2022-01-22 19:13:58 首次发布

本文链接：https://blog.csdn.net/weixin_44238066/article/details/122641900

版权

1 流的概念

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

2 流的分类

按方向
输入流：将<存储设备>中的内容读到<内存>中
输出流：将<内存>中的内容写到<存储设备>中
按单位
字节流：以字节为单位，可以读写所有数据
字符流：以字符为单位，只能读写文本数据
按功能
节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础之上增强功能

在这里插入图片描述

3 字节流

字节流的父类（抽象类）：InputStream和OutputStream

//InputStream 字节输入流
public int read(){}
public int read(byte[] b){}
public int read(byte[] b, int off, int len){}

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

文件字节流

FileInputStream

FileInputStream从文件系统中的文件获取输入字节。什么文件可用取决于主机环境。
构造方法：
FileInputStream(String name) throws FileNotFoundException：通过打开与实际文件的连接来创建一个 FileInputStream，该文件由文件系统中的路径名 name命名。
public int read(byte[] b) throws IOException：从该输入流读取最多b.length字节的数据到字节数组。

读入缓冲区的总字节数，如果没有更多的数据，因为文件的结尾已经到达，则返回-1 。

psvm(String[] args) throws Exception{//可能会找不到文件，所以抛出异常
  // 1 创建FileInputStream 并指定文件路径
  FileInputStream fis = new FileInputStream("d:\\abc.txt");
  // 2 读取文件
  // fis.read();
  // 2.1单字节读取
  int data = 0;
  while((data = fis.read()) != -1){
    System.out.print((char)data);
  }
  // 2.2 一次读取多个字节
  byte[] buf = new byte[3]; // 大小为3的缓存区
  int count = fis.read(buf); // 一次读3个
  System.out.println(new String(buf));
  System.out.println(count);
  int count2 = fis.read(buf); // 再读3个
  System.out.println(new String(buf));
  System.out.println(count2);
  
  // 将上述优化：
  byte[] buf = new byte[1024];
  int count = 0;
  while((count = fis.read(buf)) != -1){
    System.out.println(new String(buf, 0, count));
  }
  
  // 3 关闭
  fis.close();
}

FileOutputStream

FileOutputStream用于写入诸如图像数据的原始字节流。
构造方法1：
public FileOutputStream(String name) throws FileNotFoundException：创建文件输出流以指定的名称写入文件。
构造方法2：
public FileOutputStream(File file,boolean append) throws
FileNotFoundException：创建文件输出流以指定的名称写入文件。如果第二个参数是true
，则字节将写入文件的末尾而不是开头。
public void write(byte[] b) throws IOException：将b.length字节从指定的字节数组写入此文件输出流。

psvm(String[] args) throws Exception{
  // 1 创建文件字节输出流
  FileOutputStream fos = new FileOutputStream("路径", true);// true表示不覆盖 接着写 
	// 2 写入文件
  fos.write(97);
  fos.write('a');
  // String string = "hello world";
  fos.write(string.getByte());
  // 3 关闭
  fos.close();
}

复制文件（边读边写）：

// 1 创建流
// 1.1 文件字节输入流
FileInputStream fis = new FileInputStream("路径");
// 1.2 文件字节输出流
FileInputStream fos = new FileOutpuStream("路径");
// 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();

字节缓冲流

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

BufferedInputStream

构造函数：
public BufferedInputStream(InputStream in)：创建一个BufferedInputStream并保存其参数，输入流in供以后使用。内部缓冲区数组创建并存储在buf 。

// 使用字节缓冲流 读取 文件
psvm(String[] args) throws Exception{
  // 1 创建BufferedInputStream
  FileInputStream fis = new FileInputStream("路径");
  BufferedInputStream bis = new BufferedInputStream(fis);
  // 2 读取
  int data = 0;
  while((data = bis.read()) != -1){
    sout((char)data);
  }
   
  // 3 关闭
  bis.close();
}

默认缓冲流大小为8k，可以自定义缓冲流：

 // 用自己创建的缓冲流
  byte[] buf = new byte[1024];
  int count = 0;
  while((count = bis.read(buf)) != -1){
    sout(new String(buf, 0, count));
  }

BufferedOutputStream

构造方法1：
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
构造方法2：
BufferedOutputStream(OutputStream out, int size)
创建一个新的缓冲输出流，以便以指定的缓冲区大小将数据写入指定的底层输出流。

// 使用字节缓冲流 写入 文件
psvm(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缓冲区（因为数据没到8k的大小，先暂存到缓冲区而不立即写入文件）
    bos.flush(); // 刷新到硬盘（立即写入）
  }
  // 3 关闭
  bos.close();
}

对象流

ObjectOutputStream / ObjectInputStream
增强了缓冲区功能
增强了读写8种基本数据类型和字符串的功能
增强了读写对象的功能
使用流传输对象的过程称为序列化、反序列化

序列化：将对象转换为序列，或者说将对象写入流之中。一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。

反序列化：从流中读取对象。

ObjectOutputStream

构造方法：
protected ObjectOutputStream(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream。

// 使用ObjectOutputStream实现序列化
psvm(String[] args)throws Exception{
  // 1. 创建对象流
  FileOutputStream fos = new FileOutputStream("d:\\st.bin");
  ObjectOutputSream oos = new objectOutputSream(fos);
  // 2. 序列化（写入操作）
  Student zhangsan = new Student("zs", 20);//Student类要实现Serializable接口
  oos.WriteObject(zhangsan);
  // 3. 关闭
  oos.close();
  sout("序列化完毕");
}

public class Student implements Serializable{}

ObjectInputStream

构造方法：
protected ObjectInputStream(InputStream in)：创建从指定的InputStream读取的ObjectInputStream。
Object readObject() ：从ObjectInputStream读取一个对象。

// 使用ObjectInputSteam实现反序列化（读取重构对象）
psvm(String[] args)throws Exception{
  // 1. 创建对象流
  FileInputStream fis = new FileInputStream("d:\\stu.bin");
  ObjectInputStream ois = new ObjectInputStream(fis);
  // 2. 读取文件（反序列化）
  Student s = (Student)ois.readObject();//返回Object类型，需转换
  // 3. 关闭
  ois.close();
  sout("执行完毕");
  sout(s.toString());  
}

注意事项

某个类要想序列化必须实现Serializable接口
序列化类中对象属性（属性中的引用数据类型）也要求实现Serializable接口
序列化版本号ID（serialVersionUID ）的作用：保证序列化的类和反序列化的类是同一个类
使用transient修饰的属性，这个属性就不能被序列化
静态属性不能被序列化
序列化多个对象，可以借助集合来实现

借助集合来实现序列化多个对象：

psvm(String[] args)throws Exception{
  // 1. 创建对象流
  FileOutputStream fos = new FileOutputStream("d:\\st.bin");
  ObjectOutputSream oos = new objectOutputSream(fos);
  // 2. 序列化（写入操作）
  Student s1 = new Student("张三", 20);
  Student s2 = new Student("李四", 22);
  ArrayList<Student> list = new ArrayList<>();
  list.add(s1);
  list.add(s2);
  oos.WriteObject(list);
  // 3. 关闭
  oos.close();
  sout("序列化完毕");
}

psvm(String[] args)throws Exception{
  // 1. 创建对象流
  FileInputStream fis = new FileInputStream("d:\\stu.bin");
  ObjectInputStream ois = new ObjectInputStream(fis);
  // 2. 读取文件（反序列化）
  ArrayList<Student> list = (ArrayList<Student>)ois.readObject();
  //返回Object类型，需转换
  // 3. 关闭
  ois.close();
  sout("执行完毕");
  sout(list.toString());  
}

5 字符流

注：在UTF-8编码中，
一个中文字符 / 中文标点符号占3个字节；
一个英文字符 / 英文标点 / 数字符号占1个字节。

因为字节流是逐个字节读取，要是读取汉字或者其他内容的文本的话会出现乱码，因为一个字节无法组成汉字，所以要用到字符流。
字符流的两个父类（抽象类）：
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)

文件字符流

FileReader和FileWriter

FileReader

单个字符读取：

// 1. 创建FileReader 文件字符输入流
FileReader fr = new FileReader("..");
// 2. 读取
// 2.1 单个字符读取
int data = 0;
while((data = fr.read()) != -1){
  sout((char)data);// 读取一个字符
}

// 3. 关闭
fr.close();

使用自定义字符缓冲区读取：

// 1. 创建FileReader 文件字符输入流
FileReader fr = new FileReader("..");
// 2. 读取
// 2.2 使用字符缓冲区读取
char[] buf = new char[2]; 
//2表明2个字符2个字符地读，缓冲区大小可以自定义
int count = 0;
while((count = fr.read(buf) != -1)){
  sout(new String(buf, 0, count));
}
// 3. 关闭
fr.close();

FileWriter

// 1. 创建FileWriter对象
FileWriter fw = new FileWriter("..");
// 2. 写入
  fw.write("Java是世界上最好的语言");
  fw.flush();

// 3. 关闭
fw.close();
sout("执行完毕");

复制文件（使用FileReader和FileWriter）：
不能复制图片或二进制文件（声音、视频、可编译文件等），使用字节流可以复制任意文件。

psvm(String[] args) throws Exception{
  // 1. 创建
  FileReader fr = new FileReader("...");
  FileWriter fw = new FileWriter("...");
  // 2. 读写
  int data = 0;
  while((data = fr.read()) != -1){
    fw.write(data);
    fw.flush();
  }
  // 3. 关闭
  fw.close();
  fr.close();
}

字符缓冲流

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

BufferedReader

从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取

构造方法1：BufferedReader(Reader in)：创建使用默认大小的输入缓冲区的缓冲字符输入流。
public int read()：读一个字符，如果已经达到流的结尾，则为-1。
public String readLine()：读一行文字。一行被视为由换行符（’\ n’），回车符（’\ r’）中的任何一个或随后的换行符终止。如果已达到流的末尾，则为null

psvm(String[] args) throws Exception{
  // 创建缓冲流
  FileReader fr = new FileReader("..");
	BufferedReader br = new BufferedReader(fr);
  // 读取
  // 1. 第一种方式 一个一个字符地读取
  char[] buf = new char[1024];
  int count = 0;
  while((count = br.read(buf)) != -1){
    sout(new String(buf, 0, count));
  }
  // 2. 第二种方式 一行一行地读取
  String line = null;
  while((line = br.readLine()) != null){
    sout(line);
  }
  
	// 关闭
  br.close();
}

BufferedWriter

将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。

psvm(String[] args) throws Exception{
 	// 1. 创建BufferedWriter对象
    FileWriter fw = new FileWriter("...");//若已有该文件，则会覆盖文件
    BufferedWriter bw = new BufferedWriter(fw);
    // 2. 写入
    for(int i = 0; i < 10; i ++){//写十遍
        bw.write("写入的内容");
        bw.newLine(); // 写入一个换行符
        bw.flush();
    }
    // 3. 关闭
    bw.close();

转换流

InputStreamReader

InputStreamReader是从字节流（硬盘）到字符流（内存）的桥：它读取字节，并使用指定的charset将其解码为字符。
它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
构造方法1：
InputStreamReader(InputStream in)
创建一个使用默认字符集的InputStreamReader。
构造方法2：
InputStreamReader(InputStream in, String charsetName)
创建一个使用命名字符集的InputStreamReader。
String getEncoding() 返回此流使用的字符编码的名称。
int read() 读一个字符

psvm(String[] args) throws Exception{
  // 1 创建InputStreamReader对象
  FileInputStream fis = new FisInputStream("..");
  InputStreamReader isr = new InputStreamReader(fis, "utf-8");
  // 2 读取文件
  int data = 0;
  while((data = isr.read()) != -1){
    sout((char)data);
  }
  // 3 关闭
  isr.close();
}

OutputStreamWriter

OutputStreamWriter是字符的桥梁流以字节流：向其写入的字符编码成使用指定的字节charset 。
它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
构造方法1：
OutputStreamWriter(OutputStream out)
创建一个使用默认字符编码的OutputStreamWriter。
构造方法2：
OutputStreamWriter(OutputStream out, String charsetName)
创建一个使用命名字符集的OutputStreamWriter。
void flush() 刷新流。
void write(int c) 写一个字符

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

6 File类

文件和目录路径名的抽象表示。
常量：
static String pathSeparator
与系统相关的路径分隔符字符，为方便起见，表示为字符串。（即 ;）
static char pathSeparatorChar
与系统相关的路径分隔符。（即 ;）
static String separator
与系统相关的默认名称 - 分隔符字符，以方便的方式表示为字符串。（即 \）
static char separatorChar
与系统相关的默认名称分隔符。（即 \）
构造方法：
File(File parent, String child)
从父抽象路径名和子路径名字符串创建新的 File实例。
File(String pathname)
通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
File(String parent, String child)
从父路径名字符串和子路径名字符串创建新的 File实例。
File(URI uri)
通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。

常用方法：

boolean createNewFile() 当且仅当具有该名称的文件尚不存在时，创建一个由该抽象路径名命名的新的空文件。
boolean mkdir() 创建由此抽象路径名命名的单个目录。
boolean mkdirs() 创建由此抽象路径名命名的多级目录。
boolean delete() 删除由此抽象路径名表示的文件或目录。
boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
String getName() 返回由此抽象路径名表示的文件或目录的名称。
String getParent() 返回此抽象路径名的父 null的路径名字符串，如果此路径名未命名为父目录，则返回null。
boolean isDirectory() 测试此抽象路径名表示的文件是否为目录。
boolean isFile() 测试此抽象路径名表示的文件是否为普通文件。
long length() 返回由此抽象路径名表示的文件的长度。
File[] listFiles() 返回一个抽象路径名数组，表示由该抽象路径名表示的目录中的文件。
boolean renameTo(File dest) 重命名由此抽象路径名表示的文件。

对文件操作

/*
File类的使用
1. 分隔符
2. 对文件操作
3. 对文件夹操作
*/
public class FileDemo {
    public static void main(String[] args) throws Exception{
//        separator();
//        fileOpe();
        directoryOpe();
    }
    //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("G:\\360MoveData\\Users\\cheng\\Desktop\\demo1.txt");
        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(3000);//3秒
        // 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());
    }   
}

对文件夹操作

    // 对文件夹操作
    public static void directoryOpe() throws Exception{
        // 1. 创建文件夹
        File dir = new File("G:\\360MoveData\\Users\\cheng\\Desktop\\aaa\\bbb\\ac");
        if(!dir.exists()){
            //dir.mkdir(); // 只能创建单级目录
            dir.mkdirs(); // 创建多级目录
        }

        // 2. 删除文件夹
        // 2.1 直接删除
//        System.out.println("删除结果："+dir.delete()); // 1.只能删除最里面的目录；2.而且只删除空目录
        // 2.2 让jvm退出时删除
//        dir.deleteOnExit();
//        Thread.sleep(3000);//3秒
        // 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.isDirectory());
        System.out.println("是否隐藏" + dir.isHidden());

        // 5. 遍历文件夹
        File dir2 = new File("G:\\360MoveData\\Users\\cheng\\Desktop\\杂项");
        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());
}

对文件夹递归操作

1.递归遍历文件夹（显示里面所有文件，包括其所有子文件夹里面的所有文件）

//递归遍历文件夹
    public static void main(String[] args) {
//        listDir(new File("G:\\360MoveData\\Users\\cheng\\Desktop\\杂项1"));
        deleteDir(new File("G:\\360MoveData\\Users\\cheng\\Desktop\\杂项2"));
    }
    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());
    }