Java IO框架

1.流

1. 概念

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

2. 流的分类

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

2.字节流

2.1字节流的父类（抽象类）

1. InputStream：字节输入流

2. OutputStream：字节输出流

3. 常用方法

2.2FileInputStream（读）和FileOutputStream（写）

1. FIleInputStream:

• public int read (byte [] b) 从流中读取多字节，将读到内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1

import java.io.FileInputStream;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //创建FileInputStream对象，并指定读入文件路径
        FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\a.txt");

        //一次读取一个字节
//        //fis.read();//只能读取一个字节
//        //使用循环读取全部字节
//        int data=0;
//        //当读完时返回值为-1
//        while ((data=fis.read())!=-1){
//            System.out.println((char)data);//注意读入字符要强转为char型
//        }

        //一次读取多个字节
        byte[] buf=new byte[3];//定义一个byte数组，使每次读入3个字节
        int count=0;
        //fis.read(buf)一次读buf.length字节，并返回读取的个数，读完返回-1
        while ((count=fis.read(buf))!=-1){
            //创建String类new String(byte bytes[], int offset, int length)
            System.out.println(new String(buf,0,count));
        }
        fis.close();//最后要关闭文件
        System.out.println("执行完毕！");
    }
}

2. FileOutputStream：

• public void write (byte [] b) 一次写多个字节，将b数组中所有字节，写入输出流

import java.io.FileOutputStream;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建FileOutputStream对象，并写出文件到文件路径，默认写方式为覆盖，可以令append:true变为添加
        FileOutputStream fos=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\a.txt",true);
        //2.写入文件
        //一次写入一个字节
        fos.write(97);//输入数字会自动转为字符
        fos.write('a');
        //一次写入多个字节
        String string="HelloWorld!";
        //fos.write(byte [])
        //string.getBytes()转化字符串为byte数组
        fos.write(string.getBytes());
        //关闭文件
        fos.close();
        System.out.println("执行成功！");
    }

}

3. 例子：使用FileInputStream和FileOutputStream完成文件复制

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        //1.1创建输入流
        FileInputStream fis=new FileInputStream("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\1.jpg");
        //1.2创建输出流
        FileOutputStream fos=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\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("复制完成！");
    }
}

2.3字节缓冲流

1. 缓冲流：BufferedInputStream/BufferedOutputStream

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

2. BufferedInputStream使用

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedInputStream
        FileInputStream fis=new FileInputStream("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\a.txt");
        BufferedInputStream bis=new BufferedInputStream(fis);
        //2.读取
//        int data=0;
//        //2.1 bis.read()是默认将8k的数据写入缓存区
////        //data=bis.read()是从缓存区中再每次取一个字节
////        while((data=bis.read())!=-1){
////            System.out.print((char)data);
////        }
        //2.2 bis.read()是默认将8k的数据写入缓存区
        //bis.read(buf)是从缓存区中每次取buf长度的字节
        byte[] buf=new byte[1024];
        int count=0;
        while((count=bis.read(buf))!=-1){
            System.out.print(new String(buf,0,count));
        }
        //3.关闭
        //此时只需要关闭BufferedInputStream，FileInputStream会自动关闭
        bis.close();
    }
}

3. BufferedOutputStream使用

import java.awt.*;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedOutputStream
        FileOutputStream fos=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\b.txt");
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        //2.写入文件
        for (int i=0;i<10;i++){
            //bos.write是将文件写入8k的输出缓冲区，并没有写入存储
            bos.write("HelloWorld".getBytes());//字符串转byte数组
            //bos.flush()刷新数据到硬盘
            bos.flush();
        }
        bos.close();//关闭时会默认调用一次bos.flush();
    }
}

3.对象流

3.1对象流：ObjectOutputStream/ObjectInputStream

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

3.2 序列化

• 使用ObjectOutputStream实现序列化
• 序列化的类必须要实现Serializable接口

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
 * 使用ObjectOutputStream实现序列化
 * 序列化的类必须要实现Serializable接口
 */
public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        FileOutputStream fos=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2.序列化，写入操作
        Student zhangsan = new Student("张三", 20);
        oos.writeObject(zhangsan);
        //3.关闭流
        oos.close();//内部实现一次oos.flush,并同时关闭fos
        System.out.println("序列化完成");
    }
}

import java.io.Serializable;
//序列化的类必须要实现Serializable接口
public class Student implements Serializable {
    private String name;
    private int age;

    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 +
                '}';
    }
}

