首页 > 其他分享 >File类，递归，字符集，IO流（字节流，字符流，缓冲流，转换流，转换流，序列化流，释放资源的方式）

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

时间：2024-09-01 22:50:41浏览次数：12  
标签：字符 读取 转换 String 文件 File 序列化 public 字节

目录

一、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();
        }
    }
}

标签：字符,读取,转换,String,文件,File,序列化,public,字节
From： https://blog.csdn.net/Asiyaa/article/details/141505810

相关文章

  • 【类型转换】使用c#实现简易的类型转换(Emit，Expression，反射)
    引言哈喽。大家好，好久不见，最近遇到了一个场景，就是在FrameWork的asp.netmvc中，有个系统里面使用的是EntityFramework的框架，在这个框架里，提供了一个SqlQuery的方法，这个方法很好用啊，以至于在EFCORE8里面又添加了回来，不过不知道性能怎么样，我遇到的场景是通过SqlQuery查询的......
  • C#自定义控件—转换开关
    C#用户控件之转换开关如何自定义一个转换键（Toggle）？三步绘制一个精美控件：定义属性；画布重绘；添加事件；主要技能：如何自定义属性；画布重绘的一般格式；控件的事件触发过程；技能扩展转换按钮使能时添加二次确认弹框？在From窗体中应用控件时，点击事件没有触发？属性名称在......
  • Linux项目自动化构建清理工具-make/Makefile如何实现编译代码
     目录1、make和makefile有什么用？2、如何使用这两个工具：2.1创建mekefile文件2.2输入make指令2.3输入makeclean指令3、makefile文件如何编译程序什么是依赖关系和依赖方法：TIP：4、make和makefile怎么知道可执行程序是比较新的呢？认识一下时间：（ACM）5、.PHONY修饰目标文件......
  • 华为笔试——整数与IP地址间的转换
    描述原理：ip地址的每段可以看成是一个0-255的整数，把每段拆分成一个二进制形式组合起来，然后把这个二进制数转变成一个长整数。举例：一个ip地址为10.0.3.193每段数字             相对应的二进制数10                   000010100     ......
  • [图文直播]基于ZFile和MinIO搭建私有网盘
    前言ZFile以下是ZFile的官网，上面也涉及到了搭建方法https://docs.zfile.vip/install/os-windows此次仅记录本人按照官方的部署方法进行实操验证。下载ibm-semeru-open-jdk_x64_windows_8u372b07_openj9-0.38.0.msizfile-release.jar具体下载地址见上面的官网安装......
  • C# split big file into small files as, and merge the small files into big one
    namespaceConsoleApp59{internalclassProgram{staticstringpath=System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);staticvoidMain(string[]args){stringfilePa......
  • [图文直播]搭建Zfile私有网盘
    特别提醒部署好后，发现还需要借助外部存储源，而且暂时还没有增加对FTP的支持，那就意味着即便我搭建私有FTP，也暂时无法实现真正的私有网盘。暂时不符合我的要求，仅记录。前言以下是ZFile的官网，上面也涉及到了搭建方法https://docs.zfile.vip/install/os-windows此次仅记录本人按照......
  • llamafile本地安装配置并部署及远程测试大语言模型详细实战教程
    ......
  • MySQL中日期和时间戳的转换：字符到DATE和TIMESTAMP的相互转换
    在MySQL中，经常需要在DATE、TIMESTAMP和字符串之间进行相互转换。以下是一些常见的转换方法：1.字符串到日期/时间类型字符串转DATE:使用STR_TO_DATE()函数将字符串转换为DATE类型。你需要提供字符串的格式。SELECTSTR_TO_DATE('2024-08-24','%Y-%m-%d')ASmy_......
  • 超长二进制利用Integer转换
    1.Integer缺点目前测试Integer只能一次性转4*7位二进制数，也就是7位16进制，故进行改进2.改进操作：每四位二进制一转换，以免到上限报错注解格式：序号（代码顺序）+解释publicclassMain{publicstaticvoidmain(String[]args){//1.测试文本：创建int数组放入16......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99