Java笔记：IO流（B站韩顺平）

创建文件

三种方式：

//1.
    @Test
    public void create01() {
        //文件路径
        String filePath = "e:/JavaFile/news1.txt";
        File file = new File(filePath);//创建对象

        try {
            //创建文件
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("文件创建成功!");
    }

//2.根据 父目录文件 + 子路径 构建
    @Test
    public void create02() {
        //父目录文件
        File parentFile = new File("e:\\JavaFile\\");
        //子路径
        String fileName = "news2.txt";
        //这里只是创建一个Java对象
        File file = new File(parentFile, fileName);

        try {
            //写入磁盘
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("文件创建成功！");
    }

//3.
    @Test
    public void create03() {
        String parentPath = "e:\\JavaFile\\";//父目录
        String fileName = "news3.txt";//子路径

        File file = new File(parentPath, fileName);//父目录 + 子路径

        try {
            //这里写入磁盘
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("文件创建成功！");
    }

获取文件相关信息：

    //获取文件的信息
    @Test
    public void info() {
        //先创建文件对象
        File file = new File("e:\\JavaFile\\news1.txt");

        //调用相应方法，得到对应信息
        System.out.println("文件名=" + file.getName());//文件名=news1.txt
        System.out.println("绝对路径=" + file.getAbsolutePath());//绝对路径=e:\JavaFile\news1.txt
        System.out.println("父目录=" + file.getParent());//父目录=e:\JavaFile
        System.out.println("文件大小（字节）=" + file.length());//文件大小（字节）=0
        System.out.println("文件是否存在=" + file.exists());//文件是否存在=true
        System.out.println("是不是一个文件=" + file.isFile());//是不是一个文件=true
        System.out.println("是不是一个目录=" + file.isDirectory());//是不是一个目录=false
    }

utf-8，一个字母一个字节，一个汉字三个字节

目录操作

删除文件：delete()

    //判断 e:\JavaFile\news1.txt 是否存在，存在则删除
    @Test
    public void m1() {
        String filePath = "e:\\JavaFile\\news1.txt";//路径
        File file = new File(filePath);//创建对象

        //判断文件是否存在
        if (file.exists()) { //判断是否存在，返回boolean
            //删除
            if (file.delete()) { //删除，返回boolean
                System.out.println("删除成功!");
            } else {
                System.out.println("删除失败!");
            }
        } else {
            System.out.println("该文件不存在!");
        }
    }

 删除目录：delete()

//判断目录是否存在，存在即删除
//Java编程中，目录也被当作文件
@Test
public void m2() {
    String filePath = "e:\\JavaFile\\demo02";//目录，也看作文件
    File file = new File(filePath);
    if (file.exists()) { //判断
        if (file.delete()) { //删除
            System.out.println("删除成功!");
        } else {
            System.out.println("删除失败!");
        }
    } else {
        System.out.println("该目录不存在!");
    }
}

 创建目录：mkdir(), mkdirs()

    //判断目录是否存在，不存在则创建
    @Test
    public void m3() {
        String directoryPath = "e:\\JavaFile\\demo\\a\\b\\c";//路径
        File file = new File(directoryPath);
        
        if (file.exists()) { //判断
            System.out.println("该目录存在！");
        } else {
            //创建一级目录 mkdir()
            //多级目录    mkdirs()
            if (file.mkdirs()) {//创建多级目录
                System.out.println("创建成功！");
            } else {
                System.out.println("创建失败！");
            }
        }
    }

IO流原理&流的分类

输入流 input：读取外部数据到程序（内存）中

输出流 output：将程序（内存）中的数据输出到外部

流的分类

按操作的数据单位分：字节流（8bit），字符流（按字符）

按数据流向分：输入流，输出流

按流的角色分：节点流，处理流 / 包装流

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

以上四个都是抽象类，其子类都以父类名称作为名称的后缀

文本文件最好用字符流

流和文件

举例：用户购买商品。

快递员是输入输出流，物品是文件中的数据

（感觉例子有点奇怪）

字节流

FileInputStream

常用子类：

 字节流读取文件：

    /**
     * 演示读取文件
     * 单个字节的读取，效率比较低
     */
    @Test
    public void readFile01() {
        //要读取的路径
        String filePath = "e:\\JavaFile\\hello.txt";
        //FileInputStream对象
        FileInputStream fileInputStream = null;
        int readData = 0;//读文件的返回结果

        try {
            //创建 FileInputStream 对象，用于读取 文件
            fileInputStream = new FileInputStream(filePath);

            //从该输入流读取 一个字节 的数据，如果没有输入可用，此方法将阻止
            //如果返回-1，表示读取完毕，到达文件的末尾
            while ((readData = fileInputStream.read()) != -1) {
                System.out.print((char) readData); //转成 char 显示
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流，释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

FileOutputStream

 写文件

    /**
     * 演示使用 FileOutputStream 将数据写到文件中
     * 如果文件不存在，则创建
     */
    @Test
    public void writeFile() {
        //创建对象
        FileOutputStream fileOutputStream = null;
        //文件路径
        String filePath = "e:\\JavaFile\\a.txt";

        try {
            //得到 FileOutputStream 对象
            //这种方式创建对象，是以覆盖的方式写文件
//            fileOutputStream = new FileOutputStream(filePath);
            //这种是追加内容
            fileOutputStream = new FileOutputStream(filePath, true);
            //写入 一个字节
            fileOutputStream.write('H');//char --> int
            //写入字符串（字节数组）
            String str = "hello,world!";
            //str.getBytes() 可以把字符串转成 字节数组
            fileOutputStream.write(str.getBytes());
            //字符串偏移量:从第几个位置开始，写几个（长度）
            fileOutputStream.write(str.getBytes(), 0, str.length());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

文件拷贝

    public static void main(String[] args) {
        //完成文件拷贝
        //E:\JavaFile\demo\xiongmaotou.jpg
        //e:\JavaFile\picture

        String srcFilePath = "E:\\JavaFile\\demo\\xiongmaotou.jpg";
        String destFilePath = "e:\\JavaFile\\picture\\xiongmaotou.jpg";
        FileInputStream fileInputStream = null;//文件输入流，读文件
        FileOutputStream fileOutputStream = null;//文件输出流，写文件

        try {
            fileInputStream = new FileInputStream(srcFilePath);
            fileOutputStream = new FileOutputStream(destFilePath);

            //定义一个字节数组，提高读取效率
            byte[] buf = new byte[1024];//1k
            //实际读取到的字节数
            int readLen = 0;

            while ((readLen = fileInputStream.read(buf)) != -1) {//读
                //读取到后就写入到文件，即边读边写
                //读多少写多少
                //用这种
                fileOutputStream.write(buf, 0, readLen);//写
//                //不要用这种，这样如果最后读到的字节不够1024个，会把byte默认的0写进去
//                fileOutputStream.write(buf);
            }
            System.out.println("拷贝成功");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭输入流和输出流，释放资源
            try {
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }