File类和IO流_io流和file类关系-CSDN博客

本文链接：https://blog.csdn.net/zhangyongbaba/article/details/107587055

3.3.3 字节流-try...catch捕获异常

一、File类和IO流概述：

1.1 IO流是什么

1. 可以将数据从本地文件中读取出来

2. 可以将数据从内存保存到本地文件

1.2 File类是什么

1. 在读写数据时告诉虚拟机要操作的(文件/文件夹)在哪

2. 对(文件/文件夹)本身进行操作,包括创建,删除等

二、File类

2.1 File的构造方法

1. File(String pathName) 根据字符串路径创建一个File对象

代码：

String path = "D:/test/jsonText1.txt";
File file = new File(path);

2. File(String parent,String child) 根据字符串父级路径和子级路径创建File对象

代码：

String path1 = "D:/text";
String path2 = "jsonText1.txt";
File file = new File(path1,path2); // 拼接路径
System.out.println(file);

3. File(File parent,String child) 根据File类型父级路径和字符串子级路径创建File对象

代码：

File file = new File("D:/test");
String path = "jsonText1.txt";
File file1 = new File(file,path);
System.out.println(file1);

2.2 File的创建功能

1. boolean createNewFile() 创建一个新文件

代码示例：

File file = new File("D:/test/a.txt");
boolean newFile = file.createNewFile();
System.out.println(newFile);

2. boolean mkdir() 创建单级文件夹

File file = new File("D:/test/aaa");
boolean mkdir = file.mkdir();
System.out.println(mkdir);

3. boolean mkdirs() 创建多级文件夹

File file = new File("D:/test/aaa/bbb/cc/cd");
boolean mkdirs = file.mkdirs();
System.out.println(mkdirs);

2.3 File的删除方法

1. File的删除方法

boolean delete(): 删除文件或文件夹

2. 删除方法注意事项:

delete方法直接删除不走回收站

如果删除的是一个文件,直接删除

如果删除的是一个文件夹,需要先删除文件夹中的内容,最后才能删除文件夹

2.4 File的获取和判断方法

1. File类的判断方法

boolean isDirectory() 判断是否是文件夹

boolean isFile() 判断是否是文件

boolean exists() 判断文件是否存在

2. File类的获取方法

     String getAbsolutePath() 获取绝对路径

     String getPath() 获取构造方法中的路径

     String getName() 获取文件或文件夹的名称

2.5 File的listFiles方法

1. File[] listFiles(): 获取文件夹下的所有文件和文件夹对象,封装到File数组中返回

2. listFiles方法注意事项

（1）当调用者不存在时,返回null

（2）当调用者是一个文件时,返回null

（3）当调用者是一个空文件夹时,返回一个长度为0的数组

（4）当调用者是一个有内容的文件夹时,将里面所有文件和文件夹的路径放在File数组中返回

（5）当调用者是一个有隐藏文件的文件夹时,将里面所有文件和文件夹的路径放在File数组中返回,包含隐藏内容

（6）当调用者是一个需要权限才能进入的文件夹时,返回null

示例代码：

1. 删除一个多级文件夹

private static void fileRemove(File aaa) {
    // 先删掉这个文件夹里的所有内容
    // 递归
    // 注意：可以解决所有文件夹和递归结合的题目
    // 1. 进入问价夹，获取里面的所有的文件和子文件夹
    File[] files = aaa.listFiles();
    // 2. 遍历,得到aaa文件里面每一个文件和文件夹的File对象
    for (File file : files) {
        // 3. 判断，如果是文件，直接删除
        if (file.isFile()){
            file.delete();
        }else {
            // 递归
            fileRemove(file); // 参数一定要是aaa文件夹里面的文件夹
        }
    }
    //  最后在删除这个文件夹
    aaa.delete();

2. 统计一个文件夹中每种文件的个数并打印
打印格式如下：tex：3个
             doc：4个
             jpg：6个
             ...

private static void getFileNum(HashMap<String, Integer> map, File file) {
    // 1. 进入问价夹，获取里面的所有的文件和子文件夹
    File[] fileList = file.listFiles();
    // 2. 遍历所有的文件
    for (File file1 : fileList) {
        // 3. 如果是文件，使用“.”进行切割，如果切割出来的数组长度大于2，说明是一个标准的文件
        if (file1.isFile()) {
            String file1Name = file1.getName();
            String[] split = file1Name.split("\\.");
            // 如果切割出来的数组长度大于2，说明是一个标准的文件
            if (split.length == 2){
                // 4. 取出来后缀名
                String suffix = split[1];
                // 5. 判断后缀名是不是第一次存入集合
                if (map.containsKey(suffix)){
                    // 如果不是进行次数加一操作
                    Integer count = map.get(suffix);
                    count++;
                    map.put(suffix,count);
                }else {
                    // 如果是，存入集合
                    map.put(suffix,1);
                }
            }
        }else {
            // 如果是一个文件夹，进行递归
            getFileNum(map,file1);
        }
    }
}

三、IO流

3.1 概述：

IO流用于操作计算机硬盘和内存中的文件数据。I表示intput,是数据从硬盘进内存的过程,称之为读；O表示output,是数据从内存到硬盘的过程,称之为写。

3.2 IO流的分类

1. 按流向分：分为输入流和输出流

2. 按类型分：

字节流:可以操作所有类型的文件,包括图片视频等等。

字符流只能操作纯文本文件,例如java文件,txt文件等等。

3.3 字节流

3.3.1 字节输入流

FileInputStream

public static void main(String[] args) throws IOException {
        // 创建对象
        FileInputStream fis = new FileInputStream("BytesStream/a.txt");

        // read() 读取

        int read;
        // 当读到-1的时候，表示读取文件内容结束
        while ((read = fis.read()) != -1) {
            System.out.println((char)read);
        }

    }

3.3.2 字节输出流

FileOutputStream

public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("BytesStream/b.txt");

        //method(fos);

        // 可以指定数组的索引可以写入，指定长度
        String s = "我是XXXX";
        // 可以一次写一个数组
        byte[] bytes = s.getBytes();
        fos.write(bytes,1,5);
    }

    private static void method(FileOutputStream fos) throws IOException {
        String s = "我是XXXX";
        // 可以一次写一个数组
        byte[] bytes = s.getBytes();
        fos.write(bytes);
        fos.close();
    }

