2020.2.10 Java IO流

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了2020.2.10 Java IO流，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含24243字，纯文字阅读大概需要35分钟。

内容图文

Java IO框架

一.流

1.基础概念

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

数据借助流 传输

二.流的分类

1.按方向分类

输入流：将<存储设备>中的内容读入到<内存>中

输出流：将<内存>中的内容写入到<存储设备>中

文件------(输入流)------->程序------(输出流)------->文件

2.按单位分类

字节流：以字节为单位，可以读写所有数据

字符流：以字符为单位，只能读写文本数据

3.按功能分类

节点流：具有实际传输数据的读写功能---------->（如：底层流）

过滤流：在节点流的基础之上增强功能---------->（如：缓冲流）

三.字节流

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

• 因为父类是抽象类，所以实现时，需要通过其子类

1.字节输入流：InputStream（父类）

此抽象类是表示输入字节流的所有类的超类

• 1）其子类：文件字节输入流：FileInputStream

//FileInputStream文件字节输入流的使用
public class demo01 {
    //由于可能出现找不到该路径下面的文件，所以需要抛出这个异常
    public static void main(String[] args) throws Exception {
        //1.创建FileInputStream文件字节输入流，并指定文件路径
        FileInputStream fis=new FileInputStream("D:\\test01.txt");
        //2.读取文件read()
        /*System.out.println("一个字节读：");
        //fis.read();----->返回的是int类型的数据
        int date=0;
        while( (date=fis.read())!=-1){
            System.out.print((char)date);
        }
        System.out.println();*/
        System.out.println("一次性读多个字节：");
        byte buf[]=new byte[5];//创建一个缓冲区
        int count=0;
        while((count =fis.read(buf))!=-1){
            //read(byte[] buf)从流中读取多个字节，存放人buf数组
            // --->返回实际读到的字节数，如果达到尾部则返回-1
            System.out.println(new String(buf,0,count));
        }
        //3.关闭
        fis.close();
        System.out.println("读取完毕！！！");
    }
}
/*
结果：将D:\\test01.txt文件中的数据，存到缓冲区buf[]，然后在程序中打印出来。（读取文件）
*/

• 2）字节缓冲输入流BufferedInputStream
• 是对 节点流或底层流的增强

//字节缓冲输入流BufferedInputStream的使用---读文件
public class demo04 {
    public static void main(String[] args) throws Exception {
        //1.创建流
        FileInputStream fis=new FileInputStream("D:\\test01.txt");
        BufferedInputStream bis=new BufferedInputStream(fis);
        //是对上面的底层流/节点流的增强
        //2.进行读操作
        int date=0;
        while((date=bis.read())!=-1){
            System.out.print((char)date);
        }
        //字节缓冲输入流BufferedInputStream自己有一个缓冲数组可以读入数据
        //相对于利用文件输入缓冲流FileInputStream效率要高很多
        //3.关闭
        bis.close();//关闭字节缓冲输入流，里面自动关闭字节输入流
    }
}
/*
结果：读取D:\\test01.txt文件中的数据，然后在程序中打印出来。
*/

2.字节输出流：OutputStream（父类）

此抽象类是表示输出字节流的- 所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。

• 1）其子类：文件字节输出流FileOutStream

//文件字节输出流FileOutStream的使用
public class demo02 {
    //由于可能出现找不到该路径下面的文件，所以需要抛出这个异常
    public static void main(String[] args) throws Exception{
        //1.创建文件字节输出流FileOutStream对象，并指定文件路径
       // FileOutputStream fos=new FileOutputStream("D:\\test02.txt");
        //这种构造方法，当每次执行程序时，都会像文件中写入数据，将前面的覆盖
         FileOutputStream fos=new FileOutputStream("D:\\test02.txt",true);
         //---可以不会覆盖，继续写入数据
        //2.写入文件
        fos.write(97);
        fos.write(98);
        fos.write(99);//这里的99是int类型，写入文件后转换为它Ascll码所对应的字符
        fos.write('d');//char型数据可以自己转换为int型
        fos.write('e');//

        String s="fghijkl";
        fos.write(s.getBytes());//写入文件中的是数组，String是类，要转换先
        //3.关闭
        fos.close();
        System.out.println("执行完毕");
    }
}
/*
结果：在D盘中创建了一个test02.txt文件，并写入写入字符abcdefghijkl，再执行一次，就再写入一次。
*/

