14.JavaSE-IOStream

\光辉岁月/2026-10-16 11:32

文件相关概念

文件

对我们并不陌生,文件是保存数据的地方,比如大家经常使用的word文档,txt文件,excel文件...都是文件。它既可以保存一张图片,也可以保持视频,声音....

文件流

文件在程序中是以流的形式来操作的。

流: 数据在数据源(文件)和程序(内存)之间经历的路径，这里以内存为相对位置，有以下两种：

输入流: 数据从数据源(文件)到程序(内存)的路径

输出流: 数据从程序(内存)到数据源(文件)的路径

常用的文件操作

创建文件相关方法

构造器

new File(String pathname) //根据路径构建一个File对象

new File(File parent,String child) //根据父文件路径对象+子路径构建

new File(String parent,String child) //根据父路径+子路径构建

通过createNewFile方法创建

java 复制代码 
@Test
public void createFile1(){
    String filePath = "f:\\1.txt";
    File file = new File(filePath); //内存中创建对象
    try {
        file.createNewFile(); //在磁盘中创建文件
        System.out.println("文件创建成功!");
    } catch (IOException e) {
        e.printStackTrace();
    }
}
@Test
public void createFile2(){
    File parentFile = new File("f:\\");
    File file = new File(parentFile, "2.txt");
    try {
        file.createNewFile();
        System.out.println("文件创建成功");
    } catch (IOException e) {
        e.printStackTrace();
    }
}
@Test
public void createFile3(){
    File file = new File("f:\\", "3.txt");
    try {
        file.createNewFile();
        System.out.println("文件创建成功");
    } catch (IOException e) {
        e.printStackTrace();
    }
}
常用文件操作

getName、getAbsolutePath、getParent、length、exists、isFile、isDirectory

java 复制代码 
@Test
public void info() throws IOException{
    File f1 = new File("D:\\Program Files\\Git");
    System.out.println("绝对路径："+f1.getAbsolutePath());
    File f2 = new File("git-cmd.exe");
    System.out.println("f2的绝对路径：" + f2.getAbsolutePath());
    File f3 = new File(f1, "git-cmd.exe");
    System.out.println("f3的绝路径" + f3.getAbsolutePath());
    //常用方法
    System.out.println("当前文件是"+f3);
    System.out.println("文件是否存在" + f3.exists());
    System.out.println("是否是文件夹"+f3.isDirectory());
    System.out.println("是否是文件"+f3.isFile());
    System.out.println("文件的长度" + f3.length());
    long time = f3.lastModified();
    Date d = new Date(time);
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    System.out.println("文件最后修改时间：" + sdf.format(d));
    //常用方法2
    // 以字符串数组的形式，返回当前文件夹下的所有文件（不包含子文件及子文件夹）
    String[] list = f1.list();
    System.out.println(Arrays.toString(list));
    // 以文件数组的形式，返回当前文件夹下的所有文件（不包含子文件及子文件夹）
    File[] files = f1.listFiles();
    System.out.println(Arrays.toString(files));
    // 以字符串形式返回获取所在文件夹
    System.out.println(f1.getParent());
    // 以文件形式返回获取所在文件夹
    System.out.println(f1.getParentFile());
    // 创建文件夹，如果父文件夹skin不存在，创建就无效
    f1.mkdir();
    // 创建文件夹，如果父文件夹skin不存在，就会创建父文件夹
    f1.mkdirs();
    // 创建一个空文件,如果父文件夹skin不存在，就会抛出异常
    f1.createNewFile();
    // 所以创建一个空文件之前，通常都会创建父目录
    f1.getParentFile().mkdirs();
    // 列出所有的盘符c: d: e: 等等
    System.out.println(Arrays.toString(File.listRoots()));
}

目录操作

在java中，目录其实就是一种特殊的文件 ，所以上示例中目录的方法都是以文件对象操作的。

mkdir 创建一级目录

mkdirs 创建多级目录

delete 删除空目录(目录里面有文件，得先删除文件)或文件

现代 Java 更推荐：

java 复制代码 
Files.readAllBytes(path);
Files.write(path, bytes);
Files.copy(src, dest, StandardCopyOption.REPLACE_EXISTING);
Files.newBufferedReader(path, StandardCharsets.UTF_8);
Files.newBufferedWriter(path, StandardCharsets.UTF_8);
Files.walk(path);
Files.deleteIfExists(path);