3.3.3 字节流-try...catch捕获异常

1. 在异常处理时提供finally块来执行所有清除操作。比如说IO流中的释放资源。

2. 特点：被finally控制的语句一定会执行，除非JVM退出
3. 异常处理标准格式：try...catch...finally

步骤：

1. 将创建字节流对象和写出数据的代码放在try中

2. 在catch中捕获IOException异常

3. 在finally中进行释放资源

示例代码：

FileOutputStream fos = null;
try {
    fos = new FileOutputStream("BytesStream/a.txt");
    fos.write(10);
    fos.close();
} catch (IOException e) {
    e.printStackTrace();
}finally {
    if (fos != null) {
        try {
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.4 缓冲流

用法和字节流一样，但是效率比字节流高，因为缓冲流底层读取或者写入的时候是通过数组来进行传输的。

1. 字节缓冲流：

BufferOutputStream: 字节缓冲输出流

BufferedInputStream: 字节缓冲输入流

2. 构造方法：

字节缓冲输出流: BufferedOutputStream(OutputStream out)

字节缓冲输入流: BufferedInputStream(InputStream in)

3. 读和写的方法:

BufferedOutputStream: 从父类OutputStream继承写的方法

BufferedInputStream: 从父类InputStream继承读的方法

3.5 字符流

1. 字符输出流：FileWriter

        FileWriter fw = new FileWriter("CharStream/c.txt");

        fw.write("草木有本心\t\n");
        fw.flush();
        fw.write("何求美人折");

        fw.close();

2. 字符输入流：FileReader

        // 创建字符输入流对象
        //FileReader fr = new FileReader(new File("CharStream/b.txt"));
        FileReader fr = new FileReader("CharStream/b.txt");

        //读取数据
        // 一次读取一个
        int len;
        while ((len = fr.read())!=-1){
            System.out.println((char) len);
        }
        fr.close();

        // 一次读取多个
        char[] chars = new char[1024];
        int len;
        while ((len = fr.read(chars)) != -1) {
            System.out.println(new String(chars,0,len));
        }
        fr.close();

3.6 字符缓冲流

3.6.1字符缓冲输入流的使用

1.BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。默认值足够大，可用于大多数用途

2.构造方法:

BufferedReader(Reader in)

BufferedReader(Reader in, int sz)

        // 字符缓冲输入流
        BufferedReader br = new BufferedReader(new FileReader("CharStream/user.txt"));

        char[] chars = new char[1024];
        int len;
        while ((len = br.read(chars))!=-1) {
            System.out.println(new String(chars,0,len));
        }
        br.close();

3.成员方法:

继承父类的成员方法进行使用

3.6.2 字符缓冲输出流-输出数据

1. 字符缓冲输出流的使用

BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途

2. 构造方法:

BufferedWriter(Writer out)

BufferedWriter (Writer out, int sz)

        // 字符缓冲输出流
        BufferedWriter bw =new BufferedWriter(new FileWriter("CharStream/d.txt"));

        bw.write(97);
        bw.write("\r\n");

        char[] chars = {97,98,99,100,100};
        bw.write(chars);
        bw.write("\r\n");

        bw.write(chars,0,3);
        bw.write("\r\n");

        bw.write("我是大书包");
        bw.write("\r\n");

        String line = "abcdefg";
        bw.write(line,0,5);

        bw.flush();
        bw.close();

3. 成员方法:

继承父类的成员方法进行使用

3.6.3 字符缓冲流特有方法

1. BufferedWriter：

void newLine()：写一行行分隔符，行分隔符字符串由系统属性定义

2. BufferedReader：

public String readLine() ：读一行文字。结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null

四、转换流

4.1 概念

就是进行字节流和字符流之间转换的

InputStreamReader: 是字节流通向字符流的桥梁

OutputStreamWriter: 是字符流通向字节流的桥梁

4.2 使用

1.创建读和写的流对象,可以指定编码,不指定默认是utf-8

InputStreamReader 构造方法：

InputStreamReader(InputStream in)

InputStreamReader(InputStream in, String charsetName)

OutputStreamWriter 构造方法：

OutputStreamWriter(OutputStream out)

OutputStreamWriter(OutputStream out, String charsetName)

2.进行读和写的操作

读: read(char[] cbuf)

写: write(String str)

3.关流,释放资源

close()

示例代码：

InputStreamReader isr = new InputStreamReader(new FileInputStream("C:\\Users\\y1833\\Desktop\\ccc.txt"),"gbk");
int len;
while ((len = isr.read()) != -1) {
    System.out.println((char)len);
}
isr.close();

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("C:\\Users\\y1833\\Desktop\\ccc.txt"),"utf-8");

osw.write("我爱学习");
osw.close();

五、对象操作流

5.1 对象操作流程-基本特点

1. 对象的序列化

将内存中的对象写入到本地文件中

2. 对象的反序列化

将文件中保存的对象数据读取到内存中

5.2 对象操作流-序列化

对象序列化的基本使用：

1. 定义一个学生类，提供name和age两个成员变量。并实现Serializable接口

2. 创建对象输出流：ObjectOutputStream

3. 创建一个学生对象

4. 调用writeObject()方法，将学生对象写出

5. 释放资源

5.3 对象操作流-反序列化

对象反序列化流的基本使用

创建对象反序列化流：ObjectInputStream()
调用readObject()方法。读取对象数据
将读取的对象向下转型
输出对象中的内容
释放资源

注意事项：

序列化号不一致导致的异常

serialVersionUID，直接将序列化号定义成常量,可以解决类文件不一致的问题

序列化时某个成员不想参与如何解决

transient，如果一个成员不想参与序列化操作,可以使用该关键字修饰

/*
如果想要这个类的对象能被序列化，那么这个类必须要实现一个接口，Serializable

Serializable 接口的意义：
1. Serializable是一个标志性接口，里面没有任何的抽象方法
2.  只要一个类实现了这个Serializable接口，那么就表示这个类的对象可以被序列化

serialVersionUID 序列号
如果我们自己没有定义，那么虚拟机会根据类中的信息会自动的计算出一个序列号
如果我们修改了类中的信息，那么虚拟机会再次计算出一个序列号

出错步骤：
    第一步：把User对象序列化到本地
    第二步：修改了Javabean类，导致类中的序列号变化
    第三步：把文件中的对象读到内存，本地中的序列号和类中的序列号不一致了
解决：
    不让虚拟机帮我们自动计算，我们自己手动给出，而且这个值不要变
 */
import java.io.Serializable;

public class User implements Serializable {
    private static final long serialVersionUID = 123L;

    private String username;
    // 如果不想某个成员便两个被序列化，在成员变量前加上transient修饰即可
    private transient String password;

    public User() {
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}


public class Demo4 {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 对象输入流（反序列化）
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("OtherIOModule/user.txt"));

        User o = (User) ois.readObject();
        System.out.println(o);
        String password = o.getPassword();
    }
}

六、Properties

6.1 Properties集合概述

1. 是一个Map体系的集合类

2. Properties中有和IO相关的方法

3. 键值对的数据类型基本都定义为字符串

6.2 Properties-load

如何将文件中的键值对数据读取到Properties集合中

void load(Reader reader)：将本地文件中的键值对数据读取到集合中

6.3 Properties-store

void store(Writer writer, String comments)：将集合中的键值对数据写出到本地文件中

    public static void main(String[] args) throws IOException {
        //method1Save();

        Properties prop = new Properties();
        prop.put("张三","123");
        prop.put("王五","456");
        prop.put("李四","789");
        FileWriter fw = new FileWriter("OtherIOModule/prop.properties");
        prop.store(fw,"yongbaba");
        fw.close();

    }

    private static void method1Save() throws IOException {
        // 读取
        Properties prop = new Properties();
        // 因为需要释放资源，所以不能使用匿名对象
        FileReader fr = new FileReader("OtherIOModule/prop.properties");
        // 调用完了load方法后，文件中的键值对数据已经在集合中了
        prop.load(fr);
        fr.close();
        System.out.println(prop);
    }