3.3 反序列化

• 使用ObjectInputStream实现反序列化（读取重新构成对象）
• 反序列化只能重构一次对象

import java.io.*;

/**
 * 使用ObjectInputStream实现反序列化（读取重新构成对象）
 * 反序列化只能重构一次对象
 */
public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        FileInputStream fis=new FileInputStream("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2.反序列化（重构对象）
        Student s=(Student) ois.readObject();
        //Student s1=(Student) ois.readObject();//反序列化只能重构一次对象
        //3.关闭流
        ois.close();//内部实现一次oos.flush,并同时关闭fos
        System.out.println(s.toString());
    }
}

package com.yang;

import java.io.Serializable;
//序列化的类必须要实现Serializable接口
public class Student implements Serializable {
    private String name;
    private int age;

    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 +
                '}';
    }
}

3.4 序列化和反序列化注意事项

• 序列化类必须要实现Serializable接口
• 序列化类中对象属性要求实现Serializable接口
• 要添加序列化版本号ID，保证序列化和反序列化的类是同一个类
• 使用transient(瞬态的)关键字修饰的属性，不会进行序列化
• 静态属性不会进行序列化
• 序列化多个对象时，可以借助集合实现

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

/**
 - 序列化类必须要实现Serializable接口
 - 序列化类中对象属性要求实现Serializable接口
 - 要添加序列化版本号ID，保证序列化和反序列化的类是同一个类
 - 使用transient(瞬态的)关键字修饰的属性，不会进行序列化
 - 静态属性不会进行序列化
 - 序列化多个对象时，可以借助集合实现
 */
//序列化操作
public class Demo2 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        FileOutputStream fos=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2.序列化，写入操作
        Student zhangsan = new Student("张三", 20);
        Student lisi=new Student("lisi",18);
        //2.1多次序列化多个对象
        //oos.writeObject(zhangsan);
        //oos.writeObject(lisi);
        //2.2借助集合实现序列化多个对象
        ArrayList<Student> list=new ArrayList<>();
        list.add(zhangsan);
        list.add(lisi);
        oos.writeObject(list);
        //3.关闭流
        oos.close();//内部实现一次oos.flush,并同时关闭fos
        System.out.println("序列化完成");
    }
}


//反序列化操作
import java.io.*;
import java.util.ArrayList;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        FileInputStream fis=new FileInputStream("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2.反序列化（重构对象）
        //2.1多个对象可以使用多次反序列化重构
        //Student s1=(Student) ois.readObject();
        //Student s2=(Student) ois.readObject();
        //2.2使用集合接收多反序列化对象
        ArrayList<Student> list= (ArrayList<Student>) ois.readObject();
        //3.关闭流
        ois.close();//内部实现一次oos.flush,并同时关闭fos
        System.out.println(list.toString());
    }
}


package com.yang;


//Student类
import java.io.Serializable;
//序列化的类必须要实现Serializable接口
public class Student implements Serializable {
    //添加序列化版本号ID，保证序列化和反序列化的类是同一个类;数字可以自己写，也可以使用默认值
    private static final long serialVersionUID = -2257541161529509239L;
    private String name;
    //使用transient(瞬态的)关键字修饰的属性，不会进行序列化
    private transient int age;
    //静态属性不会进行序列化
    public static String country="China";
    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 +
                '}';
    }
}

4. 字符流

4.1 字符编码

• ISO-8859-1：ASCII、西欧、希腊语、泰语、阿拉伯语、希伯来语
• UTF-8：针对Unicode码表的可变长度字符编码
• GB2312：简体中文
• GBK：简体中文、扩充
• BIG5台湾，繁体中文

4.2 字符流

• 字符流的父类（抽象类）
  • Reader：字符输入流
  • Writer：字符输出流

4.3 文件字符流FileReader/FileWriter

1. FileReader:
   • public int read (char [] c) //从流中读取多个字符，将读到内容存入c数组中，返回实际读到的字符数；如果达到文件尾部则返回-1

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建流FileReader
        FileReader fr=new FileReader("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\a.txt");
        //2.读取
        //2.1单字符读取，每次读取一个字符(1~3个字节)
