Java编程基础21——IO(字节流)

1_IO流概述及其分类

1.概念
- IO流用来处理设备之间的数据传输
- Java对数据的操作是通过流的方式
- Java用于操作流的类都在IO包中
- 流按流向分为两种：输入流，输出流。
- 流按操作类型分为两种：
  - 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的
  - 字符流 : 字符流只能操作纯字符数据，比较方便。
2.IO流常用父类
- 字节流的抽象父类：
  - InputStream
  - OutputStream
- 字符流的抽象父类：
  - Reader
  - Writer
3.IO程序书写
- 使用前，导入IO包中的类
- 使用时，进行IO异常处理
- 使用后，释放资源

2_FileInputStream

read()一次读取一个字节

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo1_FileInputStream {
    public static void main(String[] args) throws IOException {
//        demo1();
        FileInputStream fis = new FileInputStream("xxx.txt");    //创建一个文件输入流对象,并关联xxx.txt
        int b;                                                    //定义变量,记录每次读到的字节
        while((b = fis.read()) != -1) {                            //将每次读到的字节赋值给b并判断是否是-1
            System.out.println(b);                                //打印每一个字节
        }
        
        fis.close();                                            //关闭流释放资源
    }

    private static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("xxx.txt");//创建流对象
        int x = fis.read();                                    //从硬盘上读取一个字节
        System.out.println(x);
        int y = fis.read();
        System.out.println(y);
        int z = fis.read();
        System.out.println(z);
        int a = fis.read();
        System.out.println(a);
        int b = fis.read();
        System.out.println(b);    
        
        fis.close();                                //关流释放资源
    }
}

3_read()方法返回值为什么是int

read()方法读取的是一个字节,为什么返回是int,而不是byte
字节输入流可以操作任意类型的文件，比如图片音频等，这些文件底层都是以二进制形式的存储的，如果每次读取都返回byte，会有可能在读到111111111，而11111111是byte类型的-1，程序在遇到-1就会停止读取，用int类型接收遇到11111111会在其前面补上24个0凑足4个字节，那么byte类型的-1就变成int类型的255了，这样可以保证整个数据读完，而结束标记的-1是int类型的。

4_FileOutputStream

write()一次写出一个字节

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo2_FileOutputStream {

    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("yyy.txt");    //自动创建没有的对象
        fos.write(97);                    //虽然写出的是一个int数，但是到文件上的是一个字节，会自动去除前三个八位
        fos.write(98);
        fos.write(99);
        
        fos.close();
    }
}

5_FileOutputStream追加

A:案例演示

public static void main(String[] args) throws IOException {
//        demo1();
        FileOutputStream fos = new FileOutputStream("yyy.txt",true);//追加在第二个参数传true
        fos.write(97);
        fos.write(98);
        
        fos.close();
}

6_拷贝图片

FileInputStream读取
FileOutputStream写出

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo3_Copy {
    public static void main(String[] args) throws IOException {
//        demo1();
        FileInputStream fis = new FileInputStream("视频.avi");        //创建输入流对象，关联视频
        FileOutputStream fos = new FileOutputStream("copy.avi");    //创建输出流对象，关联copy.avi
        
        int b;
        while((b = fis.read()) != -1) {                    //在不断读取每个字节
            fos.write(b);                                //将每一个字节写出
            
        }
        fis.close();                                    //关流释放资源
        fos.close();
    }

    private static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("图片1.png");        //创建输入流对象，关联图片
        FileOutputStream fos = new FileOutputStream("copy.jpg");    //创建输出流对象，关联cop.jpg
        
        int b;
        while((b = fis.read()) != -1) {                    //在不断读取每个字节
            fos.write(b);                                //将每一个字节写出
            
        }
        fis.close();                                    //关流释放资源
        fos.close();
    }
}

7_拷贝音频文件画原理图

A:案例演示
- 字节流一次读写一个字节复制音频
弊端:效率太低

图片描述

8_字节数组拷贝之available()方法

