File类，递归，字符集，IO流（字节流，字符流，缓冲流，转换流，转换流，序列化流，释放资源的方式）

于 2024-08-31 15:52:23 发布
阅读量568 收藏 10
点赞数 24
分类专栏： JavaSE基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Asiyaa/article/details/141505810
版权

目录

一、File类

File是java.io.包下的类， File类的对象，用于代表当前操作系统的文件（可以是文件、或文件夹）。
注意：File类只能对文件本身进行操作，不能读写文件里面存储的数据。

1.创建File类的对象

构造器说明
public File(String pathname)根据文件路径创建文件对象
public File(String parent, String child)根据父路径和子路径名字创建文件对象
public File(File parent, String child)根据父路径对应文件对象和子路径名字创建文件对象
File file = new File(“文件/文件夹/绝对路径/相对路径”);

注意

File对象既可以代表文件、也可以代表文件夹。

File封装的对象仅仅是一个路径名，这个路径可以是存在的，也允许是不存在的。

2.绝对路径、相对路径

绝对路径：从盘符开始
File file = new File(“D:\itheima\a.txt”);
相对路径：不带盘符，默认直接到当前工程下的目录寻找文件。
File file = new File(“模块名\a.txt**”);**

3.File提供的判断文件类型、获取文件信息功能

方法名称说明
public boolean exists()判断当前文件对象，对应的文件路径是否存在，存在返回true
public boolean isFile()判断当前文件对象指代的是否是文件，是文件返回true，反之。
public boolean isDirectory()判断当前文件对象指代的是否是文件夹，是文件夹返回true，反之。
public String getName()获取文件的名称（包含后缀）
public long length()获取文件的大小，返回字节个数
public long lastModified()获取文件的最后修改时间。
public String getPath()获取创建文件对象时，使用的路径
public String getAbsolutePath()获取绝对路径

4.File类创建文件的功能

方法名称说明
public boolean createNewFile()创建一个新的空的文件
public boolean mkdir()只能创建一级文件夹
public boolean mkdirs()可以创建多级文件夹

File类删除文件的功能

方法名称说明
public boolean delete()删除文件、空文件夹

注意：delete方法默认只能删除文件和空文件夹，删除后的文件不会进入回收站。

5.File类提供的遍历文件夹的功能

方法名称说明
public String[] list()获取当前目录下所有的"一级文件名称"到一个字符串数组中去返回。
public File[] listFiles()获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回（重点）

使用listFiles方法时的注意事项：

当主调是文件，或者路径不存在时，返回null
当主调是空文件夹时，返回一个长度为0的数组
当主调是一个有内容的文件夹时，将里面所有一级文件和文件夹的路径放在File数组中返回
当主调是一个文件夹，且里面有隐藏文件时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
当主调是一个文件夹，但是没有权限访问该文件夹时，返回null

二、递归

什么是方法递归
递归是一种算法，在程序设计语言中广泛应用。
从形式上说：方法调用自身的形式称为方法递归（ recursion）。

递归的形式
直接递归：方法自己调用自己。
间接递归：方法调用其他方法，其他方法又回调方法自己。

使用方法递归时需要注意的问题：
递归如果没有控制好终止，会出现递归死循环，导致栈内存溢出错误。

public class RecursionTest3 {
    public static void main(String[] args) throws Exception {
          searchFile(new File("D:/") , "QQ.exe");
    }

    /**
     * 去目录下搜索某个文件
     * @param dir  目录
     * @param fileName 要搜索的文件名称
     */
    public static void searchFile(File dir, String fileName) throws Exception {
        // 1、把非法的情况都拦截住
        if(dir == null || !dir.exists() || dir.isFile()){
            return; // 代表无法搜索
        }

        // 2、dir不是null,存在，一定是目录对象。
        // 获取当前目录下的全部一级文件对象。
        File[] files = dir.listFiles();

        // 3、判断当前目录下是否存在一级文件对象，以及是否可以拿到一级文件对象。
        if(files != null && files.length > 0){
            // 4、遍历全部一级文件对象。
            for (File f : files) {
                // 5、判断文件是否是文件,还是文件夹
                if(f.isFile()){
                    // 是文件，判断这个文件名是否是我们要找的
                    if(f.getName().contains(fileName)){
                        System.out.println("找到了：" + f.getAbsolutePath());
                        Runtime runtime = Runtime.getRuntime();
                        runtime.exec(f.getAbsolutePath());
                    }
                }else {
                    // 是文件夹，继续重复这个过程（递归）
                    searchFile(f, fileName);
                }
            }
        }
    }
}

三、字符集

1.编码,字符集
编码，为一个字符编一个二进制数据

  • 美国人把他们用到的字符和字符对应的编码总结成了一张码表，这张码表叫做ASCII码表（也叫ASCII字符集）。
  • 中国人为了在计算机中存储中文，也编了一个中国人用的字符集叫做GBK字符集，这里面包含2万多个汉字字符，GBK中一个汉字采用两个字节来存储，为了能够显示英文字母，GBK字符集也兼容了ASCII字符集，在GBK字符集中一个字母还是采用一个字节来存储。

2.汉字和字母的编码
特点：

  • 如果是存储字母，采用1个字节来存储，一共8位，其中第1位是0
  • 如果是存储汉字，采用2个字节来存储，一共16位，其中第1位是1

