本文主要是介绍Java之IO流【个人笔记/已完结】，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

一、File

1.1 File 类概述和构造方法

File：它是文件和目录路径的抽象表示

• 文件和目录是可以通过 File 封装成对象的
• 其封装的并不是真正存在的文件，仅仅是个路径名。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转化为具体存在的。

import javax.imageio.stream.FileCacheImageOutputStream;
import java.io.File;

public class Main {
    public static void main(String[] args) {

        //将给定路径的名字字符串转换为抽象路径名来创建新的File实例
        File f1 = new File("C:\\WayToSuccess\\ItCast\\java.txt");
        System.out.println(f1); //C:\WayToSuccess\ItCast\java.txt   证明是抽象路径的表示形式，且重写了toString()方法

        //从父路径名字字符串和子路径名字字符串创建新的File实例
        File f2 = new File("C:\\WayToSuccess\\ItCast","java.txt");
        System.out.println(f2); //C:\WayToSuccess\ItCast\java.txt

        //从父路径和子路径名字符串创建新的File实例
        File f3 = new File("C:\\WayToSuccess\\ItCast");
        File f4 = new File(f3,"java.txt");
        System.out.println(f4); //C:\WayToSuccess\ItCast\java.txt
    }
}

1.2 File 类创建功能

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

public class Main {
    public static void main(String[] args) throws IOException {
        //在C:\WayToSuccess\ItCast目录下创建一个文件：java.txt
        File f1 = new File("C:\\WayToSuccess\\ItCast\\java.txt");
        System.out.println(f1.createNewFile()); //true

        //在C:\WayToSuccess\ItCast目录下创建一个目录JavaSE
        File f2 = new File("C:\\WayToSuccess\\ItCast\\JavaSE");
        System.out.println(f2.mkdir()); //true

        //在C:\WayToSuccess\ItCast目录下创建一个多级目录JavaWEB\\HTML
        File f3 = new File("C:\\WayToSuccess\\ItCast\\JavaWEB\\HTML");
        System.out.println(f3.mkdirs());    //true
    }
}

创建结果如下：

1.3 File 类删除功能

绝对路径：完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如：C:\WayToSuccess\ItCast
相对路径：必须使用取自其他路径名的信息进行解释。例如：WayToSuccess\ItCast

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

public class Main {
    public static void main(String[] args) throws IOException {
        //当前模块目录下创建java.txt文件
        File f1 = new File("FileIO\\java.txt");
        System.out.println(f1.createNewFile());

        //删除模块目录下java.txt文件
        System.out.println(f1.delete());

        //当前模块目录下创建ItCast目录
        File f2 = new File("FileIO\\ItCast");
        System.out.println(f2.mkdir());

        //删除模块目录下ItCast目录
        System.out.println(f2.delete());

        //当前模块目录下创建ItCast目录，然后在该目录下创建一个文件java.txt
        File f3 = new File("FileIO\\ItCast");
        System.out.println(f3.mkdir());
        File f4 = new File("FileIO\\ItCast\\java.txt");
        System.out.println(f4.createNewFile());

        //删除当前模块下的目录ItCast，必须一级一级删除
        System.out.println(f4.delete());
        System.out.println(f3.delete());
    }
}

1.4 File 类判断和获取功能

public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("FileIO\\java.txt");

        System.out.println(f1.isDirectory());   //判断是否是目录   false
        System.out.println(f1.isFile());    //判断是否是文件   true
        System.out.println(f1.exists());    //判断存在  true

        System.out.println(f1.getAbsolutePath());   //获取绝对路径    C:\WayToSuccess\File\FileIO\java.txt
        System.out.println(f1.getPath());   //获取相对路径    FileIO\java.txt
        System.out.println(f1.getName());   //获取文件名     java.txt

        File f2 = new File("C:\\WayToSuccess\\ItCast");

        //返回目录中所有的文件和目录
        String[] strArray = f2.list();
        for (String str : strArray){
            System.out.println(str);    //java.txt  JavaSE  JavaWEB
        }

        File[] fileArray = f2.listFiles();
        for (File file : fileArray){
            /*
            C:\WayToSuccess\ItCast\java.txt
            C:\WayToSuccess\ItCast\JavaSE
            C:\WayToSuccess\ItCast\JavaWEB
         */
            System.out.println(file);   //绝对路径  重写了toString方法
            System.out.println(file.getName()); //相对路径  java.txt  JavaSE  JavaWEB
        }
    }
}