IO流原理及分类

IO流原理

I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理数据传输。如读/写文件，网络通讯等。Java程序中，对于数据的输入/输出操作以"流(stream)"的方式进行。java.io包下提供了各种"流"类和接口，用以获取不同种类的数据,并通过方法输入或输出数据。

  • 输入input: 读取外部数据(磁盘、光盘等存储设备的数据)到程序(内存)中。
  • 输出output: 将程序(内存)数据输出到磁盘、光盘等存储设备中
流的分类

按处理数据单位 不同分为：字节流(8 bit)二进制文件，字符流(按字符)文本文件。

按数据流的流向不同分为：输入流、输出流

按流的角色的不同分为：节点流，处理流/包装流

以上四个类均为抽象类，需要子类继承实现。

try-with-resources

只要资源是在 try (...) 的括号里声明的，并且实现了 AutoCloseable 或 Closeable，try-with-resources 就会在 try 块结束时自动调用它的 close() 方法。

Java 7 引入的 try-with-resources 本质上会被编译器展开成类似这样的结构：

java 复制代码 
try {
    // 使用资源
} finally {
    if (resource != null) {
        resource.close();
    }
}

关闭顺序是：逆序关闭，也就是先关闭最后声明的资源。

注意：

  • 只有写在 try (...) 里的资源才会自动关闭

  • 包装流一般只关闭最外层，

    java 复制代码 
    try (BufferedReader br = new BufferedReader(new FileReader("a.txt"))) {
    // ...
}
// br.close() 会自动关闭底层的 FileReader。

try (FileReader fr = new FileReader("a.txt");
     BufferedReader br = new BufferedReader(fr)) {
    // ...
}
//也会关闭，但 br.close() 已经会关闭 fr，然后 fr.close() 可能再次关闭。多数情况下 close() 是幂等的，但最好只关闭最外层资源。

FilelnputStream:文件输入流

构造器

FileInputStream(File file) 创建一个 FileInputStream通过打开一个连接到一个实际的文件,文件名为 file File对象的文件系统。

FileInputStream(FileDescriptor fdObj) 创建一个使用文件描述符 fdObj FileInputStream,代表一个现有的连接到一个实际的文件在文件系统。

FileInputStream(String name) 创建一个 FileInputStream通过打开一个连接到一个实际的文件,文件路径名name命名的文件系统。

常用方法

public abstract int read() throws IOException

public int read(byte[] b) throws IOException

public int read(byte[] b, int off, int len) throws IOException

close 关闭文件

示例代码:

java 复制代码 
@Test
public void readFile01(){
    String filePath = "f:\\3.txt";
    try(FileInputStream inputStream = new FileInputStream(filePath)){
        int readLength;
        while ((readLength = inputStream.read()) != -1){
            System.out.println((char) readLength);
        }
    }catch (IOException e) { //自动处理异常，也可像下面的方法一样，throw异常交给调用这处理
        e.printStackTrace();
    }
}

@Test
public void readFile02() throws IOException {
    String filePath = "f:\\3.txt";
    try(FileInputStream inputStream = new FileInputStream(filePath)){
        int readLength;
        byte[] buf = new byte[8];
        while ((readLength = inputStream.read(buf)) != -1){
            System.out.print(new String(buf, 0, readLength));
        }
    }catch (IOException e) { //自动处理异常，也可像下面的方法一样，throw异常交给调用这处理
        e.printStackTrace();
    }
}

用FileInputStream 字节流正确读取中文：

  1. 必须了解文本是以哪种编码方式保存字符的
  2. 使用字节流读取了文本后，再使用对应的编码方式去识别这些数字，得到正确的字符
JAVA 复制代码 
package stream;
  
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
  
public class TestStream {
  
