IO框架

什么是流

概念：内存与存储设备之间传输数据的通道。

水借助管道传输；数据借助流传输。

流的分类

按方向【重点】：
- 输入流：将<存储设备>中的内容读入到<内存>中。
- 输出流：将<内存>中的内容写入到<存储设备>中。

按单位：
- 字节流：以字节为单位，可以读写所有数据。
- 字符流：以字符为单位，只能读写文本数据。
按功能：
- 节点流：具有实际传输数据的读写功能。
- 过滤流：在节点流的基础之上增强功能。

字节流

字节流的父类（抽象类）：
- 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.
FileOutStream:
- public void write(byte[] b) //一次写多个字节，将b数组中所有字节，写入输出流。

FileInputStream的使用

Demo01.java

package com.IO;


import java.io.FileInputStream;

/**
 * 演示FileInputStream的使用
 * 文件字节输入流
 * @author 大白很白
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1创建FileInputStream，并指定文件路径
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");//不知道有没有这个文件，先抛出异常
        //2读取文件
        //fis.read()//一个字节一个字节的读取
        //2.1单个字节读取
//        int data = 0;
//        while((data=fis.read())!=-1){
//            System.out.print((char)data);//abcdefg
//        }
        //2.2一次读取多个字节
//        byte[] buf = new byte[3];
//        int count = fis.read(buf);
//        System.out.println(new String(buf));
//        System.out.println(count);
//        /*
//        abc
//        3
//         */
//
//        int count2 = fis.read(buf);
//        System.out.println(new String(buf));
//        System.out.println(count2);
//        /*
//        def
//        3
//         */
//
//        int count3 = fis.read(buf);
//        System.out.println(new String(buf,0,count3));
//        System.out.println(count3);
        /*
        g
        1
         */
        byte[] buf = new byte[3];//new byte[1024],一次性读完
        int count = 0;
        while((count=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
            /*
            abc
            def
            g
             */
        }
        //3关闭
        fis.close();
        System.out.println();
        System.out.println("执行完毕");//执行完毕
    }
}

FileOutputStream的使用

Demo02.java

package com.IO;

import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;

/**
 * 演示文件字节输出流的使用
 * FileOutputStream
 * @author 大白很白
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1创建文件字节输出流对象
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);//文件结果未知，先抛出异常
        //2写入文件
//        fos.write(97);//a的ascii编码
//        fos.write('b');
//        fos.write('c');
        String string = "helloworld";
        fos.write(string.getBytes());//bbb.txt中内容为helloworldhelloworld，用了append，继续写
        //3关闭
        fos.close();
        System.out.println("执行完毕");

    }
}

字节流复制文件

Demo03.java

package com.IO;

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

/**
 * 使用文件字节流实现文件的复制
 * @auth 大白很白
 */
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1创建流
        //1.1文件字节输入流
        FileInputStream fis = new FileInputStream("d:\\001.jfif");
        //1.2文件字节输出流
        FileOutputStream fos = new FileOutputStream("d:\\002.jfif");
        //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。

BufferdInputStream的使用

内部带8k缓冲区

Demo04.java

package com.IO;

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

/**
 * 使用字节缓冲流读取文件
 * BufferedInputStream
 * author 大白很白
 */
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //2读取
//        int data = 0;
//        while ((data=bis.read())!=-1){
//            System.out.print((char) data);
//        }

        byte[] buf = new byte[1024];
        int count = 0;
        while ((count=bis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3关闭
        bis.close();
    }
}

BufferedOutputStream的使用

Demo05.java

package com.IO;

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

/**
 * 使用字节缓冲流写入文件
 * BufferedOutputStream
 * @author 大白很白
 */
public class Demo05 {
    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\r\n".getBytes());//写入8k缓冲区
            bos.flush();//刷新到硬盘
        }
        //3关闭(内部调用flush方法）
        bos.close();
    }
}

对象流

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

序列化（内存--->存储空间，写入）

Student.java

package com.IO;

import java.io.Serializable;

/**
 * 学生类
 * @author 大白很白
 */
public class Student implements Serializable {//标记接口，实现接口表示Student类可以序列化
    private String name;
    private int age;

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

Demo06.java

package com.IO;

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

/**
 * 使用ObjectOutputStream实现对象的序列化
 * 要求：序列化类必须要实现Serializable接口
 * @author 大白很白
 */
public class Demo06 {
    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);
        //3关闭
        oos.close();//close()自带flush
        System.out.println("序列化完毕");
    }
}

