20_IO

IO框架

一. 流的概念

• 概念：内存与存储设备之间传输数据的通道
  • 水借助管道传输；数据借助流传输

二. 流的分类

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

三. 字节流

1. 字节流的父类（抽象类）

• InputStream：字节输入流
  • public int read(){}
  • public int read(byte[] b){}
  • public int read(byte[] b, int off, int len){}
• OutputStream：字节输出流
  • public int write(){}
  • public int write(byte[] b){}
  • public int write(byte[] b, int off, int len){}

2. 文件字节流

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

文件字节输入流(FileInputStream)

		//1. 创建字节文件输入流对象 FileInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");

        //2. 读取文件
        //2.1 读取单个字节
//        int data = 0;
//        while ((data = fis.read()) != -1){
//            System.out.print((char) data);
//        }
        //2.2 一次读取多个字节
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count = fis.read(buf)) != -1){
            System.out.print(new String(buf,0,count));
        }

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

文件字节输出流(FileOutputStream)

		//1. 创建字节文件输出流对象 FileOutputStream
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);//true代表继续往文件里追加数据
        //2. 写入文件
        fos.write(97);
        fos.write('b');
        fos.write('c');

        String string = "Hello world";
        fos.write(string.getBytes());

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

使用文件字节流实现文件的复制

		//1. 创建流
        //1.1文件字节输入流
        FileInputStream fis = new FileInputStream("D:\\谷歌下载\\4K壁纸.jpg");
        //1.2文件字节输出流
        FileOutputStream fos = new FileOutputStream("D:\\谷歌下载\\4K壁纸1.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("复制完成");

3. 字节缓冲流

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

使用字节缓冲流读取文件

		//1. 创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\bbb.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //2.读取
        int data = 0;
        while ((data = bis.read()) != -1){
            System.out.print((char)data);
        }
        //3. 关闭
        bis.close();

使用字节缓冲流启动文件

		//1. 创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);

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

        //3. 关闭(同时内部调用flush方法，一次性刷新所有数据到硬盘)
        bos.close();

4. 对象流

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

序列化

		//注意：
		//(1)序列化的类必须要实现Serializable接口
		//(2)序列化类中的对象属性也要实现Serializable接口
		//(3)序列化版本号ID,保证序列化的类和反序列化的类是同一个类
		//(4)使用transient（瞬间的）修饰属性，这个属性不能序列化
		//(5)静态属性不能被序列化
		//(6)序列化多个对象，可以借助集合实现
		//1. 创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);

        //2. 序列化（写入操作）
        Student jay = new Student("杰",22);
        oos.writeObject(jay);
        //3. 关闭
        oos.close();
        System.out.println("序列化完毕");

反序列化

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

四. 编码方式

• 字符编码
  • ISO-8859-1
    • 收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号
  • UTF-8
    • 针对Unicode码表的可变长度字符编码
  • GB2312
    • 简体中文
  • GBK
    • 简体中文、扩充
  • BIG5
    • 台湾，繁体中文
• 当编码方式和解码方式不一致时，会出现乱码

五. 字符流

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

• Reader:字符输入流
  • public int read(){}
  • public int read(char[] c){}
  • public int read(char[] c, int off, int len){}
• Writer:字符输出流
  • public int write(){}
  • public int write(char[] c){}
  • public int write(char[] c, int off, int len){}

2. 文件字符流

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

使用FileReader读取文件

		//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 多个字符读取
        char[] buf = new char[2];
        int count = 0;
        while ((count = fr.read(buf)) != -1){
            System.out.print(new String(buf,0,count));
        }

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

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

使用FileWriter写入文件

		//1. 创建FileWriter对象
        FileWriter fw = new FileWriter("d:\\hello.txt");

        //2. 写入数据
        for (int i = 0; i < 5; i++) {
            fw.write("java是世界上最好的语言\r\n");
            fw.flush();

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

使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件

字节流可复制任意文件

		//1.创建对象
        FileReader fr = new FileReader("d:\\hello.txt");
        FileWriter fw = new FileWriter("d:\\hello1.txt");

        //2. 边读边写
        int count = 0;
        char[] ch = new char[2];
        while ((count = fr.read(ch)) != -1){
            fw.write(ch,0,count);
            fw.flush();
        }
        //3. 关闭
        fr.close();
        fw.close();
        System.out.println("复制完毕");

3. 字符缓冲流

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

BufferedReader

		//1. 创建缓冲流
        FileReader fr = new FileReader("d:\\hello.txt");
        BufferedReader br = new BufferedReader(fr);

        //2. 读取
        //2.1 第一种方法
//        char[] buf = new char[1024];
//        int count = 0;
//        while ((count = br.read(buf)) != -1){
//            System.out.println(new String(buf,0,count));
//        }
        //关闭
        //2.2 第二种方法 一次读一行
        String line = null;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
        br.close();

BufferedWriter

		//1. 创建字符缓冲流
        FileWriter fw = new FileWriter("d:\\hello.txt");
        BufferedWriter bw = new BufferedWriter(fw);

        //2. 写入数据
        for (int i = 0; i < 5; i++) {
            bw.write("java天下第一");
            bw.newLine();//写入一个换行符 windows \r\n linux \n
            bw.flush();
        }

        //3. 关闭
        bw.close();

4. 打印流

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

		//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("打印完毕");

六. 转换流

InputStreamReader读取文件

		//1. 创建InputStreamReader对象
        FileInputStream fis = new FileInputStream("d:\\hello.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写入文件，使用指定编码

		//1. 创建OutputStreamWriter
        FileOutputStream fos = new FileOutputStream("d:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");

        //2. 写入
        for (int i = 0; i < 5; i++) {
            osw.write("王者再见\r\n");
            osw.flush();
        }
        //3. 关闭
        osw.close();
        System.out.println("执行完毕");

七. File类

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

1. 方法

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

2. FileFilter接口

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

package com.io.demo04;

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

public class Demo01 {

    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. 创建文件
        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());
        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 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());//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:\\文件");
        File[] files = dir2.listFiles();
        System.out.println("--------------------");
        for (File file : files) {
            System.out.println(file);
        }

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

        File[] files2 = dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.getName().endsWith(".txt");
            }
        });

        for (File file : files2) {
            System.out.println(file.getName());
        }

    }
}

3. 递归遍历和递归删除

package com.io.demo04;

import java.io.File;

public class ListDemo {

    public static void main(String[] args) {

        listDir(new File("d:\\aaa"));
        deleteDir(new File("d:\\aaa"));

    }

    //案例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);//递归
                }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());

    }
}

八.Properties集合

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

		//1. 创建集合
        Properties properties = new Properties();
        //2. 添加数据
        properties.setProperty("张三","18");
        properties.setProperty("李四","20");
        properties.setProperty("王五","19");

        System.out.println(properties.toString());
        //3. 遍历
        //3.1---keySet---
        //3.2---entrySet---
        //3.3---stringPropertyNames()---
        Set<String> proNames = properties.stringPropertyNames();
        for (String proName : proNames) {
            System.out.println(proName + ":" + properties.getProperty(proName));
        }
        //4. 和流有关的方法
        //------1. list方法------
        PrintWriter pw = new PrintWriter("d:\\print.txt");
        properties.list(pw);
        pw.close();
        //------2. store方法------
//        FileWriter fw = new FileWriter("d:\\store.properties");
//        properties.store(fw,"注释");
//        fw.close();

        //------3. load方法------
        Properties properties1 = new Properties();
        FileReader fr = new FileReader("d:\\store.properties");
        properties1.load(fr);
        System.out.println(properties1.toString());