当前位置： 首页 > news >正文

13.Java IO 流（文件流、字符流、字符处理流、字节处理流、对象处理流、标准流、转换流、打印流、Properties 配置文件、其他流）

news 2025/7/27 11:52:51

一、文件引入

1、文件的概念
  • 文件是保存数据的地方（例如，文档，图片，音视频等）
2、文件流
  • 流：数据在数据源（文件）和程序（内存）之间经历的路径

  1. 输入流：数据从数据源（文件）到程序（内存）的路径

  2. 输出流：数据从程序（内存）到数据源（文件）的路径

3、常用文件操作
（1）基本介绍
  • 创建文件对象常用构造器
构造器说明
File(String pathname)根据路径创建 File 对象
File(File parent, String child)根据父目录 File 对象 + 子路径创建 File 对象
File(String parent, String child)根据父目录+子路径创建 File 对象
  • 文件对象常用方法
方法说明
createNewFile()创建文件
getName()获取文件名称
getParent()获取文件父级目录
length()获取文件大小（以字节为单位）
exists()判断文件是否存在
isFile()判断是否是一个文件
isDirectory()判断是否是一个目录
delete()删除空目录或文件
mkdir()创建单级目录
mkdirs()创建多级目录
（2）基本使用

基本使用案例一

  • FileTest 类
package com.my.test.file;import java.io.File;
import java.io.IOException;public class FileTest {public static void main(String[] args) throws IOException {File file = new File("d:\\");File file1 = new File("d:\\FileTestText1.txt");File file2 = new File("d:\\", "FileTestText2.txt");File file3 = new File(file, "FileTestText3.txt");if (file1.createNewFile()) {System.out.println("创建成功");} else {System.out.println("创建失败");}if (file2.createNewFile()) {System.out.println("创建成功");} else {System.out.println("创建失败");}if (file3.createNewFile()) {System.out.println("创建成功");} else {System.out.println("创建失败");}}
}
  • 输出结果
创建成功
创建成功
创建成功

基本使用案例二

  • FileMethodTestText.txt
Hello World
  • FileMethodTest 类
package com.my.test.file;import java.io.File;public class FileMethodTest {public static void main(String[] args) {File file = new File("d:\\FileMethodTestText.txt");System.out.println(file.getName());System.out.println(file.getParent());System.out.println(file.length());System.out.println(file.exists());System.out.println(file.isFile());System.out.println(file.isDirectory());if (file.delete()) {System.out.println("文件删除成功");}System.out.println(file.exists());System.out.println("==============================");File directory = new File("d:\\a\\b\\c");if (directory.mkdirs()) {System.out.println("目录创建成功");}System.out.println(directory.exists());}
}
  • 输出结果
FileMethodTestText.txt
d:\
11
true
true
false
文件删除成功
false
==============================
目录创建成功
true

二、IO 流引入

1、概述

  • IO 是 Input Output 的缩写，IO 流用于处理数据传输（如读写文件，网络通讯等）

  • Java程序中，对于数据的输入 / 输出操作以流（Stream）的方式运行

  • java.io 包下提供了各种流类和接口，以获取不同种类的数据，并通过方法输入或输出

  1. 输入 Input：读取外部数据（文件，磁盘，光盘等中的数据）到程序（内存）

  2. 输出 Output：将程序中的数据输出到外部（文件，磁盘，光盘等）

2、流的分类

  1. 按操作数据单位不同分为：字节流（二进制文件），字符流（文本文件）

  2. 按数据流的流向不同分为：输入流，输出流

  3. 按流的角色不同分为：节点流，处理流（包装流）

3、IO 流体系
（1）抽象基类

  • 输入字节流 InputStream

  • 输入字符流 Reader

  • 输出字节流 OutputStream

  • 输出字符流 Writer

（2）概述
  • Java IO 流涉及 40 多个类，都是从 4 个抽象基类派生，由这 4 个抽象基类派生出来的子类都以其父类作为类名的后缀

三、文件流