A:案例演示
- int read(byte[] b):一次读取一个字节数组
- write(byte[] b):一次写出一个字节数组
- available()获取读的文件所有的字节个数
弊端:有可能会内存溢出

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo3_Copy {
    public static void main(String[] args) throws IOException {    
        //第二种拷贝，不推荐，有可能导致内存溢出
        FileInputStream fis = new FileInputStream("视频.avi");        //创建输入流对象，关联视频
        FileOutputStream fos = new FileOutputStream("copy.avi");    //创建输出流对象，关联copy.avi
//        int len = fis.available();
//        System.out.println(len);
        
        byte[] arr = new byte[fis.available()];                    //创建与文件一样大小的字节数组
        fis.read(arr);                                            //将文件上的字节读取到内存中
        fos.write(arr);                                            //将字节数组中的字节数据写到文件上
        
        fis.close();
        fos.close();
    }
}

9_定义小数组

write(byte[] b)
write(byte[] b, int off, int len)写出有效的字节个数

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo4_ArrayCopy {
    public static void main(String[] args) throws IOException {
//        demo1();
        FileInputStream fis = new FileInputStream("xxx.txt");
        FileOutputStream fos = new FileOutputStream("yyy.txt");
        
        byte[] arr = new byte[2];
        int len;
        while((len = fis.read(arr)) != -1) {
            fos.write(arr,0,len);
        }
        
        fis.close();
        fos.close();
    }

    private static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("xxx.txt");
        byte[] arr = new byte[2];
        int a = fis.read(arr);                        //将文件上的字节读取到字节数组中
        
        System.out.println(a);                        //读到的有效字节个数
        for (byte b : arr) {                        //第一次获取到文件上的a和b
            System.out.println(b);
        }
        System.out.println("----");
        int c = fis.read(arr);
        System.out.println(c);
        for (byte b : arr) {
            System.out.println(b);
        }
        
        fis.close();
    }
}

10_定义小数组的标准格式

A:案例演示
- 字节流一次读写一个字节数组复制图片和视频

public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("视频.avi");
        FileOutputStream fos = new FileOutputStream("copy.avi");
        
        byte[] arr = new byte[1024 * 8];
        int len;
        while((len = fis.read(arr)) != -1) {        //忘记写arr，返回的是码表值
            fos.write(arr,0,len);
        }
        
        fis.close();
        fos.close();
    }

11_BufferedInputStream和BufferOutputStream拷贝

A:缓冲思想
- 字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，
- 这是加入了数组这样的缓冲区效果，java本身在设计的时候，
- 也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流
B.BufferedInputStream
- BufferedInputStream内置了一个缓冲区(数组)
- 从BufferedInputStream中读取一个字节时
- BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个
- 程序再次读取时, 就不用找文件了, 直接从缓冲区中获取
- 直到缓冲区中所有的都被使用过, 才重新从文件中读取8192个
C.BufferedOutputStream
- BufferedOutputStream也内置了一个缓冲区(数组)
- 程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中
- 直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里
D.小数组的读写和带Buffered的读取哪个更快?
- 定义小数组如果是8192个字节大小和Buffered比较的话
- 定义小数组会略胜一筹,因为读和写操作的是同一个数组
- 而Buffered操作的是两个数组

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo5_BufferCopy {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("视频.avi");    //创建输入流对象
        FileOutputStream fos = new FileOutputStream("copy.avi");//创建输出流对象
        
        //byte[] arr = new byte[8192]; 
        BufferedInputStream bis = new BufferedInputStream(fis);//创建缓冲区对象，对输入流进行包装，让其变得更强
        BufferedOutputStream bos = new BufferedOutputStream(fos);    
        
        int b;
        while((b = bis.read()) != -1) {
            bos.write(b);
        }
        
        bis.close();
        bos.close();
    }
}

12_flush和close方法的区别

flush()方法
- 用来刷新缓冲区的,刷新后可以再次写出
close()方法
- 用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出

public static void main(String[] args) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("视频.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.mp3"));    
        
        int b;
        while((b = bis.read()) != -1) {
            bos.write(b);
            bos.flush();
        }
//        bos.close();
//        bis.close();
    }

13_字节流读写中文)

字节流读取中文的问题
- 字节流在读中文的时候有可能会读到半个中文,造成乱码
字节流写出中文的问题
- 字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组
- 写出回车换行 write("rn".getBytes());

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo6_Chinese {
    public static void main(String[] args) throws IOException {
//        demo1();
        FileOutputStream fos = new FileOutputStream("zzz.txt");
        fos.write("同九年，汝独秀".getBytes());
        fos.write("\r\n".getBytes());
        
        fos.close();
    }
    
    private static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("yyy.txt");
        byte[] arr = new byte[4];
        int len;
        while((len = fis.read(arr)) != -1) {
            System.out.println(new String(arr,0,len));
        }
        fis.close();
    }
}