2）字节缓冲输出流：BufferedOutputStream

//字节缓冲（输出）流BufferedOutputStream的使用---写入文件
public class demo05 {
    public static void main(String[] args) throws Exception {
        //1.创建流
        FileOutputStream fos=new FileOutputStream("D:\\test03.txt");
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        //是对上面的底层流/节点流的增强
        //2.进行写操作
        for(int i=0;i<9;i++){
            bos.write(new String("heeeheeheh!\n").getBytes());
            //写入了字节缓冲（输出）流BufferedOutputStream的缓冲区
            bos.flush();//刷新到硬盘，否则没有写入到文件中
        }
        //相对于利用文件输入缓冲流FileOutputStream效率要高很多
        //3.关闭（内部调用课flush方法）
        bos.close();//关闭字节缓冲输出流，里面自动关闭字节输出流
    }
}
/*
结果：在D盘中创建了一个test03.txt文件，并写入字符heeeheeheh!十次，每写一次换一行
*/

3.字节输入输出流的综合使用

• 1）使用文件字节流进行文件的复制

//使用文件字节流进行文件的复制
public class demo03 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        //1.1创建字节输入流
        FileInputStream fis=new FileInputStream("D:\\1.jpg");
        //1.2创建字节输出流
        FileOutputStream fos=new FileOutputStream("D:\\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("复制完成");
    }
}
/*
结果：在D盘中复制了一个和1.jpg一样的图片2.jpg
*/

4.对象流ObjectInputStream/ObjectOutputStream

• 对象流ObjectInputStream/ObjectOutputStream也是InputStream/OutputStream的子类

• 增强缓冲区功能

• 增强了读写8种基本数据类型和字符串功能

• 增强了读写对象的功能

• readObject()--------从流中读取一个对象（从流中读取一个对象，也就是从文件中读取一个对象，称为反序列化）

? writeObject()------- --向流中写入一个对象（将内存中的对象写入流中，也就是写入文件中，称为序列化）

• 使用流传输对象的过程称为序列化、反序列化

public class demo07 {
    //使用ObjectInputStream实现对象的反序列化
    public static void main(String[] args)throws Exception {
        //1.创建对象流
        FileInputStream fis=new FileInputStream("D:\\test04.txt");
        ObjectInputStream ois=new ObjectInputStream(fis);
        //2.创建对象并读对象（反序列化）
        Object s2=ois.readObject();//读的对象类型是Object类型
        //对象被读一次就没有了，不能再进行反序列化读操作
        //Object s2=ois.readObject();//读的对象类型是Object类型
        //3.关闭
        ois.close();
        System.out.println("反序列化完毕");
        System.out.println(s2);
    }
}
/*结果：
程序中（内存中）打印：
反序列化完毕
Student{name='lyj', age=20}
（将test04.txt文件中的对象读入程序（内存）中）
*/

//使用ObjectOutputStream实现对象的序列化
//要求：序列化的类必须要实现Serializable接口
public class demo06 {
    public static void main(String[] args)throws Exception {
        //1.创建对象流
        FileOutputStream fos=new FileOutputStream("D:\\test04.txt");
        ObjectOutputStream oos=new ObjectOutputStream(fos);
        //2.创建对象并写入对象（序列化）
        Student s1=new Student("lyj",20);
        System.out.println(s1);
        oos.writeObject(s1);
        //3.关闭
        oos.close();
        System.out.println("序列化完毕");
        //4.对于要写入的对象的那个类---序列化，需要实现一个接口Serializable
    }
}
/*结果：
在（存储设备）D盘中创建出一个文件test04.txt，并将创建的对象s1写入该文件中
在程序中（内存中）打印序列化完毕
*/

public class Student implements Serializable {
    //实现这个Serializable接口，标志着这个类可以序列化
        private String name;
        private  int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

• 对象流需要注意的事项：

• • 1）序列化类必须要实现Serializable接口
  • 2）序列化类中的对象属性要求也要实现Serializable接口（比如：如果序列化类Student中 的某一属性的类型 是自己创建的新类Teacher ，要想实现序列化，这个新类也需要实现Serializable接口）
  • 3）可以利用序列化版本号ID，保证序列化的类和反序列化的类是同一类

  ? 一般先执行序列化的程序，再执行反序列化的程序，这个版本号就可以一致了