当读取文件中的字符时，通过识别读取到的第1位是0还是1来判断是字母还是汉字

  • 如果读取到第1位是0，就认为是一个字母，此时往后读1个字节。
  • 如果读取到第1位是1，就认为是一个汉字，此时往后读2个字节。

3.Unicode字符集
为了解决各个国家字符集互不兼容的问题，由国际化标准组织牵头，设计了一套全世界通用的字符集，叫做Unicode字符集。在Unicode字符集中包含了世界上所有国家的文字，一个字符采用4个字节存储。
Unicode字符集中的字符进行了重新编码，一共设计了三种编码方案。分别是UTF-32、UTF-16、UTF-8; 其中比较常用的编码方案是UTF-8

UTF-8这种编码方案的特点

1.UTF-8是一种可变长的编码方案，分为4个长度区
2.英文字母、数字占1个字节兼容(ASCII编码)
3.汉字字符占3个字节
4.极少数字符占4个字节

4.编码和解码

  • 编码：把字符串按照指定的字符集转换为字节数组
String提供了如下方法说明
byte[] getBytes()使用平台的默认字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
byte[] getBytes(String charsetName)使用指定的字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
  • 解码：把字节数组按照指定的字符集转换为字符串
String提供了如下方法说明
String(byte[] bytes)通过使用平台的默认字符集解码指定的字节数组来构造新的 String
String(byte[] bytes, String charsetName)通过指定的字符集解码指定的字节数组来构造新的 String
// 1、编码
String data = "a和b";
byte[] bytes = data.getBytes(); // 默认是按照平台字符集（UTF-8）进行编码的。
System.out.println(Arrays.toString(bytes));

// 按照指定字符集进行编码。
byte[] bytes1 = data.getBytes("GBK");
System.out.println(Arrays.toString(bytes1));

// 2、解码
String s1 = new String(bytes); // 按照平台默认编码（UTF-8）解码
System.out.println(s1);

String s2 = new String(bytes1, "GBK");
System.out.println(s2);

四、IO流

1.概述

IO流的作用：就是可以对文件或者网络中的数据进行读、写的操作。

“I” 指Input，称为输入流：负责把数据读到内存中

“O” 指Output，称为输出流：负责写数据出去

按照流的方向分为
在这里插入图片描述

按流中数据的最小单位
在这里插入图片描述
IO流分为：
1.字节流：字节流又分为字节输入流、字节输出流

字节输入流：以内存为基准，来自磁盘文件/网络中的数据以字节的形式读入到内存中去的流
字节输出流：以内存为基准，把内存中的数据以字节写出到磁盘文件或者网络中去的流。

2.字符流：字符流由分为字符输入流、字符输出流

字符输入流：以内存为基准，来自磁盘文件/网络中的数据以字符的形式读入到内存中去的流。
字符输出流：以内存为基准，把内存中的数据以字符写出到磁盘文件或者网络介质中去的流。

在这里插入图片描述

2.字节流

① FileInputStream
FileInputStream，每次读取一个字节
作用：以内存为基准，可以把磁盘文件中的数据以字节的形式读入到内存中去。

构造器说明
public FileInputStream(File file)创建字节输入流管道与源文件接通
public FileInputStream(String pathname)创建字节输入流管道与源文件接通
方法名称说明
public int read()每次读取一个字节返回，如果发现没有数据可读会返回-1.
public int read(byte[] buffer)每次用一个字节数组去读取数据，返回字节数组读取了多少个字节，
如果发现没有数据可读会返回-1.

使用FileInputStream读取文件中的字节数据，步骤如下

第一步：创建FileInputStream文件字节输入流管道，与源文件接通。
第二步：调用read()方法开始读取文件的字节数据。
第三步：调用close()方法释放资源

代码如下：

public class FileInputStreamTest1 {
    public static void main(String[] args) throws Exception {
        // 1、创建文件字节输入流管道，与源文件接通。
        InputStream is = new FileInputStream(("file-io-app\\src\\test01.txt"));

        // 2、开始读取文件的字节数据。
        // public int read():每次读取一个字节返回，如果没有数据了，返回-1.
        int b; // 用于记住读取的字节。
        while ((b = is.read()) != -1){
            System.out.print((char) b);
        }
        
        //3、流使用完毕之后，必须关闭！释放系统资源！
        is.close();
    }
}

FileInputStream，每次读取多个字节
作用：以内存为基准，把文件中的数据以字节的形式读入到内存中去。

public class FileInputStreamTest2 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个字节输入流对象代表字节输入流管道与源文件接通。
        InputStream is = new FileInputStream("file-io-app\\src\\test02.txt");

        // 2、开始读取文件中的字节数据：每次读取多个字节。
        //  public int read(byte b[]) throws IOException
        //  每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1.

        // 3、使用循环改造。
        byte[] buffer = new byte[3];
        int len; // 记住每次读取了多少个字节。  abc 66
        while ((len = is.read(buffer)) != -1){
            // 注意：读取多少，倒出多少。
            String rs = new String(buffer, 0 , len);
            System.out.print(rs);
        }
        // 性能得到了明显的提升！！
        // 这种方案也不能避免读取汉字输出乱码的问题！！

        is.close(); // 关闭流
    }
}