//        int data=0;
//        while ((data=fr.read())!=-1){
//            System.out.print((char)data);
//        }
        //2.2 一次读多个字符
        char [] buf=new char[10];
        int count=0;
        while ((count=fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3.关闭流
        fr.close();//内部实现一次oos.flush,并同时关闭fos
        System.out.println("执行完成");
    }
}

2. FileWriter
   • public void writer (String str) //一次写多个字符，将b数组中所有字符写入输出流。

import java.io.FileWriter;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建FileW对象，并写出文件到文件路径，默认写方式为覆盖，可以令append:true变为添加
        FileWriter fw=new FileWriter("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\a.txt");
        //2.写入文件
        for(int i=0;i<10;i++){
            fw.write("Java是最好的语言\r\n");
            fw.flush();
        }
        //关闭文件
        fw.close();
        System.out.println("执行成功！");
    }
}

3. 使用FileReader ()和FileWriter() 来复制文件

   • 注意因为涉及到字符的转码问题，只能够幅值文本文件，不能够复制图片、视频、音频等二进制文件。

   import java.io.FileReader;
   import java.io.FileWriter;
   
   public class Demo1 {
       public static void main(String[] args) throws Exception{
           //1.创建文件流
           FileReader fr=new FileReader("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\a.txt");
           FileWriter fw=new FileWriter("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\b.txt");
           //2.读写文件
           int data=0;
           while((data=fr.read())!=-1){
               fw.write(data);
               fw.flush();
           }
           //关闭文件
           fr.close();
           fw.close();
           System.out.println("执行成功！");
       }
   
   }
   

4.4 字符缓冲流BufferedReader/BufferedWriter

1. 缓冲流BufferedReader/BufferedWriter

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

2. 使用字符缓冲流BufferedReader读取文件

import java.io.*;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建缓冲流BufferedReader
        FileReader fr=new FileReader("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\a.txt");
        BufferedReader br=new BufferedReader(fr);
        //2.读取
        //2.1第一种方式读取
//        char [] buf=new char[1024];
//        int count=0;
//        while((count=br.read(buf))!=-1){
//            System.out.println(new String(buf,0,count));
//        }
        //2.2一行一行读
        String line=null;
        while((line=br.readLine())!=null){
            System.out.println(line);
        }
        //关闭文件
        br.close();
        System.out.println("执行成功！");
    }

}

3. 使用字符缓冲流BufferedWriter写入文件

import java.io.*;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建缓冲流BufferedWriter
        FileWriter fw=new FileWriter("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\a.txt");
        BufferedWriter bw=new BufferedWriter(fw);
        //2.写入文件
        for (int i=0;i<10;i++){
            bw.write("好好学习");
            bw.newLine();//换行符相当于\r\n
        }
        //关闭文件
        bw.close();
        System.out.println("执行成功！");
    }

}

5. 打印流PrintWriter

• PrintWriter:
  • 封装了print () /println () 方法，支持写入后换行
  • 支持数据原样打印（数字，字符，true，字符串）

import java.io.*;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建打印流
        PrintStream ps=new PrintStream("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\a.txt");
        //2.打印输出，原样打印
        ps.println(97);//输出97
        ps.println('c');//输出c
        ps.println(3.14);//输出3.14
        ps.println("I love 中国");//输出I love 中国
        ps.println(true);//输出true
        //3.关闭文件
        ps.close();
        System.out.println("执行成功！");
    }

}

6. 转换流

1. 桥转换流：InputStreamReader/OutputStreamWriter

   • 可以将字节流转换为字符流

   • 可设置字符的编码方式

2. 使用InputStreamReader读取数据，并指定编码

import java.io.*;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建InputStreamReader对象
        FileInputStream fis=new FileInputStream("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\a.txt");
        InputStreamReader isr=new InputStreamReader(fis,"utf-8");//指定读入格式
        //2.读取文件
        int data=0;
        while ((data=isr.read())!=-1){
            System.out.print((char)data);
        }
        //3.关闭文件
        isr.close();
        System.out.println("执行成功！");
    }

}

3. 使用OutputStreamWriter输出数据，并指定编码

import java.io.*;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建OutputStreamWr iter对象
        FileOutputStream fos=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\a.txt");
        OutputStreamWriter osw=new OutputStreamWriter(fos,"gbk");//指定写出格式为gbk
        //2.写入文件
        for(int i=0;i<10;i++){
            osw.write("我是LiMing\r\n");
        }
        //3.关闭文件
        osw.close();
        System.out.println("执行成功！");
    }

}