  • 4）对于不想序列化的属性可以使用transient（瞬间的）修饰属性
  • 5）静态属性不能序列化
  • 6）序列化多个对象可以借助集合来实现

//使用ObjectOutputStream实现对象的序列化（加强）
public class demo08 {
    public static void main(String[] args)throws Exception {
        //1.创建对象流
        FileOutputStream fos=new FileOutputStream("D:\\test05.txt");
        ObjectOutputStream oos=new ObjectOutputStream(fos);
        //2.创建多个对象并利用集合，写入对象（序列化）
        //不用集合的话就要写多遍writeObject()
        Teacher t1=new Teacher("aaa",36,1001);
        System.out.println(t1);
        Teacher t2=new Teacher("bbb",43,1002);
        System.out.println(t2);
        ArrayList<Teacher> list=new ArrayList<>();
        list.add(t1);
        list.add(t2);
        for(Teacher teacher:list){
            System.out.println(teacher.toString());
        }
        //由于id是静态变量，所以它的值只有一个，会被后面的取代
        oos.writeObject(list);
        //3.关闭
        oos.close();
        System.out.println("序列化完毕");
        //4.对于要写入的对象的那个类---序列化，需要实现一个接口Serializable
    }
}
/*结果：
在内存中（程序中）打印出：
Teacher{name=aaa, age=36, id=1001}
Teacher{name=bbb, age=43, id=1002}
Teacher{name=aaa, age=36, id=1002}
Teacher{name=bbb, age=43, id=1002}
序列化完毕
在存储设备（文件）在D盘中创建出一个文件test05.txt，并将创建的对象list写入该文件中
*/

//使用ObjectInputStream实现对象的反序列化（加强）
public class demo09 {
    public static void main(String[] args)throws Exception {
        //1.创建对象流
        FileInputStream fis=new FileInputStream("D:\\test05.txt");
        ObjectInputStream ois=new ObjectInputStream(fis);
        //2.创建多个对象并利用集合，读取对象（反序列化）
        //不用集合的话就要写多遍readObject()
        ArrayList<Teacher> t3=(ArrayList<Teacher>) ois.readObject();//读的对象类型是Object类型
        //对象被读一次就没有了，不能再进行反序列化读操作
        // ArrayList<Teacher> t3=(ArrayList<Teacher>) ois.readObject();//读的对象类型是Object类型
        //3.关闭
        for(Teacher teacher:t3){
            System.out.println(teacher.toString());
        }
        ois.close();
         System.out.println("反序列化完毕");
    }
}
/*结果：
在内存中（程序中）打印出：
Teacher{name=aaa, age=0, id=0}
Teacher{name=bbb, age=0, id=0}
反序列化完毕
（将test05.txt文件中的对象读入程序（内存）中）
*/

public class Teacher implements Serializable {
    //实现这个Serializable接口，标志着这个类可以序列化
    private static final long serialVersionUID=100L;
    //serialVersionUID序列化版本号，保证序列化的类和反序列化的类是同一类
    private String name;
    private transient   int age;
    private static int id;
    //对于不想序列化的属性可以使用transient（瞬间的）修饰属性
    //静态属性不能序列化

