第二十七讲——流（IO框架）

第二十七讲——IO 框架

1——什么是流

input output

概念; 内存与储存设备之间传输数据的通道
数据借助流传输

流的分类

按方向分
- 输入流; 将 存储设备 中的内容读入到内存中
- 输出流；将内存中的内容写入到 储存设备 中

按单位分
- 字节流; 以字节为单位，可以读写所有数据（因为计算机内容都是以字节的方式存储的）
- 字符流，以字符为单位，只能读写文本数据

按功能分；
- 节点流; 具有实际传输数据的读写功能
- 过滤流; 在节点流的基础之上增强功能

2 ——字节流

字节流的父类( abstract )

IntputStream ：字节输入流

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

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

文件字节流

FileInputStream
- public int read(byte[] b) //从流中读取多个字节，将读到内容存入 b 数组，返回实际读到的字节数，如果达到文件的尾部，则返回 -1
FileOutputStream
- public void write(byte[] b) // 一次写多个字节，将数组 b 中所有的字节，写入输出流

FileInputStream

Application

package Test01;
import java.io.FileInputStream;
/**
 * 演示 FileInputStream的使用

 * 文件字节输入流
 * @author 夏天的风
 */
public class Application {

    public static void main(String[]args) throws Exception{
        // 1 创建 FileInputStream : 并指定文件路径
        FileInputStream fis = new FileInputStream("D:\\aaa.txt");
        // 这里会有异常抛出 因为输入的路径可能会不存在 所以一定要设置 如果不存在的操作 方法上抛出异常
        // 2 读取文件
/*        int data = 0;
        while((data = fis.read())!=-1){
            System.out.print((char)data);
            // 默认以编码的形式  所以需要强转
        }
        System.out.println();
        System.out.println("===============");*/
        // 2.1 一次读取多个字节
//        byte[] b1 = new byte[3];
//
//        int count = fis.read(b1); // fis.read(b1) 返回实际打印的个数
//        System.out.println(new String(b1));
//        // 看api 中 有String 构造方法 String(Byte[] bytes) 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
//        System.out.println(count);
//
//        int count01 = fis.read(b1);
//        System.out.println(new String(b1));
//        System.out.println(count01);
//
//        int count02 = fis.read(b1);
//        System.out.println(new String(b1,0,count02));// api
//        //public String(char[] value,
//        //              int offset,
//        //              int count)参数：
//        //value - 作为字符源的数组。
//        //offset - 初始偏移量。
//        //count - 长度。
//        //长度不能为负
//        System.out.println(count02);

        byte[] b = new byte[3];//new byte[1024];
        int count = 0;
        while((count = fis.read(b))!=-1){
            System.out.println(new String(b,0,count));
        }
        //read()  方法如果因为已经到达流末尾而没有可用的字节，则返回值 -1。在输入数据可用、检测到流末尾或者抛出异常前，此方法一直阻塞。所以只能用一个 read
        // 3 关闭
        fis.close();
        System.out.println();
        System.out.println("输入完毕 ");
    }

}

Print

F:\Application\out\production\Application Test01.Application
ABC
DEF
G

输入完毕 

Process finished with exit code 0

FileOutputStream

Application

package Test01;
import java.io.FileOutputStream;
import java.io.FileInputStream;
/**
 * 演示文件字节输出流的使用
 * FileOutputStream
 * @author 夏天的风
 */
public class Test {
    public static void main(String[] args) throws Exception{
        System.out.println("============输出===============");
        // 1. 创建文件
        FileOutputStream fil = new FileOutputStream("F:\\japan.txt",true);
        //new FileOutputStream("F:\\japan.txt",true); 如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处 也就是说每次运行就会 append 追加内容
        
        // 2. 写入文件

//        fil.write(97);// 会返回 数字对应的编码 a
//        fil.write('b');
//        fil.write('c');
        String str = "Hello World!!!";
        fil.write(str.getBytes());// 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
        String str0 = "须记少时凌云志，曾许人间第一流";
        fil.write(str0.getBytes());
        //3 关闭流
        fil.close();
        System.out.println("执行完毕");
    }
}

