IO流
字节流
IO流的概述和分类
IO流概述：
-
IO：输入/输出(Input/Output)
-
流：是一种抽象概念，是对数据传输的总称，也就是说数据在设备间的传输称为流，流的本质是数据传输
-
IO流就是用来处理设备间数据传输问题的
常见的应用：文件复制；文件上传；文件下载
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zyYRWWFj-1629101681830)(C:\Users\zhou\AppData\Roaming\Typora\typora-user-images\image-20210816103119592.png)]
IO流分类：
- 按照数据的流向
- 输入流：读数据
- 输出流：写数据
- 按照数据类型来分
- 字节流：
- 字节输入流；字节输出流
- 字符流：
- 字符输入流；字符输出流
- 字节流：
字节流写数据
字节流抽象基类
- InputStream: 这个抽象类是表示字节输入流的所有类的超类
- OutputStream: 这个抽象类是表示字节输出流的所有类的超类
- 子类名特点：子类名称都是以父类名作为子类名后缀
FileOutPutStream: 文件输出流用于将数据写入File
- FileOutPutStream(String name): 创建文件输出流以指定的名称写入文件
使用字节输出流写数据的步骤:
-
创建字节输出流对象（调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件）
-
调用字节输出流对象的写数据方法
-
释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）
//创建字节输出流对象 FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt"); //底层：FileOutputStream fos = new FileOutputStream(new File("myByteStream\\fos.txt")); //调用字节输出流对象的写数据方法 fos.write(97); //最后都要释放资源 fos.close();
字节流写数据的3种方式
void write(int b): 将指定的字节写入此文件输入流，一次写一个数据
FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
fos.write(97);
fos.write(98);
fos.write(99);
fos.close();
void write(byte[] b): 将b.length字节从指定的字节数组写入此文件输出流，一次写一个字节数组数据
FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
byte[] bys = {97, 98, 99, 100, 101};
fos.write(bys);
fos.close();
void write(byte[] b, int off, int len): 将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流，一次写一个字节数组的部分数据
FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
//byte[] getBytes(): 返回字符串对象的字节数组
byte[] bytes = "abcde".getBytes();
fos.write(bytes, 0, bytes.length); //abcde
fos.write(bytes, 1, 3); //bcd
fos.close();
字节流写数据的两个小问题
1.字节流写数据如果实现换行呢？
每写完一行后，往文件中输出一个换行符即可。
- window: \n
- linux: \n
- max: \n
//创建字节输出流对象
FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
//写数据
for (int i = 0; i < 10; i++) {
fos.write("hello".getBytes());
fos.write("\n".getBytes());
}
//释放资源
fos.close();
2.字节流写数据如何实现追加写入？
-
使用FileOutputStream的如下构造方法：
public FileOutputStream(String name, boolean append)
-
将第二个参数append设为true，表示这个文件输出流实现的是追加写入，字节将写入文件的末尾而不是开头。
//创建字节输出流对象
FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt", true);
//写数据
for (int i = 0; i < 10; i++) {
fos.write("hello".getBytes());
fos.write("\n".getBytes());
}
//释放资源
fos.close();
字节流写数据加异常处理
FileOutputStream fos = null;
try {
fos = new FileOutputStream("myByteStream\\fos.txt");
fos.write("hello".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
//判断fos是否为null，避免空指针异常
if (fos != null) {
try {
//在finally中释放资源
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
字节流读数据
需求：把文件fos.txt中的内容读取出来在控制台输出
FileInputStream: 从文件系统中的文件获取输入字节
- FileInputStream(String name): 通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的路径名name命名
使用字节输入流读数据的步骤：
1.创建字节输入流对象
2.调用字节输入流对象的读数据方法
3.释放资源
//创建字节输入流对象
FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
//调用字节输入流对象的读数据方法
//int read(): 从该输入流读取一个字节的数据
//第一次读取数据
int by = fis.read();
System.out.println(by); //104
System.out.println((char) by); //h
//第二次读取数据
by = fis.read();
System.out.println(by); //104
System.out.println((char) by); //h
//再多读取两次
by = fis.read();
System.out.println(by);
by = fis.read();
System.out.println(by);
//如果到达文件的末尾，返回值为-1
//使用while循环读取多个数据
int by = fis.read();
while (by != -1) {
System.out.print((char)by);
by = fis.read();
}
//优化上面的程序
int by;
while ((by = fis.read()) != -1) {
System.out.print((char) by);
}
//释放资源
fis.close();
案例—复制文本文件
需求：把"F:\itcast\窗里窗外.txt"复制到模块目录下的"窗里窗外.txt"中.
思路：
1. 根据数据源创建字节输入流对象
2. 根据目的地创建字节输出流对象
3. 读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）
4. 释放资源
//根据数据源创建字节输入流对象
FileInputStream fis = new FileInputStream("F:\\itcast\\窗里窗外.txt");
//根据目的地创建字节输出流对象
FileOutputStream fos = new FileOutputStream("myByteStream\\窗里窗外.txt");
//读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）
int by;
while ((by = fis.read()) != -1) {
fos.write(by);
}
//释放资源
fis.close();
fos.close();
字节流读数据（一次读一个字节数组数据）
需求：把文件fos.txt中的内容读取出来在控制台输出
普通读取：
//创建字节输入流对象
FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
//调用字节输入流对象的读数据方法
byte[] bys = new byte[5];
//第一次读取数据
int len = fis.read(bys);
System.out.println(len); //5，读取的数据长度
//String (byte[] bytes)
System.out.println(new String(bys, 0, len));
//第二次读取数据
len = fis.read(bys);
System.out.println(len);
System.out.println(new String(bys, 0, len));
//第三次读取数据
len = fis.read(bys);
System.out.println(len);
System.out.println(new String(bys, 0, len));
//再多读取两次
len = fis.read(bys);
System.out.println(len); //-1，读取到文件的末尾
//释放资源
fis.close();
/*
hello
world
ja
第一次：hello
第二次：\nworl
第三次：d\nja
*/
循环的方式读取：
//创建字节输入流对象
FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
byte[] bys = new byte[1024]; //1024及其整数倍
int len;
while ((len = fis.read(bys)) != -1) {
System.out.println(new String(bys, 0, len));
}
//释放资源
fis.close();
字节流复制图片
FileInputStream fis = new FileInputStream("F:\\itcast\\1.jpg");
FileOutputStream fos = new FileOutputStream("myByteStream\\mn.jpg");
int len;
byte[] bys = new byte[1024];
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
fis.close();
fos.close();
字节缓冲流
字节缓冲流：
- BufferOutputStream: 该类实现缓冲输出流。通过设置这样的流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
- BufferOutputStream: 创建BufferOutputStream将创建一个内部缓冲区数组，当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节
构造方法：
- 字节缓冲输出流：BufferOutputStream(OutputStream out)
- 字节缓冲输入流：BufferInputStream(InputStream in)
为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？
- 字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作
字节缓冲流写数据：
//创建字节缓冲输出流对象
//内部缓冲区默认是8192个字节的字节数组
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\bos.txt"));
//写数据
bos.write("hello\r\n".getBytes());
bos.write("world\r\n".getBytes());
//释放资源
bos.close();
字节缓冲流读数据
//字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myByteStream\\bos.txt"));
//一次读一个字节数据
//int by;
//while ((by = bis.read()) != -1) {
// System.out.print((char) by);
//}
//一次读取一个字节数组的数据
int len;
byte[] bys = new byte[1024];
while ((len = bis.read(bys)) != -1) {
System.out.println(new String(bys, 0, len));
}
bis.close();
案例—复制视频
需求：把"F:\itcast\字节流复制图片.avi" 复制到模块目录下的"字节流复制图片.avi"
四种方式实现复制视频，并记录每种方式复制视频的时间
- 基本字节流一次读写一个字节
- 基本字节流一次读写一个字节数组
- 字节缓冲流一次读写一个字节
- 字节缓冲流一次读写一个字节数组
import java.io.*;
public class CopyVideoDemo {
public static void main(String[] args) throws IOException {
//记录开始时间
long startTime = System.currentTimeMillis();
//复制视频
// method1(); //14142毫秒
// method2(); //21毫秒
// method3(); //44毫秒
// method4(); //7毫秒
//记录结束时间
long endTime = System.currentTimeMillis();
System.out.println("共耗时：" + (endTime - startTime) + "毫秒");
}
//基本字节流一次读取一个字节
public static void method1() throws IOException {
FileInputStream fis = new FileInputStream("F:\\itcast\\basket.mp4");
FileOutputStream fos = new FileOutputStream("myByteStream\\1.mp4");
int by;
while ((by = fis.read()) != -1) {
fos.write((char) by);
}
}
//基本字节流一次读取一个字节数组
public static void method2() throws IOException {
FileInputStream fis = new FileInputStream("F:\\itcast\\basket.mp4");
FileOutputStream fos = new FileOutputStream("myByteStream\\1.mp4");
byte[] bys = new byte[1024];
int len;
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
fis.close();
fos.close();
}
//字节缓冲流一次读写一个字节
public static void method3() throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\itcast\\basket.mp4"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\1.mp4"));
int by;
while ((by = bis.read()) != -1) {
bos.write((char) by);
}
bis.close();
bos.close();
}
public static void method4() throws IOException {
//复制视频
//创建字符缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\itcast\\basket.mp4"));
//创建字符缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\1.mp4"));
//读数据，并把数据写入
int len;
byte[] bys = new byte[1024];
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bis.close();
bos.close();
}
}
扫一扫
1748
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