    public Teacher(String name, int age,int id) {
        this.name = name;
        this.age = age;
        Teacher.id=id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static int getId() {
        return id;
    }

    public static void setId(int id) {
        Teacher.id = id;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name=" + name  +
                ", age=" + age  +
                ", id=" +id+
                '}';
    }
}

四.编码方式

1.字符编码

• 1个字节表示一个字符

• （又称万国码，国际上使用）1、2、3字节表示一个字符

• 1、2字节表示一个字符

• 1、2字节表示一个字符

• （没讲）

五.字符流

1.字符流的父类Reader、Writer（抽象类）

2.文件字符输入流FileReader

//文件字符输入流FileReader的使用
public class demo10 {
        //由于可能出现找不到该路径下面的文件，所以需要抛出这个异常
        public static void main(String[] args) throws Exception {
            //1.创建FileReader文件字节输入流，并指定文件路径
            FileReader fr = new FileReader("D:\\test11.txt");
            //2.读取文件read()
       /* System.out.println("一个字符一个字符读：");
        //fr.read();----->返回的是一个字符
        int date=0;
        while( (date=fr.read())!=-1){
            System.out.print((char)date);
        }*/
            System.out.println("一次性读多个字符：");
            char buf[] = new char[5];//创建一个缓冲区
            int count = 0;
            while ((count = fr.read(buf)) != -1) {
                //read(char[] c)从流中读取多个字符，将读到内容存放人c数组
                // --->返回实际读到的字符数，如果达到尾部则返回-1
                System.out.println(new String(buf, 0, count));
            }
            //3.关闭
            fr.close();
        }
}
/*结果：从存储设备中（D盘的test11.txt文件）的数据读出（按照字符的形式），打印到内存中（程序中）
*/

3.文件字符输出流FileWriter

//文件字符输出流FileWriter的使用
public class demo11 {
        //由于可能出现找不到该路径下面的文件，所以需要抛出这个异常
        public static void main(String[] args) throws Exception{
            //1.创建文件字符输出流FileOutStream对象，并指定文件路径
            FileWriter fw=new FileWriter("D:\\test12.txt");
            //这种构造方法，当每次执行程序时，都会像文件中写入数据，将前面的覆盖
            // FileWriter fw=new FileWriter("D:\\test12.txt",true);
            //---可以不会覆盖，继续写入数据
            //2.写入文件write(int n)
            fw.write(97);
            fw.write(98);
            fw.write(99);//这里的99是int类型，写入文件后转换为它Ascll码所对应的字符
            fw.write('d');//char型数据可以自己转换为int型，然后根据上面方法执行转换
            fw.write('e');//

            String s="fghijkl";
            char c[]={'m','n','o',97,98,'哈','哈'};
            fw.write(s);//写入文件中可以是数组，也可以是String类，与文件输出字节流不同
            fw.write(c);
            //3.关闭
            fw.close();
            System.out.println("执行完毕");
        }
    }
/*结果：
内存（程序）在D盘中创建了一个文件test11.txt，并向存储设备（文件）中写入
abcdefghijklmnoab哈哈
*/

注意：文件输出字符流与文件输入字节流的write方法区别在于：前者的write方法可以写入String字符串类型，也可以写入数组，但是后者只能写入数组

4.字符输入输出流的综合使用

• 1）使用文件字符流进行文件的复制

• 使用FileReader和FileWriter复制文本文件时，不能复制图片或者不能复制二进制文件（因为图片是二进制数据，它是没有字符的，所以当把文件读到 内存程序中 它无法转换为字符数据，也就是没法解析故形成乱码，将其再写入复制文件时，就是乱码了）

• public class demo12 {
      public static void main(String[] args)throws Exception {
          //1.创建文件字符输入流FileReader
          FileReader fr1=new FileReader("D:\\test12.txt");
          //2.创建文件字符输出流FileWriter
          FileWriter fw1=new FileWriter("D:\\test14.txt");
          //3.复制文件---边读边写
          int count=0;
          while((count=fr1.read())!=-1){
              fw1.write(count);
          }
          //4.关闭
          fr1.close();
          fw1.close();
          System.out.println("复制完成");
      }
  }
  /*
  结果：在D盘中复制了一个和test12.txt数据一样的文件test14.txt
  */
  

• 字节流可以复制任何文件

5.字符缓冲流BufferedReader/BufferedWriter

• 分别为Reader的子类和Writer的子类

• 高效读写

• 支持输入换行符

• 可一次写一行、读一行

字符缓冲流的创建都是需要先创建一个底层流

//字符缓冲输入流BufferedReader的使用---读文件
public class demo13 {
        public static void main(String[] args) throws Exception {
            //1.创建流
            FileReader fr=new FileReader("D:\\test01.txt");
            BufferedReader br=new BufferedReader(fr);
            //是对上面的底层流/节点流的增强
            //2.进行读操作---利用自身的缓冲数组

            /*int date=0;
            while((date=br.read())!=-1){
                System.out.print((char)date);
            }*/
            //字节缓冲输入流BufferedReader自己有一个缓冲数组可以读入数据
            //相对于利用文件输入缓冲流FileReader效率要高很多

            //3.一行一行读取readLine(String)
            String line=null;
            while((line=br.readLine())!=null){
                System.out.println(line);
            }
       //readLine()=null代表读到最后
            //4.关闭
            br.close();//关闭字节缓冲输入流，里面自动关闭字节输入流
        }
}
/*
结果：读取D:\\test01.txt文件中的数据，然后在程序中打印出来。
*/

//字符缓冲（输出）流BufferedWriter的使用---写入文件
public class demo14 {
        public static void main(String[] args) throws Exception {
            //1.创建流
            FileWriter fw=new FileWriter("D:\\test15.txt");
            BufferedWriter bw=new BufferedWriter(fw);
            //是对上面的底层流/节点流的增强
            //2.进行写操作
            for(int i=0;i<9;i++){
                bw.write(new String("加油加油！"));
                //写入了字符缓冲（输出）流BufferedReaderd，这里的写入可以是字符串String类型
                //也可以转换成数组.toCharArray()
                bw.newLine();//打印换行符
                //换行操作也可以可以"加油加油！\n"
                bw.flush();//如果数据有先写入缓冲区，就需要刷新到硬盘，否则没有写入到文件中
                //此处可以不用
            }
            //相对于利用文件输入缓冲流FileWriter效率要高很多
            //3.关闭（内部调用课flush方法）
            bw.close();//关闭字节缓冲输出流，里面自动关闭字节输出流
            System.out.println("执行完毕");
        }
}
/*
结果：在D盘中创建了一个test15.txt文件，并写入字符“加油加油！”十次，每写一次换一行
*/

6.文本输出流PrintWriter

• 是Writer的子类

//PrintWriter的使用
public class demo15 {
    public static void main(String[] args) throws Exception {
        //1.创建打印流
        PrintWriter prw=new PrintWriter("D:\\print.txt");
        //2.打印
        prw.append('c');//将指定字符打印到此处创建的writer中
        prw.append(" heihei\n");//添加指定字符串
        prw.println(97);
        prw.println("a");
        prw.println(3.14);
        prw.println('b');
        //不像write()方法会将int 类型的数据转变为Asca码表的字符 写入文件中
        //打印什么，写入文件的就是什么
        //3.关闭
        prw.close();
    }
}
/*结果：
内存（程序）在D盘中创建了一个文件print.txt，并向存储设备（文件）中写入
c heihei
97
a
3.14
b
*/

7.转换流InputStreamReader/OutputStreamWriter

• 内存中的字符和硬盘中的字节相互转换

• InputStreamReader可以将字节流转换为字符流（存储文件是二进制的，读入内存程序中，可以将字节流转为字符流）

/使用InputStreamReader读取文件，并使用指定的编码
public class demo16 {
    public static void main(String[] args) throws Exception {
        //1.创建字节流和字符流
        FileInputStream fis=new FileInputStream("D:\\test15.txt");
        InputStreamReader isr=new InputStreamReader(fis,"utf-8");
        //编码方式---看文件编码方式
        //ANSI的编码方式是----“gbk”
        //2.读取文件
        int date=0;
        while((date=isr.read())!=-1){
            System.out.println((char)date);
        }
        //3.关闭
        isr.close();
    }
}

• OutputStreamWriter可以将字符流转换为字节流（将内存程序中的字符，写入存储文件中，将字符流转为字节流）

//使用OutputStreamWriter写文件，并使用指定的编码
public class demo17 {
        public static void main(String[] args) throws Exception {
            //1.创建字节流和字符流
            FileOutputStream fos=new FileOutputStream("D:\\test16.txt");
            OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");
            //编码方式---看文件你想要的编码方式
            //ANSI的编码方式是----“gbk”
            //2.写文件
           for(int i=0;i<10;i++){
               osw.write("fuck冲冲冲冲！\n");
           }
            //3.关闭
            osw.close();
        }
}

• 它们都可以设置字符的编码方式

六.File类

1.File类的基本概念和方法

2.File基本方法的使用

/*
* File类的使用
* 1）分隔符
* 2）文件操作 
*/
public class Demo01 {
    public static void main(String[] args) throws Exception {
        //1.分隔符
        System.out.println("路径分隔符:"+ File.pathSeparator);
        System.out.println("名称分隔符:"+ File.separator);
        //2.文件操作
// 1)创建文件
        File file=new File("D:\\ajava\\file.txt");
        //只是创建了file这个对象，在硬盘里面不一定有
        if(!file.exists()) {
            //如果文件在硬盘中不存在
            boolean b = file.createNewFile();
            //在硬盘里创建一个文件，返回内存是boolean类型
            System.out.println("创建文件：" + b);
        }
// 2.1) 删除文件
            //System.out.println("删除文件："+file.delete());
            //在硬盘里删除一个文件，返回内存是boolean类型
// 2.2) 使用jvm删除文件
           //file.deleteOnExit();
           //Thread.sleep(5000);
           //程序结束之后才删除
// 3) 获取文件信息
            System.out.println("获取文件的绝对路径："+file.getAbsolutePath());
            System.out.println("获取文件路径："+file.getPath());
            System.out.println("获取父目录："+file.getParent());
            System.out.println("获取文件长度："+file.length());
            System.out.println("获取文件创建时间"+new Date(file.lastModified()));
// 4)判断文件
        System.out.println("是否可写："+file.canWrite());
        System.out.println("是否是文件："+file.isFile());
        System.out.println("是否隐藏："+file.isHidden());
        }
}
/*
路径分隔符:;
名称分隔符:\
创建文件：true
获取文件的绝对路径：D:\ajava\file.txt
获取文件路径：D:\ajava\file.txt
获取父目录：D:\ajava
获取文件长度：0
获取文件创建时间Wed Feb 10 01:55:39 CST 2021
是否可写：true
是否是文件：true
是否隐藏：false
*/

注意：可以通过鼠标右键--->属性改变文件的一些信息

/*
 * File类的使用
 * 3)文件夹操作
 * */
public class Demo02 {
    public static void main(String[] args) throws Exception {
        //3.文件夹操作
// 1)创建文件夹
        File dir=new File("D:\\ajava\\aaa\\bbb");
        //只是创建了dir这个对象，在硬盘里面不一定有
        if(!dir.exists()) {
            //如果文件夹在硬盘中不存在
         // boolean b = dir.mkdir();----->只能创建单级目录
            boolean b = dir.mkdirs();//----->可以创建多级目录
            //在硬盘里创建一个文件夹，返回内存是boolean类型
            System.out.println("创建文件夹：" + b);
        }
        //（只能删除空目录，目录里面没有文件，而且只删除最后一个目录，这里是删除bbb）
// 2.1) 直接删除文件夹
        //System.out.println("删除文件："+dir.delete());
        //在硬盘里删除一个文件，返回内存是boolean类型
// 2.2) 使用jvm删除文件
           //dir.deleteOnExit();
           //Thread.sleep(5000);
           //程序结束之后才删除
// 3)获取文件夹信息
        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("是否是文件："+dir.isFile());
        System.out.println("是否是文件夹："+dir.isDirectory());
        System.out.println("是否隐藏："+dir.isHidden());
        System.out.println("==========================================");
// 5)遍历文件夹
        File dir2=new File("D:\\ajava");
        
        String[] files=dir2.list();
        for(String s:files){
            System.out.println(s);
    }
}
}
/*
结果：
获取文件的绝对路径：D:\ajava\aaa\bbb
获取文件路径：D:\ajava\aaa\bbb
获取最底层文件夹名称：bbb
获取最底层文件夹的父目录：D:\ajava\aaa
获取文件创建时间2021-2-10 2:20:33
是否是文件：false
是否是文件夹：true
是否隐藏：false
==========================================
D:\ajava下面的文件有：
1.jpg
2.jpg
aaa
file.txt
print.txt
test01.txt
test02.txt
test03.txt
test04.txt
test05.txt
test11.txt
test12.txt
test13.txt
test14.txt
test15(1).txt
test15.txt
test16.txt
*/

注意：对于文件夹的删除：

只能删除空目录，目录里面没有文件，而且只删除最后一个目录，这里是删除bbb

3.FileFilter接口

• 用在遍历文件夹的时候！！！！！！！

public static void main(String[] args) throws Exception {   
        System.out.print("使用listFiles()遍历");
        System.out.println("D:\\ajava下面的文件有：");
        //匿名内部类
        File[] files1=dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith("jpg")) {
                    return true;
                }
                return false;
            }
            //返回文件名后缀为jpg的文件
        });
        for(File file:files1){
            System.out.println(file.getName());
        }
}
/*
结果：
使用listFiles()遍历D:\ajava下面的文件有：
1.jpg
2.jpg
*/

