JavaSE（十）

tsyjjOvO

879人浏览 · 2026-01-26 08:32:26

tsyjjOvO · 2026-01-26 08:32:26 发布

IO流

1、File类

1.1 File类概述

File类（全限定名：java.io.File）是 Java IO 体系中用于表示文件或目录路径的核心类，File类可以创建、删除目录或文件，判断某个目录或文件是否存在，但不能读写文件的内容

1.2 相对路径和绝对路径

绝对：包含盘符在内的完整路径，如：E:/io/java.txt
相对：相对于项目根目录的路径，如：io/file

1.3 案例

package com.hg.IO;

import java.io.File;

public class FileConstructorTest {
    public static void main(String[] args) {
        System.out.println("=================File类的构造方法==================");
        File f1 = new File("D:\\IdeaProjects\\javase\\10_IO\\sb.txt");//绝对路径
        System.out.println(f1.getAbsolutePath());

        File f2 = new File("10_IO/sb.txt"); //相对路径
        System.out.println(f2.getAbsolutePath());

        File f3 = new File("D:\\IdeaProjects\\javase\\10_IO\\", "sb.txt");
        System.out.println(f3.getAbsolutePath());

        File f4 = new File(new File("D:\\IdeaProjects\\javase\\10_IO\\"), "sb.txt");
        System.out.println(f4.getAbsolutePath());
    }
}

1.4 创建、判断、获取和删除功能

package com.hg.IO;

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

public class FileMethodTest {
    public static void main(String[] args) throws IOException {
        System.out.println("==================创建目录===================");
        File file1 = new File("io/myFile");
        System.out.println(file1.mkdirs());

        System.out.println("==================创建文件===================");
        File file2 = new File("io/myFile/sb.txt");
        System.out.println(file1.createNewFile());

        System.out.println("====================判断功能====================");
        System.out.println("是否是目录：" + file1.isDirectory());
        System.out.println("是否是文件：" + file2.isFile());
        System.out.println("是否存在：" + file1.exists());

        System.out.println("====================获取功能====================");
        System.out.println("绝对路径：" + file2.getAbsolutePath());
        System.out.println("相对路径：" + file2.getPath());
        System.out.println("文件大小：" + file2.length());
        System.out.println("文件名：" + file2.getName());
        File[] files = new File("D:\\IdeaProjects\\javase").listFiles();
        for (File file : files) {
            if (file.isFile()){
                System.out.println(file.getAbsolutePath() + "-----" + file.length());
            }else {
                System.out.println(file.getAbsolutePath());
            }
        }

        System.out.println("====================删除功能======================");
        System.out.println("删除文件：" + new File("io/myFile/sb.txt").delete());
        System.out.println("删除文件：" + new File("io/myFile").delete());
        System.out.println("删除文件：" + new File("io").delete());
    }
}

2、IO流

2.1 IO流概述

I/O流：是input output stream的缩写，是程序与文件交互的桥梁，用于读/写文件

注意：输入与输出是相对于应用程序而言的，比如文件读写，读取文件是输入流，写文件是输出流

2.2 IO流的分类

        IO流的分类：
        1、根据处理的数据类型不同可以分为：字符流和字节流。
        2、根据数据的流向不同可以分为：输入流和输出流。

2.3 IO流的体系结构

3、字节流

3.1 字节流概述

字节流（Byte Stream）是 Java I/O 中最基本的数据流，以字节（8位）为单位进行读写操作。它直接处理原始的二进制数据，适用于所有类型的数据（如图片、音频、视频等非文本文件）。

3.2 FileOutputStream

package com.hg.IOStream;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class FileOutPutStreamTest {
    public static void main(String[] args) throws IOException {
        File file = new File("io/byteStream.txt");
        if (!file.exists()){
            file.getParentFile().mkdirs();
            file.createNewFile();
        }
        //字节输出流
        OutputStream os = new FileOutputStream(file);
        os.write("hello,sister!!!".getBytes());
        os.flush(); //清空缓存
        os.close();
    }
}

3.3 FileInputStream

package com.hg.IOStream;

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

public class FileInPutStreamTest {
    public static void main(String[] args) throws IOException {
        FileInputStream is = new FileInputStream("io/byteStream.txt");
        int res;
        while ((res = is.read()) != -1){
            //一个英文字母占一个字节（byte），即8个2进制（bit）
            System.out.println((char) res);
        }
    }
}

4、字符流

4.1 字符流概述

字符流（Character Stream）是Java对字节流的高层封装，以字符（char,1char=2字节）为单位读写数据，主要用于处理文本数据且自动处理字符编码（如UTF-8、GBK）。

注意：一个汉字占2个字节，一个英文字符占1个字节。

4.2 FileReader