Print

F:\Application\out\production\Application Test01.Test
执行完毕

Process finished with exit code 0

字节流复制文件

package Test01;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/***
 * 使用文件字节流实现文件的复制
 * @author 夏天的风
 */
public class Test01 {
    public static void main(String[] args) throws Exception {
        // 1. 创建流
        // 1.1 文件字节输入流
        FileInputStream fis = new FileInputStream("F:\\0.jpg");
        // 1.2 文件字节输出流
        FileOutputStream fos = new FileOutputStream("F:\\00.jpg");
        // 2 一边读 一边写
        byte[] b = new byte[1024];
        int count = 0;
        while((count = fis.read(b))!=-1){
            fos.write(b,0,count);
//            b - 数据。
//            off - 数据中的起始偏移量。
//            len - 要写入的字节数。fis.read(b) 返回实际读取的数值
        }
        // 3. 关闭流
        fis.close();
        fos.close();
        System.out.println("复制完毕");
    }
}

Print

F:\Application\out\production\Application Test01.Test01
执行完毕

Process finished with exit code 0

BufferedInputStream

缓冲流； BufferedInputStream/BufferedOutputStream

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

Application

package Test01;

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

/**
 * 使用字节缓冲流读取
 * BufferedInputStream
 * @author 夏天的风
 */
