java自学笔记（day08），归纳总结自：B站千锋学院java

I/O框架

经验贴：

由于导入以下这个包，导致无法对new String进行传参

import com.sun.org.apache.xpath.internal.operations.String;

---

输入流读，输出流写。可以理解为，把自己当作内存，若想看硬盘的东西（表示硬盘把东西传给内存，也就是输入到自己）；若想给硬盘写东西（表示内存把东西传给硬盘，也就是输出到硬盘）。

什么是流：

流的分类

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

字节流

• 字节流的父类（抽象类）：
  • 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：
  • public int read(byte[] b) //从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1

package com.iostream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
*
* 演示FileInputStream的使用
* 文件字节输入流
* */
public class Demo1 {
    public static void main(String[] args) throws Exception {
        //1.创建FileInputStream
        FileInputStream fis = new FileInputStream("D:\\demo1.txt");
        //2.读取文件
        //fis.read
        //2.1单个字节读取
//        int data = 0;
//        while ((data = fis.read()) != -1){   //先将读取的int值赋给data，再用data与-1进行比较
//            System.out.print((char) data);
//        }
//        //2.2一次读取多个字节
//        byte[] buf = new byte[3];
//
//        int count = fis.read(buf);  //读取缓冲区
//        System.out.println(new String(buf));
//        System.out.println(count);
//
//        int count2 = fis.read(buf);  //读取缓冲区
//        System.out.println(new String(buf));
//        System.out.println(count2);
//
//        int count3 = fis.read(buf);  //读取缓冲区
//        System.out.println(new String(buf, 0, count3));
//        System.out.println(count3);

        byte[] buf = new  byte[3];
        int count = 0;
        while ((count = fis.read(buf)) != -1){
            System.out.println(new String(buf, 0, count));  //此指每次对缓冲区buf，从0开始，读取count个
        }


        //3.关闭
        fis.close();
        System.out.println();
        System.out.println("执行完毕");

    }
}

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

package com.iostream;

import java.io.FileOutputStream;

/*
*
* 演示文件字节流输出流的使用
* */
public class Demo2 {
    public static void main(String[] args) throws Exception{
        //1.创建文件字节流输出对象
        FileOutputStream fos = new FileOutputStream("D:\\demo2.txt", true);  //true代表再次运行的时候可以继续往后写
        //2.写入文件
        fos.write(97);
        fos.write('b');
        fos.write('c');
        String string = "hello world!";
        fos.write(string.getBytes());
        //3.关闭
        fos.close();
        System.out.println("执行完毕");
        //abchello world!abchello world!
    }
}

• 字节流复制文件

package com.iostream;

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

/*
*
* 使用文件字节流实现文件的复制
* */
public class Demo3 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        //1.1文件字节输入流
        FileInputStream fis = new FileInputStream("D:\\001.jpg");
        //1.2文件字节输出流
        FileOutputStream fos = new FileOutputStream("D:\\002.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("复制完毕");
    }
}

字节缓冲流

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

package com.iostream;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.lang.reflect.Field;

/*
*
* 使用字节缓冲流读取
* BufferedInputStream
* */
public class Demo4 {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedInputStream
        FileInputStream fis = new FileInputStream("D:\\demo1.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //2.读取
        int data = 0;
        while ((data = bis.read()) != -1){
            System.out.println((char) data);
        }

        //也可以自己写一个buf缓冲区
//        byte[] buf = new byte[1024];
//        int count = 0;
//        while ((count = bis.read(buf)) != -1){
//            System.out.println(new String(buf, 0, count));
//        }

        //关闭
        bis.close();
    }
}

package com.iostream;

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

/*
*
* 使用字节缓冲流写入文件
* BufferedOutputStream
* */
public class Demo5 {
    public static void main(String[] args) throws Exception{
        //1.创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("D:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //2.写入文件
        for (int i = 0; i < 10; i++){
            bos.write("helloworld\n".getBytes());  //写入8K缓冲区
            bos.flush();  //刷新到硬盘
        }

        //3.关闭(内部调用flush方法)
        bos.close();
    }
}

对象流

• 对象流：ObjectOutputStream / ObjectInputStream
  • 增强了缓冲区功能
  • 增强了读写8种基本数据类型和字符串功能
  • 增强了读写对象的功能
    • readObject() 从流中读取一个对象
    • writeObject(Object obj) 向流中写入一个对象

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

package com.iostream;

/**
 * 学生类
 * */
import java.io.Serializable;

public class Student implements Serializable {
    /**
     * serialVersionUID：序列号版本号ID，
     * */

    private static final long serialVersionUID = -1790400553581872301L;
    private String name;
    private transient int age;

    private static String country = "中国";

