目录
[前言]
大家好,我是你们的躺平哥,希望和大家一起努力进入理想的公司!冲冲冲!!一起学习的小伙伴们可以点赞支持一下,大家一起加油,嘿嘿~
***在系统学习之前为了理解一下IO流是干啥的,我特意去搜了一下,感觉他说的很容易理解,如下:
Java中的IO流是输入输出流。至于理解,可以将输入和输出两个端点看作是两个工厂,工厂之间需要互相运输货物,而流则是两工厂之间的公路,没有公路就不能互相运输,至于字符,字节和二进制则可以看作是运输的方式和单位大小,比如说把二进制理解成三轮车,那么字节就是小卡车,而字符则是集卡之类的。
1.IO流的概述和分类
IO流概述:
IO:输入/输出(input/output)
流:是一种抽象概念,是对数据传输的总称。也就是说在设备间的传输称为流。流的本质是数据传输!
IO流就是用来处理设备间数据传输问题的
常见的应用:文件复制;文件上传;文件下载
IO流分类:
1)按照数据的流向
输入流:读数据
输出流:写数据
2)按照数据类型来分
字节流
字节输入流;字节输出流
字符流
字符输入流;字符输出流
一般来说,我们说IO流的分类是按照数据类型来分的
那么问题来了,什么时候用字节流什么时候用字符流?
如果数据通过window自带的笔记本软件打开,我们还可以读懂里面的内容,使用字符流,否则就用字节流。如果你不知道该使用哪种类型的流,就用字节流(万能)。
2.用字节流写数据
字节流抽象基类:
InputStream:这个抽象类是表示字节输入流的所有类的超类。
OutputStream:这个抽象类是表示字节输出流的所有类的超类。
子类名称特点:子类名称都是以其父类作为子类名的后缀
FileOutputStream:文件输出流用于将数据写入File
FileOutputStream(String name):创建文件输出流以指定的名称写入文件【构造方法】
package com.itheima_01;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
FileOutputStream:文件输出流用于将数据写入File
FileOutputStream(String name);创建文件输出流以指定的名称写入文件
*/
public class demo01 {
public static void main(String[] args) throws IOException {
//创建字节输出流对象
//FileOutStream(String name );创建文件输出流以指定的名称写入文件
FileOutputStream fos =new FileOutputStream("fos.txt");
/*
坐了三件事情:
A:调用系统创建功能创建了文件
B:创建了字节输出流对象
C:让字节输出流对象指向创建好的文件
*/
//void write (int b;)将指定的字节写入此文件输出流
fos.write(97);
//fos.write(57);
//fos.write(55);字符9跟7!
//最后都要释放资源
//void close();关闭此文件输出流并释放与此相关联的任何系统资源。
fos.close();
}
}
总结:使用字节输出流写数据的步骤:
1)创建字节输出(调用系统功能创建了文件,创建字节输出流对象,让字节输出流向对象)
2)调用字节输出流对象的写数据方法。
3)释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)
3.字节流写数据的三种方式
注:int off是索引开始,即从int off开始写长度为int len 的数据到文件输出流
构造方法和输出方法的代码演示如下(手动敲得!):
package itheima;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
class demo1 {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("fos.txt");
//new File(name)
//FileOutputStream fos=new FileOutputStream(new File("myByteStream\\fos.txt"))
//FileOutputStream(File file);创建文件按输出流以指定的File对象表示的文件
/*File file=new File("fos.txt")
FileOutputStream fos2 =new FileOutStream(file);
FileOutputStream fos2 =new FileOutStream(new File("fos.txt"));
以上就是两种构造方法,一般使用第一种就行
void write(int b);将指定的字节输入此文件输出流
*/
// fos.write(97);
// fos.write(98);
// fos.write(99);
// fos.write(100);
// fos.write(101);
// void write(byte[] b);将b.length字节从指定的字节数组写入此文件输出流
// byte[] bys ={97,98,99,100,101};
//byte[] getBytes();返回字符串对应的字节数组
byte[] bys = "abcde".getBytes();
// fos.write(bys);
//void write(byte[] b,int off,int len);将len字符从指定的字节数组开始,从偏移量off开始写入此文件输出流
//fos.write(bys,0,bys.length);
fos.write(bys,1,3);
//释放资源
fos.close();
}
}
4.字节流写数据的两个小问题
字节流写数据的两个小问题: 1:字节流写数据如何实现换行呢? 2:字节流写数据如何实现追加写入呢?
1)如何实现换行
package itheima;
import java.io.FileOutputStream;
import java.io.IOException;
public class demo2 {
/*
字节流写数据的两个小问题:
1:字节流写数据如何实现换行呢?
2:字节流写数据如何实现追加写入呢?
*/
public static void main(String[] args) throws IOException {
//创建字节输出流对象
FileOutputStream fos2 = new FileOutputStream("fos2.txt");
//写数据
for (int i = 0; i < 10; i++) {
fos2.write("hello".getBytes());
fos2.write("\n".getBytes());
}
//释放资源
fos2.close();
}
}
2)写数据如何实现追加写入?
换一个构造方法即可!
public FileOutputStream(String name,boolean append)
具体实例如下:
package itheima;
import java.io.FileOutputStream;
import java.io.IOException;
public class demo2 {
/*
字节流写数据的两个小问题:
1:字节流写数据如何实现换行呢?
window:\r\n
2:字节流写数据如何实现追加写入呢?
public FileOutputStream(String name,boolean append)
创建文件输出流已指定的名称写入文件。
如果第二个参数为ture,则字节将写入文件的末尾而不是开头
*/
public static void main(String[] args) throws IOException {
//创建字节输出流对象
// FileOutputStream fos2 = new FileOutputStream("fos2.txt");
FileOutputStream fos2 = new FileOutputStream("fos2.txt",true);
//写数据
for (int i = 0; i < 10; i++) {
fos2.write("hello".getBytes());
fos2.write("\n".getBytes());
}
//释放资源
fos2.close();
}
}
5.字节流写数据加异常处理
finally:在异常处理时提供finally块来执行所有清除操作。比如说IO流中的释放资源
特点:被finally控制的语句一定会执行,除非JVM退出
try{
肯呢个出现的异常代码:
}catch(异常类名 变量名)
异常的处理代码:
}finally{
执行所有清除的操作;
}
package itheima;
import javax.imageio.IIOException;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class demo3 {
/*
字节流写数据加入异常处理
*/
public static void main(String[] args) {
// try{
// FileOutputStream fos3=new FileOutputStream("fos3.txt");
//fos3.write("hello".getBytes());
//fos3.close();
// }catch(IOException e){
// e.printStackTrace();
// }
//加入finally来实现释放资源
FileOutputStream fos3 = null;
try {
fos3 = new FileOutputStream("fos3.txt");
fos3.write("hello".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fos3 != null) //在释放资源之前要进行不为null的判断
{
try {
fos3.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
6.字节流读数据(一次读一个字节数据)
需求:把文件fos.txt中的内容读取出来在控制台上输出
FileInputStream:把文件系统中的文件获取输入字节
FileInputStream(String name):通过打开与实际文件的链接来创建一个FileInputStream,该文件由文件系统中的路径名name命名
使用字节输入流读数据的步骤:
(1)创建字节输入流对象
(2)调用字节输入刘对象的读数据方法
(3)释放资源
package cn.itcast.demo;
import java.io.FileInputStream;
import java.io.IOException;
public class demo1 {
public static void main(String[] args)throws IOException {
FileInputStream fis=new FileInputStream("C:\\ECLIPSE\\fos.txt");
//第一次读取
int by= fis.read();
System.out.println(by);
System.out.println((char)by);
//第二次读取数据
by =fis.read();
System.out.println(by);
System.out.println((char)by);
//再多读取两次
by =fis.read();
System.out.println(by);
by =fis.read();
System.out.println(by);
int by =fis.read();
while(by !=-1){
System.out.print((char)by);
by=fis.read();
}
//优化上面的程序
/*
fis.read();读数据
by=fis.read();把读到的·数据赋值给by
by!=-1;判断读取到的数据是否是-1
*/
int by;
while((by=fis.read())!=-1){
System.out.print((char)by);
}
//释放资源
fis.close();
}
}
如果文件读到末尾,读取的为-1;
字节流读数据的标准代码
int by;
while((by=fis.read())!=-1){
System.out.print((char)by);
}
案例:复制文本文件
需求:把“C\\itcast\\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt”
思路:
1.根据数据源创建字节输入流对象。
2.根据目的地创建字节流输出对象
3.读写数据,复制文本文件(一次读取一个字节,一次写入一个字节)
4释放资源
package cn.itcast.demo;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class demo2 {
public static void main(String[] args)throws IOException {
//根据数据源创建字节输入流对象
FileInputStream fis=new FileInputStream("C:\\itcast\\窗里窗外.txt");
//根据目的地创建字节输出流对象
FileOutputStream fos=new FileOutputStream("C:\\itcast\\窗里窗外.txt");
//读取数据,复制文本(一次读取一个字节,一次写入一个字节)
int by;
while((by=fis.read())!=-1) {
fos.write(by);
}
//释放资源
fos.close();
fis.close();
}
}
7.字节流读数据(一次读一个字节数组数据)
import java.io.FileInputStream;
import java.io.IOException;
public class demo01 {
/*
需求:把文件fos.txt中的内容读取出来在控制台输出
使用 字节输入流读数据的步骤
1.创建字节输入流对象
2.调用字节输出流对象的读数据方法
3.释放资源
*/
public static void main(String[] args) throws IOException {
//创建字节输入流对象
FileInputStream fis=new FileInputStream("D:\\Java\\src\\fos.txt");
/*
调用字节输入流对象得读数据方法
int read(byte[] b);从该输入流读取最多b.length个字节的数据到一个字节数组
*/
/* byte[] bys=new byte[5];
//第一次读取数据
int len =fis.read(bys);
System.out.println(len);
//String (byte[] bytes)
System.out.println(new String(bys));
System.out.println(new String(bys,0,len));
//第二次读取数据
int len =fis.read(bys);
System.out.println(len);
//String (byte[] bytes)
System.out.println(new String(bys));
System.out.println(new String(bys,0,len));
//第三次读取数据
int len =fis.read(bys);
System.out.println(len);
//String (byte[] bytes)
System.out.println(new String(bys));
System.out.println(new String(bys,0,len));
*/
//优化方案
byte[] bys =new byte[1024];//1024及其整数倍
int len;
while((len=fis.read(bys))!=-1){
System.out.println(new String(bys,0,len));
}
/*
hello\r\n
world\r\n
第一次:hello
第二次:\r\nwor
第三次:ld\r\nr
*/
//释放资源
fis.close();
}
}
优化方案:
byte[] bys =new byte[1024];//1024及其整数倍
int len;
while((len=fis.read(bys))!=-1){
System.out.println(new String(bys,0,len));
}
案例:复制图片
需求:把E:\\itcast\\mn.jpg复制到模块目录下的mn.jpg
思路:
1:根据数据源创建字节输入流对象
2:根据目的地创建字节输出流对象
3:读写数据,复制图片(一次读取一个字节数组,一次写入一个字节数组)
4:释放资源
代码如下:
package cn.itcast;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class defmo {
public static void main(String[] args) throws IOException {
FileInputStream fis=new FileInputStream("C:\\itcast\\mn.jpg");
FileOutputStream fos=new FileOutputStream("D:\\Java\\untitled\\mn.jpg");
byte[]bys =new byte[1024];
int len;
while((len=fis.read(bys))!=-1){
fos.write(bys,0,len);
}
fis.close();
fos.close();
}
}
8.字节缓冲流
字节缓冲流:
作用:提高读写数据效率的
*BufferOutputStream:该类实现缓冲输出流。通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入的每个字节导致底层系统的调用。
BufferredInputStream:创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时,内部缓冲区将根据需要从所包含的输入流中重新填充,一次很多字节。
构造方法:
字节缓冲输出流: BufferedOutputStream(OutputStream out)
字节缓冲输入流: BufferedInputStream(InputStream in)
为什么构造方法需要的是字节流,而不是具体的文件或者路径呢?
字节缓冲流仅仅提供缓冲区,而真正读写数据还得依靠基本的字节流对象进行操作
字节缓冲流读数据和写数据代码如下:
import java.io.*;
public class demo {
//字节缓冲输出流:BufferedOutputStream(OutputStream out)
//字节缓冲输入流: BufferedInputStream(InputStream in)
public static void main(String[] args) throws IOException {
//字节缓冲输出流: BufferedOutputStream(OutputStream out)
// FileOutputStream fos=new FileOutputStream("bos.txt" );
// BufferedOutputStream bos=new BufferedOutputStream(fos);
/* BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("bos.txt" ));
//写数据
bos.write("hello\r\n".getBytes());
bos.write("world\r\n".getBytes());
//释放资源
bos.close();
*/
BufferedInputStream bis=new BufferedInputStream(new FileInputStream("bos.txt" ));
//一次读取一个字节数据
// int by;
// while((by=bis.read())!=-1){
// System.out.print((char)by);
// }
//一次读取一个字节数组数据
byte[] bys=new byte[1024];
int len;
while((len=bis.read(bys))!=-1){
System.out.println(new String(bys,0,len));
}
//释放资源
bis.close();
}
}
案例:复制视频
需求:
把c\\itcast\\字节流复制图片.avi 复制到模块目录下的字节流复制图片.avi
思路:
1),根据数据源创建字节输入流对象
2),根据目的地创建字节输出流对象
3),读写数据,复制图片(一次读取一个字节数组,一次写入一个字节数组)
4),释放资源
四种方式实现复制视频,并记录每种方式复制视频的时间
1):基本字节流一次读写一个字节
2):基本字节流一次读写一个字节数组
3):字节缓冲流一次读写一个字节
4):字节缓冲流一次读写一个字节数组
代码如下:
import java.io.*;
//四种方式实现复制视频,并记录每种方式复制视频的时间
//
// 1):基本字节流一次读写一个字节 共耗时 64565毫秒
//
// 2):基本字节流一次读写一个字节数组 共耗时 107 毫秒
//
// 3):字节缓冲流一次读写一个字节 共耗时 405 毫秒
//
// 4):字节缓冲流一次读写一个字节数组 共耗时 60 毫秒
public class demo {
public static void main(String[] args) throws IOException{
//记录开始时间
long starTime =System.currentTimeMillis();
//复制视频
//method1();
// method1();
// method1();
// method1();
//记录结束时间
long endTime =System.currentTimeMillis();
System.out.println("共耗时:"+(endTime-starTime));
//基本字节流一次读写一个字节数组
public static void method2() throws IOException {
//E:\\itcast\\字节流复制图片.avi
//模块目录下的 字节流 复制图片.avi
FileInputStream fis=new FileInputStream("mg.mp4");
FileOutputStream fos=new FileOutputStream("D:\\Java\\untitled2\\mg.mp4");
byte[] bys=new byte[1024];
int len;
while ((len= fis.read(bys))!=-1){
fos.write(bys,0,len);
}
//基本字节流一次读写一个字节
public static void method2() throws IOException {
int by;
while((by=fis.read())!=-1) {
fos.write(by);
}
//字节缓冲流一次读写一个字节
public static void method3() throws IOException {
BufferedInputStream bis=new BufferedInputStream("mg.mp4");
BufferedOutputStream bos =new BufferedOutputStream("D:\\Java\\untitled2\\mg.mp4");
int by;
while((by= bis.read())!=-1){
bos.write(by);
}
//字节缓冲流一次读写一个字节数组
public static void method4() throws IOException {
BufferedInputStream bis=new BufferedInputStream("mg.mp4");
BufferedOutputStream bos =new BufferedOutputStream();
byte[] bys=new byte[1024];
int len;
while((len=fis.read(bys)!=-1)){
fos.write(bys,0,len);
}
bos.close();
bis.close();
}
}
根据以上不难看出,他们之间确实存在效率的差别的!
1):基本字节流一次读写一个字节 共耗时 64565毫秒
2):基本字节流一次读写一个字节数组 共耗时 107 毫秒
3):字节缓冲流一次读写一个字节 共耗时 405 毫秒
4):字节缓冲流一次读写一个字节数组 共耗时 60 毫秒
感谢未来大佬们的支持,冲冲冲!