Day20JavaSE——IO流之字节流
Day20JavaSE——IO流之字节流
文章目录
- Day20JavaSE——IO流之字节流
- IO流概述
- 字节流的抽象基类
- FileOutputStream&FileInputStream
- FileOutputStream
- FileInputStream
- 高效字节输入输出流
- 字节流复制文件
- 复制文本文件&MP3文件
- 异常处理
IO流概述
A:IO流概述
IO流用来处理设备之间的数据传输
Java对数据的操作是通过流的方式
Java用于操作流的对象都在IO包中 java.io
B:IO流分类
a:按照数据流向 站在内存角度
输入流 读入数据
输出流 写出数据
b:按照数据类型
字节流 可以读写任何类型的文件 比如音频 视频 文本文件
字符流 只能读写文本文件
什么情况下使用哪种流呢?
如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流。其他用字节流。
如果你什么都不知道，就用字节流
字节流的抽象基类
A:IO流基类概述
a:字节流的抽象基类：
InputStream ，OutputStream。
b:字符流的抽象基类：
Reader ， Writer。
注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream。
如：Reader的子类FileReader。
B:FileOutputStream的构造方法
由一个案例引出使用IO流写数据，由于字节流先出现就先学习字节输出流基类OutputStream，
使用具体子类FileOutputStream
FileOutputStream&FileInputStream
FileOutputStream
public class Test1 {
public static void main(String[] args) throws IOException {
//FileOutputStream：文件输出流是用于将数据写入File
//按住ctrl点击添加书签
/*
* FileOutputStream(File file)
* 创建文件输出流以写入由指定的 File对象表示的文件。
* FileOutputStream(File file, boolean append)
* 创建文件输出流以写入由指定的 File对象表示的文件。
* 如果第二个参数是true ，则字节将被写入文件的末尾而不是开头，也就是追加写入，不会覆盖原内容
* FileOutputStream(FileDescriptor fdObj)
* 创建文件输出流以写入指定的文件描述符，表示与文件系统中实际文件的现有连接。
* FileOutputStream(String name)
* 创建文件输出流以指定的名称写入文件。
* FileOutputStream(String name, boolean append)
* 创建文件输出流以指定的名称写入文件。如果第二个参数是true
* 则字节将写入文件的末尾而不是开头，也就是追加写入，不会覆盖原内容
* */
//创建一个文件对象
File file = new File("a.txt");
//创建刚还文件对象的文件输出流
FileOutputStream outa = new FileOutputStream(file);
//创建文件输出流以指定的名称写入文件，这个构造函数会自动新建一个文件
FileOutputStream outb = new FileOutputStream("b.txt");
//创建文件输出流以指定的名称写入文件，字节写入文件的开头
FileOutputStream outc = new FileOutputStream("c.txt", false);
Scanner sc = new Scanner(System.in);
System.out.println("请输入要写入的内容");
String s = sc.nextLine();
//若要写入中文或一个字符串，就需要调用String类中的getByte函数
//将字符串提取为byte类型
byte[] writeText= s.getBytes();
/*void write(byte[] b)
将 b.length个字节从指定的字节数组写入此文件输出流。
void write(byte[] b, int off, int len)
将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。
void write(int b)
将指定的字节写入此文件输出流。*/
//一次写入一个字节，超出一个字节就会丢弃掉多余字节
outa.write(6);
outb.write('c');
//将转换好的字符串放入字节数组中，再调用write函数写入文件内
outc.write(writeText);
//最后要关闭
/*void close()
关闭此文件输出流并释放与此流相关联的任何系统资源。*/
outa.close();
outb.close();
outc.close();
}
}
public class Test2 {
public static void main(String[] args) throws IOException {
FileOutputStream out1 = new FileOutputStream("d.txt");
//往文件中写入数据
System.out.println("========往文件中写入一个字节========");
out1.write(97);
out1.write(100);
//如果多出一个字节，就会丢弃多余字节
//out1.write(200);
System.out.println("=======往文件中写入一个字节数组======");
FileOutputStream out2 = new FileOutputStream("e.txt");
//一次写入一个字节数组
ByteArrayOutputStream baos;
byte[] write = {94, 95, 96, 97, 98, 99};
out2.write(write);
System.out.println("=========往文件中写入一串中文=======");
FileOutputStream out3 = new FileOutputStream("f.txt");
String str="会感到十分光滑";
//字符串需要转换成字节数组才能使用字节流写入
byte[] chinese = str.getBytes();
out3.write(chinese);
System.out.println("===往文件中写入一个字节数组的一部分===");
FileOutputStream out4 = new FileOutputStream("g.txt");
String str1="会感到十分光滑";
//字符串需要转换成字节数组才能使用字节流写入
byte[] chinese1 = str.getBytes();
out4.write(chinese1,3,6);
//流使用完记得要释放资源
out1.close();
out2.close();
out3.close();
out4.close();
/*注意事项：
创建字节输出流对象了做了几件事情 ?
a : 调用系统资源创建a.txt文件
b:创建了一个文件对象
c:把该文件对象指向这个文件
流使用完毕，为什么一定要close() ?
a : 通知系统释放关于管理a.txt文件的资源
b:让Io流对象变成垃圾, 等待垃圾回收器对其回收*/
}
}
public class Test3 {
public static void main(String[] args) throws IOException {
System.out.println("============追加写入============");
//创建一个不会覆盖原内容的文件及文件对象
FileOutputStream outputStream = new FileOutputStream("h.txt", true);
outputStream.write("啊随风倒敢死队风格".getBytes());
//写入换行符
/* windows下的换行符是 \r\n
Linux \n
Mac \r
*/
outputStream.write("\r\n".getBytes());
outputStream.write("公司的风格岁的法国".getBytes());
outputStream.write("\r\n".getBytes());
outputStream.close();
}
}
public class Test4 {
public static void main(String[] args) {
//流的异常处理
FileOutputStream out = null;
try {
new FileOutputStream("i.txt");
} catch (IOException e) {
e.printStackTrace();
}finally{
//如果FileOutputStream对象不是null，则释放资源，否则打印异常信息
try{
if(out!=null){
out.close();
}
}catch (IOException e){
e.printStackTrace();
}
}
}
}
FileInputStream
public class Text1 {
public static void main(String[] args) {
/*
* FileInputStream(File file)
* 通过打开与实际文件的连接创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
* FileInputStream(FileDescriptor fdObj)
* 创建 FileInputStream通过使用文件描述符 fdObj ，其表示在文件系统中的现有连接到一个实际的文件。
* FileInputStream(String name)
* 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。*/
try {
FileInputStream in1 = new FileInputStream("d.txt");
System.out.println("===========读取文件中的数据===========");
System.out.println("==============读一个字节=============");
/*int read()
* 从该输入流读取一个字节的数据。 */
int read = in1.read();
System.out.println(read);
int read1 = in1.read();
System.out.println(read1);
//如果读取不到有效的字节，就会返回-1 ，我们经常使用-1来判断这个文件的数据是否读取完毕。
int read2 = in1.read();
System.out.println(read2);
//流使用完毕，释放资源
in1.close();
System.out.println("============读一个字节数组============");
/*int read(byte[] b)
* 从该输入流读取最多 b.length个字节的数据为字节数组。 */
FileInputStream in2 = new FileInputStream("h.txt");
//创建一个字节数组缓存区
byte[] inBuffer = new byte[1024];
//把读取的字节，装进传进来的容器中
//返回的是一次实际读取的有效字节数
int len = in2.read(inBuffer);
System.out.println("读取到的有效字节数是" + len);
System.out.println(Arrays.toString(inBuffer));
//把读取到的字节数组转化成字符串显示
java.lang.String s = new java.lang.String(inBuffer, 0, len);
System.out.println(s);
//流使用完毕，释放资源
in2.close();
System.out.println("============读取有效的字节============");
/*int read(byte[] b, int off, int len)
* 从该输入流读取最多 len字节的数据为字节数组.*/
//一次从文件中读取3个字节，从0索引处开始把读取到的3个字节放入容器中
//如果读取不到有效字节返回的是 -1
FileInputStream in3 = new FileInputStream("g.txt");
//设置缓存区
byte[] inBuffer2 = new byte[1024];
int inLen = in3.read(inBuffer2, 0, 6);
System.out.println("读取到的有效字节个数：" + inLen);
/*inLen = in3.read(inBuffer2, 0, 6);
System.out.println("读取到的有效字节个数：" + inLen);*/
/*有效字节数就是有实际内容的字节
inLen = in3.read(inBuffer2, 0, 128);
System.out.println("读取到的有效字节个数：" + inLen);*/
String s1 = new String(inBuffer2, 0, inLen);
System.out.println(s1);
//流使用完毕，释放资源
in3.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
高效字节输入输出流
public class Test {
public static void main(String[] args) {
//高效的字节输入输出流
//BufferedInputStream
//BufferedOutputStream
try {
test1();//使用单字节复制完成共耗时29146ms
test2();//复制完成共耗时16933毫秒
test3();//使用缓存区复制完成共耗时12ms
test4();//复制完成共耗时12毫秒
/*同一个文件，当使用字节复制的时候高效流比普通流的使用的时间缩短了一半
* 但是当使用缓存复制的时候，高效流和普通流使用的时间一样*/
} catch (IOException e) {
e.printStackTrace();
}
}
private static void test1() throws IOException {
System.out.println("============使用普通流字节复制============");
FileInputStream dataInCompare = new FileInputStream("C:\\Users\\adair_liu\\Desktop\\复试资料\\Jam - 七月上.mp3");
FileOutputStream dataOutCompare = new FileOutputStream("C:\\Users\\adair_liu\\Desktop\\Test\\Jam - 七月上.mp3");
int inDataCompare = 0;
//调用系统函数计算开始复制的时间
long startCompare = System.currentTimeMillis();
while ((inDataCompare = dataInCompare.read()) != -1) {
dataOutCompare.write(inDataCompare);
dataOutCompare.flush();
}
//调用系统函数计算复制复制完成的时间
long endCompare = System.currentTimeMillis();
System.out.println("使用单字节复制完成共耗时"+(endCompare-startCompare)+"ms");
//释放资源
dataInCompare.close();
dataOutCompare.close();
}
private static void test2() throws IOException {
System.out.println("============使用高效流字节复制============");
/* BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
*/
BufferedInputStream in = new BufferedInputStream(new FileInputStream("C:\\Users\\adair_liu\\Desktop\\复试资料\\Jam - 七月上.mp3"));
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("C:\\Users\\adair_liu\\Desktop\\Test\\Jam - 七月上.mp3"));
int by=0;
long start = System.currentTimeMillis();
while ((by = in.read()) != -1) {
out.write(by);
out.flush();
}
long end = System.currentTimeMillis();
System.out.println("复制完成共耗时" + (end - start) + "毫秒");
//释放资源
in.close();
out.close();
}
private static void test3() throws IOException {
System.out.println("============使用普通流缓存复制============");
//定义1kb=1024byte的数据，这里开辟了8kb的缓存区
byte[] dataBuffer = new byte[1024*8];
FileInputStream dataIn = new FileInputStream("C:\\Users\\adair_liu\\Desktop\\复试资料\\Jam - 七月上.mp3");
FileOutputStream dataOut = new FileOutputStream("C:\\Users\\adair_liu\\Desktop\\Jam - 七月上.mp3");
//定义一个变量，来记录每次读取到的有效字节个数
int len = 0;
//调用系统函数计算开始复制的时间
long start = System.currentTimeMillis();
//read函数返回的是当前读取到的有效字节数
while ((len = dataIn.read(dataBuffer)) != -1) {
//将字节数组缓存区中的数据写入文件
dataOut.write(dataBuffer,0,len);
dataOut.flush();
}
//调用系统函数计算复制复制完成的时间
long end = System.currentTimeMillis();
System.out.println("使用缓存区复制完成共耗时"+(end-start)+"ms");
//释放资源
dataIn.close();
dataOut.close();
}
private static void test4() throws IOException {
System.out.println("============使用高效流缓存复制============");
BufferedInputStream in = new BufferedInputStream(new FileInputStream("C:\\Users\\adair_liu\\Desktop\\复试资料\\Jam - 七月上.mp3"));
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("C:\\Users\\adair_liu\\Desktop\\Jam - 七月上.mp3"));
//一次读取一个字节，写入一个字节来复制mp3
byte[] bytes = new byte[1024 * 8];
int by = 0;
long start = System.currentTimeMillis();
while ((by = in.read(bytes)) != -1) {
out.write(bytes,0,by);
out.flush();
}
long end = System.currentTimeMillis();
System.out.println("复制完成共耗时" + (end - start) + "毫秒");
//释放资源
in.close();
out.close();
}
}
字节流复制文件
复制文本文件&MP3文件
public class Test1 {
public static void main(String[] args) {
try {
System.out.println("============方式一============");
//一个字节一个字节的复制
FileInputStream in = new FileInputStream("h.txt");
FileOutputStream out = new FileOutputStream("C:\\Users\\adair_liu\\Desktop\\h.txt");
int data = 0;
while ((data = in.read()) != -1) {
out.write(data);
out.flush();
}
//释放资源
in.close();
out.close();
System.out.println("============方式二============");
/*1byte=8bit
* 1kb=1024byte
* 1M=1024kb
* 1G=1024M
* 1T=1024G*/
//一次复制一个字节的数据过于缓慢
//如果要复制一个1M大小的MP3文件的话
//一次复制一个字节的数据就会不停地读写1024的平方次
//要是我们读写的文件大小是NM，则复制文件的时间复杂度为O(N*1024*1024)
//所以此处我们引入缓存区的概念
//一次缓存1024*1024byte=1M的数据，这样时间复杂度相对于O(N)就可以看成是O(1)
System.out.println("============缓存区复制============");
//定义1kb=1024byte的数据，这里开辟了8kb的缓存区
byte[] dataBuffer = new byte[1024*8];
FileInputStream dataIn = new FileInputStream("C:\\Users\\adair_liu\\Desktop\\复试资料\\Jam - 七月上.mp3");
FileOutputStream dataOut = new FileOutputStream("C:\\Users\\adair_liu\\Desktop\\Jam - 七月上.mp3");
//定义一个变量，来记录每次读取到的有效字节个数
int len = 0;
//调用系统函数计算开始复制的时间
long start = System.currentTimeMillis();
//read函数返回的是当前读取到的有效字节数
while ((len = dataIn.read(dataBuffer)) != -1) {
//将字节数组缓存区中的数据写入文件
dataOut.write(dataBuffer,0,len);
dataOut.flush();
}
//调用系统函数计算复制复制完成的时间
long end = System.currentTimeMillis();
System.out.println("使用缓存区复制完成共耗时"+(end-start)+"ms");
//释放资源
dataIn.close();
dataOut.close();
System.out.println("==========单字节复制同一个文件==========");
FileInputStream dataInCompare = new FileInputStream("C:\\Users\\adair_liu\\Desktop\\复试资料\\Jam - 七月上.mp3");
FileOutputStream dataOutCompare = new FileOutputStream("C:\\Users\\adair_liu\\Desktop\\Test\\Jam - 七月上.mp3");
int inDataCompare = 0;
//调用系统函数计算开始复制的时间
long startCompare = System.currentTimeMillis();
while ((inDataCompare = dataInCompare.read()) != -1) {
dataOutCompare.write(inDataCompare);
dataOutCompare.flush();
}
//调用系统函数计算复制复制完成的时间
long endCompare = System.currentTimeMillis();
System.out.println("使用单字节复制完成共耗时"+(endCompare-startCompare)+"ms");
//释放资源
dataInCompare.close();
dataOutCompare.close();
/*由以上我们可以看到，复制大文件，合适的缓存区能够大量的减少代码的时间复杂度*/
} catch (IOException e) {
e.printStackTrace();
}
}
}
异常处理
public class Test2 {
public static void main(String[] args) {
//流的异常处理
FileInputStream dataIn=null;
FileOutputStream dataOut=null;
try {
dataIn = new FileInputStream("C:\\Users\\adair_liu\\Desktop\\Java\\MyNote\\Java笔记\\Day19JavaSE——IO概述&异常&File文件类\\04视频\\录像160.mp4");
dataOut = new FileOutputStream("C:\\Users\\adair_liu\\Desktop\\录像160.mp4");
//1、定义字节数组充当缓冲区
byte[] dataBuffer = new byte[1024];
//2.定义一个变量。用来记录每次读取到的有效字节个数
int len=0;
//3.频繁的读写
long start = System.currentTimeMillis();
while ((len = dataIn.read(dataBuffer)) != -1) {
dataOut.write(dataBuffer,0,len);
dataOut.flush();
}
long end = System.currentTimeMillis();
System.out.println("复制完成共耗时" + (end - start) + "毫秒");
} catch (IOException e) {
e.printStackTrace();
}finally {
try{
if(dataIn!=null){
dataIn.close();
}
if(dataOut!=null){
dataOut.close();
}
}catch (IOException e){
e.printStackTrace();
}
}
}
}
em.currentTimeMillis();
System.out.println(“复制完成共耗时” + (end - start) + “毫秒”);
} catch (IOException e) {
e.printStackTrace();
}finally {
try{
if(dataIn!=null){
dataIn.close();
}
if(dataOut!=null){
dataOut.close();
}
}catch (IOException e){
e.printStackTrace();
}
}
}
}