    public Student() {
    }

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

package com.iostream;

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


/**
* 使用ObjectOutputStream实现对象的序列化
* 注意事项：
*   1.序列化类必须实现Serializable接口(java.io.NotSerializableException)
*   2.序列化类中对象属性要求实现Serializable接口
*   3.序列化版本号ID serialVersionUID，保证序列化的类和反序列化的类是同一个类
*   4.使用transient(瞬间的)修饰属性，这个属性不能序列化
*   5.静态属性不能序列化
*   6.序列化多个对象，可以借助集合实现
* */
public class Demo6 {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileOutputStream fos = new FileOutputStream("D:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);

        //2.序列化(写入操作)
//        Student zhangsan = new Student("张三", 20);
//        oos.writeObject(zhangsan);
        Student zhangsan = new Student("张三", 20);
        Student lisi = new Student("李四", 22);
        ArrayList<Student> list = new ArrayList<>();
        list.add(zhangsan);
        list.add(lisi);
        oos.writeObject(list);



        //3.关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}

package com.iostream;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;

/**
* 使用ObjectInputStream实现反序列化(读取重构成对象)
* */
public class Demo7 {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileInputStream fis = new FileInputStream("D:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);

        //2.读取文件(反序列化)
//        Student s = (Student) ois.readObject();
//        System.out.println(s.toString());

        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
        System.out.println(list.toString());  //[Student[name='张三', age=0], Student[name='李四', age=0]]
        //3.关闭
        ois.close();
        System.out.println("反序列化完毕");
    }
}

字符编码

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

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

字符流

• 字符流的父类（抽象类）：
  • 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：
  • public int read (char[] c) //从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1

package com.iostream;

import java.io.FileReader;

/**
 * 使用FileReader读取文件
 * */
public class Demo9 {
    public static void main(String[] args) throws Exception{
        //1.创建FileReader文件字符输入流
        FileReader fr = new FileReader("D:\\hello.txt");

        //2.读取
        //2.1单个字符读取
//        int data = 0;
//        while ((data = fr.read()) != -1){
//            System.out.print((char) data);
//        }
        //2.2多个字符读取
        int count = 0;
        char[] buf = new char[1024];
        while ((count = fr.read(buf)) != -1){
            System.out.println(new String(buf, 0, count));
        }
        //你好世界helloworld

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

}

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

package com.iostream;

import java.io.FileReader;
import java.io.FileWriter;

/**
 * 使用FileWriter写入文件
 * */
public class Demo10 {
    public static void main(String[] args) throws Exception{
        //1.创建FileWriter对象
        FileWriter fw = new FileWriter("D:\\write.txt");
        //2.写入
        for (int i = 0; i < 10; i++){
            fw.write("java是世界上最好的语言\n");
            fw.flush();
        }
        //3.关闭
        fw.close();
        System.out.println("执行完毕");
    }
}

• 字符流复制文件

package com.iostream;

import java.io.FileReader;
import java.io.FileWriter;

/**
 * 使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件
 * 使用字节流复制任意文件。
 * */
public class Demo11 {
    public static void main(String[] args) throws Exception{
        //1.创建FileReader、FileWriter
        FileReader fr = new FileReader("D:\\write.txt");
        FileWriter fw = new FileWriter("D:\\write2.txt");
        //2.一边读，一边写
        int data = 0;
        while ((data = fr.read()) != -1){
            fw.write(data);
            fw.flush();
        }
        //3.关闭
        fw.close();
        fr.close();
        System.out.println("复制完毕");
    }
}

字符缓冲流

• 缓冲流：BufferedReader / BufferedWriter
  • 高效率写
  • 支持输入换行符
  • 可一次写一行、读一行

package com.iostream;

import java.io.BufferedReader;
import java.io.FileReader;

/**
 *使用字符缓冲流读取文件
 * BufferedReader
 * */
public class Demo12 {
    public static void main(String[] args) throws Exception{
        //1.创建缓冲流
        FileReader fr = new FileReader("D:\\write.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.print(new String(buf, 0, count));
//        }
        //2.2第二种方式，一行一行的读取
        String line = null;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
        //3.关闭
        br.close();
    }
}

package com.iostream;

import java.io.BufferedWriter;
import java.io.FileWriter;

/**
 * 演示BufferedWriter的使用
 * */
public class Demo13 {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedWriter对象
        FileWriter fw = new FileWriter("D:\\buffer.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("执行完毕");
    }
}

​

打印流

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

package com.iostream;

import java.io.PrintWriter;

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

转换流

• 桥转换流：InputStreamReader / OutputStreamWriter（可记忆硬盘中存储字节流，内存中存储字符流）
  • 可将字节流转换为字符流
  • 可设置字符的编码方式

package com.iostream;

import java.io.FileInputStream;
import java.io.InputStreamReader;

/**
 * 使用InputStreamReader读取文件，指定使用的编码
 * */
public class Demo15 {
    public static void main(String[] args) throws Exception{
        //1.创建InputStreamReader对象
        FileInputStream fis = new FileInputStream("D:\\write.txt");
        InputStreamReader isr = new InputStreamReader(fis, "utf-8");  //编码方式utf-8
        //2.获取文件
        int data = 0;
        while ((data = isr.read()) != -1){
            System.out.print((char) data);
        }
        //3.关闭
        isr.close();

    }
}

package com.iostream;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/**
 * 使用OutputStreamWriter写入文件，使用指定的编码
 * */
public class Demo16 {
    public static void main(String[] args) throws Exception{
        //1.创建OutputStreamWriter
        FileOutputStream fos = new FileOutputStream("d:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk");
        //2.写入
        for (int i = 0; i < 10; i++){
            osw.write("我爱中国\r\n");
            osw.flush();
        }
        //3.关闭
        osw.close();
        System.out.println("执行完毕");
    }
}

File类

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

package com.iostream;

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

/**
 * File类的使用
 * (1)分隔符
 * (2)文件操作
 * (3)文件夹操作
 * */
public class Demo17 {
    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.创建文件   createNewFile()
        File file = new File("D:\\file.txt");  //相对路径，也即是当前路径
//        System.out.println(file.toString());
        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(5000);    //5秒后删除

        //3.获取文件信息
        System.out.println("获取文件的绝对路径："+file.getAbsolutePath());
        System.out.println("获取路径："+file.getPath());
        System.out.println("获取文件名称："+file.getName());
        System.out.println("获取父目录："+file.getParent());  //获取父目录：D:\
        System.out.println("获取文件长度："+file.length());
        System.out.println("文件创建时间："+new Date(file.lastModified()).toLocaleString());

        //4.判断
        System.out.println("是否可写："+file.canWrite());  //是否可写：true
        System.out.println("是否临时文件："+file.isFile());  //是否临时文件：true
        System.out.println("是否隐藏："+file.isHidden());  //是否隐藏：false
    }

    //3.文件夹操作
    public static void directoryOpe() throws Exception {
        //1.创建文件夹
        File dir = new File("D:\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if (!dir.exists()){
            //dir.mkdir();  //只能创建单级目录
            System.out.println("创建结果："+dir.mkdirs());
        }

        //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.遍历文件夹
        File dir2 = new File("D:\\图片");
        String[] files = dir2.list();
        System.out.println("----------------");
        for (String string : files) {
            System.out.println(string);
        }
        //001.jpg
        //001.png
        //002.jpg
        
    }
}

FileFilter接口

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

System.out.println("--------FileFilter接口的使用------------");
File[] files1 = dir2.listFiles(new FileFilter() {
    @Override
    public boolean accept(File pathname) {
        if (pathname.getName().endsWith(".jpg")){
            return true;
        }
        return false;
    }
});
for (File file : files1) {
    System.out.println(file.getName());
}
//001.jpg
//002.jpg

递归遍历和递归删除

package com.iostream;

import java.io.File;

/**
 * 案例1：递归遍历文件夹
 * 案例2：递归删除文件夹
 * */
public class Demo18 {
    public static void main(String[] args) {
//        listDir(new File("D:\\myfiles"));
        deleteDir(new File("D:\\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()){  //如果file是文件夹则递归调用listDir()
                    listDir(file);
                }else {
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
    //D:\myfiles
    //D:\myfiles\新建 XLSX 工作表.xlsx
    //D:\myfiles\新建文件夹
    //D:\myfiles\新建文件夹\新建 PPT 演示文稿.ppt
    //D:\myfiles\新建文件夹\新建文本文档.txt
    //D:\myfiles\新建文件夹 (2)
    //D:\myfiles\新建文件夹 (2)\新建 DOC 文档.doc
    //D:\myfiles\新建文件夹 (2)\新建文本文档.txt
    //D:\myfiles\新建文本文档.txt

    //案例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());
    }
    //D:\myfiles\新建 XLSX 工作表.xlsx删除：true
    //D:\myfiles\新建文件夹\新建 PPT 演示文稿.ppt删除：true
    //D:\myfiles\新建文件夹\新建文本文档.txt删除：true
    //D:\myfiles\新建文件夹删除：true
    //D:\myfiles\新建文件夹 (2)\新建 DOC 文档.doc删除：true
    //D:\myfiles\新建文件夹 (2)\新建文本文档.txt删除：true
    //D:\myfiles\新建文件夹 (2)删除：true
    //D:\myfiles\新建文本文档.txt删除：true
    //D:\myfiles删除：true
}

总结

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