反序列化

Demo07.java

package com.IO;

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

/**
 * 使用ObjectInputStream实现反序列化(读取重构成对象）
 * @author 大白很白
 */
public class Demo07 {
    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();
        //3关闭
        ois.close();
        System.out.println("执行完毕");//执行完毕
        System.out.println(s.toString());//Student{name='张三', age=20}


    }
}

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

序列化类必须实现Serializable接口
序列化类中对象属性要求实现Serializable接口
序列化版本号ID，保证序列化的类和反序列化的类是同一个类，serialVersionUID
使用transient(瞬间的、瞬时的)修饰属性，这个属性不能序列化
静态属性不能序列化
序列化多个对象（可用new ArrayList<>();），借助集合实现

常见字符编码

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

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

Demo01.java

package com.IO.demo02;

import java.io.FileInputStream;
//文件字节输入流
public class Dem01 {
    public static void main(String[] args) throws Exception{
        //1创建FileInputStream对象
        FileInputStream fis = new FileInputStream("d:\\hello.txt");
        //2读取
        int data = 0;
        while((data=fis.read())!=-1){//一个字节一个字节读，汉字是一个汉字三个字节，故读汉字时会乱码，应使用字符流
            System.out.print((char)data);
        }
        //3关闭
        fis.close();
    }
}

字符流

字符流的父类（抽象类）
- 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.
FileWriter：
- public void write(String str) //一次写多个字符，将b数组中所有字符，写入输出流。

FileReader的使用

Demo02.java

package com.IO.demo02;

import java.io.FileReader;

/**
 * 使用FileReader读取文件
 * @author 大白很白
 */
public class Demo02 {
    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);
//        }
        char[] buf = new char[2];
        int count = 0;
        while ((count=fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3关闭
        fr.close();
    }
}

FileWrite的使用

Demo03.java

package com.IO.demo02;

import java.io.FileWriter;

/**
 * 使用FileWriter写入文件
 * @author 大白很白
 */
public class Demo03 {
    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牛逼\r\n");//\r\n是回车加换行，\n是换行，\r是回车，操作当前行，\n跳到下一行
            fw.flush();
        }
        //3关闭
        fw.close();
        System.out.println("写入完毕");
    }
}

字符流复制文件

Demo04.java

package com.IO.demo02;

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

/**
 * 使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件（图片无字符编码格式）
 * 使用字节流可以复制任意类型文件
 * @author 大白很白
 */
public class Demo04 {
    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关闭
        fr.close();
        fw.close();
        System.out.println("复制完毕");
    }
}

字符缓冲流

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

BufferedReader的使用

Demo05.java

package com.IO.demo02;

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

/**
 * 使用字符缓冲流读取文件
 * BUfferedReader
 * @author 大白很白
 */
public class Demo05 {
    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();

    }
}

BufferedWriter的使用

Demo06.java

package com.IO.demo02;

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

/**
 * 演示BufferedWriter的使用
 * @author 大白很白
 */