1、文件输入流 FileInputStream
（1）基本介绍
  • 常用构造器
构造器说明
FileInputStream(String name)通过一个指定文件路径的字符串创建一个 FileInputStream 对象
FileInputStream(File file)通过一个 File 对象创建一个 FileInputStream 对象
文件路径在创建 File 对象时指定
  • 常用方法
方法说明
close()关闭流
read()从输入流中读取一个字节
read(byte b[])从输入流中最多将 b.length 个字节读入 byte 数组中
read(byte b[], int off, int len)从输入流中将指定长度字节读入 byte 数组中
（2）基本使用
  • FileInputStreamTestText1.txt
Hello World~
  • FileInputStreamTestText2.txt
Hello World~~
  • FileInputStreamTest 类
package com.my.test.filestream;import java.io.FileInputStream;
import java.io.IOException;public class FileInputStreamTest {public static void main(String[] args) throws IOException {FileInputStream fileInputStream1 = new FileInputStream("d:\\FileInputStreamTestText1.txt");int readData = 0;while ((readData = fileInputStream1.read()) != -1) {System.out.println((char) readData);}fileInputStream1.close();System.out.println("==============================");FileInputStream fileInputStream2 = new FileInputStream("d:\\FileInputStreamTestText2.txt");byte[] buf = new byte[8];int length = 0;while ((length = fileInputStream2.read(buf)) != -1) {System.out.println(new String(buf, 0, length));}fileInputStream1.close();}
}
  • 输出结果
H
e
l
l
oW
o
r
l
d
~
==============================
Hello Wo
rld~~
2、文件输出流 FileOutputStream
（1）基本介绍
  • 常用构造器
构造器说明
FileOutputStream(String name)通过一个指定文件路径的字符串创建一个 FileOutputStream 对象
FileOutputStream(File file)通过一个 File 对象创建一个 FileOutputStream 对象
文件路径在创建 File 对象时指定
FileOutputStream(String name, boolean append)通过一个指定文件路径的字符串构建一个FileOutputStream 对象
append 为 true 表示追加输出数据，为 false 表示覆盖输出数据
FileOutputStream(File file, boolean append)通过一个 File 对象创建一个 FileOutputStream 对象
文件路径在创建 File 对象时指定
append 为 true 表示追加输出数据，为 false 表示覆盖输出数据
  • 常用方法
方法说明
close()关闭流
write(byte b[])将 b.length 个字节从 byte 数组写入输出流中
write(byte b[], int off, int len)将指定长度字节从 byte 数组写入输出流中
（2）基本使用
  • FileOutputStreamTest 类
package com.my.test.filestream;import java.io.FileOutputStream;
import java.io.IOException;public class FileOutputStreamTest {public static void main(String[] args) throws IOException {FileOutputStream fileOutputStream = new FileOutputStream("d:\\FileOutputStreamTestText.txt", true);String str = "HelloWorld~~~";fileOutputStream.write(str.getBytes());System.out.println("文件创建完成");fileOutputStream.close();}
}
  • 输出结果
文件创建完成
  • FileOutputStreamTestText.txt
HelloWorld~~~
3、案例：文件拷贝
（1）需求
  • 使用文件流完成文件（文本文件 / 图片 / 音乐）拷贝
（2）具体实现
  • HelloWorld.txt
Hello World 1
Hello World 2
  • FileCopyTest 类
package com.my.test.filestream;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class FileCopyTest {public static void main(String[] args) throws IOException {FileInputStream fileInputStream = new FileInputStream("d:\\HelloWorld.txt");FileOutputStream fileOutputStream = new FileOutputStream("d:\\FileCopyTestText.txt");byte[] buf = new byte[8];int length = 0;while ((length = fileInputStream.read(buf)) != -1) {fileOutputStream.write(buf, 0, length);}System.out.println("文件拷贝成功");fileInputStream.close();fileOutputStream.close();}
}
  • 输出结果
文件拷贝成功
  • FileCopyTestText.txt
