前段时间学习的IO流基础知识，现整理出来，以备以后查看

一、File类

1、文件和文件夹的创建

windows中文件路径用 \ 区分，Unix中用 / 区分

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

public class FileDemo01 {
    public static void main(String[] args) {
        try {
            //注意，如果文件夹或者文件已存在，则调用下列方法失败
            //创建文件
            File file1 = new File("D:\\test1.txt");
            boolean createFile = file1.createNewFile();
            System.out.println(createFile? "创建文件成功" : "创建文件失败");
            //创建文件夹
            File file2 = new File("D:\\test1");
            boolean creatDir = file2.mkdir();
            System.out.println(creatDir? "创建文件夹成功" : "创建文件夹失败");
            //创建多级文件夹
            File file3 = new File("D:\\test2\\html\\span");
            boolean createDirs = file3.mkdirs();
            System.out.println(createDirs? "创建多级文件夹成功" : "创建多级文件夹失败");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2、文件删除和查询

文件删除

import java.io.File;

public class FileDemo02 {
    public static void main(String[] args) {
        //文件删除
        File file = new File("D:\\test1.txt");
        boolean deleteFlag = file.delete();
        System.out.println("文件删除结果："+ deleteFlag);
    }
}

文件是否存在、文件大小（英文字母占1字节，中文汉字占3字节）、文件名和文件绝对路径查询

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

public class FileDemo03 {
    public static void main(String[] args) {
        try {
            File file = new File("D:\\test.txt");
            //查询文件是否存在
            boolean fileExist = file.exists();
            if (fileExist) {
                System.out.println("文件已存在");
            } else {
                //不存在则创建文件
                boolean createFile = file.createNewFile();
                System.out.println("文件不存在，文件创建结果："+createFile);
            }

            //判断文件大小，返回的是字节
            Long fileSize = file.length();
            System.out.println("文件大小为："+fileSize);

            //获取文件路径
            String filePath = file.getAbsolutePath();
            System.out.println("文件路径为："+filePath);
            //获取文件名称
            String fileName = file.getName();
            System.out.println("文件名是："+fileName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3、递归

能不用递归就尽量不用递归，如果处理层数较多的文件夹以及文件时可以考虑

import java.io.File;

public class FileDemo04 {
    public static void showFile(String filePath) {
        File file = new File(filePath);
        //判断当前文件是否是文件夹
        boolean isDirectory = file.isDirectory();

        //如果是文件夹，那么输出该文件夹下的所有文件
        if (isDirectory) {
            File[] files = file.listFiles();
            //对数组进行非空判断
            if (null != files && 0 != files.length) {
                //对所有文件进行for循环，如果是文件夹，就递归调用本方法，如果不是就输出文件路径
                for (File tempFile: files) {
                    if (tempFile.isDirectory()) {
                        showFile(tempFile.getPath());
                    } else {
                        System.out.println("普通文件，路径为："+tempFile.getPath());
                    }
                }
            }
        } else {
            //如果不是文件，那么输出文件路径
            System.out.println("普通文件，路径为："+file.getPath());
        }
    }

    public static void main(String[] args) {
        FileDemo04.showFile("D:\\tools\\chrome");
    }
}

二、IO流

io流关闭原则

1、字节流

字节输入流
FileInputStream BufferInputStream 的祖宗类InputStream

1）FileInputStream 文件字节输入流

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

public class FileInputStreamDemo01 {

    public static void main(String[] args) {
        try {
            //初始化程序到文件的通道
            //FileInputStream inputStream = new FileInputStream("D:\\test.txt");
            //第二种初始化方法，这种好些，可以判断文件是否存在且文件字节长度是否大于0，满足条件存在才建立连接
            File file = new File("D:\\inPut.txt");
            FileInputStream fileInputStream = new FileInputStream(file);
            //读取文件，用while判断文件是否已被读取完
            System.out.println(file.length());
            int cha = 0;
            while (-1 != (cha = fileInputStream.read())) {
                System.out.print((char) cha);
            }
            //关闭文件和程序之间的通道
            fileInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意：FileInputStream里面的read()方法只能一个个读取字节，读取中文就有问题

2)BufferedInputStream，字节缓冲输入流

读取更快，可以一次读取多个字节

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

public class BufferedInputStreamDemo04 {

    public static void main(String[] args) {
        try {
            //创建读取文件流
            InputStream ins = new FileInputStream("D:\\inPut.txt");
            BufferedInputStream bins = new BufferedInputStream(ins);

            //声明每次读取的字节数量
            byte[] read = new byte[1024];
            int len = 0;
            //每次读取固定的字节，最后一次读取可能读不满
            while (-1 != (len = bins.read(read))) {
                System.out.println(len);
            }

            //关闭文件读取流
            bins.close();
            ins.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字节输出流
FileOutputStream BufferOutputStream 的祖宗类OutputStream

1)FileOutputStream 文件字节输出流

import java.io.FileOutputStream;

public class FileOutputStreamDemo02 {

    public static void main(String[] args) {

        try {
            //声明要输入的内容
            String content = "yes,you are right!";
            //声明管道连接到盘符，这里的append，如果传true，那么就会把要写入盘符的内容拼在文件的最后面
            FileOutputStream fos = new FileOutputStream("D:\\outPut.txt", true);
            //获取字节数组
            byte[] tempBytes = content.getBytes();
            //写入盘符，如果文件不存在则会帮我们自动创建文件
            fos.write(tempBytes);
            //关闭输出流
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2)BufferedOutStream，字节缓冲输出流

输出更快，可以一次输出多个字节

import java.io.*;

public class BufferedOutputStreamDemo05 {

    public static void main(String[] args) {
        try {
            //创建文件读取输入流
            InputStream ins = new FileInputStream("D:\\inPut.txt");
            BufferedInputStream bins = new BufferedInputStream(ins);

            //创建文件输入流
            OutputStream outs = new FileOutputStream("D:\\copy2.txt");
            BufferedOutputStream bos = new BufferedOutputStream(outs);

            //设置每次读取的字节数量
            byte[] bytes = new byte[1024];
            int len = 0;
            //读取文件，持续写入
            while (-1 != (len = bins.read(bytes))) {
                bos.write(bytes, 0, len);
            }

            //关闭输入输出流
            bos.close();
            outs.close();
            bins.close();
            ins.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3)IO流实现复制

先读取再写入

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

public class FileCopyDemo03 {

    public static void main(String[] args) {

        try {
            //创建读取文件流
            FileInputStream fis = new FileInputStream("D:\\inPut.txt");
            //创建输出文件流
            FileOutputStream fos = new FileOutputStream("D:\\copy.txt");
            int ch = 0;
            //判断文件是否读取完毕
            while (-1 != (ch = fis.read())) {
                fos.write(ch);
            }
            //关闭文件输入输出流
            fos.close();
            fis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

2.字符流

读取纯文本文件比较方便，帮我们处理的中文乱码问题，按照字符读取文件

1)FileReader 字符输入流

import java.io.FileReader;

public class FileReaderDemo06 {

    public static void main(String[] args) {

        try {
            //创建字符读取流
            FileReader fr = new FileReader("D:\\China.txt");

            //设置每次读取的字符数量
            char[] chars = new char[1024];
            int len = 0;
            //读取文件
            while (-1 != (len = fr.read(chars))) {
                //char转String
                String str = new String(chars, 0, len);
                System.out.println("文件的内容为:" + str);
            }

            //关闭读取流
            fr.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2)FileWriter 字符输出流

import java.io.FileWriter;

public class FileWriterDemo07 {

    public static void main(String[] args) {
        try {
            //声明字符串
            String content = "    是的，我也爱她";
            //创建文件字符输出流，传true的时候，字符会拼接在原文件的最后
            FileWriter fwt = new FileWriter("D:\\copyChina.txt", true);
            //写入字符
            fwt.write(content);
            //关闭输出流
            fwt.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

如有错误，欢迎指正