Java常用工具_IO流

1. 异常

1.1 异常的概述

image.png

1.2 异常的处理方式

Java中异常的顶层父类是Throwable
finally中的语句一定会执行，即使catch中有return，finally里的代码也会执行，这就是加不加finally的区别。

image.png image.png

package cn.case5;

public class Test4 {
    public static void main(String[] args) throws Exception{
        try {
            show();
        } catch(Exception e) {
            System.out.println("hello");
        }
        System.out.println("看看我！");
//        show();
    }

    public static void show() throws Exception {
        int a = 10 / 0;
        System.out.println("a: " + a);
    }
}

2. IO流

IO流是Java中用来传输数据的方式

2.1 IO流的分类

按照流向分：输入流（读数据）、输出流（写数据）

---

按照操作分：
字节流（以字节为单位来操作数据）

• InputStream：字节输入流的顶层抽象类
  FileInputStream：普通的字节输入流
  BufferedInputStream：高效的字节输入流（也叫：字节缓冲输入流）
• OutputStream：字节输出流的顶层抽象类
  FileOutputStream：普通的字节输出流
  BufferedOutputStream：高效的字节输出流（也叫：字节缓冲输出流）

字符流：以字符为单位来操作数据

• Reader：字符输入流的顶层抽象类
  FileReader：普通的字符输入流
  BufferedReader：高效的字符输入流（也叫：字符缓冲输入流）
• Writer：字符输出流的顶层抽象类
  FileWriter：普通的字符输出流
  BufferedWriter：高效的字符输出流（也叫：字符缓冲输出流）

---

Reader和Writer，InputStream和OutputStream都是抽象类，常用的子类如下

image.png image.png

2.2 File类

学习File类的创建、判断和获取
创建：如果文件不存在，则创建并返回true，如果存在，则不创建返回false
mkdir只能创建单级目录，若要创建多级目录使用mkdirs，实际开发中，一般只使用mkdirs，它既可以创建多级目录也可以创建单级目录

image.png image.png

package cn.case5;

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

public class Test5 {
    public static void main(String[] args) throws IOException {
        // 方法1
        File file1 = new File("E:\\Download\\1.txt");
        System.out.println("file1: " + file1);
        // 方法2
        File file2 = new File("E:\\Download", "1.txt");
        System.out.println("file2: " + file2);
        // 方法3
        File file3 = new File("E:\\Download");
        File file4 = new File(file3, "1.txt");
        System.out.println("file4: " + file4);

        // 返回值如下：
        // file1: E:\Download\1.txt
        //file2: E:\Download\1.txt
        //file4: E:\Download\1.txt
        System.out.println("--------------------------------------");
        // 创建文件,Alt+Enter快捷键，添加抛异常
        File file5 = new File("E:\\Download\\2.txt");
        boolean flag1 = file5.createNewFile();
        System.out.println("flag1: " + flag1);
        // 创建文件夹
        File file6 = new File("E:\\Download\\a");
        boolean flag2 = file6.mkdir();
        System.out.println("flag2: " + flag2);
        // 创建多级文件夹s
        File file7 = new File("E:\\Download\\a\\b\\c");
        boolean flag3 = file7.mkdirs();
        System.out.println("flag3: " + flag3);
        System.out.println("--------------------------------------");
        // 2.判断功能
        System.out.println("file7是否是一个目录： " + file7.isDirectory());
        System.out.println("file7是否是一个文件： " + file7.isFile());
        System.out.println("file7是否存在： " + file7.exists());
        System.out.println("--------------------------------------");
        // 3. 获取功能
        File file8 = new File("lib/1.txt");
        System.out.println("绝对路径: " + file8.getAbsolutePath());
        System.out.println("相对路径: " + file8.getPath());
        System.out.println("文件名: " + file8.getName());
        File file9 = new File("lib");
        String[] names = file9.list();
        System.out.println("lib文件夹下的文件（文件夹）名：");
        for (String name : names) {
            System.out.println(name);
        }
        File[] files = file9.listFiles();
        System.out.println("lib文件夹下的文件（文件夹）对象：");
        for (File file : files) {
            System.out.println(file);
        }
    }
}

3. 字符流读写文件

3.1 读数据

步骤：创建字符输入流对象->读取数据->释放资源

image.png image.png

3.2 写数据

image.png image.png image.png