Hello World 1
Hello World 2

四、字符流

1、字符输入流 FileReader
（1）基本介绍
  • 常用构造器
构造器说明
FileReader(String fileName)通过一个指定文件路径的字符串创建一个 FileReader 对象
FileReader(File file)通过一个 File 对象创建一个 FileReader 对象
文件路径在创建 File 对象时指定
  • 常用方法
方法说明
close()关闭流
read()读取单个字符，如果到文件末尾则返回 -1
read(char[] cbuf)读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回 -1
（2）基本使用
  • FileReaderTestText1.txt
这里测试字符输入流~
  • FileReaderTestText2.txt
这里测试字符输入流~~
  • FileReaderTest 类
package com.my.test.charstream;import java.io.FileReader;
import java.io.IOException;public class FileReaderTest {public static void main(String[] args) throws IOException {FileReader fileReader1 = new FileReader("d:\\FileReaderTestText1.txt");int data = 0;while ((data = fileReader1.read()) != -1) {System.out.println((char) data);}fileReader1.close();System.out.println("==============================");FileReader fileReader2 = new FileReader("d:\\FileReaderTestText2.txt");char[] charArr = new char[5];int length = 0;while ((length = fileReader2.read(charArr)) != -1) {System.out.println(new String(charArr, 0, length));}fileReader2.close();}
}
  • 输出结果

这
里
测
试
字
符
输
入
流
~
==============================
这里测试
字符输入流
~~
2、字符输出流 FileWriter
（1）基本介绍
  • 常用构造器
构造器说明
FileWriter(String name)通过一个指定文件路径的字符串创建一个 FileWriter 对象
FileWriter(File file)通过一个 File 对象创建一个 FileWriter 对象
文件路径在创建 File 对象时指定
FileWriter(String name, boolean append)通过一个指定文件路径的字符串创建一个 FileWriter 对象
append 为 true 表示追加输出数据，为 false 表示覆盖输出数据
FileWriter(File file, boolean append)通过一个 File 对象创建一个 FileWriter 对象
文件路径在创建 File 对象时指定
append 为 true 表示追加输出数据，为 false 表示覆盖输出数据
  • 常用方法
方法说明
close()关闭流
flush()刷新
write(int c)写入单个字符
write(char[] cbuf)写入字符数组
write(char[] cbuf, int off, int len)写入字符数组的指定部分
write(String str)写入字符串
write(String str, int off, int len)写入字符串的指定部分
（2）注意事项
  • FileWriter 使用后，必须要关闭（close）或刷新（flush），否则会写入不到指定的文件
（3）基本使用
  • FileWriterTest 类
package com.my.test.charstream;import java.io.FileWriter;
import java.io.IOException;public class FileWriterTest {public static void main(String[] args) throws IOException {FileWriter fileWriter = new FileWriter("d:\\FileWriterTestText.txt", true);fileWriter.write("这里测试字符输出流".toCharArray());System.out.println("文件创建完成");fileWriter.close();}
}
  • 输出结果
文件创建完成
  • FileWriterTestText.txt
这里测试字符输出流

五、处理流引入

1、基本介绍

  • 节点流可以从一个特定的数据源读写数据，如 FileReader，FileWriter

  • 处理流也称包装流，连接在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能

2、节点流和处理流的区别

  1. 节点流是底层流，直接跟数据源相接

  2. 处理流包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法完成输入输出

  3. 处理流包装节点流，使用了修饰器设计模式，不会直接与数据源相接

3、节点流的功能体现

  1. 性能的提高：主要以增加缓冲的方式来提高输入输出的效率

  2. 操作的便捷：提供了一系列便捷的方法来输入输出大批量数据

七、字符处理流

1、字符处理输入流 BufferedReader
  • BufferedReaderTestText.txt
Hello
BufferedReader
  • BufferedReaderTest 类