    public static void main(String[] args) {
        File f = new File("E:\\project\\j2se\\src\\test.txt");
        try (FileInputStream fis = new FileInputStream(f)) {
            byte[] all = new byte[(int) f.length()];
            fis.read(all);
            //文件中读出来的数据是
            System.out.println("文件中读出来的数据是：");
            for (byte b : all) 
            {
                int i = b&0x000000ff;  //只取16进制的后两位
                System.out.print(Integer.toHexString(i));
            }
            System.out.println("把这个数字，放在GBK的棋盘上去：");
            String str = new String(all,"GBK");
            System.out.println(str);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
  
    }
}

FileOutputStream:文件输出流

朝文件里面写入内容，如果文件不存在会自动创建文件(但是不会创建目录)。

java 复制代码 
@Test
public void fileWrite01(){
    String filePath = "f://a.txt"; //如果是"f://demo/a.txt"路径，将会抛出文件找不到异常。
    String writeStr = "hello world";
    try (FileOutputStream fileOutputStream = new FileOutputStream(filePath)){
        //如果每次执行想追加内容，使用一下构造器
        //fileOutputStream = new FileOutputStream(filePath, true);
        fileOutputStream.write('H'); //写入一个字符
        fileOutputStream.write(writeStr.getBytes()); //写一个字节数组。getBytes将字符串转化成字节数组
        fileOutputStream.write(writeStr.getBytes(), 0, writeStr.indexOf('w')); //写入部分字节
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Reader:字符输入流

FileReader

FileReader相关方法:

  1. new FileReader(File/String)
  2. read:每次读取单个字符，返回该字符，如果到文件末尾返回-1
  3. read(char[]):批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1。
    相关API:new String(char)：将char[]转换成String
  1. new String(char[], off, len):将char\[\]的指定部分转换成String
java 复制代码 
@Test
public void fileReader01() {
    String filePath = "f:\\a.txt";
    int read = 0;
    try (FileReader fr = new FileReader(filePath)){
        while ((read = fr.read()) != -1){
            System.out.print((char) read);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Test
public void fileReader02() {
    String filePath = "f:\\a.txt";
    int readLen = 0;
    char[] buf = new char[10];
    try (FileReader fr = new FileReader(filePath)){
        while ((readLen = fr.read(buf)) != -1){
            System.out.print(new String(buf, 0, readLen));
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Writer:字符输出流

FileWriter

FileWriter常用方法

  1. new FileWriter(File/String):覆盖模式，相当于流的指针在首端
  2. new FileWriter(File/String, true):追加模式，相当于流的指针在尾端
  3. write(int):写入单个字符
  4. write(char[]):写入指定字符数组
  5. write(char[],off,len):写入指定字符数组的指定部分
  6. write (string):写入整个字符串
  7. write(string,off,len):写入字符串的指定部分
    注意:FileWriter使用后，必须要关闭(close)或刷新(flush)，而close() 会先 flush() 再关闭。否则写入不到指定的文件!
java 复制代码 
@Test
public void fileWriter(){
    String filePath = "f:\\3.txt";
    FileWriter fileWriter = null;
    char[] c = {'好', '世', '界', '!', ' '};
    String str = "人间正道是沧桑! ";
    try {
        fileWriter = new FileWriter(filePath, StandardCharsets.UTF_8);
        fileWriter.write('你');//写入单个字符
        fileWriter.write(c);//写入字符数组
        fileWriter.write(c, 0, 3);//写入字符数组部分字符
        fileWriter.write(str);//写入字符串
        fileWriter.write(str, 0,4);//写入部分字符串
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            fileWriter.close();//或者flush
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字节流 vs 字符流的选择

  • 二进制文件：图片、视频、音频、序列化文件 → 字节流。
  • 文本文件：txt、java、properties、csv → 字符流 + 指定编码。

节点流和处理流

  1. 节点流 ：可以从一个特定的数据源读写数据。用于直接操作目标设备所对应的流类。节点流类所对应的IO源或目标称为流节点。
  2. 处理流 ：(也叫包装流 )是"连接"在已存在的流（节点流或处理流)之上，为程序提供更为强大的读写功能。这种模式也称之为一种装饰模式 （修饰器模式）。

模拟装饰模式：

java 复制代码 
public class DecoratorTest {
    public static void main(String[] args) {
        BufferReader_ bufferReader_ = new BufferReader_(new FileReader_());
        bufferReader_.readFile();
        System.out.println("=========读取十次文件============");
        bufferReader_.readNumFile(10);
        BufferReader_ bufferReader = new BufferReader_(new StringReader_());
        bufferReader.readString();
        System.out.println("=========读取字符串次文件============");
        bufferReader.readNumString(10);

    }
}

/**
 * 模拟reader抽象类
 */
abstract class Reader_ {
    public void readFile(){}
    public void readString(){}
}

/**
 * 模拟节点流1
 */
class FileReader_ extends Reader_{
    public void readFile(){
        System.out.println("读取了一次文件内容");
    }
}

/**
 * 模拟节点流2
 */
class StringReader_ extends Reader_{
    public void readString(){
        System.out.println("读取了一次文件字符串");
    }
}

/**
 * 模拟处理流(包装流)
 */
class BufferReader_ extends Reader_{
    private Reader_ rd;

    public BufferReader_(Reader_ rd) {
        this.rd = rd;
    }
    
    //节点流方法
    public void readFile(){
        this.rd.readFile();
    }
    //扩展readFile方法
    public void readNumFile(int num){
        for (int i = 0; i < num; i++) {
            rd.readFile();
        }
    }
	//节点流方法
    public void readString(){
        this.rd.readString();
    }
    //扩展readNumString方法
    public void readNumString(int num){
        for (int i = 0; i < num; i++) {
            rd.readString();
        }
    }
}

BufferedReader和BufferedWriter

BufferedReader和 BufferedWriter属于字符流，是按照字符来读取数据的。适用于文本数据操作。

关闭时处理流，只需要关闭外层流即可

BufferedReader
java 复制代码 
public void bufferReader_() throws IOException {
    String filePath = "f:\\a.txt";
    try(BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath, StandardCharsets.UTF_8))){
        String line;
        while ((line = bufferedReader.readLine()) != null){
            System.out.println(line);
        }
    }
}
BufferedWriter
java 复制代码 
public void bufferedWriter_() throws IOException {
    String filePath = "f:\\3.txt";
    try(BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath, StandardCharsets.UTF_8))){
        bufferedWriter.write("hello, 小花");
        bufferedWriter.newLine();//插入一个换行
        bufferedWriter.write("hello, 小李");
        bufferedWriter.newLine();
        bufferedWriter.write("hello, 鸡蛋");
    }
}

BufferedInputStream和BufferedOutputStream

类图体系

BufferedInputStream是字节流在创建BufferedInputStream时，会创建一个内部缓冲区数组.

BufferedOutputStream是字节流,实现缓冲的输出流,可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统

应用示例：
java 复制代码 
 public void copyBinFile() throws IOException {
     String srcPath = "C:\\Users\\light\\Pictures\\idea\\wallhaven-4v891p.jpg";
     String distPath = "E:\\javacode\\j2se\\IOStream\\mumlove.jpg";

     byte[] buf = new byte[8192];
     int readLen;
     try(BufferedInputStream in = new BufferedInputStream(new FileInputStream(srcPath));
         BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(distPath))
        ){
         while ((readLen = in.read(buf)) != -1){
             out.write(buf, 0, readLen);
         }
     }
     System.out.println("复制完成");
 }

ObjectInputStream和ObjectOutputStream

作用

这两个类主要作用是数据的序列化和反序列化，需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的,该类必须实现如下两个接口之一 :

Serializable // 这是一个标记接口，没有方法。推荐使用实现这个接口。

Externalizable //该方法有接口需要实现。

类图
示例代码

ObjectOutputStream_.php代码示例：

java 复制代码 
public class ObjectOutputStream_ {
     public void objectOutputStream() throws IOException {
        String filePath = "E:\\javacode\\j2se\\IOStream\\seribe.txt";
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));){
            oos.writeInt(10);
            oos.writeBoolean(true);
            oos.writeDouble(2.5);
            oos.writeChar('c');
            oos.writeUTF("阿黄你好!"); //写入字符串
            //只有实现Serializable接口的数据才能被序列化保存到文件
            oos.writeObject(new Dog("旺财", 10));
            System.out.println("数据序列化完毕");
        }
    }
}
//自定义类需要实现Serializable才能够被序列化
class Dog implements Serializable {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

保存成功的文件并非以文本的形式保存：

ObjectInputStream_.php代码示例：

java 复制代码 
public void objectInputStream() throws IOException, ClassNotFoundException {
    String filePath = "E:\\javacode\\j2se\\IOStream\\seribe.txt";
    //反序列化的时候读取数据要和写入数据时的顺序一致
    try(ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath))){
        System.out.println(ois.readInt());
        System.out.println(ois.readBoolean());
        System.out.println(ois.readDouble());
        System.out.println(ois.readChar());
        System.out.println(ois.readUTF());
        //在这里返回的值是一个Object的类型，如果需要使用Dog类方法，就需要向下转型
        //所以反序列化必须将所需要的资源类放在可以引用的地方(假设ObjectInputStream_.java和ObjectOutputStream_.java
        //不在一个包内，反序列化的时候，Dog类必须能被ObjectInputStream_引用到)
        //如果Dog类有代码更新，必须将Dog类从新序列化，然后才能够进行反序列化
        Object o = ois.readObject();
        Dog dog = (Dog) o;
        System.out.println(dog);
    }
}
使用细节
  1. 序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性
  2. 序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
  3. 序列化对象时, 要求里面属性的类型也需要实现Serializable接口(如果类的属性的类型是另外一个类，此类也必须实现Serializable接口)
  4. 序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化；
  5. 反序列化时的读取数据的顺序必须和序列化时写入数据的顺序一致。

标准输入输出流

对于任意实现了Formattable接口的对象都将调用formatTo方法;否则将调用toString方法，它可以将对象转换为字符串。

可以使用静态的String.format方法创建一个格式化的字符串，而不打印输出:

String message = String.format("Hello，%s. Next year, you'll be %d", name, age);

要想对文件进行读取，就需要一个用File对象构造一个Scanner对象，如下所示:

Scanner in = new Scanner(Paths.get("myfile.txt")，"UTF-8");

如果文件名中包含反斜杠符号，就要记住在每个反斜杠之前再加一个额外的反斜杠:"c:\\mydirectory\\myfile.txt"。

static Path get(String pathname) 根据给定的路径名构造一个Path。

然后，就可以利用Scanner对象方法对文件进行读取。

要想写入文件，就需要构造一个PrintWriter对象。在构造器中，只需要提供文件名:

PrintWriter out = new PrintWriter("myfile.txt","UTF-8");

如果文件不存在，创建该文件。可以像输出到System.out一样使用print、println 以及printf命令。

如果用一个不存在的文件构造一个Scanner，或者用一个不能被创建的文件名构造一个PrintWriter,

那么就会发生异常。Java编译器认为这些异常比"被零除"异常更严重。

java 复制代码 
public class InputAndOutStream_ {
    public static void main(String[] args) {
        // System类的 public final static InputStream in = null;
        // system.in 编译类型 InputStream
        // System.in 运行类型 BufferedInputStream
        System.out.println(System.in.getClass()); //class java.io.BufferedInputStream

        //System 类的 public final static PrintStream out = null;
        //system.out 编译类型 PrintStream
        //system.out 运行时类型 PrintStream
        System.out.println(System.out.getClass()); //class java.io.PrintStream
    }
}
打印流

打印流只有输出流没有输入流

PrintStream
java 复制代码 
public class PrintStream_ {
    public static void main(String[] args) throws IOException {
        //直接用法
        try(PrintStream out = System.out){
             //在默认情况下，PrintStream输出数据的位置是标准输出，即显示器
            out.print("hello, xxxx");
            out.println("hello, ssss");
            //因为print底层使用的是write ，所以可以直接调用write进行打印/输出
            out.write("旺财就知道吃".getBytes());
        }
        //我们可以去修改打印流输出的位置/设备
        // 1.输出修改成到"e: \\f1.txt"
        // 2."hello，light"就会输出到e:\\f1.txt
        // 3. public static void setOut(PrintStream out){
        //      checkIO();
        //      setOut0(out); native修饰的方法，修改了out
        //    }
        System.setOut(new PrintStream( "f:\\f1.txt"));
        System.out.println("hello，light");
    }
}
PrintWriter
java 复制代码 
PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\f2.txt"));
printWriter.print( "hi,北京你好~");
printWriter.close(); //如果没有关闭文件，数据就不会写入文件。

InputStreamReader 和 OutputStreamWriter

转换流用于在字节流和字符流之间桥接，并可指定字符集

为什么要有转换流？

因为当读取文件数据时，由于我们idea设置的编码是UTF-8编码，默认会按照UTF-8编码解析。如果文件的编码不是UTF-8时，读入的时候会出现乱码问题。

java 复制代码 
@Test
public void noTransform() throws IOException {
    //读取f:\\la.txt文件到程序 a.txt编码不是UTF-8编码
    String filePath = "f:\\a.txt";
    BufferedReader br = new BufferedReader(new FileReader(filePath));
    String s = br.readLine();
    System.out.println("读取到的内容:" + s);
    br.close(); //读取到的内容:��ã�hello
}
类图

public InputStreamReader(InputStream in, Charset cs) { ... }这个构造器在读入字节转入字符时候可以指定编码。

public OutputStreamWriter(OutputStream out, Charset cs) { ... }这个构造器在输出字节转入字符时候可以指定保存文件的编码。

当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流。可以在使用时指定编码格式(比如utf-8,gbk , gb2312, ISO8859-1等)

java 复制代码 
@Test
public void transform() throws IOException {
    String filePath = "f:\\a.txt";
    try(InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), StandardCharsets.GBK);
       BufferedReader br = new BufferedReader(isr);){
       String s = br.readLine();
       System.out.println("读取到的内容:" + s); 
    }
}