public class Test02 {
    public static void main(String[] args) throws Exception {
        // 1. 创建 BufferedInputStream
        FileInputStream fis = new FileInputStream("F:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        // 字节缓冲流需要 传入字节流  目的是为了增强 字节流的功能

        // 2. 读取
//        int data = 0;
//         while((data = bis.read())!=-1){
//            System.out.print((char)data);
//        }
        //我们也可以直接创建一个缓冲区 默认的缓冲区是 8k
        byte[] b = new byte[8000000];
        int count = 0;
        while((count = bis.read(b))!=-1){
            System.out.print(new String(b,0,count));
        }

        // 3. 关闭 只要关闭缓冲区就行 不用关闭字节流
        bis.close();

    }
}

print

F:\Application\out\production\Application Test01.Test02
ABCDEFG
Process finished with exit code 0

BufferedOutputStream

Application

package Test01;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

/**
 * 使用字节缓存流写入文件
 * BufferedOutputStream
 * @author 夏天的风
 */
public class Test03 {
    public static void main(String[] args) throws Exception{
        // 1. 创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("F:\\ABC.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        // 2. 写入文件
        for (int i = 0; i < 10 ; i++) {
            bos.write("Hello World!!!\n".getBytes()); //先写入了缓冲区 所以不会直接输入 必须添加 flush 刷新到盘符
            bos.flush(); // 刷新到盘符
        }
        // 3. 关闭 只要关闭 缓冲流就可以了
        bos.close();// 如果前面没有调用 flush 在关闭的时候内部会调用 flush 一次性刷新到硬盘
        // 不过每次读取刷新一次，是为了防止没电的时候，失去数据
        System.out.println("执行完毕！");
    }
}

Print

F:\Application\out\production\Application Test01.Test03
执行完毕！

Process finished with exit code 0

3——对象流

对象流； ObjectOutputStream | ObjectInputStream
1. 增强了缓冲区功能
2. 增强了读写8种基本数据类型和字符串功能
3. 增强了读写对象的功能
readObject( ) 从流中读取一个对象

wirteObject(Object obj) 向流中写如一个对象

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

(把一个内存中的对象，写入到储存空间去) 序列化

（把储存空间中的文件，读入到内存中再形成对象）反序列化

序列化

Class

package Work;

import java.io.Serializable;
// 要导入改实现类
public class Student implements Serializable {
    private int age ;
    private String name ;
    public Student(){

    }
    public Student(int age,String name){
        this.age = age;
        this.name = name;
    }
    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{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

Application

package Work;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
 * 使用ObjectOutputStream 实现对象的序列化
 * 要求; 序列化必须要实现 Serializable 接口
 * @author 夏天的风
 */
public class Work02 {
    public static void main(String[]args)throws Exception{
        // 1. 创建对象流
        FileOutputStream fol = new FileOutputStream("E:\\serializable.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fol);
        // 2. 序列化操作(写入操作)
        Student zhangsan = new Student(12, "张三");
        oos.writeObject(zhangsan);
        // 本来 每次写入的时候 都应该 flush 刷新一下 但是 close 本身就具备刷新的功能 所以这里就不用了
        // 3. close()
        oos.close();
        System.out.println("序列化  完毕！");
        // 要序列化的对象 必须实现 serializable
        // serializable 只是一个标识  标识可序列化的意思
    }
    }

Print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Work.Work02
序列化  完毕！

Process finished with exit code 0

写入的数据看不懂没关系写入成功就行

反序列化

Application

package Work;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

/**
 * 使用 ObjectInputStream 实现反序列化 （读取重构成对象）
 * @author 夏天的风
 */
public class Work03 {
    public static void main(String[] args) throws Exception{
        // 1. 创建对象流
        FileInputStream fil = new FileInputStream("E:\\serializable.txt");
        ObjectInputStream ois = new ObjectInputStream(fil);
        // 2. 读取文件(反序列化)
        Student s1 = (Student) ois.readObject();
        //Student s2 = (Student) ois.readObject(); 读两次会有异常报错 读完了不能再读
        // System.out.println(s.toString());// 在这里还没有刷新 flush 所以不会打印出来
        // 如果被执行的文件 处于打开的状态也不会打印出来
        // 3. 关闭
        ois.close();
        System.out.println("反序列化 完毕！");
        System.out.println(s1.toString());
    }
}

print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Work.Work03
反序列化 完毕！
Student{age=12, name='张三'}

Process finished with exit code 0

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

    /**
     * 注意事项;
     * (1) 序列化类必须要实现 Serializable 接口
     * (2) 序列化类中对象属性要求实现 Serializable 接口
     * (3) 序列化版本号 ID serialVersionUID 保证序列化的类和反序列化的类是同一个类
     * (4) 使用 transient (瞬间的) 修饰属性 这个属性不能被序列化
     * (5) 静态属性不能被序列化
     */

/**
序列化多个对象， 可以借助集合实现
*/
==============序列化======
Student 张三 = new Student("张三"，12);
Student 李四 = new Student("李四"，15);
ArrayList<Student> list = new ArrayList<>();
list.add(张三)；
list.add(李四);
oos.wirteObject(list);
=============反序列化============
ArrayList<Student> s = (ArrayList<Student>)ois.readObject()

4——字符流

ISO-8859-1 收录除ASCII外还包括西瓯、希腊、泰语、阿拉伯语、希伯来语，所对应的文字符号
UTF-8 针对 Unicode 码表哦的可变长度字符编码
GB2312 简体中文
GBK 简体中文扩充
BIG5 台湾繁体中文

当编码方式和解码方式不一致时会出现乱码

字符流抽象类

Reader ; 字符输入流

public int read(){}
public int read(char[] c){}
public int read(char[],int off,int len){}

Writer ；字符输出流

public void write(int n){}
public void write(String str){}
public void write(char[] c){}

文件字符流

FileReader

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

FileWriter

public void write(String str)
    //一次写多个字符，将 b 数组中所有字符，写入输出流

如果用之前的字节流来读取 UTF-8 的中文，那么就需要建立合适缓冲区

        FileInputStream fil = new FileInputStream("E:\\Hello.txt");
//        int i;
//        while((i = fil.read())!=-1){
//            System.out.print((char)i);
//        }
        // 建立 缓冲区 读取 中文 UTF-8
        byte[] b = new byte[1024];
        int i = 0;
        while((i = fil.read(b))!=-1){
            System.out.print(new String(b,0,i));
        }

print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Demo.Demo02
Hellow  World  !!!
你好     世界      !!!
Process finished with exit code 0

FileReader

使用文件字符流就可以直接读取

Application

package Demo;
import java.io.FileReader;
public class Demo02 {
    public static void main(String[]args) throws Exception{
        // 1. 创建 文件字符流0
        FileReader fr = new FileReader("E:\\Hello.txt");
        // 2.1  单个读取数据
        int i = 1;
//        while((i = fr.read())!=-1){
//            System.out.print((char) i);
//        }

        // 2.2  多个读取
        char[] b = new char[1024];
        while((i = fr.read(b))!=-1){
            System.out.print(new String(b,0,i));
        }
        // 3. 关闭
        fr.close();
    }
}

print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Demo.Demo02
Hellow  World  !!!
你好     世界      !!!
Process finished with exit code 0

FileWriter

Application

package Demo;
/**
 * 使用 FileWriter 写入文档
 * @author 夏天的风
 */
import java.io.FileWriter;
public class Demo03 {
    public static void main(String[]args) throws Exception{
        // 1. 创建流
        FileWriter fw = new FileWriter("E:\\xxz.txt");
        // 2. 写入文档
        for(int i = 0; i<100; i++){
            fw.write(i+"\txxz\n");
            fw.flush();
        }
        // 3. 关闭流
        fw.close();
        System.out.println("执行完毕！");
    }
}

Print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Demo.Demo03
执行完毕！

Process finished with exit code 0

字符流复制文件

不能复制图片或二进制文件

使用字节流可以复制所有格式

package Demo;
/**
 * 使用 FileWriter 写入文档
 * 使用 字符流复制文件
 * @author 夏天的风
 */
import java.io.FileReader;
import java.io.FileWriter;
public class Demo03 {
    public static void main(String[]args) throws Exception{
        // 1. 创建流
        FileWriter fw = new FileWriter("E:\\xxz.txt");
        // 2. 写入文档
        for(int i = 0; i<100; i++){
            fw.write(i+"\txxz\n");
            fw.flush();
        }
        // 3. 关闭流
        //fw.close();
        // 使用字符流复制文件
        // 1. 创建复制文件 和创建读取 原始数据
        FileWriter fw2 = new FileWriter("E:\\xxz0.txt");
        FileReader fr = new FileReader("E:\\xxz.txt");
        // 2.1 单个传递数据
        int i ;
//        while((i = fr.read())!=-1){
//            fw2.write((char) i);
//            fw2.flush();
//        }
        // 2.2 多个传递数据
        i = 0;
        char[] b = new char[1024];
        while((i = fr.read(b))!=-1){
            fw2.write(b,0,i);
        }
        // 3. 关闭流
        fw.close();
        fw2.close();
        fr.close();
        System.out.println("执行完毕！");
    }
}

Print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Demo.Demo03
执行完毕！

Process finished with exit code 0

BufferedReader

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

Application

package Demo;
import java.io.FileReader;
import java.io.BufferedReader;

/**
 * 使用字符缓冲流读取字符
 * BufferedReader
 * @author 夏天的风
 */
public class Demo04 {
    public static void main(String[]args) throws Exception{
        // 1. 创建缓冲流
        FileReader fr = new FileReader("E:\\Hello.txt");
        BufferedReader br = new BufferedReader(fr);
        // 2.1 读取
//        int i ;
//        char[] c = new char[1024];
//        while((i = br.read(c))!=-1){
//            System.out.print(new String(c,0,i));
//        }
        // 2.2 读取一行加循环
//        String line = null;
//        while((line = br.readLine())!=null){
        //包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
//            System.out.println(line);
//        }
        System.out.println(br.readLine());
        // 3. 关闭
        br.close();
    }
}

Print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Demo.Demo04
Hellow  World  !!!

Process finished with exit code 0

BufferedWriter

Application

package Demo;
import java.io.FileWriter;
import java.io.BufferedWriter;

/**
 * 演示 BufferedWrite 的使用
 * @author 夏天的风
 */
public class Demo05 {
    public static void main(String[] args) throws Exception{
        // 1. 创建BufferedWrite 对象
        FileWriter fw = new FileWriter("E:\\北窗.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        // 2. 写入文档
        for (int i = 0;i<10;i++){
            bw.write("何以解忧，唯有暴富！！！");
            bw.newLine();
            //写入一个换行符   优点会根据操作系统 来选择换行符
            // windows \r\n  linux  \n
            bw.flush();
        }
        // 3. 关闭
        bw.close();
        System.out.println("执行完毕！！");
    }
}

Print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Demo.Demo05
执行完毕！！
Process finished with exit code 0

5——打印流—PrintWriter

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

Application

package Demo;

import java.io.PrintWriter;

/**
 *  演示 PrintWriter 的使用
 *
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        // 1. 创建打印流
        PrintWriter pw = new PrintWriter("E:\\print.txt");
        // 2. 打印
        pw.println(97);
        pw.println("大学生");
        pw.println(3.14);
        pw.println('A');
        // 3. 关闭
        pw.close();
        System.out.println("执行完毕！！！");
    }
}

Print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Demo.Demo06
执行完毕！！！
Process finished with exit code 0

6——转换流

桥转换流； InputStreamReader / OutputStreamWriter
1. 可将字节流转换为字符流
2. 可设置字符的编码方式

内存和硬盘之间数据格式的转换

InputStreamReader

Application

package Demo;

import java.io.FileInputStream;// 字节输入流
import java.io.InputStreamReader;// 转换流

/**
 * 使用 InputStreamReader 读取文件，指定使用的编码
 */
public class Demo07 {
    public static void main(String[]args) throws Exception{
        // 1. 创建流
        FileInputStream fis = new FileInputStream("E:\\学生.txt");//字节流是不允许使用指定编码的 只能使用默认编码
        //InputStreamReader isr = new InputStreamReader(fis,"utf-8");//指定使用的编码
        InputStreamReader isr = new InputStreamReader(fis,"gbk");// 读取的编码与文件不符合就读取不了文件
        //如果一定要读取 把文件 另存为相同的编码 才能读取
        // gbk 在不同的国家表示不同的编码 在中国表示 ANSI
        // 2. 读取文件
        int i;
        while((i = isr.read())!=-1){
            System.out.print((char) i);
        }
        // 3. 关闭
        isr.close();
        System.out.println("\n执行完毕！");
    }
}

Print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Demo.Demo07
好好学习 天天向上！！！
执行完毕！

Process finished with exit code 0

OutputSteamWriter

Application

package Demo;
import java.io.OutputStreamWriter;
import java.io.FileOutputStream;
/**
 * 使用 OutputStreamWriter 写入文件 ，使用指定的编码
 * @author 夏天的风
 */
public class Demo08 {
    public static void main(String[] args) throws Exception{
        // 1. 创建流
        FileOutputStream fos = new FileOutputStream("E:\\中华.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
        // 2. 写入文件
        for (int i = 0; i < 10 ; i++) {
            osw.write("中华人民共和国\n");
            osw.flush();
        }
        // 3. 关闭
        osw.close();
        System.out.println("执行完毕！！！");
    }
}

Print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Demo.Demo08
执行完毕！！！
Process finished with exit code 0

7——File类

概念; 代表物理盘符中的一个文件或者文件夹

方法 ;

    createNewFile()//创建一个新的文件
    mkdir()//创建一个新目录
    delete()//删除文件或空目录
    exists()//测试此抽象路径名表示的文件或目录是否存在。
    getAbsolutepath()//获取 文件的绝对路径
    getName()//取得名字
    getDirectory()//获取文件/目录所在的目录
    isFile()//是否是文件
    length()//获取文件的长度
    listFiles()//列出目录中的所有内容
    renameTo()//修改文件名为

文件操作

Application

package Demo;

import java.io.File;
import java.util.Date;

public class Demo09 {
    public static void main(String[] args) throws Exception{
        separator();
        fileOpe("E:\\学生.txt");

    }
    // (1) 分隔符
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        // 看环境变量中 path 中的文件路径 都是用分隔符隔开的
        System.out.println("名称分隔符"+File.separator);
        //路径的分隔符
    }

    // (2) 文件操作
    public static void fileOpe(String fileName) throws Exception{
        // 1. 创建文件  createNewFile()
        File file = new File(fileName);
        //System.out.println(file.toString());
        // 给 file 传递了一个路径 实际上电脑上并没有这个文件
        // 这只是创建了一个文件对象 并没有创建文件
        boolean b = file.createNewFile();// 进行创建 并返回 是否创建成功 并且需要抛出异常 如果本身有文件 返回 false
        System.out.println("创建结果00;"+b);

        if(!file.exists()){ // 测试此抽象路径名表示的文件或目录是否存在 返回 true　false
            // ! 取反
            boolean a = file.createNewFile();// 是否创建成功 并且需要抛出异常
            System.out.println("创建结果01;"+a);
        }
        //createNewFile()
        //返回：没有就创建 有返回 false
        //如果指定的文件不存在并成功地创建，则返回 true；如果指定的文件已经存在，则返回 false
        //抛出：
        //IOException - 如果发生 I/O 错误

        // 2.1 删除文件  delete
        // System.out.println("删除结果;  "+file.delete());

        // 2.2 使用 jvm deleteOnExit 退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5000); // 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
        System.out.println("=============获取文件信息==========");
        
        // 3.  获取文件信息
        // 3.1  获取文件路径  绝对  相对
        System.out.println("获取文件的绝对路径;"+file.getAbsolutePath()); // E:\学生.txt  文件所在的真实位置
        // 如果在创建文件时 把 (E:\\) 删除就叫相对路径  就会在 src 所在的地方创建文件 绝对路径为   F:\Application\学生.txt
        System.out.println("获取路径; "+file.getPath());
        // 原本什么路径  就是什么路径 绝对就返回绝对 相对就返回相对
        // 3.2
        System.out.println("获取文件名称; "+file.getName());
        // 3.3
        System.out.println("获取父目录; "+file.getParent());
        // 3.4
        System.out.println("获取文件长度; "+file.length());
        //3.5
        System.out.println("文件创建时间; "+new Date(file.lastModified()).toLocaleString());
        // 4. 判断
        System.out.println("是否可写; "+file.canWrite());
        System.out.println("是否是文件; "+ file.isFile());
        System.out.println("是否隐藏; "+file.isHidden());

    }

}

Print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Demo.Demo09
路径分隔符;
名称分隔符\
创建结果00;false
=============获取文件信息==========
获取文件的绝对路径;E:\学生.txt
获取路径; E:\学生.txt
获取文件名称; 学生.txt
获取父目录; E:\
获取文件长度; 0
文件创建时间; 2021年5月6日 下午1:08:19
是否可写; true
是否是文件; true
是否隐藏; false

Process finished with exit code 0

文件夹操作

Application

package Demo;

import java.io.File;
import java.io.FileWriter;
import java.util.Date;

public class Demo09 {
    public static void main(String[] args) throws Exception{
//        separator();
//        fileOpe("E:\\学生.txt");
        directoryOpe();
    }

    // (3)==================文件夹操作=========================
    public static void directoryOpe() throws Exception{
        // 1. 创建文件夹
        File dir = new File("E:\\a\\b\\c");
        System.out.println(dir.toString()); // 这是一个对象路径 此时还没有创建
        if(!dir.exists()){
            //dir.mkdir();//只能创建单级目录
            System.out.println("返回结果"+dir.mkdirs());// 创建多级目录
        } // 返回值是 false true
        // 2. 删除文件夹
        // 2.1 直接删除
        //System.out.println("删除结果; "+dir.delete());//只能删除底层的空目录
        // 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.isDirectory());
        System.out.println("是否是隐藏; "+dir.isHidden());
        // 5. 遍历文件夹  可以用 List 也可以用 listFile 返回 String 和 File File 可以调用一些属性
        File dir2 = new File("E:\\a");
        File[] files = dir2.listFiles();
        // listFiles()  返回值 File 数组
        System.out.println("----------------------------");
        for (File file : files) {
            System.out.println(file);
        }

    }

}

Print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Demo.Demo09
E:\a\b\c
返回结果true
获取绝对路径;E:\a\b\c
获取路径E:\a\b\c
获取文件夹名称; c
获取父目录; E:\a\b
获取创建时间; 2021年5月6日 下午2:06:03
判断是否是文件夹; true
是否是隐藏; false
----------------------------
E:\a\1 - 副本 (10).jpg
E:\a\1 - 副本 (11).jpg
E:\a\1 - 副本 (12).jpg
E:\a\1 - 副本 (13).jpg
E:\a\1 - 副本 (14).jpg
E:\a\1 - 副本 (15).jpg
E:\a\1 - 副本 (16).jpg
E:\a\1 - 副本 (17).jpg
E:\a\1 - 副本 (2).jpg
E:\a\1 - 副本 (3).jpg
E:\a\1 - 副本 (4).jpg
E:\a\1 - 副本 (5).jpg
E:\a\1 - 副本 (6).jpg
E:\a\1 - 副本 (7).jpg
E:\a\1 - 副本 (8).jpg
E:\a\1 - 副本 (9).jpg
E:\a\1 - 副本.jpg
E:\a\1.jpg
E:\a\b

Process finished with exit code 0

FileFilter 接口

文件过滤器

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

Application

System.out.println("--------------FileFilter 接口的使用---------");

File[] files2 = dir2.listFiles(new FileFilter() {
    @Override
    public boolean accept(File file) {
        if(file.getName().endsWith(".jpg")){// 如果文件名后缀是.jpg
            return true;
        }
        return false;// false 所有文件都不返回 true 返回所有文件
    }
});
for (File file : files2) {
    System.out.println(file);
}

Print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Demo.Demo09

--------------FileFilter 接口的使用---------
E:\a\1 - 副本 (11).jpg
E:\a\1 - 副本 (17).jpg
E:\a\1 - 副本.jpg
E:\a\1.jpg

Process finished with exit code 0

递归遍历和递归删除

现在要将 Myfiles 文件夹全部内容进行遍历和删除

因为删除必须是空的文件夹所以删除文件夹之前要删除文件夹中的文件

Application

package Demo;

import java.io.File;
/**
 * 案例1; 递归遍历文件夹
 * 案例2; 递归删除文件夹
 * @author 夏天的风
 */
public class ListDemo {
    public static void main(String[] args) {
        //listDir(new File("E:\\MyFiles"));// 将该路径对象传输到 方法中
        deleteDir(new File("E:\\MyFiles"));
    }
    // 案例 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);// 如果是文件夹 递归调用自己 把 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());
        }

    }

Print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Demo.ListDemo
E:\MyFiles\1\Q.txt删除; true
E:\MyFiles\1\W.xlsx删除; true
E:\MyFiles\1删除; true
E:\MyFiles\2\E.txt删除; true
E:\MyFiles\2\R.xlsx删除; true
E:\MyFiles\2删除; true
E:\MyFiles\A.txt删除; true
E:\MyFiles\B.xlsx删除; true
E:\MyFiles删除; true

Process finished with exit code 0

Properties 属性集合

特点;
1. 存储属性名和属性值
2. 属性名和属性值都是字符串类型
3. 没有泛型
4. 和流有关

Application

package Demo;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;

public class Demo10 {
    public static void main(String[] args) throws Exception{
        // 1. 创建集合
        Properties properties = new Properties();
        // 2. 添加数据
        properties.setProperty("username","张三");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        // 3. 删除 自己去 api 找
        // 4. 遍历
        // 4.1 ---keySet---
        // 4.2 ---entrySet---
        System.out.println("========================");
        // 4.3 ---stringPropertyNames()---(本期重点)
        Set<String> pronames = properties.stringPropertyNames();
        for (String pro : pronames) {
            System.out.println(pro+"===="+properties.getProperty(pro));// 根据属性名 返回数据
        }

        // 和流有关的方法
        //------------1. list方法-----------
        PrintWriter pw = new PrintWriter("E:\\print.txt");
        properties.list(pw);
        pw.close();
        // -------------2. store 保存-------
        FileOutputStream fos = new FileOutputStream("E:\\store.properties");
        properties.store(fos,"注释");
        fos.close();
        // ------------3. load 加载-----
        System.out.println("=========================");
        Properties properties1 = new Properties();
        FileInputStream fis = new FileInputStream("E:\\store.properties");
        properties1.load(fis);
        fis.close();
        System.out.println(properties1.toString());
    }

}

Print

D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Demo.Demo10
{age=20, username=张三}
========================
age====20
username====张三
=========================
{age=20, username=张三}

Process finished with exit code 0

新增单词

1 | input | 输入 | |
--|--|--|--|--
2 | output |输出||
3|Stream|流|stm|
4|read|阅读|瑞的|
5|write|写如|掳爱t|
6|Buffered|缓冲的|buffer的|buffer
7|flush|刷新到硬盘||
8|serializable|可序列化的|色润莱兹able|
9|Reader|字符输入流||
10|Writer|字符输出流||
11|readLine|读取一行||
12|newLine|写入一个分隔符(新建一行)||
13|transient|瞬间的|tr 瞬t|
14|createNewFile|创建新的一行|亏唉T|
15|mkdir|创建目录|MK得儿|
16|exists|是否存在|ex唉丝次|
17|getAbsolutepath|获取绝对路径|Get abs鲁的帕斯|
18|getDirectory|获取相对路径|的瑞t瑞|
19|isFile|判断指定的文件是否存在且为文件||
20|listFiles|得到的是一个 File 类型的数组，返回的是该目录中的文件和目录||
21|renameTo|重命名|瑞nameTo|
22|pathSeparator|路径分隔符 ;|怕夫杀步瑞tr|
23|separator|名称分隔符 |杀步瑞tr|
24|createNewFile|创建新文件|亏哎t|

posted @ 2021-05-23 13:02 项晓忠阅读(98) 评论(0) 编辑收藏举报

Deep

朝闻道，夕死可矣

第二十七讲——流（IO框架）

第二十七讲——IO 框架

1——什么是流

流的分类

2 ——字节流

文件字节流

FileInputStream

FileOutputStream

字节流复制文件

BufferedInputStream

BufferedOutputStream

3——对象流

序列化

反序列化

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

4——字符流

字符流抽象类

文件字符流

FileReader

FileWriter

字符流复制文件

BufferedReader

BufferedWriter

5——打印流—PrintWriter

6——转换流

InputStreamReader

OutputSteamWriter

7——File类

文件操作

文件夹操作

FileFilter 接口

递归遍历和递归删除

Properties 属性集合

新增单词

公告

Deep

朝闻道，夕死可矣

第二十七讲——流（IO框架）

第二十七讲——IO 框架

1——什么是流

流的分类

2 ——字节流

文件字节流

FileInputStream

FileOutputStream

字节流复制文件

BufferedInputStream

BufferedOutputStream

3——对象流

序列化

反序列化

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

4——字符流

字符流抽象类

文件字符流

FileReader

FileWriter

字符流复制文件

BufferedReader

BufferedWriter

5——打印流—PrintWriter

6——转换流

InputStreamReader

OutputSteamWriter

7——File类

文件操作

文件夹操作

FileFilter 接口

递归遍历和递归删除

Properties 属性集合

新增单词

公告

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