去年做啥网站致富/企业网页设计报价

一、文件引入

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;

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

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

4. 序列化具备可继承性

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.in	InputStream	键盘
标准输出流 System.out	PrintStream	显示器

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;

3. 修改 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

2. 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

2. 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