package com.my.test.charbufferstream;import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class BufferedReaderTest {public static void main(String[] args) throws IOException {BufferedReader bufferedReader = new BufferedReader(new FileReader("d:\\BufferedReaderTestText.txt"));String line;while ((line = bufferedReader.readLine()) != null) {System.out.println(line);}bufferedReader.close();}
}
  • 输出结果
Hello
BufferedReader
2、字符处理输入流 BufferedWriter
package com.my.test.charbufferstream;import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;public class BufferedWriterTest {public static void main(String[] args) throws IOException {BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("d:\\BufferedWriterTestText.txt"));bufferedWriter.write("Hello");bufferedWriter.newLine();bufferedWriter.write("BufferedWriter");System.out.println("文件创建完成");bufferedWriter.close();}
}
  • 输出结果
文件创建完成
  • BufferedWriterTestText.txt
Hello
BufferedWriter
3、案例：文件拷贝
（1）需求
  • 使用字符处理流完成文件（文本文件 / 图片 / 音乐）拷贝
（2）具体实现
  • HelloWorld.txt
Hello World 1
Hello World 2
  • BufferedCopyTest 类
package com.my.test.charbufferstream;import java.io.*;public class BufferedCopyTest {public static void main(String[] args) throws IOException {BufferedReader bufferedReader = new BufferedReader(new FileReader("d:\\HelloWorld.txt"));BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("d:\\BufferedWriterCopyText.txt"));String line;while ((line = bufferedReader.readLine()) != null) {bufferedWriter.write(line);// 插入一个换行bufferedWriter.newLine();}System.out.println("文件拷贝成功");bufferedReader.close();bufferedWriter.close();}
}
  • 输出结果
文件拷贝成功
  • BufferedWriterCopyText.txt
Hello World 1
Hello World 2

八、字节处理流

1、字节处理输入流 BufferedInputStream
  • BufferedInputStreamTestText.txt
Hello
BufferedInputStream
  • BufferedInputStreamTest 类
package com.my.test.bytebufferstream;import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;public class BufferedInputStreamTest {public static void main(String[] args) throws IOException {BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("d:\\BufferedInputStreamTestText.txt"));byte[] bytes = new byte[10];int len;while ((len = bufferedInputStream.read(bytes)) != -1) {System.out.print(new String(bytes, 0, len));}bufferedInputStream.close();}
}
  • 输出结果
Hello
BufferedInputStream
2、字节处理输出流 BufferedOutputStream
  • BufferedOutputStreamTest 类
package com.my.test.bytebufferstream;import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class BufferedOutputStreamTest {public static void main(String[] args) throws IOException {BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("d:\\BufferedOutputStreamTestText.txt"));bufferedOutputStream.write("Hello".getBytes());bufferedOutputStream.write("\n".getBytes());bufferedOutputStream.write("BufferedOutputStream".getBytes());System.out.println("文件创建完成");bufferedOutputStream.close();}
}
  • 输出结果
文件创建完成
  • BufferedOutputStreamTestText.txt
Hello
BufferedOutputStream

九、对象处理流

1、序列化
（1）序列化和反序列化

  • 序列化：在保存数据时，保存数据的值和数据类型

  • 反序列化：在恢复数据时，恢复数据的值和数据类型

（2）对象序列化
  • 需要让某个对象支持序列化，必须让其类支持序列，需要实现以下其中一接口

  1. Serializable 接口：标记接口，无需实现方法（推荐使用）

  2. Externalizable 接口：该接口需要实现方法

2、注意事项
  1. 序列化的类中建议添加 serialVersionUID，提高版本兼容性，例
private static final long serialVersionUID = 1L;

  1. 序列化对象时，除了 static 和 transient 修饰的成员，其他成员都会进行序列化

  2. 序列化对象时，里面属性的类型也需要支持序列化

  3. 序列化具备可继承性

3、对象处理输出流 ObjectOutputStream
  • Dog 类
package com.my.test.entity;import java.io.Serializable;public class Dog implements Serializable {String name;int age;public Dog(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +'}';}
}
  • ObjectOutputStreamTest 类
