Java之IO流【个人笔记/已完结】

本文主要是介绍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流【个人笔记/已完结】的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

Java之IO流【个人笔记/已完结】

一、File

1.1 File 类概述和构造方法

1.2 File 类创建功能

1.3 File 类删除功能

1.4 File 类判断和获取功能

二、字节流

2.1 IO 流概述和分类

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

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

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

2.5 字节流复制文本文件

2.6 字节缓冲流

三、字符流

3.1 为什么会出现字符流

3.2 编码表

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

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

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

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

3.7 字符缓冲流

3.8 字符缓冲流特有功能

3.9 IO 流小结

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