我的文件列表：

二、字节流

2.1 IO 流概述和分类

IO 流概述：

• IO：输入/输出（Input/Output）
• 流：本质是数据传输
• IO 流就是用来处理设备间数据传输问题的

IO 流分类：
① 按照数据的流向

• 输入流：读数据
• 输出流：写数据

② 按照数据类型来分

• 字节流：字节输入流、字节输出流
• 字符流：字符输入流、字符输出流

这两种流在什么情况下使用：
用Windows自带的记事本软件打开，读得懂就用字符流，读不懂就用字节流。

2.2 字节流写数据（三种方法）

字节流抽象基类

• InputStream：这个抽象类时表示字节输入流的所有类的超类
• OutputStream：这个抽象类时表示字节输出流的所有类的超类

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class Main {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileOutputStream fos = new FileOutputStream("FileIO\\java.txt");

        //一次写一个字节的数据，写入的是 a（a的ASCII码为97）
        fos.write(97);  //a
        fos.write(98);  //b
        fos.write(99);  //c

        //写入字节数组
        byte[] bytes1 = {100,101,102};   //def
        fos.write(bytes1);

        //getBytes()：返回字符串对应的字节数组
        byte[] bytes2 = "qwert".getBytes();
        fos.write(bytes2);  //qwert

        //bytes3字节数组，从下标1开始，写3个字节
        byte[] bytes3 = "asdfg".getBytes();
        fos.write(bytes3,1,3);  //sdf

        //IO流必须关闭！释放与此流相关的任何系统资源
        fos.close();
    }
}

2.3 字节流输入换行与追加写入

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class Main {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象，有追加写入
        FileOutputStream fos = new FileOutputStream("FileIO\\java.txt",true);

        //写数据
        for (int i = 0; i < 10; i++) {
            fos.write("hello".getBytes());
            fos.write("\n".getBytes());
        }

        //追加写入，true表示允许追加写入到末尾，一刷新就会多写一遍在末尾
        FileOutputStream fos2 = new FileOutputStream("FileIO\\java.txt",true);
        for (int i = 0; i < 10; i++) {
            fos2.write("world".getBytes());
            fos2.write("\n".getBytes());
        }

        //释放资源
        fos.close();
        fos2.close();
    }
}

2.4 字节流读数据（一次读一个字节）

把文件中的数据读取在控制台输出。
注意字符类型的转换！

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("FileIO\\java.txt");

        //调用字节输入流的读取方法
        int by;
        while ( (by=fis.read()) != -1){
            System.out.print((char) by);    //不强制类型转换的话，会输出97 98 99 100 101
        }

        //释放资源
        fis.close();
    }
}

输出结果：

abcde

文本文件内容：

2.5 字节流复制文本文件

思路：把文件中的内容读出来（数据源），再写入新文件（目的地）。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        //创建文件输入流对象
        FileInputStream fis = new FileInputStream("FileIO\\java.txt");

        //c创建文件输出流对象
        FileOutputStream fos = new FileOutputStream("FileIO\\Output.txt");

        //读写数据（一次只读一个，一次只写一个
        int by;
        while ((by = fis.read()) != -1){
            fos.write(by);
        }

        //释放资源
        fis.close();
        fos.close();
    }
}

java.txt（源文件）：

Output.txt（目标文件）：

2.6 字节缓冲流

字节缓冲流：

• BufferedOutputStream：该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每一个字节导致底层系统的调用。
• BufferedInputStream：创建一个内部缓冲区。当从六中读取或跳过字节是，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多个字节。

为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？

• 字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作。

写数据：

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        //创建文件输出流对象
        FileOutputStream fos = new FileOutputStream("FileIO\\bos.txt");
        //创建字节缓冲输出流对象
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //写数据
        bos.write("Hello\n\r".getBytes());
        bos.write("World\n\r".getBytes());
        //释放资源
        bos.close();
    }
}

读数据（一次只读一个字节、一次读一个字符型数组两种方式）：

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        //创建文件输入流对象（合并）
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("FileIO\\bos.txt"));
        //一次读一个字节
        int by;
        while ( (by=bis.read()) != -1 ){
            System.out.print((char) by);
        }
        
        //一次读一个数组
        byte[] bytes = new byte[1024];
        int len;
        while ((len=bis.read(bytes)) != -1){
            System.out.print(new String(bytes,0,len));
        }
        //释放资源
        bis.close();
    }
}