package com.my.test.objectstream;import com.my.test.entity.Dog;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;public class ObjectOutputStreamTest {public static void main(String[] args) throws IOException {ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("d:\\ObjectOutputStreamTestText.txt"));objectOutputStream.writeInt(100);objectOutputStream.writeUTF("HelloObjectOutputStream");objectOutputStream.writeObject(new Dog("阿黄", 2));System.out.println("文件创建完成");objectOutputStream.close();}
}
  • 输出结果
文件创建完成
  • ObjectOutputStreamTestText.txt
 w   d HelloObjectOutputStreamsr com.my.test.objectstream.Dog~|?$€ I ageL namet Ljava/lang/String;xp   t 闃块粍
4、对象处理输入流 ObjectInputStream
  • Dog 类
package com.my.test.entity;import java.io.Serializable;public class Dog implements Serializable {String name;int age;public Dog(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +'}';}
}
  • ObjectInputStreamTest 类
package com.my.test.objectstream;import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;public class ObjectInputStreamTest {public static void main(String[] args) throws IOException, ClassNotFoundException {ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("d:\\ObjectOutputStreamTestText.txt"));System.out.println(objectInputStream.readInt());System.out.println(objectInputStream.readUTF());System.out.println(objectInputStream.readObject());objectInputStream.close();}
}
  • 输出结果
100
HelloObjectOutputStream
Dog{name='阿黄', age=2}

十、标准流

1、基本介绍
标准流类型默认设备
标准输入流 System.inInputStream键盘
标准输出流 System.outPrintStream显示器
2、标准输入流 System.in
  • SystemInTest 类
package com.my.test.standardstream;import java.util.Scanner;public class SystemInTest {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.print("请输入：");String next = scanner.next();System.out.println("Hello " + next);}
}
  • 输出结果
请输入：sunke
Hello sunke
3、标准输出流 System.out
  • SystemOutTest 类
public class SystemOutTest {public static void main(String[] args) {System.out.println(System.out.getClass());System.out.println("Hello System.out");}
}
  • 输出结果
class java.io.PrintStream
HelloSystem.out

十一、转换流

1、基本介绍

  1. 转换输入流 InputStreamReader：Reader 的子类，可以将 InputStream（字节流）包装成 Reader（字符流）

  2. 转换输出流 OutputStreamWriter：Writer 的子类，可以将 OutputStream（字节流）包装成 Writer（字符流）

  • 当处理纯文本数据时，使用字符流效率更高，并且可以有效解决中文问题

  • 转换流指定编码：UTF-8、gbk、gb2313 等

2、转换输入流 InputStreamReader
  • InputStreamReaderTestText.txt
你好，转换输入流
  • InputStreamReaderTest 类
package com.my.test.transform;import java.io.*;public class InputStreamReaderTest {public static void main(String[] args) throws IOException {InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("d:\\InputStreamReaderTestText.txt"), "gbk");BufferedReader bufferedReader = new BufferedReader(inputStreamReader);String line;while ((line = bufferedReader.readLine()) != null) {System.out.println(line);}bufferedReader.close();}
}
  • 输出结果
你好，转换输入流
3、转换输出流 OutputStreamWriter
  • OutputStreamWriterTest 类
package com.my.test.transform;import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;public class OutputStreamWriterTest {public static void main(String[] args) throws IOException {OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("d:\\OutputStreamWriterTestText.txt"), "gbk");BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);bufferedWriter.write("你好，转换输出流".toCharArray());System.out.println("文件创建完成");bufferedWriter.close();}
}
  • 输出结果
文件创建完成
  • OutputStreamWriterTestText.txt
你好，转换输出流

十二、打印流

1、节打印流 PrintStream
  • PrintStreamTest 类