Properties

properties是专门用于读写配置文件的集合类。

配置文件的格式必须要求是：键=值。建值对不需要有空格,值不需要用引号一起来。默认类型是String

类图
常用方法

load: 加载配置文件的键值对到Properties对象

list:将数据显示到指定设备

getProperty(key):根据键获取值

setProperty(key,value):设置键值对到Properties对象,没有的话相当于创建

store:将Properties中的键值对存储到配置文件,在idea中，保存信息到配置文件,如果含有中文，文件中会存储为unicode码

java 复制代码 
@Test
public void saveFile() throws IOException {
    Properties properties = new Properties();
    //如果该文件没有key就是创建,如果该文件有key ,就是修改
    properties.setProperty("charset", "utf8");
    properties.setProperty("user", "小明");
    properties.setProperty("passwd", "admin888");
    //第一个参数是writer对象，第二个参数是注释
    properties.store(new FileWriter("src\\mysql1.properties"), null);
    System.out.println("保存成功");
}

@Test
public void readFile() throws IOException {
    String path = "./src/mysql.properties";
    Properties properties = new Properties();
    //加载
    properties.load(new FileReader(path));
    properties.list(System.out);
    //获取某个键值
    String user = properties.getProperty("user", "root");
    String passwd = properties.getProperty("passwd", "123456");
    String ip = properties.getProperty("ip");
    System.out.println(user);
    System.out.println(passwd);
    System.out.println(ip);
}

