JAVASE-IO2.1 IO流概述和分类.
Java定义了两个超类(抽象类):
java将流分为两类:节点流与处理流:实际应用中,我们可以通过串联一组高级流到某个低级流上以流水线式的加工处理对某设备的数据进行读写,这个过程也成为流的连接,这也是IO的精髓所在. 2.2字节流写数据
文件流文件输出流:java.io.FileOutputStream 2.3字节流写数据的3中方式2.4字节流写数据的两个小问题2.5字节流写数据加异常处理2.6字节流读数据（一次读一个字节数据）2.7字节流复制文本文件2.8字节流读数据（一次读一个字节组数据）2.9块读写的文件复制操作2.10 写文本数据2.11文件输出流——追加模式2.12 读取文本数据2.13高级流
缓冲流
使用缓冲流完成文件复制操作缓冲输出流写出数据时的缓冲区问题 对象流字符流
转换流缓冲字符流
2.1 IO流概述和分类.
java io可以让我们用标准的读写操作来完成对不同设备的读写数据工作.
java将IO按照方向划分为输入与输出,参照点是我们写的程序.
输入:用来读取数据的,是从外界到程序的方向,用于获取数据.
输出:用来写出数据的,是从程序到外界的方向,用于发送数据.
java将IO比喻为"流",即:stream. 就像生活中的"电流",“水流"一样,它是以同一个方向顺序移动的过程.只不过这里流动的是字节(2进制数据).所以在IO中有输入流和输出流之分,我们理解他们是连接程序与另一端的"管道”,用于获取或发送数据到另一端.
Java定义了两个超类(抽象类):java.io.InputStream:所有字节输入流的超类,其中定义了读取数据的方法.因此将来不管读取的是什么设备(连接该设备的流)都有这些读取的方法,因此我们可以用相同的方法读取不同设备中的数据java.io.OutputStream:所有字节输出流的超类,其中定义了写出数据的方法. java将流分为两类:节点流与处理流:
节点流:也称为低级流.节点流的另一端是明确的,是实际读写数据的流,读写一定是建立在节点流基础上进行的.处理流:也称为高级流.处理流不能独立存在,必须连接在其他流上,目的是当数据流经当前流时对数据进行加工处理来简化我们对数据的该操作. 实际应用中,我们可以通过串联一组高级流到某个低级流上以流水线式的加工处理对某设备的数据进行读写,这个过程也成为流的连接,这也是IO的精髓所在.
IO：输入/输出（Input/Output）
流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输成为流，流的本质是数据传输。
IO流就是用来处理设备间数据传输问题的。
常见的应用：文件复制；文件上传；文件下载
IO流分类：
按数据的方向：
输入流：读数据
输出流：写数据
按数据类型分：
字节流：字节输入流；字节输出流
字符流：字符输入流；字符输出流
一般来说，我们说IO流的分类是按照数据类型来分的，那么这两种流都在什么情况下使用呐？
如果数据通过windows自带的记事本软件打开，我们还可以读懂里面的内容就使用字符流，否则使用字节流。不知道何种类型就是用字节流。 2.2字节流写数据
字节流抽象基类
InputStream：这个抽象类是表示输入流的所有类的超类OutputStream：这个抽象类是表示输出流的所有类的超类子类名特点：子类名称都是以其父类名作为子类名的后缀
使用字节输出流写数据的步骤：
创建字节输出流对象（调用系统创建文件；创建字节输出流对象；让字节输出流对象指向文件）调用字节输出流对象的书写数据方法释放资源（关闭文件输出流并释放与此流相关联的任何系统资源） 文件流
文件流是一对低级流,用于读写文件数据的流.用于连接程序与文件(硬盘)的"管道".负责读写文件数据.
文件输出流:java.io.FileOutputStreampackage io;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FOSDemo {
public static void main(String[] args) throws IOException {
//向当前目录下的demo.dat文件中写入数据
//文件流创建时，如果该文件不存在会自动将其创建(前提是该文件所在目录必须存在!)
FileOutputStream fos = new FileOutputStream("./demo.dat");
fos.write(1);
fos.write(2);
fos.close();
System.out.println("执行完了!");
}
}
package exercise.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo01 {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("fos.txt");
//void write(int b):将指定的字节写入此文件输出流
fos.write(97);
//fos.write(57);
//fos.write(55);
fos.close();
}
}
2.3字节流写数据的3中方式
| 方法名 | 说明 |
|---|---|
| void write(int b) | 将指定的字节写入此文件输出流，一次写一个字节数据 |
| void write(byte[] b) | 将b.length字节从指定的字节数组写入此文件输出流，一次写一个字节数组数据 |
| void write(byte[] b, int off, int len) | 将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流，一次写一个字节数组的部分数据 |
package exercise.File;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo02 {
public static void main(String[] args) throws IOException {
//FileOutStream(String name):创建文件输出流以指定的名称写入文件
FileOutputStream fos1 = new FileOutputStream("fos1.txt");
FileOutputStream fos2 = new FileOutputStream("fos2.txt");
FileOutputStream fos3 = new FileOutputStream("fos3.txt");
//new File (name)
// FileOutputStream fos2 = new FileOutputStream(new File("fos2.txt"))
//1.void write(int b),将指定的字节写入此文件输出流
fos1.write(97);
fos1.write(98);
fos1.write(99);
fos1.write(100);//abcd
//2.void write(byte[] b),将b.length字节从指定的字节数组写入此文件输出流
byte[] bytes = {97,98,99,100};
fos2.write(bytes);//abcd
byte[] bytes1 = "efgh".getBytes();
fos2.write(bytes1);//abcdefgh
//3.void write(byte[] b,int off,int len),将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流
fos3.write(bytes,0,bytes.length);//abcd
//释放资源
fos1.close();
fos2.close();
fos3.close();
}
}
2.4字节流写数据的两个小问题
字节流写数据如何实现换行呐？
windows:rn
linux:n
mac:r
字节流写数据如何实现追加写入呐？
public FileOutputStream(String name,boolean append) throws FileOutputStream创建文件输出流以指定的名称写入文件，如果第二个 参数为true，则字节将写入文件的末尾而不是开头
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo03 {
public static void main(String[] args) throws IOException {
//创建字节输出流对象
//FileOutputStream fos = new FileOutputStream("fos.txt");
FileOutputStream fos = new FileOutputStream("fos.txt",true);
//写数据
for (int i = 0; i < 10; i++) {
fos.write("hello".getBytes());
//hellohellohellohellohellohellohellohellohellohello
fos.write("n".getBytes());//换行输出,但用记事本打开仍没有换行
fos.write("rn".getBytes());//可行
}
//释放资源
fos.close();
}
}
2.5字节流写数据加异常处理
finally：在异常处理时提供finally块来执行所有清楚操作。比如说IO流中的释放资源。
特点：被finally控制的语句一定会执行，除非JVM退出。
try{
可能出现异常的代码；
}catch(异常类名 变量名){
异常的处理代码；
}finally{
执行所有清楚操作；
}
空2.6字节流读数据（一次读一个字节数据）
需求:把文件fos.txt中的内容读取出来在控制台输出
FileInputStream：从文件系统中的文件获取输入字节。
FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream,该文件由文件系统中的路径名name命名。
使用字节输入流都数据的步骤：
1.创建字节输入流对象
2.调用字节输入流对象的读数据方法
3.释放资源
package exercise01;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStream01 {
public static void main(String[] args) throws IOException {
//创建字节输入流对象
FileInputStream fis = new FileInputStream("fos1.txt");
//调用字节输入流对象的读数据方法,int read():从该输入流读取一个字节的数据
int by;
while((by = fis.read()) != -1){
System.out.println((char)by);
}
//释放资源
fis.close();
}
}
2.7字节流复制文本文件
package io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyDemo {
public static void main(String[] args) throws IOException {
//创建文件输入流读取原文件
FileInputStream fis = new FileInputStream("image.jpg");
//创建文件输出流写入复制文件
FileOutputStream fos = new FileOutputStream("image_cp.jpg");
int d;//保存每次读取到的字节
long start = System.currentTimeMillis();//获取当前系统时间的毫秒值(UTC时间)
while((d = fis.read()) != -1) {
fos.write(d);
}
long end = System.currentTimeMillis();//获取当前系统时间的毫秒值(UTC时间)
System.out.println("复制完毕!耗时:"+(end-start)+"ms");
fis.close();
fos.close();
}
}
需求：把E:File斗罗大陆.txt复制到模块目录下的“斗罗大陆.txt”.
分析：
1.复制文本文件，其实就把文本文件的内容从一个文件中读取出来（读数据），然后写入到另一个文件中（目的地）；
2.数据源：E:File斗罗大陆.txt-----读数据----InputStream----FileInputStream.
3.目的地：斗罗大陆.txt-----写数据—OutputStream----FileOutputFile.
思路：
1.根据数据源创建字节输入流对象；
2.根据目的地创建字节输出流对象；
3.读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）；
4.释放资源。
package exercise01;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyTxtDemo {
public static void main(String[] args) throws IOException {
//1.根据数据源创建字节输入流对象；
FileInputStream fis = new FileInputStream("E:\File\斗罗大陆.txt");
//2.根据目的地创建字节输出流对象；
FileOutputStream fos = new FileOutputStream("斗罗大陆.txt");
//3.读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）
int by;
while((by = fis.read())!= -1){
fos.write(by);
}
//4.释放资源。
fis.close();
fos.close();
}
}
2.8字节流读数据（一次读一个字节组数据）
需求：把文件fos.txt中的内容读取出来在控制台输出
1.创建字节输入流对象
2.调用字节输入流对象的读数据方法
3.释放资源
package exercise01;
import com.sun.org.apache.xpath.internal.operations.String;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStream02 {
public static void main(String[] args) throws IOException {
//1.创建字节输入流对象
FileInputStream fis = new FileInputStream("fos.txt");
//2.调用字节输入流对象的读数据方法
//int read(byte[] b):从该输入流读取最多b.length个字节的数据到下一个字节数组
byte[] bys = new byte[1024];
int len;
while((len = fis.read())!=-1){
System.out.println(new String(bys,0,len));
}
fis.close();
}
}
2.9块读写的文件复制操作
int read(byte[] data)一次性从文件读取给定的字节数组总长度的字节量，并存入到该数组中。返回值为实际读取到的字节量。若返回值为-1则表示读取到了文件末尾。
块写操作void write（byte[] data）一次性将给定的字节数组所有字节写入到文件中。
void write（byte[] data,int offset,int len）一次性将给定的字节数组从下标offset除开始的连续len个字节写入文件。
package io;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyDemo2 {
public static void main(String[] args) throws IOException {
//使用块读写形式完成文件复制
//创建文件输入流读取文件
FileInputStream fis = new FileInputStream("1.mp4");
//创建文件输出流写入文件
FileOutputStream fos = new FileOutputStream("10.mp4");
int len;
byte[] data = new byte[1024*10];
while((len = fis.read(data))!=-1){
fos.write(data,0,len);
}
System.out.println("写出完毕");
fis.close();
fos.close();
}
}
2.10 写文本数据
String提供方法：byte[] getBytes(String charsetName),将当前字符串转换为一组字节。
参数为字符集的名字，常用的是UTF-8。其中中文3字节表示1个，英文1字节表示一个。
package io;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
public class WriteStringDemo {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("demo.txt");
String str = "super idol的笑容都没你的甜";
byte[] data = str.getBytes(StandardCharsets.UTF_8);
fos.write(data);
fos.write("正午的阳光".getBytes(StandardCharsets.UTF_8));
System.out.println("写入完毕");
}
}
2.11文件输出流——追加模式
FileOutputStream(String path,boolean append)FileOutPutStream(File file,boolean append)
当第二个参数传入true时，文件流为追加模式，即：指定的文件若存在，则原有数据保留，新写入的数据会被顺序的追加到文件中。
package io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class FileAppendDemo {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("demo.txt",true);
fos.write("化学".getBytes(StandardCharsets.UTF_8));
fos.write("数学".getBytes(StandardCharsets.UTF_8));
fos.write("语文".getBytes(StandardCharsets.UTF_8));
System.out.println("写入完毕");
fos.close();
}
}
2.12 读取文本数据
package io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class ReadStringDemo {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("demo.txt");
byte[] data = new byte[1024];
int len = fis.read(data);
System.out.println("读取到了"+len+"字节");//读取到了79字节
String line = new String(data ,0,len,"UTF-8");
System.out.println(line);
System.out.println(line.length());//33
fis.close();
}
}
2.13高级流
连接示意图
缓冲流java.io.BufferedOutputStream和java.io.BufferedInputStream
缓冲流是一对高级流，作用是提高读写数据的效率。
缓冲流内部有一个字节数组，默认长度为8K。缓冲流读写数据时一定是将数据的读写方式转换为块读写来保证读写效率。
使用缓冲流完成文件复制操作package io;
import java.io.*;
public class CopyDemo3 {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("1.mp4");
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream("2.mp4");
BufferedOutputStream bos = new BufferedOutputStream(fos);
int d;
long start = System.currentTimeMillis();
while((d = bis.read())!=-1){//使用缓冲流读取字节数据
fos.write(d);//使用缓冲流写出字节
}
long end = System.currentTimeMillis();
System.out.println("写出完毕的时间："+(end-start));
bos.close();//关闭流时只需要关闭高级流即可，它会自动关闭它连接的流
bis.close();
}
}
缓冲输出流写出数据时的缓冲区问题
通过缓冲流写出的数据会被临时存入缓冲流内部的字节数组，直到数组存满数据才会真实写出一次。
package io;
import java.io.*;
import java.nio.charset.StandardCharsets;
public class BOSDemo {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("bos.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
String line = "你好，java。";
byte[] bytes = line.getBytes(StandardCharsets.UTF_8);
bos.write(bytes);
bos.flush();
System.out.println("写出完毕");
bos.close();
}
}
对象流
java.io.ObjectOutputStream和ObjectInputStream
对象流时一对高级流，在流的连接中的作用是对对象的序列化与反序列化。
对象序列化：将一个java对象按照其结构转换为一组字节的过程。
对象反序列化：将一组字节还原为java对象(前提是这组字节是一个序列化得到的字节)
对象序列化的流连接操作原理图：
序列化：
package io;
import java.io.Serializable;
import java.util.Arrays;
public class Person implements Serializable {
static final long serialVersionUID = 1L;
private String name;//姓名
private int age;//年龄
private String gender;//性别
private String[] otherInfo;//其他信息
//private int salary;//工资
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String[] getOtherInfo() {
return otherInfo;
}
public void setOtherInfo(String[] otherInfo) {
this.otherInfo = otherInfo;
}
public Person(String name, int age, String gender, String[] otherInfo) {
this.name = name;
this.age = age;
this.gender = gender;
this.otherInfo = otherInfo;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", age=" + age +
", gender='" + gender + ''' +
", otherInfo=" + Arrays.toString(otherInfo) +
'}';
}
}
package io;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class OOSDemo {
public static void main(String[] args) throws IOException {
String name = "苍老师";
int age = 28;
String gender = "男";
String [] otherInfo = {"是一名演员","来自霓虹","爱好书法"};
//重写toString方法，否则输出对象名为类名@地址
//未重写：io.Person@232204a1 类名@地址
Person p = new Person(name,age,gender,otherInfo);
System.out.println(p);//输出p.toString()返回值
//Person{name='苍老师', age=28, gender='男', otherInfo=[是一名演员, 来自霓虹, 爱好书法]}
//将Person对象写入文件Person.obj中
FileOutputStream fos = new FileOutputStream("./Person.obj");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(p);
System.out.println("写出完毕");
oos.close();
}
}
对象反序列化：
package io;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class OISDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
FileInputStream fis = new FileInputStream("Person.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
//抛出异常的操作：alt+enter(回车)
Person p = (Person) (ois.readObject());
System.out.println(p);
ois.close();
}
}
字符流
java将流按照读写单位划分为字节流和字符流。java.io.InputStream和java.io.OutputStream是所有字节流的超类而java.io.Reader和Writer是所有字符流的超类，他们和字节流的超类是平级关系。Reader和Writer是两个抽象类，里面规定所有字符流都必须具备的读写字符的相关方法。字符流最小读写单位为字符（char）,但是底层实际还是读写字节，只是字符与字节的转换工作由字符流完成。 转换流
java.io.InputStreamReader和OutputStreamWriter
他们是字符流非常常用的一对实现类同时也是一对高级流，实际开发中我们不直接操作他们，但是他们在流连接中是非常重要的一环。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r9Ehs2jH-1644756927773)(E:达内图片转换输出流写数据.png)]
使用转换输出流写文本文件
package io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OSWDemo {
public static void main(String[] args) throws IOException {
//向文件osw.txt中写入文字
FileOutputStream fos = new FileOutputStream("osw.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos);
osw.write("我可以接受你的所有，所有小脾气。");
osw.write("我可以带你去吃很多,很多好东西。");
System.out.println("写出完毕");
osw.close();
}
}
使用转换输入流读取文本文件
package io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
public class ISRDemo {
public static void main(String[] args) throws IOException {
//将osw.txt文件中的所有文字读取回来
FileInputStream fis = new FileInputStream("osw.txt");
InputStreamReader isr = new InputStreamReader(fis);
//循环将文件所有字符读取回来
int d;
while((d = isr.read())!=-1){
System.out.print((char)d);
}
isr.close();
}
}
转换流的意义：
实际开发中我们还有功能更好用的字符高级流，但是其他的字符高级流都有一个共同点：不能直接连接在字节流上。而实际操作设备的流都是低级流。同时也都是字节流。因此不能直接在流连接中串联起来。转换流是一对可以连接在字节流上的字符流。其他的高级字符流可以连接在转换流上，在流连接中起到”转换器“的作用（负责字符与字节的实际转换）。
缓冲字符流缓冲字符输出流：java.io.PrintWriter
java.io.BufferedWriter和BufferedReader
缓冲字符流内部也有一个缓冲区，读写文本数据以块读写形式加快效率，并且并且缓冲流有一个特别的功能:可以按行读写文本数据.
java.io.PrintWriter具有自动行刷新的缓冲字符输出流,实际开发中更常用.它内部总是会自动连接BufferedWriter作为块写加速使用.
package io;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
public class PWDemo {
public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
//向文件中写入字符串
PrintWriter pw = new PrintWriter("pw.txt","UTF-8");
pw.println("我看过沙漠下暴雨");
pw.println("看过大海亲吻鲨鱼");
pw.println("看过黄昏追逐黎明");
pw.println("没看过你");
System.out.println("写出完毕");
pw.close();
}
}
流链接中使用PW
package io;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class PWDemo2 {
public static void main(String[] args) throws FileNotFoundException {
//文件字节输出流(是一个字节流)，向文件中写入字节数据
FileOutputStream fos = new FileOutputStream("pw2.txt",true);
//转换输出流(是一个高级流，且是一个字符流)1.衔接字节流2.将字符转换位字节
OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
//缓冲输出流(是一个高级流，且是一个字符流)。块读写数据加速
BufferedWriter bw = new BufferedWriter(osw);
//具有自动行刷新的缓冲字符流
PrintWriter pw = new PrintWriter(bw);
//完成简易记事本。控制台输入的每行字符串都执行写入文件。单独输入exit是推出。
Scanner scanner = new Scanner(System.in);
while(true){
String line = scanner.nextLine();
if("exit".equalsIgnoreCase(line)){
break;
}
pw.println(line);
}
pw.close();
}
}
PrintWriter的自动行刷新功能
如果实例化PW时第一个参数传入的是一个流，则此时可以在传入一个boolean型的参数，此值位true时就打开了自动行刷新，每当我们应PW的println方法写出一行字符串后就会自动flush.
package io;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class PWDemo3 {
public static void main(String[] args) throws FileNotFoundException {
//文件字节输出流（低级流）,向文件中写入数据
FileOutputStream fos = new FileOutputStream("pw3.txt",true);
//转换输出流(一个高级流，且是一个字符流)。1.衔接字符与字节流2.将字符流转换位字节流
OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
// OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
//缓冲字符流(高级流)。块写文本数据加速。
BufferedWriter bw = new BufferedWriter(osw);
//加上true具有了自动行刷新功能
PrintWriter pw = new PrintWriter(bw,true);
//完成简易记事本
Scanner scanner = new Scanner(System.in);
while(true){
String line = scanner.nextLine();
if("exit".equalsIgnoreCase(line)){
break;
}
pw.println();
}
pw.close();
}
}
缓冲字符输入流:java.io.BufferedReader
是一个高级字符流，特点是块读文本数据，并且可以按行读取字符串。
package io;
import java.io.*;
public class BRDemo {
public static void main(String[] args) throws IOException {
//将当前源程序读取出来并输出到控制台上
FileInputStream fis = new FileInputStream("pw2.txt");
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
String line;
while((line = br.readLine())!=null){
System.out.println(line);
}
br.close();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fE8RQtl5-1644756927774)(E:达内图片IO总结.png)]
加上true具有了自动行刷新功能
PrintWriter pw = new PrintWriter(bw,true);
//完成简易记事本
Scanner scanner = new Scanner(System.in);
while(true){
String line = scanner.nextLine();
if(“exit”.equalsIgnoreCase(line)){
break;
}
pw.println();
}
pw.close();
}
}
**缓冲字符输入流:java.io.BufferedReader**
是一个高级字符流，特点是块读文本数据，并且可以按行读取字符串。
```java
package io;
import java.io.*;
public class BRDemo {
public static void main(String[] args) throws IOException {
//将当前源程序读取出来并输出到控制台上
FileInputStream fis = new FileInputStream("pw2.txt");
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
String line;
while((line = br.readLine())!=null){
System.out.println(line);
}
br.close();
}
}