package com.my.test.printstream;import java.io.IOException;
import java.io.PrintStream;public class PrintStreamTest {public static void main(String[] args) throws IOException {PrintStream out = System.out;out.println("Hello PrintStream");out.println("你好，字节打印流");System.setOut(new PrintStream("d:\\PrintStreamTestText1.txt"));System.out.println("Hello PrintStream 1");System.out.println("你好，字节打印流 1");PrintStream printStream = new PrintStream("d:\\PrintStreamTestText2.txt");printStream.write("Hello PrintStream 2".getBytes());printStream.write("\r".getBytes());printStream.write("你好，字节打印流 2".getBytes());out.println("文件创建成功");out.close();printStream.close();}
}
  • 输出结果
Hello PrintStream
你好，字节打印流
文件创建成功
  • PrintStreamTestText1.txt
Hello PrintStream 1
你好，字节打印流 1
  • PrintStreamTestText2.txt
Hello PrintStream 2
你好，字节打印流 2
2、字符打印流 PrintWriter
  • PrintWriterTest 类
package com.my.test.printstream;import java.io.FileNotFoundException;
import java.io.PrintWriter;public class PrintWriterTest {public static void main(String[] args) throws FileNotFoundException {PrintWriter printWriter = new PrintWriter("d:\\PrintWriterTestText.txt");printWriter.write("Hello PrintWriter");printWriter.write("\r");printWriter.write("你好，字符打印流");System.out.println("文件创建成功");printWriter.close();}
}
  • 输出结果
文件创建成功
  • PrintWriterTestText.txt
Hello PrintWriter
你好，字符打印流
3、小结

  1. 打印流只有输出流，没有输入流

  2. PrintStream 经典使用

PrintStream out = System.out;
  1. 修改 System.out.println(); 的打印位置
System.setOut(new PrintStream("【文件路径】"));

十三、Properties 配置文件

1、基本介绍
  • Properties 配置文件格式如下，其中键值对不需要有空格，不要引号，默认类型为 String
【键】=【值】
  • Properties 常用方法
方法说明
load加载配置文件的键值对到 Properties 对象
list将数据显示到指定位置
getProperty根据键获取值
setProperty设置键值对到 Properties 对象
store将 Properties 对象中的键值对存储到配置文件中
在 IDEA 中，若保存信息中有中文，会存储为 Unicode 编码
2、基本使用
  1. PropertiesTestText.properties
ip=192.168.10.1
username=root
password=123456
  1. PropertiesTest.java
package com.my.test.properties;import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;public class PropertiesTest {public static void main(String[] args) throws IOException {Properties properties1 = new Properties();properties1.load(new FileReader("d:\\PropertiesTestText.properties"));properties1.list(System.out);System.out.println(properties1.getProperty("ip"));System.out.println(properties1.getProperty("username"));System.out.println(properties1.getProperty("password"));System.out.println("==============================");Properties properties2 = new Properties();properties2.setProperty("hobby", "read");properties2.setProperty("age", "20");properties2.store(new FileWriter("d:\\PropertiesChangeTestText.properties"), null);System.out.println("文件创建完成");}
}
  • 输出结果
-- listing properties --
password=123456
ip=192.168.10.1
username=root
192.168.10.1
root
123456
==============================
文件创建完成
  • PropertiesChangeTestText.properties
#Wed Dec 21 09:17:23 CST 2022
age=20
hobby=read

十四、其他流

1、LineNumberReader
（1）基本介绍
  • LineNumberReader 是 Java IO 流中的一个类，它继承自 BufferedReader，这个类除了拥有 BufferedReader 的所有功能外，还增加了跟踪行号的能力
方法说明
getLineNumber()用于获取当前读取位置的行号
行号是从 0 开始计数的，每当读取到换行符 \n 或回车符 \r 时，行号就会增加
setLineNumber(int lineNumber)用于设置当前读取位置的行号
该方法并不会改变流的实际读取位置，即它不会将文件指针移动到指定的行
它只是改变了 LineNumberReader 内部用于记录行号的变量的值
（2）演示
  1. LineNumberReaderTest.txt