public class Demo06 {
    public static void main(String[] args) throws Exception {
        //1创建BufferedWriter对象
        FileWriter fw = new FileWriter("d:\\rebuffer.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()方法，支持写入后换行
- 支持数据原样打印

Demo07.java

package com.IO.demo02;

import java.io.PrintWriter;

/**
 * 演示PrintWriter的使用
 * @author 大白很白
 */
public class Demo07 {
    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('c');
        pw.println(3.14);
        //3关闭
        pw.close();
        System.out.println("执行完毕");
        /**
         * print.txt
         * 97
         * true
         * c
         * 3.14
         */
    }

}

转换流

桥转换流：InputStreamReader/OutStreamWriter
- 可将字节流转换为字符流
- 可设置字符的编码方式

转换流的使用

InputStreamReader的使用

Demo01.java

package com.IO.demo03;

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

/**
 * 使用InputStreamReader读取文件，指定使用的编码
 * @author 大白很白
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1创建InputStreamReader对象
        FileInputStream fis = new FileInputStream("d:\\write.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();

    }
}

OutputStreamWriter的使用

Demo02.java

package com.IO.demo03;

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

/**
 * 使用OutputStreamWriter写入文件，使用指定的编码
 * @author 大白很白
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1创建OutputStreamWriter
        FileOutputStream fos = new FileOutputStream("d:\\writer3.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()//判断FiIe对象所对象所代表的对象是否存在
- getAbsolutePath()//获取文件的绝对路径
- getName()//取得名字
- getparent()//获取文件/目录所在的目录
- isDirectory()//是否是目录
- isFile()//是否是文件
- length()//获得文件的长度
- IistFiIes()//列出目录中的所有内容
- renameTo()//修改文件名为

文件和文件夹操作

Demo01.java

package com.IO.demo04;

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

/**
 * File类的使用
 * （1）分隔符
 * （2）文件操作
 * （3）文件夹操作
 * @author 大白很白
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //separator();
        //fileOperations();
        directoryOperations();
    }
    //（1）分隔符
    public static void separator(){
        System.out.println("路径分隔符"+File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }

    //（2）文件操作
    public static void fileOperations() 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);//休眠5s
        //3获取文件信息
        System.out.println("获取文件的绝对路径:"+file.getAbsolutePath());
        System.out.println("获取路径:"+file.getPath());
        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("是否可写:"+file.canWrite());
        System.out.println("是否是文件:"+file.isFile());
        System.out.println("是否隐藏:"+file.isHidden());
    }

    //（3）文件夹操作
    public static void directoryOperations() throws Exception{
        //1创建文件夹
        File dir = new File("d:\\test\\test1");
        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:\\test\\test1");
        String[] files = dir2.list();
        System.out.println("----------------------");
        for (String string : files) {
            System.out.println(string);
        }
        System.out.println("---------------FileFilter接口的使用--------");
        File[] files2 = dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".txt")) {
                    return true;
                }
                return false;
            }
        });
        for (File file : files2) {
            System.out.println(file.getName());
        }
    }
}

FileFliter接口

见上面

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

递归遍历和递归删除

listDemo.java

package com.IO.demo04;

import java.io.File;

/**
 * 案例1：递归遍历文件夹
 * 案例2：递归删除文件夹
 * @author 大白很白
 */
public class ListDemo {
    public static void main(String[] args) {
        //listDir(new File("d:\\myFiles"));
        deleteDir(new File("d:\\myFiles"));
    }
    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);//递归
                }else {
                    System.out.println(file.getAbsolutePath());
                }

            }
        }


    }
    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());
    }
}

Properties

Properties:属性集合
特点
- 1 存储属性名和属性值
- 2 属性名和属性值都是字符串类型
- 没有泛型
- 和流有关

Properties使用

Demo02.java

package com.IO.demo04;

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

/**
 * 演示Properties集合的使用
 * @author 大白很白
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1创建集合
        Properties properties = new Properties();
        //2添加数据
        properties.setProperty("username", "lisi");
        properties.setProperty("age", "20");
        System.out.println(properties.toString());
        //3遍历
        //3.1-----keyset---
        //3.2-----entryset----
        //3.3-----stringPropertyNames()-----
        Set<String> pronames = properties.stringPropertyNames();
        for (String pro:pronames
             ) {
            System.out.println(pro);
            System.out.println(pro+"======"+properties.getProperty(pro));
        }
        //4和流有关的方法
        //------------1list方法--------
//        PrintWriter pw = new PrintWriter("d:\\print.txt");
//        properties.list(pw);
//        pw.close();

//        //---------2store方法------
//        FileOutputStream fos = new FileOutputStream("d:\\store.properties.txt");
//        properties.store(fos,"注释");
//        fos.close();
        
        //-------------3load方法加载------------
        Properties properties2 = new Properties();
        FileInputStream fis = new FileInputStream("d:\\store.properties.txt");
        properties2.load(fis);
        fis.close();
        System.out.println(properties2.toString());
    }
}

总结

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

posted @ 2022-05-29 20:56 大白很白阅读(50) 评论(0) 收藏举报

刷新页面返回顶部

IO框架

什么是流

流的分类

字节流

文件字节流

FileInputStream的使用

FileOutputStream的使用

字节流复制文件

字节缓冲流

BufferdInputStream的使用

BufferedOutputStream的使用

对象流

序列化（内存--->存储空间，写入）

反序列化

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

常见字符编码

字符流

文件字符流

FileReader的使用

FileWrite的使用

字符流复制文件

字符缓冲流

BufferedReader的使用

BufferedWriter的使用

打印流

转换流

转换流的使用

InputStreamReader的使用

OutputStreamWriter的使用

File类

文件和文件夹操作

FileFliter接口

递归遍历和递归删除

Properties

Properties使用

总结

公告