4.递归遍历、删除文件夹

//递归遍历、删除文件夹
public class Demo03 {
    public static void main(String[] args) {
        listDir(new File("D:\\ajava\\adirectory"));
        //deleteDir(new File("D:\\ajava\\adirectory"));
        //调用文件夹递归遍历方法
    }
    //案例1----递归遍历文件夹
    public static void listDir(File dir){
        File[] files=dir.listFiles();
        //将该文件夹下面的所有文件放入一个数组
        System.out.println(dir.getPath());
        if(files!=null&&files.length>0){
            for(File file:files){
                if(file.isDirectory()){
                    //若该文件为文件夹，则调用文件夹递归遍历方法
                    listDir(file);
                } 
                //如果该文件不为文件夹，则将文件打印
                else{
                    System.out.println(file.getPath());
                }
            }
        }
    }
    //案例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.getPath()+"删除："+file.delete());
               }
           }
        }
        //文件夹删除
        System.out.println(dir.getPath()+"删除："+dir.delete());
    }
}
/*
文件夹递归遍历：
D:\ajava\adirectory
D:\ajava\adirectory\directory1
D:\ajava\adirectory\directory1\file3.txt
D:\ajava\adirectory\directory1\file4.ppt
D:\ajava\adirectory\directory2
D:\ajava\adirectory\directory2\file5.rtf
D:\ajava\adirectory\file1.doc
D:\ajava\adirectory\file2.xls
文件夹递归删除：
D:\ajava\adirectory\directory1\file3.txt删除：true
D:\ajava\adirectory\directory1\file4.ppt删除：true
D:\ajava\adirectory\directory1删除：true
D:\ajava\adirectory\directory2\file5.rtf删除：true
D:\ajava\adirectory\directory2删除：true
D:\ajava\adirectory\file1.doc删除：true
D:\ajava\adirectory\file2.xls删除：true
D:\ajava\adirectory删除：true
*/