package com.hg.Reader_Writer;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class FileReaderTest {
    public static void main(String[] args) throws IOException {
        Reader r = new FileReader("io/charStream.txt");
        //int res = r.read();
        //System.out.println((char) res);//int-->Unicode
        int res;
        while ((res = r.read()) != -1){
            System.out.println(res + "-->" + (char) res);
        }
    }
}

4.3 FileWriter

package com.hg.Reader_Writer;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class FileWriterTest {
    public static void main(String[] args) throws IOException {
        File file = new File("io/charStream.txt");
        if (!file.getParentFile().exists()){
            file.getParentFile().mkdirs();
            file.createNewFile();
        }
        Writer w = new FileWriter(file);
        w.write("哈喽师姐！！");
        w.flush();
        w.close();
    }
}

5、缓冲流

5.1为什么要使用缓冲流？

BufferedInputStream是字节输入流的缓冲包装类，它会在内存中创建一个缓冲区（默认8192字节），一次性从文件读取多字节数据到缓冲区，后续读取直接从缓冲区获取，避免频繁的磁盘IO操作，大幅提升读取效率。

BufferedOutputStream是字节输出流的缓冲包装类，它会在内存中创建缓冲区（默认8192字节），数据先写入缓冲区，只有当缓冲区满、手动刷新（flush()）或关闭流（close()）时，才会一次性将缓冲区数据写入目标（如文件），避免频繁的磁盘IO操作，大幅提升写入效率。

5.2 BufferedOutputStream

package com.hg.BufferStream;

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

public class BufferedOutputStreamTest {
    public static void main(String[] args) throws IOException {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io/bufferedStream.txt"));
        bos.write("hello BufferedOutputStream".getBytes());
        bos.flush();
        bos.close();
    }
}

5.3 BufferedInputStream

package com.hg.BufferStream;

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

public class BufferedInputStreamTest {
    public static void main(String[] args) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("io/bufferedStream.txt"));
        int res;
        while ((res = bis.read()) != -1){
            System.out.print((char) res);
        }
    }
}

5.4 BufferedReader

package com.hg.Reader_Writer;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderTest {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("io/bufferedCharStream.txt"));
        String res = null;
        while ((res = br.readLine()) != null){
            System.out.println(res);
        }
    }
}

5.5 BufferedWriter

package com.hg.Reader_Writer;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterTest {
    public static void main(String[] args) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter("io/bufferedCharStream.txt"));
        bw.write("师姐你好！！！\n可以加个weChat吗？");
        bw.flush();
        bw.close();
    }
}

6、转换流

字符流无法指定编码格式，转换流将字节流按照指定字符编码进行转换的操作，例如我们需要将字符数据写入到文件中，并且希望以特定的编码格式（如GBK）保存文件

6.1 OutputStreamWriter

是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节

package com.hg.ByteCharStream;

import java.io.*;
import java.nio.charset.StandardCharsets;

public class OutputStreamWriterTest {
    public static void main(String[] args) throws IOException {
        //字符-----(ISO-8859-1)---------->字节
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:/b.txt"), StandardCharsets.ISO_8859_1));
        bw.write("哈哈哈");
        bw.close();
    }
}

6.2 InputStreamReader

是从字节流到字符流的桥梁，它读取字节，并使用指定的编码将其解码为字符

package com.hg.ByteCharStream;

import java.io.*;

public class InputStreamReaderTest {
    public static void main(String[] args) throws IOException {
        //字节---（GBK）-->字符
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("D:/a.txt"), "GBK"));
        String res;
        while ((res = br.readLine()) != null){
            System.out.println(res);
        }
        br.close(); //关闭最外层流即可
    }
}

7、对象流

7.1概述

对象序列化是将对象转换为可以存储的字节的过程

7.2 ObjectOutputStream

package com.hg.ObjectStream;

import java.io.*;

public class ObjectOutputStreamTest {
    public static void main(String[] args) throws IOException {
        Student student = new Student("叶瞬光", 18);

        ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("io/objectStream.txt")));
        oos.writeObject(student);
        oos.close();
    }
}

class Student implements Serializable{
    private String name;
    private transient Integer age; //transient：暂时的，age不进行序列化

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

7.3 ObjectInputStream

package com.hg.ObjectStream;

import java.io.*;

public class ObjectInputStreamTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("io/objectStream.txt")));
        Student student = (Student) ois.readObject();
        System.out.println(student);
    }
}

7.4 serialVersionUID

serialVersionUID是Java中用于实现序列化和反序列化操作的一个版本标识符。
1.由编译器自动生成(建议)：
如果你没有显式定义serialVersionUID，编译器将根据类的某些特征自动生成它，包括：类名、方法名、字段。
2.手动指定：
你可以通过在类中添加一个private static final long serialVersionUID=...声明来手动指定serialVersionUID。