7. File类（文件和文件夹）

• 概念：代表物理盘符中的一个文件或者文件夹
• File类的使用
  • 分隔符(路径分隔符；File.pathSeparator) (名称分隔符\ File.separator)
  • 文件操作
  • 文件夹操作
• 方法
  • createNewFile() 创建一个新文件
  • mkdir() 创建一个新目录
  • delete() 删除文件或者空目录
  • exists() 判断File对象所代表的对象是否存在
  • getAbsolutePath() 获取文件的绝对路径
  • getName() 获取名字
  • getParent() 获取文件或目录所在的目录
  • isDirectory() 是否是目录
  • isFile() 是否是文件
  • length() 获取文件的长度
  • listFiles() 列出目录中所有内容
  • renameTo() 修改文件名

7.1 文件操作

• 分隔符
• 创建文件
• 删除文件
• 获取文件信息
• 判断文件信息

package com.yang;


import java.util.Date;
import java.io.*;
public class Demo1 {
    public static void main(String[] args) throws Exception{
        separator();
        fileOpe();
    }
    //（1）分隔符
    public static void separator(){
        System.out.println("========打印分割符========");
        System.out.println("路径分隔符"+File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }
    //（2）文件操作
    public static void fileOpe() throws Exception{
        //1.创建文件
        //(1)创建文件对象
        System.out.println("========创建文件========");
        File file=new File("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\c.txt");
        //(2)创建文件
        //file.exists()判断文件是否存在，存在返回true，不存在返回false
        if(!file.exists()){
            boolean b=file.createNewFile();//file.createNewFile()创建文件，创建成功返回true，失败为false
            System.out.println("创建结果为："+b);
        }
        //2.删除文件
        System.out.println("========删除文件========");
        //2.1直接删除文件
//        System.out.println("删除结果是："+file.delete());//file.delete()删除为true，失败false
        //2.2使用jvm退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5000);//进程休眠5s,便于查看jvm退出时删除结果
        //3.获取文件信息
        System.out.println("========获取文件信息========");
        System.out.println("获取文件绝对路径："+file.getAbsolutePath());
        System.out.println("获取路径："+file.getPath());//new file对象是使用的是什么路径，这里就显示什么路径
        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("========判断========");
        System.out.println("是否可写："+file.canWrite());
        System.out.println("是否是文件："+file.isFile());
        System.out.println("是否隐藏："+file.isHidden());
    }
}

7.2 文件夹操作

• 创建文件夹
• 删除文件夹
• 获取文件夹信息
• 判断文件夹信息
• 遍历文件夹

import java.util.Date;
import java.io.*;


public class Demo1 {
    public static void main(String[] args) throws Exception{
        directoryOpe();
    }
    //文件夹操作
    public static void directoryOpe() throws Exception{
        //1.创建文件夹
        System.out.println("======创建文件夹=======");
        File dir=new File("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if(!dir.exists()){
            //dir.mkdir()//只能创建单级目录
            System.out.println("创建结果："+dir.mkdirs());//创建多级目录
        }
        //2.删除文件夹
        System.out.println("======删除文件夹=======");
        //2.1直接删除(只能删除最里层目录，且目录为空)
        //System.out.println("删除结果："+dir.delete());
        //2.2 jvm退出是删除文件夹
//        dir.deleteOnExit();
//        Thread.sleep(5000);
        //3.获取文件夹信息
        System.out.println("======获取目录信息=======");
        System.out.println("获取目录绝对路径："+dir.getAbsolutePath());
        System.out.println("获取目录路径："+dir.getPath());
        System.out.println("获取目录名称："+dir.getName());//目录名称为最内层文件夹
        System.out.println("获取目录父目录："+dir.getParent());//父目录为最内层文件夹的父目录
        System.out.println("获取目录创建时间："+new Date(dir.lastModified()).toLocaleString());
        //4.判断
        System.out.println("======判断目录信息=======");
        System.out.println("是否是文件夹："+dir.isDirectory());
        System.out.println("是否隐藏："+dir.isHidden());
        //5.遍历文件夹
        System.out.println("======遍历文件夹=======");
        File dir2=new File("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写");
        String[] files=dir2.list();//返回文件夹中的所有文件名称
        for (String file : files) {
            System.out.println(file);
        }
    }
}

7.3 FileFilter接口

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

import java.util.Date;
import java.io.*;


public class Demo1 {
    public static void main(String[] args) throws Exception{
        directoryOpe();
    }
    //FileFilter过滤文件夹操作
    public static void directoryOpe() throws Exception{
        File dir=new File("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写");
        //1.不使用FileFilter遍历文件夹，会得到文件夹中所有文件
        String[] files=dir.list();
        for (String file : files) {
            System.out.println(file);
        }
        System.out.println("======使用FileFilter过滤文件夹=======");
        //2.使用FileFilter遍历文件夹，指定返回类型为.jpg
        System.out.println("======FileFilter接口使用");
        //new FileFilter()时需要重写public boolean accept(File pathname)方法
        File [] files1=dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                //endsWith(".jpg")判断是否以.jpg结尾，是返回true
                if(pathname.getName().endsWith(".jpg")){
                    return true;//true表示出现在listFiles()的返回值上
                }
                return false;//false表示不出现在listFiles()的返回值上
            }
        });
        for (File file : files1) {
            System.out.println(file.getName());
        }
    }
}