补充：Properties属性集合

1.Properties属性集合的特点

• Properties类表示了一个持久的属性集，它可以保存在流中或者从流中加载

2.Properties集合的使用

• 继承了Hashtable<Object,Object>

/*
* Properties集合的使用
* */
public class Demo04 {
    public static void main(String[] args) throws  Exception{
//1.创建集合
        Properties properties=new Properties();
//2.添加数据setProperty(String key,String value)
        properties.setProperty("aaa","100");
        properties.setProperty("bbb","200");
        properties.setProperty("bbb","300");
        properties.setProperty("ccc","400");
        properties.setProperty("ddd","500");
        System.out.println(properties.toString());
        //和HashMap添加数据的准则是一样的,只允许有一个key对应一个value
        // key相同后面value会替换前面的value
//3.遍历元素
        //3.1运用KeySet()方法，得到一个Set集合存储key值
        // 通过用get()方法得到该key的value值
        //3.2运用entrySet()方法，得到一个Set集合存储key和value值
        // 通过getkey()方法是得到key，getvalue()方法是得到value
        //3.3运用stringPropertyNames()方法遍历
        //得到的和3.1一样也是key值
        Set<String> key=properties.stringPropertyNames();
        for (String s:key){
            System.out.println(s+"="+properties.getProperty(s));
        }
//4.和流有关的方法
        //4.1 list(PrintStream或PrintWriter)----将属性列表写入到输出流（从内存写数据---->存储文件）
        PrintWriter pw=new PrintWriter("D:\\ajava\\writer.txt");
        properties.list(pw);
        pw.close();
        //4.2 store(OutputStream或Writer,String)-----用适合load()方法加载的的格式，将属性列表写入到输出流
       FileWriter fw=new FileWriter("D:\\ajava\\store.properties");
        properties.store(fw,"write to you");
        //----->后面的String可以理解为注释
        fw.close();
        //4.3 load(InputStream)或Reader)-----读取输入流中的属性列表（读存储文件的数据--->内存）
        Properties properties1=new Properties();
        FileReader fr=new FileReader("D:\\ajava\\store.properties");
        properties1.load(fr);
        fr.close();
        System.out.println(properties1.toString());
    }
}
/*
结果：
{bbb=300, aaa=100, ddd=500, ccc=400}
bbb=300
aaa=100
ddd=500
ccc=400
创建文件D:\\ajava\\writer.txt，并在里面写入属性列表的数据
创建文件D:\\ajava\\store.properties，并在里面写入String（注释的值）和属性列表数据，用适合load()方法加载的的格式
{bbb=300, aaa=100, ddd=500, ccc=400}
*/

内容总结

以上是互联网集市为您收集整理的2020.2.10 Java IO流全部内容，希望文章能够帮你解决2020.2.10 Java IO流所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端