IO流——字节流

IO流概述

IO流是用来处理数据在存储设备之间的传输。根据流向的不同，分为输入流和输出流；根据读写数据的类型不同分为字节流和字符流。

IO流的分类

1.按照流向分类
	输入流：读取数据的
	输出流：写入数据的

2.按照读写的数据分类
	字节流：读写字节数据的(读任何文件)
    	字节输入流(读): InputStream
    				-- FileInputStream
    				-- BufferedInputStream
    	字节输出流(写): OutputStream
    				-- FileOutputStream
    				-- BufferedOutputStream
    	
	字符流：读写字符数据的(只能读取文本文件)
    	字符输入流: Reader
    				-- FileReader
    				-- BufferedReader
    	字符输出流: Writer
    				-- FileWriter
    				-- BufferedWriter

IO流读写数据的步骤

1.创建流对象(搭桥)
2.读写数据(过桥)
3.释放资源(过河拆桥)

字节流读写数据

写数据

//1.创建流对象(搭桥)
//指定写入的文件路径，如果文件不存在会自动创建；如果文件已经存在会覆盖
FileOutputStream fos = new FileOutputStream("IODemo\\a.txt");

//2.读写数据(过桥)
//一次写一个字节
fos.write(97); //a
fos.write(98); //b
fos.write(99); //c
fos.write(100); //d

//一次写多个字节
byte[] bs= {101,102,103,104}; //efgh 
fos.write(bs);

//一次写字节数组的一部分
fos.write(bs,0,2);//ef

//写入字符串
fos.write("你好世界".getBytes());

//3.释放资源(过河拆桥)
fos.close(); 

读数据

1.创建流对象(搭桥)
2.读数据(过桥)
3.释放资源(过河拆桥)

• 一次读取一个字节

//1.创建流对象(搭桥)
FileInputStream fis = new FileInputStream("IODemo\\a.txt");

//2.读数据(过桥)
int b; //记录每次读取的字节
while ((b=fis.read())!=-1){
    System.out.print((char) b);
}

//3.释放资源(过河拆桥)
fis.close();

• 一次读多个字节

//1.创建流对象(搭桥)
FileInputStream fis = new FileInputStream("IODemo\\a.txt");

//2.读数据(过桥)
byte[] bs = new byte[1024]; 

//定义变量，记录每次读取的有效个数
int len;
//每次读取的数据存入数组中，并且返回读取到的字节个数
while ((len = fis.read(bs)) != -1) {
    //把读取到的有效字节，转换为字符串
    String str = new String(bs, 0, len);
    System.out.println(str);
} 
//3.释放资源(过河拆桥)
fis.close(); 

读写数据(复制)

文件复制原理其实就是一边读，一边写。读取源文件中的字节，然后往目标文件中写。

//1.创建流对象(搭桥)
//输入流：读取a.txt文件
FileInputStream fis=new FileInputStream("IODemo\\a.jpg");
//输出流：往b.txt文件中写数据
FileOutputStream fos=new FileOutputStream("IODemo\\b.jpg");

//2.读写数据(过桥)
byte[] bs=new byte[1024];
int len; //记录每次读取的字节个数
while ((len=fis.read(bs))!=-1){
    //把数组中有效的字节，写入文件中
    fos.write(bs,0,len);
} 

//3.释放资源(过河拆桥)
fos.close();
fis.close();

字节缓冲流

缓冲流写数据

使用BufferedOutputStream可以对FileOutputStream写入数据的过程进行缓冲，提高写入数据的效率。

//创建流对象
FileOutputStream fos = new FileOutputStream("IODemo\\a.txt");
//创建BufferedOutputStream流，对FileOutputStream进行缓冲，提高写入的效率
BufferedOutputStream bos = new BufferedOutputStream(fos);

//写入数据
bos.write("你好".getBytes());

//释放资源
bos.close();

缓冲流读取数据

使用BufferedInputStream可以对FileInputStream读取的数据的过程进行缓冲，提高读取数据的效率。

//1.创建流对象(搭桥)
FileInputStream fis = new FileInputStream("IODemo\\a.txt");
//使用BufferedInputStream对FileInputStream进行包装，提高读取的效率
BufferedInputStream bis=new BufferedInputStream(fis);

//2.读数据(过桥)
byte[] bs = new byte[1024];

//定义变量，记录每次读取的有效个数
int len;
while ((len = bis.read(bs)) != -1) {
    //把读取到的有效字节，转换为字符串
    String str = new String(bs, 0, len);
    System.out.println(str);
}

//3.释放资源(过河拆桥)
bis.close();

缓冲流读写数据(复制)

把a.jpg文件中的字节，复制到b.jpg文件中。采用缓冲流进行读和写。

//创建BufferedInputStream,读取a.jpg文件
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.exe"));
//创建BufferedOutputStream,写入b.jpg
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.exe"));
        
//创建临时存储的数组
byte[] bs = new byte[1024];
int len; //记录每次读取的字节个数
while ((len=bis.read(bs))!=-1){
    bos.write(bs,0,len); 
} 

//释放资源
bos.close();
bis.close(); 

IO流的异常处理

异常处理的格式

try{
    //可能出现异常的代码
}catch(Exception e){
    //处理异常的代码
}finally{
    //释放资源的代码 
}

public class FileCopy2 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //创建流对象
            fis = new FileInputStream("IODemo\\a.txt");
            fos = new FileOutputStream("IODemo\\b.txt");

            //读写数据
            byte[] bs = new byte[1024];
            int len; //记录每次读取的字节个数
            while ((len = fis.read(bs)) != -1) {
                fos.write(bs, 0, len);
            } 
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //不管前面try里面有没有异常，finally里面的代码都会执行。
            System.out.println("finally执行了");
            if(fis!=null){
                //释放资源的代码
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
			
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}