14_流的标准处理异常代码1.6版本及其以前

try finally嵌套

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo7_TryFinally {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("xxx.txt");
            fos = new FileOutputStream("yyy.txt");
            int b;
            while((b = fis.read()) != -1) {
                fos.write(b);
            }
        }finally {
            try {
                if(fis != null)
                    fis.close();
            }finally {                //try fianlly的目的是尽量关闭
                if(fos != null)
                    fos.close();
            }
        }
    }
}

15_流的标准处理异常代码1.7版本

try close
原理
- 在try()中创建的流对象必须实现了AutoCloseable这个接口,如果实现了,在try后面的{}(读写代码)执行后就会自动调用,流对象的close方法将流关掉

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo7_TryFinally {
    public static void main(String[] args) throws IOException {
        try(
            FileInputStream fis = new FileInputStream("xxx.txt");
            FileOutputStream fos = new FileOutputStream("yyy.txt");
            MyClose mc = new MyClose();
        ){
            int b;
            while((b = fis.read()) != -1) {
                fos.write(b);
            }
        }
    }
}

class MyClose implements AutoCloseable{    //实现AutoCloseable，自动调用close();
    public void close() {
        System.out.println("我关了");
    }
}

16_图片加密

给图片加密

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo8_test {
    public static void main(String[] args) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("图片1.jpg"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.jpg"));
        
        int b;
        while((b = bis.read()) != -1) {
            bos.write(b ^ 123);//将写出的字节异或上一个数，这个数就是秘钥，解密再异或就行
        }
        
        bis.close();
        bos.close();
    }
}

17_拷贝文件

在控制台录入文件的路径,将文件拷贝到当前项目下

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class Demo9_test {
    public static void main(String[] args) throws IOException {
        File file = getFile();                //获取文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file.getName()));
        
        int b;
        while((b = bis.read()) != -1) {
            bos.write(b);
        }
        bis.close();
        bos.close();
    }
    
    //定义一个方法获取键盘录入的文件路径，并封装成file对象返回
    //返回值类型:File    参数列表:无    
    public static File getFile() {
        Scanner sc = new Scanner(System.in);//创建键盘录入对象
        System.out.println("请输入一个文件的路径：");
        while(true) {
            String line = sc.nextLine();        //接收键盘录入的路径
            File file = new File(line);            //封装成File对象，并对其判断
            if(!file.exists()) {
                System.out.println("您录入的文件路劲不存在，请重新录入：");
            }else if(file.isDirectory()) {
                System.out.println("您录入的是文件夹路径，请重新录入：");
            }else {
                return file;                    //弹栈返回路径
            }
        }
    }
}

18_录入数据拷贝到文件

将键盘录入的数据拷贝到当前项目下的text.txt文件中,键盘录入数据当遇到quit时就退出

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class Demo10_test {
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);        //创建键盘录入对象
        FileOutputStream fos = new FileOutputStream("text.txt");//创建输出流对象，关联text.txt文件
        System.out.println("请输入数据：");
        
        while(true) {
            String line = sc.nextLine();            //将键盘录入的数据存储在line中
            if("quit".equals(line)) {
                break;                                //遇到quit退出循环
            }
            fos.write(line.getBytes());                //字符串写出必须转换成字节数组
            fos.write("\r\n".getBytes());
        }
        fos.close();
    }
}

Java编程基础21——IO(字节流)

1_IO流概述及其分类

2_FileInputStream

3_read()方法返回值为什么是int

4_FileOutputStream

5_FileOutputStream追加

6_拷贝图片

7_拷贝音频文件画原理图

8_字节数组拷贝之available()方法

9_定义小数组

10_定义小数组的标准格式

11_BufferedInputStream和BufferOutputStream拷贝

12_flush和close方法的区别

13_字节流读写中文)

14_流的标准处理异常代码1.6版本及其以前

15_流的标准处理异常代码1.7版本

16_图片加密

17_拷贝文件

18_录入数据拷贝到文件

扎瓦

引用和评论

JavaWEB开发21——综合项目(图书商城)

Java8的新特性

Java11的新特性

Java5的新特性

Java9的新特性

Java13的新特性

Java7的新特性