其他常用流

  • DataInputStream/DataOutputStream
  • RandomAccessFile
  • FileChannel
  • ByteArrayInputStream/ByteArrayOutputStream
  • CharArrayReader/CharArrayWriter
  • SequenceInputStream
  • PipedInputStream/PipedOutputStream
  • FilterInputStream/FilterOutputStream
相关推荐
云和数据.ChenGuang1 小时前
Spring AI 对接 LangGraph：构建企业级智能体工作流实战
java·人工智能·spring boot·后端·spring
云和数据.ChenGuang1 小时前
Spring AI 入门实战：构建你的第一个 AI 应用
java·人工智能·深度学习·spring·机器学习·语言模型
下雨天没带伞1 小时前
Java Stream API实战，告别for循环
java
用户3721574261351 小时前
Java 高效管理 Excel 批注：添加、读取、修改和删除
java
C语言小火车1 小时前
C++ 为什么越来越依赖标准库？
java·开发语言·c++
西索斯coding2 小时前
在 中接入 教程：p配置、m填写、扩展思考参数一篇就够（2）
java·前端·javascript·ai
隐退山林2 小时前
JWT令牌技术
java·开发语言·java-ee
w_zero_one2 小时前
动态规划（三）
java·算法·动态规划
木棉软糖2 小时前
JDBC 读 ResultSet 读到一半，报 stream closed
java·mysql·spring
热门推荐
01「全语录+省流版」邵艾伦 × 孙宇晨：聊风口、聊个人IP、聊年轻人如何抓住 AI 时代的机会02国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）03历年考研数学一、数学二、数学三真题试卷及答案PDF04GitHub 镜像站点05几个好用的ip纯净度检测网站06蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接07Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）08Telegram APK 下载安装完整指南 — 2026年最新09微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新10轻量化AI渗透武器库｜ARTEX自主攻防系统、资产梳理、漏洞挖掘、链路分析全流程智能化落地