1 + 1 = 10
1 + 0 = 01
0 + 1 = 011 + 1 + 0 = 10 + 0 = 10
1 + 1 + 1 = 10 + 1 = 11
1 + 0 + 0 = 01 + 0 = 01
1 + 0 + 1 = 01 + 1 = 10
0 + 1 + 0 = 01 + 0 = 01
0 + 1 + 1 = 01 + 1 = 10
  1. LineNumberReaderTest.java
package com.my.test.linenumberreader;import java.io.*;public class LineNumberReaderTest {public static void main(String[] args) {File file = new File("d:\\LineNumberReaderTest.txt");FileReader fileReader = null;LineNumberReader lineReader = null;try {fileReader = new FileReader(file);lineReader = new LineNumberReader(fileReader);String line;int lineNumber = 0;while ((line = lineReader.readLine()) != null) {lineNumber = lineReader.getLineNumber();System.out.println("Line " + lineNumber + ": " + line);}} catch (FileNotFoundException e) {throw new RuntimeException(e);} catch (IOException e) {throw new RuntimeException(e);} finally {try {if (lineReader != null) lineReader.close();if (fileReader != null) fileReader.close();} catch (IOException e) {e.printStackTrace();}}}
}
  • 输出结果
Line 1: 1 + 1 = 10
Line 2: 1 + 0 = 01
Line 3: 0 + 1 = 01
Line 4: 
Line 5: 1 + 1 + 0 = 10 + 0 = 10
Line 6: 1 + 1 + 1 = 10 + 1 = 11
Line 7: 1 + 0 + 0 = 01 + 0 = 01
Line 8: 1 + 0 + 1 = 01 + 1 = 10
Line 9: 0 + 1 + 0 = 01 + 0 = 01
Line 10: 0 + 1 + 1 = 01 + 1 = 10
http://www.lryc.cn/news/499884.html

相关文章：

  • 掌握 DOM 操作：让你的网页动起来
  • JVM整理部分面试题
  • ubuntu20 使用 pyspacemouse获取 spacemouse wireless 输入
  • windows下Qt5自动编译配置QtMqtt环境（11）
  • 速盾：高防cdn有哪些冷知识？
  • 全面UI组件库Telerik 2024 Q4全新发布——官方宣布支持.NET 9
  • 电脑投屏到电脑：Windows，macOS及Linux系统可以相互投屏！
  • 12.6深度学习_模型优化和迁移_模型移植
  • Grid++Report:自定义模板设计（自由表格使用），详细教程
  • [Collection与数据结构] 位图与布隆过滤器
  • idea中新建一个空项目
  • 【Python】【Conda 】Conda 与 venv 虚拟环境优缺点全解：如何做出明智选择
  • 深度学习在故障检测中的应用：从理论到实践
  • 自然语言处理与人工智能
  • 量化交易系统开发-实时行情自动化交易-8.15.Ptrade/恒生平台
  • 非常简单实用的前后端分离项目-仓库管理系统（Springboot+Vue）part 4
  • 基于MATLAB的信号处理工具：信号分析器
  • Codeforces Round 784 (Div. 4)
  • OpenNebula 开源虚拟平台,对标 VMware
  • 软件项目标书参考，合同拟制，开发合同制定，开发协议，标书整体技术方案，实施方案，通用套用方案，业务流程，技术架构，数据库架构全资料下载（原件）
  • Jenkins环境一站式教程：从安装到配置，打造高效CI/CD流水线环境-Ubuntu 22.04.5 环境离线安装配置 Jenkins 2.479.1
  • 【Android】ARouter源码解析
  • 计算直线的交点数
  • STM32基于HAL库的串口接收中断触发机制和适用场景
  • java面试宝典
  • Scala—Slice（提取子序列）方法详解
  • 【电子通识】案例：USB Type-C USB 3.0线缆做直通连接器TX/RX反向
  • 【SKFramework框架核心模块】3-5、函数扩展模块
  • 使用 EasyExcel 提升 Excel 处理效率
  • 【提高篇】3.7 GPIO（七，GPIO开发模型 一）