三、字符流

3.1 为什么会出现字符流

• 字符流 = 字节流 + 编码表

汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数，所以底层操作能识别中文汉字！

3.2 编码表

按照某种规则，将字符存储到计算机中，称为编码；将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。

重点：GBK、UTF-8

小结：采用何种规则编码，就要采用对应规则解码，否则会出现乱码！！！

3.3 字符串中的编码解码问题

import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String str = "中国";

        //编码
        byte[] bys1 = str.getBytes();
        System.out.println(Arrays.toString(bys1));   //[-28, -72, -83, -27, -101, -67]  三个字节表示一个汉字，这里默认为utf-8

        //指定编码
        byte[] bys2 = str.getBytes("GBK");
        System.out.println(Arrays.toString(bys2));  //[-42, -48, -71, -6]

        //解码
        String ss = new String(bys1,"UTF-8");
        System.out.println(ss); //中国
    }
}

3.4 字符流中的编码解码问题

字符流中和编码解码相关的两个类：

• InputStreamReader
• OutputStreamWriter

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        //写入
        FileOutputStream fos = new FileOutputStream("FileIO\\osw.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
        osw.write("中国");
        osw.close();

        //读取
        FileInputStream fis = new FileInputStream("FileIO\\osw.txt");
        InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
        //一次读一个字符数据
        int ch;
        while ((ch=isr.read()) != -1){
            System.out.print((char) ch);    //中国
        }
    }
}

3.5 字符流写数据的五种方式

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class Main {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("FileIO\\CharStream"));
        //写一个字符
        osw.write(97);  //a
        //刷新
        osw.flush();
        //再写一个字符
        osw.write(98);  //b

        //写一个字符数组
        char[] chs = {'a','b','c','d','e'};
        osw.write(chs); //abcde

        //写一个数组的一部分
        osw.write(chs,1,3); //bcd

        //写一个字符串
        osw.write("abcde"); //abcde

        //写一个字符串的一部分
        osw.write("abcde",1,3); //bcd

        //释放资源
        osw.close();
    }
}

3.6 字符流读数据的两种方式

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("FileIO\\bos.txt"));

        //一次读一个字符数据
        int ch1;
        while ((ch1 = isr.read()) != -1){
            System.out.print((char) ch1);
        }

        //一次读一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1){
            System.out.println(new String(chs,0,len));
        }

        //释放资源
        isr.close();
    }
}

3.7 字符缓冲流

字符缓冲流：

• BufferedWriter：将文本写入字符输出流，缓冲字符，一提供单个字符、数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。
• BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符、数组和行的高效读取，可以指定缓冲区的大小，或者可以使用默认大小。

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        //字符缓冲输入流
        BufferedWriter bw = new BufferedWriter(new FileWriter("FileIO\\CharStream.txt"));
        bw.write("Hello\r\n");
        bw.write("World\r\n");
        bw.close();

        //字符缓冲输出流
        BufferedReader br = new BufferedReader(new FileReader("FileIO\\CharStream.txt"));
        //一次读一个字符数据
        int ch;
        while ((ch = br.read()) != -1){
            System.out.print((char) ch);
        }
        //一次读一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = br.read(chs)) != -1){
            System.out.print(new String(chs,0,len));
        }
        br.close();
    }
}

3.8 字符缓冲流特有功能

BufferedWriter：

• void newLine()：写一行行分隔符，行分隔符字符串由系统属性定义。
  BufferedReader：
• public String readLine()：读一行文字。结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为 null。

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("FileIO\\CharStream.txt"));

        //写数据
        for (int i = 0; i < 10; i++) {
            bw.write("Hello" + i);
            bw.newLine();   //自定义换行
            bw.flush(); //刷新
        }

        //释放资源
        bw.close();

        //创建字符缓冲输入流
        BufferedReader br = new BufferedReader(new FileReader("FileIO\\CharStream.txt"));

        //读取数据
        String line;
        while ((line=br.readLine()) != null){
            System.out.println(line);	//只读内容，不读换行符号
        }

        //释放资源
        br.close();
    }
}

3.9 IO 流小结

图 from 黑马程序员


后记：
这周有些怠惰了，学习速度慢了许多。下周不会了！继续努力！

这篇关于Java之IO流【个人笔记/已完结】的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！