IO流
IO流
虹色轨迹🌠IO简介
In/Out: 相对于程序而言的输入(读取)和输出(写出)的过程。
即: 通过java程序到磁盘读取数据的过程, 我们称为In的过程, 也就是读取(输入)
将java程序中的数据写入磁盘的过程, 我们称为Out的过程, 也就是写出(输出)
在Java中，根据处理的数据单位不同，分为字节流和字符流。
字节流: 一个字节(byte)一个字节的去读取, 或者写出
字符流: 一个字符一个字符的去读取, 或者写出
JDK核心类库中提供了IO流相关的类, 这些类都在
流的概念
程序中数据的读取和写入, 可以想象成水流在管道中流动。
- 流只能单方向流动
- 输入流用来读取in
- 输出流用来写出Out
- 数据只能从头到尾顺序的读取一次或写出一次
节点流和处理流
按照流是否直接与特定的地方(如磁盘,内存,设备等)相连,分为节点流和处理流两类
节点流
可以从或向一个特定的地方(节点)读写数据
处理流
是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写
处理流特点
处理流的构造方法总是要带一个其他的流对象做参数,一个流对象经过其他流的多次包装,成为流的链接.
通常节点流也被称之为低级流.处理流也被称之为高级流或者过滤流
不能独立存在, 必须要连接低级流
节点流
OutputStream抽象类
Output输出 Stream字节流
此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。
FileOutputStream文件输出流
直接插在文件上，直接写出文件数据
创建对象：FileOutputStream(String name)
• 创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(File file)
• 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(File file, boolean append) –追加
• 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
注意: 以上构造方法中, 如果参数指向的文件以及父目录都不存在, 将会抛出FileNotFoundException异常!
如果参数指向的文件不存在, 但文件的所在目录存在, 将不会抛异常, 程序会自动创建该文件!
FileOutputStream代码案例package io;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* FOS FileOutputStream 文件输出流
* 对File文件进行写出Output,使用的方式是Stream字节流
*/
public class FOSDemo {
public static void main(String[] args) throws IOException {
//1.创建FileOutputStream输出流,将数据输出到./test.txt文件中
//File file = new File("./test.txt");
//FileOutputStream fos = new FileOutputStream(file);
//可以直接将文件的相对路径当做参数传递给流的构造方法
//true如果不写,则默认是覆盖模式,每次写入内容,都会覆盖原有内容
//如果写true,就是追加模式,不会覆盖原有内容
FileOutputStream fos = new FileOutputStream("./test.txt",true);
//2.开始向test.txt
//向文件写出一个字节 参数单位是int
//一个整数4个字节 传的是给定的int值的最后一个字节
//00000000 00000000 00000000 00000001
fos.write(1);//00000001
fos.write(97);
fos.write(98);
fos.write(99);
fos.write(13);//回车
fos.write(10);//换行
//输出byte数组 \r\n 是回车换行
fos.write("Hello EveryBody\r\n".getBytes());
//输出byte数组的一部分,输出BCD,1表示ABCDE中的下标1处的元素(B),3表示输出后面的3个字节
fos.write("ABCDE".getBytes(),1,3);
System.out.println("输出完成");
//3.关闭流(释放资源)
fos.close();
}
}
InputStream抽象类
此抽象类是表示字节输入流的所有类的超类/抽象类。
FileInputStream子类
直接插在文件上，直接读取文件数据。
创建对象
FileInputStream(File file)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
FileInputStream(String pathname)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
FileInputStream代码案例package io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* FIS FileInputStream 文件字节输入流
*/
public class FISDemo {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("./test.txt");
//使用read方法每次读取文件中的一个字节
//System.out.println((char)fis.read());
//....
//read方法读取不到内容时,会返回-1
//System.out.println(fis.read());
//System.out.println(fis.read());
//while一般用于循环次数不确定 for一般用于利用循环次数
int data;
//循环条件是判断读取的字节是否是-1,并且把读取到的字节整数赋值给data,便于输出
while ((data = fis.read())!=-1){//不等于-1说明能读到东西
System.out.print((char)data);
}
//关闭流
fis.close();
}
}
复制文件
复制文件代码案例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("./ATM.jpeg");
//创建一个输出流,将读取的原文件内容写出到目标文件中
FileOutputStream fos = new FileOutputStream("./ATMCopy.jpeg");
int d;//记录每次读取到的字节
long start = System.currentTimeMillis();
while ((d = fis.read())!=-1){//每次循环读取一个字节
//每次循环也将读取到的字节写入到复制文件中
fos.write(d);
}
long end = System.currentTimeMillis();
System.out.println("复制完毕!共耗时:"+(end-start)+"ms");
//关闭流资源
fis.close();
fos.close();
}
}
快读写优化代码案例
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("./aaa.jpg");
FileOutputStream fos = new FileOutputStream("./ccc.jpg");
/*
* 1.简单介绍实现思路
* int read(byte[] data) 一次性读取给定的字节数组data总长度的字节量,
* 返回的是实际读取到的字节量.如果返回的是-1时,表示读取到了末尾
* 2.假定该文件就只有7个字节,然后四个字节一读取
* aaa.jpg文件数据:
* 10101010 10001101 10101000 00010010 10010110 10010101 01010101
* byte[] data = new byte[4];
* int len;该变量返回读取的字节数
* 3.第一次调用方法读取4个字节
* int len = read(data);
* aaa.jpg文件数据:
* 10101010 10001101 10101000 00010010 10010110 10010101 01010101
* ^^^^^^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^^^
* data:[10101010,10001101,10101000,00010010]
* len:4 表示实际读取到了4个字节
* 4:第二次调用方法读取4个字节,只剩三个字节
* int len = read(data);
* aaa.jpg文件数据:
* 10101010 10001101 10101000 00010010 10010110 10010101 01010101
* ^^^^^^^^ ^^^^^^^^ ^^^^^^^^
* data:[10010110,10010101,01010101,00010010]
* |----本次读到的新数据--------||-旧数据--|
* len:3 表示实际读取到了3个字节
* 5:第三次调用方法读取4个字节,但是已经没有内容可以读取了
* data:[10010110,10010101,01010101,00010010]
* len:-1 表示文件末尾了
*/
/* byte[] data = new byte[10];
* 1KB=1024byte
* 1MB=1024KB
* 1GB=1024MB
* int t = 864000000;
* int t = 60*60*24*1000
*/
byte[] data = new byte[1024*10];//10kb
int len;//记录每次读取到的字节
long start = System.currentTimeMillis();
while ((len = fis.read(data))!=-1){//每次循环读取一个字节
//从下标0处开始写入,写入后面len个的字节
fos.write(data,0,len);
}
long end = System.currentTimeMillis();
System.out.println("复制完毕!共耗时:"+(end-start)+"ms");
fis.close();
fos.close();
}
}
写入字符串package io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
/**
* @author 老安
* @data 2022/6/14 19:44
* 向文件中写出字符串
*/
public class WriteStringDemo {
public static void main(String[] args) throws IOException {
//向文件demo.txt写出文本数据
FileOutputStream fos = new FileOutputStream("./demo.txt");
String line = "smell smelly,taste tasty";//闻着臭吃着香
//将字符串转换为字节数组,通常要指定转换的编码UTF-8
//java.nio.charset.StandardCharsets;
//StandardCharsets.UTF_8 表示UTF-8编码
byte[] data = line.getBytes(StandardCharsets.UTF_8);
fos.write(data);
fos.write("闻着臭,吃着香".getBytes(StandardCharsets.UTF_8));
fos.close();
}
}
简易笔记本package io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
/**
* @author 老安
* @data 2022/6/14 20:26
* 实现简易记事本工具
* 程序启动后,要求将控制台输入的每一行字符串,写入到文件note.txt
* 当在控制台输入exit时,程序退出
*/
public class TestNotes {
public static void main(String[] args) throws IOException {
System.out.println("请开始输入内容,单独输入exit退出记事本!");
//接收控制台输入的内容的扫描器
Scanner scanner = new Scanner(System.in);
//使用文件输出流绑定note.txt文件
FileOutputStream fos = new FileOutputStream("./note.txt");
while (true){//因为不知道什么时候写完,所以定义一个死循环
//接收在控制台输入的一行字符串
String line = scanner.nextLine();
//如果line是exit时,退出循环
//由于line是用户输入的,现在不好控制,所以可能会输入一个空值,
//空值调用方法,一定会发生空指针异常
//equalsIgnoreCase String也提供了一个比较字符串向同时,忽略大小写差异
if ("exit".equalsIgnoreCase(line)){
break;//break跳出当前循环,直接执行循环之后的内容
}
fos.write(line.getBytes(StandardCharsets.UTF_8));
}
//执行完就关闭流
fos.close();
}
}
文件追加模式案例package io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
/**
* @author 老安
* @data 2022/6/14 20:26
* 实现简易记事本工具
* 程序启动后,要求将控制台输入的每一行字符串,写入到文件note.txt
* 当在控制台输入exit时,程序退出
*/
public class TestNotes {
public static void main(String[] args) throws IOException {
System.out.println("请开始输入内容,单独输入exit退出记事本!");
//接收控制台输入的内容的扫描器
Scanner scanner = new Scanner(System.in);
//使用文件输出流绑定note.txt文件
FileOutputStream fos = new FileOutputStream("./note.txt",true);
while (true){//因为不知道什么时候写完,所以定义一个死循环
//接收在控制台输入的一行字符串
String line = scanner.nextLine();
//如果line是exit时,退出循环
//由于line是用户输入的,现在不好控制,所以可能会输入一个空值,
//空值调用方法,一定会发生空指针异常
//equalsIgnoreCase String也提供了一个比较字符串向同时,忽略大小写差异
if ("exit".equalsIgnoreCase(line)){
break;//break跳出当前循环,直接执行循环之后的内容
}
fos.write(line.getBytes(StandardCharsets.UTF_8));
}
//执行完就关闭流
fos.close();
}
}
处理流
缓冲流
- BufferedOutputStream缓冲输出流
- BufferedInputStream 缓冲输入流
复制文件代码案例
package io;
import java.io.*;
/**
* @author 老安
* @data 2022/6/14 21:31
* 使用缓冲流实现高效率文件复制
*/
public class CopyDemo3 {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("./aaa.jpg");
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream("./ddd.jpg");
BufferedOutputStream bos = new BufferedOutputStream(fos);
//此案例还是用单字节读取,之前读取很慢,现在用高级流测试
int d;
long start = System.currentTimeMillis();
while ((d = bis.read())!=-1){//使用缓冲流读取字节
bos.write(d);//使用缓冲流写入字节
}
long end = System.currentTimeMillis();
System.out.println("耗时:"+(end-start)+"ms");
//关闭流 如果使用了高级流,就只需要关闭高级流就可以了,会自动关闭所连接的低级流
bis.close();
bos.close();
}
}
flush代码案例package io;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
/**
* @author 老安
* @data 2022/6/14 21:55
* 缓冲流写出数据的缓冲区问题
*/
public class BOS_flushDemo {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("./bos.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
bos.write("你是我的眼~~~~~~".getBytes(StandardCharsets.UTF_8));
//如果不调用close方法,执行完毕,bos.txt没有内容
//bos.flush();
bos.close();
}
}
对象流
Person代码package io;
import java.io.Serializable;
import java.util.Arrays;
/**
* @author 老安
* @data 2022/6/16 19:50
* 使用当前类测试对象流的序列化和反序列化操作
* 对象序列化:将一个java对象按照其结构转换为一组字节的过程
* 序列化一个对象时,底层会为当前的Person生成一个版本号serialVersionUID
* 在读取对象,会先比对被序列化对象的版本号,和还原的对象类型的版本是否一致,
* 不一致,会抛出异常
* 如何解决?
* 开启兼容模式:自己指定一个版本号
* static final long serialVersionUID = 1L;
*/
public class Person implements Serializable {
//控制死当前类的版本号是1,将来如何改当前类的内容,版本号都不会发生改变
static final long serialVersionUID = 1L;
private String name;//姓名
//transient 当一个属性被transient修饰时,序列化时,就会忽略这个属性的值
//transient 转瞬即逝的,短暂的
private transient int age;//年龄
private String gender;//性别
private transient String[] otherInfo;//其他信息
//private int salary;//薪资
//全参构造
//alt+insert/右键 Generate-->Constructor crtl+A全选属性
public Person(String name, int age, String gender, String[] otherInfo) {
this.name = name;
this.age = age;
this.gender = gender;
this.otherInfo = otherInfo;
}
//get和set方法
//alt+insert/右键 Generate-->getter and setter crtl+A全选属性
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;
}
//toString
//alt+insert/右键 Generate-->toString()
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", gender='" + gender + '\'' +
", otherInfo=" + Arrays.toString(otherInfo) +
'}';
}
}
OOSDemo案例package io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/**
* @author 老安
* @data 2022/6/16 20:05
* 对象流
* java.io.ObjectOutputStream 对象输出流 序列化流
* java.io.ObjectInputStream 对象输入流 反序列化流
* 对象流是一对高级流,在流链接中完成对象与字节的转换,
* 学会了使用这组流,就可以轻松读取任何的java对象
*/
public class OOSDemo {
public static void main(String[] args) throws IOException {
String name = "康荐文";
int age = 18;
String gender = "男";
String[] otherInfo = {"单身的","帅气的","网络鉴黄师","多金"};
Person p = new Person(name, age, gender, otherInfo);
System.out.println(p);
//将p对象序列化到person.obj文件中
//创建一个文件输出流,绑定文件
FileOutputStream fos = new FileOutputStream("./person.obj");
//创建一个对象输出流,连接fos低级流
ObjectOutputStream oos = new ObjectOutputStream(fos);
/*
* writeObject(Object obj)
* 对象输出流独有的方法:该方法会将对象转换为字节,并将字节通过
* 所连接的流写出
* */
oos.writeObject(p);
System.out.println("写出完毕!");
//关闭流资源
oos.close();
/*
* java.io.NotSerializableException 执行这个程序时,出现此异常,
* 一定要检查序列化的类,是否实现了一个Serializable接口
* */
}
}
OISDemo案例package io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
/**
* @author 老安
* @data 2022/6/16 20:27
* 使用对象输入流进行对象的反序列化
*/
public class OISDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
FileInputStream fis = new FileInputStream("./person.obj");
//创建一个对象输入流,连接fis低级流
ObjectInputStream ois = new ObjectInputStream(fis);
/*
* Object readObject() 可以将文件中的字节读取出来,并且转换为java对象
* 这个方法的返回值是Object,一般都需要强转为实际类型
* */
Person p = (Person) ois.readObject();
System.out.println(p);
ois.close();
}
}
字节流和字符流
在Java中，根据处理的数据单位不同，分为字节流和字符流。
字节流: 一个字节(byte)一个字节的去读取, 或者写出
字符流: 一个字符一个字符的去读取, 或者写出
字节流
字节流(stream)：针对二进制文件(文本,图片,音频,视频…等)
InputStream(包含input都是输入流)
- FileInputStream
- BufferedInputStream
- ObjectInputStream
OutputStream(包含output都是输出流)
- FileOutputStream
- BufferedOutputStream
- ObjectOutputStream
字符流
字符流(Reader,Writer)：针对文本文件，读写容易发生乱码现象，在读写时最好指定编码集为utf-8
Reader(Reader结尾的都是字符输入流)
- FileReader
- BufferedReader
- InputStreamReader
Writer(Writer结尾的都是字符输出流)
- FileWriter
- BufferedWriter
- OutputStreamWriter
- PrintWriter/PrintStream
转换字符流
OutputStreamWriter
代码案例package io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
/**
* @author 老安
* @data 2022/6/16 21:22
* java IO 将流按照读写的单位分为字节流和字符流
* java.io.InputStream和OutputStream 是所有字节输入流和输出流的超类,
* 读写的最小单位是字节
* 而java.io.Reader和Writer 是所有字符输入流和输出流的超类,
* 读写的最小单位是字符
* 转换流:是一对常用字符流实现类:(写代码不常用,但是流链接很重要)
* java.io.InputStreamReader
* java.io.OutputStreamWriter
* 作用:
* 1:在流链接中衔接其他的高级字符流和下面的字节流(这也是转换流名字的由来)
* 2:负责将字符与对应的字节按照指定的字符集自动转换方便读写操作
*/
public class OSWDemo {
public static void main(String[] args) throws IOException {
//向osw.txt写入文本数据
//创建一个低级的字节流
FileOutputStream fos = new FileOutputStream("./osw.txt");
//String line = "super idol的笑容都没你的甜~~~";
//fos.write(line.getBytes(StandardCharsets.UTF_8));
//创建一个字符流(转换流),连接低级的字节流fos
//通常都需要指定字符集编码
OutputStreamWriter osw = new OutputStreamWriter(fos,StandardCharsets.UTF_8);
osw.write("super idol的笑容都没你的甜~~~");
osw.write("八月正午的阳光都没你耀眼");
osw.write("天天向上");
osw.close();
}
}
InputStreamReader
代码案例package io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* @author 老安
* @data 2022/6/16 21:43
* 使用转换流测试读取文本数据
*/
public class ISRDemo {
public static void main(String[] args) throws IOException {
//将osw.txt中所有内容读取出来,并输出到控制台
FileInputStream fis = new FileInputStream("./osw.txt");
//创建一个字符转换流,连接fis低级输入流
InputStreamReader isr = new InputStreamReader(fis);
//读取一个字符,返回的int值内容本质上是一个char
//但是如果返回的是-1,表示读取到了末尾
//int d = isr.read();
//System.out.println((char)d);
int d;
while ((d = isr.read())!=-1){
System.out.print((char)d);
}
isr.close();
}
}
缓冲字符流
PrintWriter
代码案例package io;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
/**
* 缓冲字符流
* java.io.BufferedWriter和BufferedReader
* 缓冲字符流内部维护了一个数组,可以块读写文本数据进行读写性能的提升
*
* java.io.PrintWriter 具有自动行刷新功能的缓冲字符输出流,内部总是连接着BufferedWriter
* 实际开发中,缓冲输出字符流我们就用这个PW
* 特点:
* 1:可以按行写字符串
* 2:可以自动行刷新
* 3:可以提高读写字符的效率
*/
public class PWDemo {
public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
//向文件pw.txt中写入文本数据
//此处可以指定编码,但是StandardCharset还没有发现,所以需要字符串指定编码
PrintWriter pw = new PrintWriter("./pw.txt", "UTF-8");
//print 不带换行 println 自带换行
pw.println("该配合你演出的我视而不见");
pw.println("阿巴阿巴阿巴阿巴阿巴阿巴");
System.out.println("写出完毕");
pw.close();
}
}
代码案例2package 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);
//具有自动行刷新功能的缓冲字符输出流
//当值设置为true时,表示打开了自动行刷新,每次调用println方法时,会自动调用flush一次
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(line);
}
pw.close();
}
}