package cn.case5;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class Test6 {
    public static void main(String[] args) throws IOException {
        // 创建字符输入流对象,1.txt的内容是abc
        Reader reader = new FileReader("lib/1.txt");
        // 读取数据,read()方法返回字符的ASCII值，读不到返回-1
        int ch;
        while ((ch = reader.read()) != -1) {
            System.out.println(ch);
        }
        // 释放资源
        reader.close();
        System.out.println("----------------------------------");

        // 创建字符输入流对象,2.txt的内容是abcdefg
        Reader reader2 = new FileReader("lib/2.txt");
        // 定义字符数组
        char[] chs = new char[3]; // 一次读取3个字符
        int len; // 返回的有效长度
        while ((len = reader2.read(chs)) != -1) {
            String s = new String(chs, 0, len);
            System.out.println(s);
        }
        // 释放资源
        reader2.close();
        System.out.println("----------------------------------");

        Writer w = new FileWriter("lib/3.txt");
        // 第一种写法，一次写一个字符
//        w.write('好');
        // 第二种写法，一次写一个指定的字符数组
        char[] chs2 = {'h','e','l','l','o'};
//        w.write(chs2);
//        w.write(chs2, 1, 2); // 从索引为1的字符开始，长度为2
        // 第三种方法，一次写一个字符串
        w.write("hello world");
        w.close();
    }
}

3.3 字符流拷贝文件

字符缓冲流自带缓冲区，大小默认为8192个字节，也就是16K，内部使用的是字符数组的读取方法

package cn.case5;

import java.io.*;

public class Test7 {
    public static void main(String[] args) throws IOException {
        Reader reader1 = new FileReader("lib/2.txt");
        Writer writer1 = new FileWriter("lib/3.txt");
        int len;
        while ((len = reader1.read()) != -1) {
            writer1.write(len);
        }
        reader1.close();
        writer1.close();

        Reader reader2 = new FileReader("lib/2.txt");
        Writer writer2 = new FileWriter("lib/4.txt");
        char[] chs = new char[1024];
        int len2;
        while ((len2 = reader2.read(chs)) != -1) {
            writer2.write(chs, 0, len2);
        }
        reader2.close();
        writer2.close();

        BufferedReader br = new BufferedReader(new FileReader("lib/2.txt"));
        BufferedWriter wr = new BufferedWriter(new FileWriter("lib/5.txt"));
        // 字符缓冲流自带缓冲区，大小为8192个字节，也就是16K，内部使用的是字符数组的读取方法
        int len3;
        while ((len3 = br.read()) != -1) {
            wr.write(len3);
        }
        br.close();
        wr.close();

        // 字符缓冲流一次读写一行
        BufferedReader br2 = new BufferedReader(new FileReader("lib/2.txt"));
        BufferedWriter wr2 = new BufferedWriter(new FileWriter("lib/6.txt"));
        // 字符缓冲流自带缓冲区，大小为8192个字节，也就是16K，内部使用的是字符数组的读取方法
        String str2;
        while ((str2 = br2.readLine()) != null) {
            wr2.write(str2);
            // 一定记得换行
            wr2.newLine();   // 换行，兼容各个系统
        }
        br2.close();
        wr2.close();
    }
}

3.4 字节流拷贝文件

拷贝纯文本文件使用字符流，拷贝其他（图片，音频，视频等）使用字节流

package cn.case5;

import java.io.*;

public class Test8 {
    public static void main(String[] args) throws IOException {
        // 字节流读取，一次读取一个字节
//        FileInputStream fis = new FileInputStream("lib/1.jpg");
//        FileOutputStream fos = new FileOutputStream("lib/2.jpg");
//        int len;
//        while ((len = fis.read()) != -1) {
//            fos.write(len);
//        }
//        fis.close();
//        fos.close();

        // 按字节数组读取，比按照字节读取快得多
//        FileInputStream fis2 = new FileInputStream("lib/1.jpg");
//        FileOutputStream fos2 = new FileOutputStream("lib/3.jpg");
//        byte[] b = new byte[2048];
//        int len2;
//        while ((len2 = fis2.read(b)) != -1) {
//            fos2.write(b, 0, len2);
//        }
//        fis2.close();
//        fos2.close();

        // 按字节缓冲流读取
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("lib/1.jpg"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("lib/4.jpg"));
        int len3;
        while ((len3 = bis.read()) != -1) {
            bos.write(len3);
        }
        bis.close();
        bos.close();
    }
}