假设文件中的数据：abcde
第一次调用read(bytes)读取了3个字节(分别是97,98,99)，并且往数组中存，此时返回值就是3
第二次调用read(bytes)读取了2个字节(分别是99,100),并且往数组中存，此时返回值是2
第三次调用read(bytes)文件中后面已经没有数据了，此时返回值为-1

使用FileInputStream每次读取多个字节，读取性能得到了提升，但读取汉字输出还是会乱码。
定义一个与文件一样大的字节数组，一次性读取完文件的全部字节。

FileInputStream读取全部字节

方式一：自己定义一个字节数组与被读取的文件大小一样大，然后使用该字节数组，一次读完文件的全部字节。

方法名称说明
public int read(byte[] buffer)每次用一个字节数组去读取，返回字节数组读取了多少个字节，
如果发现没有数据可读会返回-1.
// 1、一次性读取完文件的全部字节到一个字节数组中去。
// 创建一个字节输入流管道与源文件接通
InputStream is = new FileInputStream("file-io-app\\src\\test03.txt");

// 2、准备一个字节数组，大小与文件的大小正好一样大。
File f = new File("file-io-app\\src\\itheima03.txt");
long size = f.length();
byte[] buffer = new byte[(int) size];

int len = is.read(buffer);
System.out.println(new String(buffer));

//3、关闭流
is.close();

方式二：Java官方为InputStream提供了如下方法，可以直接把文件的全部字节读取到一个字节数组中返回。

方法名称说明
public byte[] readAllBytes() throws IOException直接将当前字节输入流对应的文件对象的字节数据装到一个字节数组返回
// 1、一次性读取完文件的全部字节到一个字节数组中去。
// 创建一个字节输入流管道与源文件接通
InputStream is = new FileInputStream("file-io-app\\src\\itheima03.txt");

//2、调用方法读取所有字节，返回一个存储所有字节的字节数组。
byte[] buffer = is.readAllBytes();
System.out.println(new String(buffer));

//3、关闭流
is.close();

直接把文件数据全部读取到一个字节数组可以避免乱码，如果文件过大，创建的字节数组也会过大，可能引起内存溢出。

② FileOutputStream写字节
作用：以内存为基准，把内存中的数据以字节的形式写出到文件中去。

构造器说明
public FileOutputStream(File file)创建字节输出流管道与源文件对象接通
public FileOutputStream(String filepath)创建字节输出流管道与源文件路径接通
public FileOutputStream(File file，boolean append)创建字节输出流管道与源文件对象接通，可追加数据
public FileOutputStream(String filepath，boolean append)创建字节输出流管道与源文件路径接通，可追加数据
方法名称说明
public void write(int a)写一个字节出去
public void write(byte[] buffer)写一个字节数组出去
public void write(byte[] buffer , int pos , int len)写一个字节数组的一部分出去。
public void close() throws IOException关闭流。

使用FileOutputStream往文件中写数据的步骤如下：

第一步：创建FileOutputStream文件字节输出流管道，与目标文件接通。
第二步：调用wirte()方法往文件中写数据
第三步：调用close()方法释放资源

代码如下：

public class FileOutputStreamTest4 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个字节输出流管道与目标文件接通。
        // 覆盖管道：覆盖之前的数据
//        OutputStream os =
//                new FileOutputStream("file-io-app/src/test04out.txt");

        // 追加数据的管道
        OutputStream os =
                new FileOutputStream("file-io-app/src/itheima04out.txt", true);

        // 2、开始写字节数据出去了
        os.write(97); // 97就是一个字节，代表a
        os.write('b'); // 'b'也是一个字节
        // os.write('磊'); // [ooo] 默认只能写出去一个字节

        byte[] bytes = "我爱你中国abc".getBytes();
        os.write(bytes);

        os.write(bytes, 0, 15);

        // 换行符
        os.write("\r\n".getBytes());

        os.close(); // 关闭流
    }
}

3.字符流

① FileReader（文件字符输入流）

作用：以内存为基准，可以把文件中的数据以字符的形式读入到内存中去。

构造器说明
public FileReader(File file)创建字符输入流管道与源文件接通
public FileReader(String pathname)创建字符输入流管道与源文件接通
方法名称说明
public int read()每次读取一个字符返回，如果发现没有数据可读会返回-1.
public int read(char[] buffer)每次用一个字符数组去读取数据，返回字符数组读取了多少个字符，
如果发现没有数据可读会返回-1.

FileReader读取文件的步骤如下：

第一步：创建FileReader对象与要读取的源文件接通
第二步：调用read()方法读取文件中的字符
第三步：调用close()方法关闭流

