IO流

主要内容：

• java.io.File 类的使用
• IO原理及流的分类
  （1）文件流（基于文件）：FileInputStream / FileOutputStream / FileReader / FileWriter
  （2）缓冲流（基于内存）：BufferedInputStream / BufferedOutputStream / BufferedReader / BufferedWriter

一、File类

注意在编程中 \ 或 / 才表示分隔符，一个 ** 表示转义符。

import java.io.File;

public class Test {
    public static void main(String[] args) {
        File f = new File("D:\\test2\\abc\\tt.txt");
        f.getName();  //获取文件或文件夹名
        f.getPath();  //获取文件或文件夹的路径（new时的路径，可能相对可能绝对）
        f.getAbsolutePath();  //获取绝对路径
        f.getAbsoluteFile();  //返回一个用当前的文件的绝对路径构建的file对象
        f.getPath();  //返回当前文件（夹）的父级路径
        f.renameTo(new File("D:\\test2\\abc\\tt1.txt"));  //给文件（夹）重命名
        f.exists();  //判断文件（夹）是否存在
        f.canWrite();  //判断文件是否可写
        f.canRead();  //判断文件是否可读
        f.isFile();  //判断当前的File对象是否是一个文件
        f.isDirectory();  //判断当前的File对象是否是一个文件夹（目录）
        f.lastModified();  //最后修改时间，返回毫秒数
        f.length();  //返回文件长度（单位：字节）
    }
}

文件相关操作：

import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        File f = new File("D:\\test2\\abc\\tt2.txt");
        if (!f.exists()) {
            try {
                f.createNewFile();  //创建一个文件
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        f.delete();  //删除一个文件
    }
}

目录相关操作：

import java.io.File;

public class Test {
    public static void main(String[] args) {
        File f = new File("D:\\test2\\abc\\cc\\dd");
        f.mkdir();  //创建单层目录
        File f1 = new File("D:\\test2\\abc\\a\\b\\c");
        f1.mkdirs(); //创建多层目录
        File f2 = new File("D:\\test2");
        f2.list();  //返回当前文件夹子集的名称，包括目录和文件（String）
        f2.listFiles();  //返回当前文件夹子集的对象，包括目录和文件（File）
    }
}

递归遍历文件：

import java.io.File;

public class Test {
    public static void main(String[] args) {
        File f = new File("D:\\test");
        new Test().test(f);
    }

    public void test(File file) {
        if (file.isFile()) {
            System.out.println(file.getAbsolutePath() + " 是文件");
        } else {
            System.out.println(file.getAbsolutePath() + " 是文件夹");
            File[] fs = file.listFiles();  //获取当前文件夹下子文件夹或文件的file对象
            if (fs != null && fs.length > 0) {
                for (File ff : fs) {
                    test(ff);  //递归
                }
            }
        }
    }
}

二、Java IO原理

IO流用来处理设备之间的数据传输。

Java程序中，对于数据的输入/输出操作以“流（stream）”的方式进行。

java.io 包提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

输入和输出的主语都是计算机。
输入input： 读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
输出output： 将程序（内存）中的数据输出到磁盘、光盘等存储设备中。

流的分类

• 按操作数据单位不同分为：字节流（8bit），字符流（16bit）
• 按数据流的流向不同分为：输入流、输出流
• 按流的角色不同分为：节点流、处理流

Java中的40多个设计IO流的类，都是从以下4个抽象基类派生的。

抽象基类	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

（1）文件字节输入流

import java.io.FileInputStream;

public class Test {
    public static void main(String[] args) {
        try {
            FileInputStream in = new FileInputStream("D:\\test2\\tt1.txt");
            byte[] b = new byte[10];  //设置一个byte数组接收读取的文件内容
            in.read(b);
            System.out.println(new String(b));
            in.close();  //注意：流在使用完毕之后一定要关闭！！
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

（2）文件字节输出流

import java.io.FileOutputStream;

public class Test {
    public static void main(String[] args) {
        Test.test();
    }

    public static void test() {
        try {
            FileOutputStream out = new FileOutputStream("D:\\test2\\tt2.txt");
            String s = "vicky";
            out.write(s.getBytes());  //write()接受bit数组，String的getBytes()方法将字符串转化为bit数组
            //write()把数据写到内存
            out.flush();  //flush()把内存中的数据刷写到硬盘上
            out.close();  //关闭流
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

需求：编写程序，把一个文件复制到指定的文件夹下。

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

public class Test {
    public static void main(String[] args) {
        Test.copyFile();
    }

    public static void copyFile() {
        try {
            FileInputStream in = new FileInputStream("D:\\test2\\tt2.txt");
            FileOutputStream out = new FileOutputStream("D:\\test2\\abc\\a\\b\\tt2.txt");
            byte[] b = new byte[10];
            in.read(b);
            out.write(b);
            out.flush();
            in.close();
            out.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

可以把两个文件路径改为形参传递，调用方法时通过实参赋值，则更具有通用性。

注意：文件字节流非常通用，可以用来操作字符的文档，还可以操作任何的其他类型文件（图片、压缩包等）。因为它直接使用二进制。

（3）文件字符输入流

import java.io.FileReader;

public class Test {
    public static void main(String[] args) {
        Test.test("D:\\test2\\abc\\a\\b\\tt2.txt");
    }

    public static void test(String inPath) {
        try {
            FileReader f = new FileReader(inPath);
            char[] ch = new char[10];
            f.read(ch);
            System.out.println(ch);
            f.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

（4）文件字符输出流

import java.io.FileWriter;

public class Test {
    public static void main(String[] args) {
        Test.test("vicky", "D:\\test2\\abc\\a\\b\\tt3.txt");
    }

    public static void test(String text, String outPath) {
        try {
            FileWriter f = new FileWriter(outPath);
            f.write(text);
            f.flush();
            f.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

用字符流拷贝文件：

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

public class Test {
    public static void main(String[] args) {
        Test.copy("D:\\test2\\abc\\a\\b\\tt2.txt", "D:\\test2\\abc\\a\\b\\c\\tt.txt");
    }

    public static void copy(String from, String to) {
        try {
            FileReader fr = new FileReader(from);
            FileWriter fw = new FileWriter(to);

            char[] ch = new char[10];

            fr.read(ch);
            fw.write(ch);
            fw.flush();
            fr.close();
            fw.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字符流只能操作字符，跟字节流不一样。

在写入一个文件时，如果目录下有同名文件将被覆盖。

在读取文件时，必须保证该文件已存在，否则出现异常。