7.4 例子：递归遍历和递归删除文件夹

• 要求递归遍历文件夹和递归删除文件夹，包括所有的子文件夹
• 文件夹中含有文件是不能被删除的，必须先删除文件

import java.util.Date;
import java.io.*;

/**
 * 1.使用递归，显示出文件夹下所有文件路径，包括子文件夹下的文件
 * 2.使用递归，删除文件夹下所有文件，文件夹
 */

public class Demo1 {
    public static void main(String[] args) throws Exception{
        System.out.println("=====递归遍历所有文件夹======");
        listDir(new File("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写1"));
        System.out.println("=====递归删除所有文件夹======");
        deleteDir(new File("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写1"));
    }
    //1.递归遍历文件夹
    public static void listDir(File dir){
        //System.out.println(dir.getAbsolutePath());
        File [] files=dir.listFiles();
        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){
        //System.out.println(dir.getAbsolutePath());
        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());
    }
}

8. Properties属性集合

• 特点

  • Properties集合中主要存储属性名和属性值
  • 属性名和属性值都是字符串类型
  • 没有泛型
  • 和流有关，能使用流输出和读入Properties属性

  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.PrintWriter;
  import java.util.Properties;
  import java.util.Set;
  
  /**
  Properties属性集合的使用
   */
  public class Demo2 {
      public static void main(String[] args) throws Exception{
          //1.创建集合
          Properties properties=new Properties();
          //2.添加数据
          properties.setProperty("username","张三");
          properties.setProperty("age","24");
          System.out.println(properties.toString());
          //3.遍历
          //3.1----方法1keySet---
          //3.2----方法2entrySet-----
          //3.3----独有的方法stringPropertyNames-----
          Set<String> pronames=properties.stringPropertyNames();//返回Properties集合中的key值
          for (String proname : pronames) {
              //properties.getProperty(key)在集合中通过key值得到property
              System.out.println(proname+"====="+properties.getProperty(proname));
          //4.和流有关的方法
          //4.1使用properties.list()方法和PrintWriter存储properties
          PrintWriter pw=new PrintWriter("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\c.txt");
          properties.list(pw);//通过properties.list()打印properties到文件
          pw.close();
          }
          //4.2使用properties.store()方法和FileOutputStream/FileOuterWriter存储properties
          //注意properties集合存储文件名后缀一般为.properties
          //存储中不能显示汉字，会将汉字转为Unicode编码存储
          FileOutputStream fos=new FileOutputStream("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\d.properties");
          properties.store(fos,"这里可以添加注释信息");
          fos.close();
          //4.3加载存储的properties信息
          System.out.println("========加载存储的properties信息==========");
          Properties properties1=new Properties();
          FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\java学习\\文件读写\\d.properties");
          properties1.load(fis);
          fis.close();
          System.out.println(properties1.toString());
          System.out.println("执行完成");
      }
  }
  

9. 总结

1. 流的概念
   • 内存与存储设备之间传输数据的通道
2. 流的分类
   • 输入流、输出流
   • 字节流、字符流
   • 节点流、过滤流
3. 序列化、反序列化
   • 将对象通过流写入到文件，或将对象通过流读取到内存，必须实现Serializable接口
4. File对象
   • 代表物理盘符中的一个文件或者文件夹

__EOF__

本文作者：Ray963
本文链接：https://www.cnblogs.com/ray93/p/16273061.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！