public class FileReaderTest1 {
    public static void main(String[] args)  {
        try (
                // 1、创建一个文件字符输入流管道与源文件接通
                Reader fr = new FileReader("io-app2\\src\\test01.txt");
                ){
            // 2、一个字符一个字符的读（性能较差）
//            int c; // 记住每次读取的字符编号。
//            while ((c = fr.read()) != -1){
//                System.out.print((char) c);
//            }
            // 每次读取一个字符的形式，性能肯定是比较差的。

            // 3、每次读取多个字符。（性能是比较不错的！）
            char[] buffer = new char[3];
            int len; // 记住每次读取了多少个字符。
            while ((len = fr.read(buffer)) != -1){
                // 读取多少倒出多少
                System.out.print(new String(buffer, 0, len));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

② FileWriter(文件字符输出流)

作用：以内存为基准，把内存中的数据以字符的形式写出到文件中去。

构造器说明
public FileWriter(File file)创建字节输出流管道与源文件对象接通
public FileWriter(String filepath)创建字节输出流管道与源文件路径接通
public FileWriter(File file，boolean append)创建字节输出流管道与源文件对象接通，可追加数据
public FileWriter(String filepath，boolean append)创建字节输出流管道与源文件路径接通，可追加数据
方法名称说明
void write(int c)写一个字符
void write(String str)写一个字符串
void write(String str, int off, int len)写一个字符串的一部分
void write(char[] cbuf)写入一个字符数组
void write(char[] cbuf, int off, int len)写入字符数组的一部分

FileWriter往文件中写字符数据的步骤如下：

第一步：创建FileWirter对象与要读取的目标文件接通
第二步：调用write(字符数据/字符数组/字符串)方法读取文件中的字符
第三步：调用close()方法关闭流

public class FileWriterTest2 {
    public static void main(String[] args) {
        try (
                // 0、创建一个文件字符输出流管道与目标文件接通。
                // 覆盖管道
                // Writer fw = new FileWriter("io-app2/src/itheima02out.txt");
                // 追加数据的管道
                Writer fw = new FileWriter("io-app2/src/test02out.txt", true);
                ){
            // 1、public void write(int c):写一个字符出去
            fw.write('a');
            fw.write(97);
            //fw.write('磊'); // 写一个字符出去
            fw.write("\r\n"); // 换行

            // 2、public void write(String c)写一个字符串出去
            fw.write("我爱你中国abc");
            fw.write("\r\n");

            // 3、public void write(String c ,int pos ,int len):写字符串的一部分出去
            fw.write("我爱你中国abc", 0, 5);
            fw.write("\r\n");

            // 4、public void write(char[] buffer):写一个字符数组出去
            char[] buffer = {'晚', '上', 'a', 'b', 'c'};
            fw.write(buffer);
            fw.write("\r\n");

            // 5、public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
            fw.write(buffer, 0, 2);
            fw.write("\r\n");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字符输出流写出数据后，必须刷新流，或者关闭流，写出去的数据才能生效

方法名称说明
public void flush() throws IOException刷新流，就是将内存中缓存的数据立即写到文件中去生效！
public void close() throws IOException关闭流的操作，包含了刷新！
//1.创建FileWriter对象
Writer fw = new FileWriter("io-app2/src/itheima03out.txt");

//2.写字符数据出去
fw.write('a');

//3.关闭流
fw.close(); //会先刷新，再关流

字节流、字符流的使用场景小结：

字节流适合做一切文件数据的拷贝（音视频，文本）；字节流不适合读取中文内容输出。
字符流适合做文本文件的操作（读，写）。

4.缓冲流

在这里插入图片描述

  • 字节缓冲输入流：BufferedInputStream
  • 字节缓冲输出流：BufferedOutputStream
  • 字符缓冲输入流：BufferedReader
  • 字符缓冲输出流：BufferedWriter

缓冲流的作用：可以对原始流进行包装，提高原始流读写数据的性能。

  • 缓冲流的底层自己封装了一个长度为8KB（8129byte）的字节数组，但是缓冲流不能单独使用，它需要依赖于原始流。

① 缓冲字节流
读数据时：它先用原始字节输入流一次性读取8KB的数据存入缓冲流内部的数组中（ps: 先一次多囤点货），再从8KB的字节数组中读取一个字节或者多个字节（把消耗屯的货）。
写数据时：它是先把数据写到缓冲流内部的8BK的数组中（ps: 先攒一车货），等数组存满了，再通过原始的
字节输出流，一次性写到目标文件中去（把囤好的货，一次性运走）。

在创建缓冲字节流对象时，需要封装一个原始流对象进来。构造方法如下

构造器说明
public BufferedInputStream(InputStream is)把低级的字节输入流包装成一个高级的缓冲字节输入流，从而提高读数据的性能
public BufferedOutputStream(OutputStream os)把低级的字节输出流包装成一个高级的缓冲字节输出流，从而提高写数据的性能
public class BufferedInputStreamTest1 {
    public static void main(String[] args) {
        try (
                InputStream is = new FileInputStream("io-app2/src/test01.txt");
                // 1、定义一个字节缓冲输入流包装原始的字节输入流
                InputStream bis = new BufferedInputStream(is);

                OutputStream os = new FileOutputStream("io-app2/src/test01_bak.txt");
                // 2、定义一个字节缓冲输出流包装原始的字节输出流
                OutputStream bos = new BufferedOutputStream(os);
        ){

            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer, 0, len);
            }
            System.out.println("复制完成！！");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

② 字符缓冲流
BufferedReader(字符缓冲输入流)
作用：自带8K（8192）的字符缓冲池，可以提高字符输入流读取字符数据的性能。
BufferedReader读数据时：它先原始字符输入流一次性读取8KB的数据存入缓冲流内部的数组中，再从8KB的字符数组中读取一个字符或者多个字符。

构造器说明
public BufferedReader(Reader r)把低级的字符输入流包装成字符缓冲输入流管道，从而提高字符输入流读字符数据的性能

字符缓冲输入流新增的功能：按照行读取字符

方法说明
public String readLine()读取一行数据返回，如果没有数据可读了，会返回null
public class BufferedReaderTest2 {
    public static void main(String[] args)  {
        try (
                Reader fr = new FileReader("io-app2\\src\\test04.txt");
                // 创建一个字符缓冲输入流包装原始的字符输入流
                BufferedReader br = new BufferedReader(fr);
        ){
//            char[] buffer = new char[3];
//            int len;
//            while ((len = br.read(buffer)) != -1){
//                System.out.print(new String(buffer, 0, len));
//            }
//            System.out.println(br.readLine());

            String line; // 记住每次读取的一行数据
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

BufferedWriter(字符缓冲输出流)

作用：自带8K的字符缓冲池，可以提高字符输出流写字符数据的性能。

构造器说明
public BufferedWriter(Writer r)把低级的字符输出流包装成一个高级的缓冲字符输出流管道，
从而提高字符输出流写数据的性能

字符缓冲输出流新增的功能：换行

方法说明
public void newLine()换行
public class BufferedWriterTest3 {
    public static void main(String[] args) {
        try (
                Writer fw = new FileWriter("io-app2/src/test05out.txt", true);
                // 创建一个字符缓冲输出流管道包装原始的字符输出流
                BufferedWriter bw = new BufferedWriter(fw);
        ){

            bw.write('a');
            bw.write(97);
            bw.write('磊');
            bw.newLine();

            bw.write("我爱你中国abc");
            bw.newLine();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

建议使用字节缓冲输入流、字节缓冲输出流，结合字节数组的方式，目前来看是性能最优的组合。

5.转换流

FileReader默认只能读取UTF-8编码格式的文件。如果使用FileReader读取GBK格式的文件，可能存在乱码，因为FileReader它遇到汉字默认是按照3个字节来读取的，而GBK格式的文件一个汉字是占2个字节，这样就会导致乱码。
在这里插入图片描述
InputStreamReader（字符输入转换流）
解决不同编码时，字符流读取文本内容乱码的问题。
解决思路：先获取文件的原始字节流，再将其按真实的字符集编码转成字符输入流，这样字符输入流中的字符就不乱码了。
InputStreamReader也是不能单独使用的，它内部需要封装一个InputStream的子类对象，再指定一个编码表，如果不指定编码表，默认会按照UTF-8形式进行转换。

构造器说明
public InputStreamReader(InputStream is)把原始的字节输入流，按照代码默认编码转成字符输入流（与直接用FileReader的效果一样）
public InputStreamReader(InputStream is ，String charset)把原始的字节输入流，按照指定字符集编码转成字符输入流(重点)
public class InputStreamReaderTest2 {
    public static void main(String[] args) {
        try (
                // 1、得到文件的原始字节流（GBK的字节流形式）
                InputStream is = new FileInputStream("io-app2/src/test06.txt");
                // 2、把原始的字节输入流按照指定的字符集编码转换成字符输入流
                Reader isr = new InputStreamReader(is, "GBK");
                // 3、把字符输入流包装成缓冲字符输入流
                BufferedReader br = new BufferedReader(isr);
                ){
            String line;
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

OutputStreamWriter（字符输出转换流）
作用：可以控制写出去的字符使用什么字符集编码。
解决思路：获取字节输出流，再按照指定的字符集编码将其转换成字符输出流，以后写出去的字符就会用该字符集编码了。
OutputStreamReader也是不能单独使用的，它内部需要封装一个OutputStream的子类对象，再指定一个编码表，如果不指定编码表，默认会按照UTF-8形式进行转换。

构造器说明
public OutputStreamWriter(OutputStream os)可以把原始的字节输出流，按照代码默认编码转换成字符输出流。
public OutputStreamWriter(OutputStream os，String charset)可以把原始的字节输出流，按照指定编码转换成字符输出流(重点)
public class OutputStreamWriterTest3 {
    public static void main(String[] args) {
        // 指定写出去的字符编码。
        try (
                // 1、创建一个文件字节输出流
                OutputStream os = new FileOutputStream("io-app2/src/test.txt");
                // 2、把原始的字节输出流，按照指定的字符集编码转换成字符输出转换流。
                Writer osw = new OutputStreamWriter(os, "GBK");
                // 3、把字符输出流包装成缓冲字符输出流
                BufferedWriter bw = new BufferedWriter(osw);
                ){
            bw.write("我是中国人abc");
            bw.write("我爱你中国123");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

6.打印流

在这里插入图片描述PrintStream/PrintWriter（打印流）
作用：打印流可以实现更方便、更高效的打印数据出去，能实现打印啥出去就是啥出去。

① PrintStream提供的打印数据的方案

构造器说明
public PrintStream(OutputStream/File/String)打印流直接通向字节输出流/文件/文件路径
public PrintStream(String fileName, Charset charset)可以指定写出去的字符编码
public PrintStream(OutputStream out, boolean autoFlush)可以指定实现自动刷新
public PrintStream(OutputStream out, boolean autoFlush, String encoding)可以指定实现自动刷新，并可指定字符的编码
方法说明
public void println(Xxx xx)打印任意类型的数据出去
public void write(int/byte[]/byte[]一部分)可以支持写字节数据出去

② PrintWriter提供的打印数据的方案

构造器说明
public PrintWriter(OutputStream/Writer/File/String)打印流直接通向字节输出流/文件/文件路径
public PrintWriter(String fileName, Charset charset)可以指定写出去的字符编码
public PrintWriter(OutputStream out/Writer, boolean autoFlush)可以指定实现自动刷新
public PrintWriter(OutputStream out, boolean autoFlush, String encoding)可以指定实现自动刷新，并可指定字符的编码
方法说明
public void println**(**Xxx xx)打印任意类型的数据出去
public void write(int/String/char[]/…)可以支持写字符数据出去

PrintStream和PrintWriter的区别

打印数据的功能上是一模一样的：都是使用方便，性能高效（核心优势）
PrintStream继承自字节输出流OutputStream，因此支持写字节数据的方法。
PrintWriter继承自字符输出流Writer，因此支持写字符数据出去。

public class PrintTest1 {
    public static void main(String[] args) {
        try (
                // 1、创建一个打印流管道
//                PrintStream ps =
//                        new PrintStream("io-app2/src/itheima08.txt", Charset.forName("GBK"));
//                PrintStream ps =
//                        new PrintStream("io-app2/src/itheima08.txt");
                PrintWriter ps =
                        new PrintWriter(new FileOutputStream("io-app2/src/test.txt", true));
                ){
                ps.print(97);	//文件中显示的就是:97
                ps.print('a'); //文件中显示的就是:a
                ps.println("我爱你中国abc");	//文件中显示的就是:我爱你中国abc
                ps.println(true);//文件中显示的就是:true
                ps.println(99.5);//文件中显示的就是99.5

                ps.write(97); //文件中显示a，发现和前面println方法的区别了吗？

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

③ 重定向输出语句
System.out.println()，System里面有一个静态变量叫out，out的数据类型就是PrintStream，它就是一个打印流，而且这个打印流的默认输出目的地是控制台，所以我们调用System.out.pirnln()就可以往控制台打印输出任意类型的数据，而且打印啥就输出啥。

7.数据流

数据和数据的类型一并写到文件中去，读取的时候也将数据和数据类型一并读出来。
在这里插入图片描述
①DataOutputStream(数据输出流)
允许把数据和其类型一并写出去。
一种包装流，创建DataOutputStream对象时，底层需要依赖于一个原始的OutputStream流对象。然后调用它的wirteXxx方法，写的是特定类型的数据。

构造器说明
public DataOutputStream(OutputStream out)创建新数据输出流包装基础的字节输出流
方法说明
public final void writeByte(int v) throws IO将byte类型的数据写入基础的字节输出流
public final void writeInt(int v) throws IOException将int类型的数据写入基础的字节输出流
public final void writeDouble(Double v) throws IOException将double类型的数据写入基础的字节输出流
public final void writeUTF(String str) throws IOException将字符串数据以UTF-8编码成字节写入基础的字节输出流
public void write(int/byte[]/byte[]一部分)支持写字节数据出去
public class DataOutputStreamTest1 {
    public static void main(String[] args) {
        try (
                // 1、创建一个数据输出流包装低级的字节输出流
                DataOutputStream dos =
                        new DataOutputStream(new FileOutputStream("io-app2/src/teat10out.txt"));
                ){
            dos.writeInt(97);
            dos.writeDouble(99.5);
            dos.writeBoolean(true);
            dos.writeUTF("晚上一个饼666！");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

②DataInputStream(数据输入流)
用于读取数据输出流写出去的数据。
一种包装流，创建DataInputStream对象时，底层需要依赖于一个原始的InputStream流对象。然后调用它的readXxx()方法就可以读取特定类型的数据。

构造器说明
public DataInputStream**(**InputStream is)创建新数据输入流包装基础的字节输入流
方法说明
Public final byte readByte() throws IOException读取字节数据返回
public final int readInt() throws IOException读取int类型的数据返回
public final double readDouble() throws IOException读取double类型的数据返回
public final String read****UTF() throws IOException读取字符串数（UTF-8）据返回
public int readInt()/read(byte[])支持读字节数据进来
public class DataInputStreamTest2 {
    public static void main(String[] args) {
        try (
                DataInputStream dis =
                        new DataInputStream(new FileInputStream("io-app2/src/test10out.txt"));
                ){
            int i = dis.readInt();
            System.out.println(i);

            double d = dis.readDouble();
            System.out.println(d);

            boolean b = dis.readBoolean();
            System.out.println(b);

            String rs = dis.readUTF();
            System.out.println(rs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

8.序列化流

序列化：意思就是把对象写到文件或者网络中去。（写对象）
反序列化：意思就是把对象从文件或者网络中读取出来。（读对象）

在这里插入图片描述

① ObjectOutputStream(对象字节输出流)

可以把Java对象进行序列化：把Java对象存入到文件中去。

构造器说明
public ObjectOutputStream(OutputStream out)创建对象字节输出流，包装基础的字节输出流
方法说明
public final void writeObject(Object o) throws IOException把对象写出去

注意：对象如果要参与序列化，必须实现序列化接口（java.io.Serializable）

② ObjectInputStream(对象字节输入流)

可以把Java对象进行反序列化：把存储在文件中的Java对象读入到内存中来。

构造器说明
public ObjectInputStream(InputStream is)创建对象字节输入流，包装基础的字节输入流
方法说明
public final Object readObject()把存储在文件中的Java对象读出来

如果要一次序列化多个对象
用一个ArrayList集合存储多个对象，然后直接对集合进行序列化即可
注意：ArrayList集合已经实现了序列化接口！

ObjectOutputStream是一个包装流，不能单独使用，需要结合原始的字节输出流使用。
第一步：先准备一个User类，必须让其实现Serializable接口。

// 注意：对象如果需要序列化，必须实现序列化接口。
public class User implements Serializable {
    private String loginName;
    private String userName;
    private int age;
    // transient 这个成员变量将不参与序列化。
    private transient String passWord;

    public User() {
    }

    public User(String loginName, String userName, int age, String passWord) {
        this.loginName = loginName;
        this.userName = userName;
        this.age = age;
        this.passWord = passWord;
    }

    @Override
    public String toString() {
        return "User{" +
                "loginName='" + loginName + '\'' +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                ", passWord='" + passWord + '\'' +
                '}';
    }
}

第二步：再创建ObjectOutputStream流对象，调用writeObject方法对象到文件。

public class Test1ObjectOutputStream {
    public static void main(String[] args) {
        try (
                // 2、创建一个对象字节输出流包装原始的字节 输出流。
                ObjectOutputStream oos =
                        new ObjectOutputStream(new FileOutputStream("io-app2/src/test.txt"));
                ){
            // 1、创建一个Java对象。
            User u = new User("admin", "张三", 32, "666888xyz");

            // 3、序列化对象到文件中去
            oos.writeObject(u);
            System.out.println("序列化对象成功！！");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

第三步：文件中已经有一个User对象，现在要使用ObjectInputStream读取出来。称之为反序列化

public class Test2ObjectInputStream {
    public static void main(String[] args) {
        try (
            // 1、创建一个对象字节输入流管道，包装 低级的字节输入流与源文件接通
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("io-app2/src/test.txt"));
        ){
            User u = (User) ois.readObject();
            System.out.println(u);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

9.释放资源的方式

① try-catch-finally

try{
    //有可能产生异常的代码
}catch(异常类 e){
    //处理异常的代码
}finally{
    //释放资源的代码
    //finally里面的代码有一个特点，不管异常是否发生，finally里面的代码都会执行。
}

② finally代码区的特点：无论try中的程序是正常执行了，还是出现了异常，最后都一定会执行finally区，除非JVM终止。
作用：一般用于在程序执行完成后进行资源的释放操作。

try-with-resource

try(资源对象1; 资源对象2;){
    使用资源的代码
}catch(异常类 e){
    处理异常的代码
}

该资源使用完毕后，会自动调用其close()方法，完成对资源的释放！
() 中只能放置资源，否则报错
什么是资源呢？
资源一般指的是最终实现了AutoCloseable接口。

public abstract class InputStream implements Closeable{ }
public abstract class OutputStream implements Closeable, Flushable { }
public interface Closeable extends AutoCloseable { }

public class Test3 {
    public static void main(String[] args)  {
    	try (
          // 1、创建一个字节输入流管道与源文件接通
          InputStream is = new FileInputStream("D:/resource/meinv.png");
          // 2、创建一个字节输出流管道与目标文件接通。
          OutputStream os = new FileOutputStream("C:/data/meinv.png");
        ){
            // 3、创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024]; // 1KB.
            // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int len; // 记住每次读取了多少个字节。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
            System.out.println(conn);
            System.out.println("复制完成！！");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
晚上一个饼
关注
  • 24
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-13_File类与IO流
m0_62036548的博客
06-09 673
File类及各种流，都定义在java.io包下。一个File对象代表硬盘或网络中可能存在的一个文件或者文件目录（文件夹），与平台无关。File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。访问文件内容本身，需要使用输入/输出流。File对象可以作为参数传递给流的构造器。Java程序中表示一个真实存在的文件或目录，必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。
重学JavaSE 第15章 : File类、IO流介绍、文件流、缓冲流、转换流、对象流等
Guizy
08-03 1689
重温Java File类、IO流介绍、文件流、缓冲流、转换流、对象流等
【小白学Java】D31》》》IO流 之 缓冲流 & 转换流
北慕辰的博客，欢迎各位大佬光临！！
07-27 807
一、缓冲流缓冲流，也叫高效流，是对4个基本的（字节/字符）（输入/输出）流的增强，所以缓冲流也有4个流BufferedOutputStream字节缓冲输出流，BufferedIutputStream字节缓冲输入流，BufferedWriter:字符缓冲输出流，BufferedReader:字符缓冲输入流， 二、转换流，字符编码，字符集charset OutputStreamWriter InputStreamReader
java字节流和字符流操作文件，指定编码写入和读取，递归创建上层目录
liqi_q的博客
10-14 1万+
java的IO流分两种流  字节流 InputStream OutputStream  字符流 Reader Writer  他们都是抽象类  具体实现  字节流 FileInputStream FileOutputStream  字符流 FileReader FileWriter          字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符
Java从入门到精通(十五) ~ IO流
风止的博客
08-03 1330
当我们做java开发时，需要在内存，磁盘，网络中传输数据时，可能要一次性要传输的数据很大，而我们的内存空间有限，无法完成大文件的批量传输，这时候我们就可以使用IO流，IO流传输数据就是像流水一样缓缓的流动传输。IO流是用于处理设备之间的数据传输的机制，Java中的IO流主要分为两大类：输入流和输出流。输入流用于从源读取数据，输出流用于向目标写入数据。流的概念可以看作是数据在源和目标之间的传输管道，数据可以是字节或字符。输出流：以内存为基准，将内存中的数据以字节或者字符的形式写到磁盘或者网络中的流。
科普文：Java基础系列之【Java 流(Stream)、文件(File)和IO 】
为无为，事无事，味无味。
08-13 689
File类介绍它是文件和目录路径名的抽象表示文件和目录是可以通过File封装成对象的对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的方法名说明通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例从父路径名字符串和子路径名字符串创建新的 File实例从父抽象路径名和子路径名字符串创建新的 File实例File类的构造方法运行结果。
File类与IO流
xiao-啸
12-01 644
File类与IO流 分隔符 Demo01File类–(File类) package cn.xiaoge.day18.demo01; /* java.io.File类 文件和目录路径名的抽象表示形式. java把电脑中的文件和文件夹(目录)封装为了一个File类, 我们可以使用File类对文件和文件夹进行操作 我们可以使用File类的方法 创...
【小白学Java】D29》》》IO流 之 过滤器 & 字节流
北慕辰的博客，欢迎各位大佬光临！！
07-22 789
一、过滤器在java中，有两种过滤器分别是FileFilter接口和FileNameFilter接口。*FiLe类中有两个ListFiles( ) 重载的方法,这两个重载的方法的参数，传递的就是过滤器 .字节输出流 字节输入流 案例一、使用文件输入流，统计代码行数 案例二、使用字节流，实现文件复制
[Java笔记19] File类、字符集、IO流
皮卡丘在充电
12-09 1104
目录 File类 File类创建对象 File类的常用API 非规律化递归解决文件搜索 字符集 字符串常见的字符底层组成 字符集的编码、解码操作 IO流 IO流的分类 文件字节输入流：FileInputStream 文件字节输出流：FileOutputStream 文件拷贝 try-catch-finally 释放资源 文件字符输入流：FileReader 文件字符输出流：FileWriter 字节流和字符流的适用场景 视频教程传送门 ->https://www.b.
史上最骚最全最详细的IO流教程，小白都能看懂！
热门推荐
宜春
11-06 4万+
相信大家都能体会到，io流用到的地方很多，就比如上传下载，传输，设计模式等....基础打扎实了，才能玩更高端的。 在博主认为真正懂IO流的优秀程序员每次在使用IO流之前都会明确分析如下四点： > （1）明确要操作的数据是数据源还是数据目的(也就是要读还是要写) （2）明确要操作的设备上的数据是字节还是文本 （3）明确数据所在的具体设备 （4）明确是否需要额外功能（比如是否需要转换流、高效流等）
JAVA中的File类，文件流，字节流和字符流超级详解（1.8万字干货 ）
2302_79993788的博客
07-19 1097
File类的常用方法方法。
JAVA 22、23 测试方法(Junit的使用)，文件类，递归，IO流（字节流，字符流，缓冲流，对象流，随机访问文件流，打印流）
barcelona733的博客
08-11 520
一、测试方法
File类&字节流&字符流
qq_43448363的博客
08-03 875
1.File类 1.1File类概述和构造方法 File：它是文件和目录路径敌人抽象表示 文件和目录是可以通过File封装成对象的 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个个路径而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的。 方法名 说明 File(String pathname) 通过给定的路径名字符串转换为抽象路径名来创建新的File实例 File(String parent,String child) 从父
java中的IO流（字符流，字节流）及一些常见面试题
qingmenghan的博客
09-13 1144
目录 一.File类 1.1File类的概述与构造方法 1.1.1File类的介绍 1.1.2File类的构造方法 1.2File类的常用方法 1.2.1File类的创建功能 1.2.2File类的判断与获取功能 1.2.3File类的删除功能​ 1.2.4绝对路径与相对路径 1.3递归 1.3.1递归介绍 1.3.2递归的注意事项 1.3.3递归遍历目录 二 .IO流 2.1IO流概述和分类 2.1.1IO流介绍 2.1.2IO流的分类 2.1.3IO流的使用...
【Java学习】第28节：IO流 (缓冲流、转换流、打印流、打印流)&序列化
m0_46013789的博客
05-23 1056
Java是一种广泛使用的编程语言，由Sun Microsystems（现在是Oracle Corporation）首次推出。它是一种跨平台的编程语言，意味着您可以编写一次代码，然后在多个不同的计算机系统上运行，而无需对其进行修改。Java被广泛用于开发各种类型的应用程序，包括企业级应用、移动应用、Web应用、游戏等。
Java基础（6）- Java代码笔记3
最新发布
weixin_47062560的博客
08-30 491
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 6292
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 6664
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
操作系统原子操作
zzt_is_me的博客
08-28 4322
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值