day20<IO流>

IO流(IO流概述及其分类)

IO流(FileInputStream)

IO流(read()方法返回值为什么是int)

IO流(FileOutputStream)

IO流(FileOutputStream追加)

IO流(拷贝图片)

IO流(拷贝音频文件画原理图)

IO流(字节数组拷贝之available()方法)

IO流(定义小数组)

IO流(定义小数组的标准格式)

IO流(BufferedInputStream和BufferOutputStream拷贝)

IO流(flush和close方法的区别)

IO流(字节流读写中文)

IO流(流的标准处理异常代码1.6版本及其以前)

IO流(流的标准处理异常代码1.7版本)

IO流(图片加密)

IO流(拷贝文件)

IO流(录入数据拷贝到文件)

 

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

###20.02_IO流(FileInputStream)
 read()一次读取一个字节

FileInputStream fis = new FileInputStream("xxx.txt"); //创建流对象

    int x = fis.read(); //从硬盘上读取一个字节

System.out.println(x); //97

    int y = fis.read();

System.out.println(y); //98

    int z = fis.read();

System.out.println(z); //99

    int a = fis.read();

System.out.println(a); //-1 结束标记是-1，不是有效字节

    int b = fis.read();

System.out.println(b); //-1

fis.close(); //关流释放资源

FileInputStream fis = new FileInputStream("xxx.txt"); //创建流对象

    int b;   //定义变量,记录每次读到的字节

    while((b = fis.read()) != -1) {  //将每次读到的字节赋值给b并判断是否是-1

System.out.println(b);  //打印每一个字节

}

fis.close();  //关闭流释放资源

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

###20.04_IO流(FileOutputStream)
 write()一次写出一个字节

FileOutputStream fos = new FileOutputStream("yyy.txt"); //创建字节输出流对象,如果没有就自动创建一个

//fos.write(97); //虽然写出的是一个int数,但是到文件上的是一个字节,会自动去除前三个8位,所以写出的一个byte

//fos.write(98);

//fos.write(99);

fos.write(100); //FileOutputStream在创建对象的时候是如果没有这个文件会帮我创建出来,如果有这个文件就会先将文件清空

fos.close();

###20.05_IO流(FileOutputStream追加)
 A:案例演示
     FileOutputStream的构造方法写出数据如何实现数据的追加写入(聊天记录)

FileOutputStream fos = new FileOutputStream("yyy.txt",true); //如果想续写就在第二个参数传true

fos.write(97);

fos.write(98);

fos.close();

###20.06_IO流(拷贝图片)
     FileInputStream读取
     FileOutputStream写出

FileInputStream fis = new FileInputStream("双元.jpg"); //创建输入流对象,关联双元.jpg

FileOutputStream fos = new FileOutputStream("copy.jpg"); //创建输出流对象,关联copy.jpg

    int b;

    while((b = fis.read()) != -1) { //在不断的读取每一个字节

fos.write(b); //将每一个字节写出

}

fis.close(); //关流释放资源

fos.close();

###20.07_IO流(拷贝音频文件画原理图)
 A:案例演示
     字节流一次读写一个字节复制音频
 弊端:效率太低

FileInputStream fis = new FileInputStream("致青春.mp3"); //创建输入流对象,关联致青春.mp3

FileOutputStream fos = new FileOutputStream("copy.mp3"); //创建输出流对象,关联copy.mp3

    int b;

    while((b = fis.read()) != -1) { //在不断的读取每一个字节

fos.write(b); //将每一个字节写出

}

fis.close(); //关流释放资源

fos.close();

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

//第二种拷贝,不推荐使用,因为有可能会导致内存溢出

FileInputStream fis = new FileInputStream("致青春.mp3"); //创建输入流对象,关联致青春.mp3

FileOutputStream fos = new FileOutputStream("copy.mp3"); //创建输出流对象,关联copy.mp3

//int len = fis.available();

//System.out.println(len);

    byte[] arr = new byte[fis.available()]; //创建与文件一样大小的字节数组

fis.read(arr); //将文件上的字节读取到内存(数组)中

fos.write(arr); //将字节数组中的字节数据一次写到文件上

fis.close();

fos.close();

###20.09_IO流(定义小数组)
     write(byte[] b)
     write(byte[] b, int off, int len)写出有效的字节个数

FileInputStream fis = new FileInputStream("xxx.txt");

    byte[] arr = new byte[2];   //2的整数倍

    int a = fis.read(arr); //将文件上的字节读取到字节数组中

System.out.println(a); //2 //读到的有效字节个数

    for (byte b : arr) { //第一次获取到文件上的a和b

System.out.println(b); //97 98

}

System.out.println("-----------------------");

    int c = fis.read(arr);

System.out.println(c); //1

    for (byte b : arr) {

System.out.println(b); //99 98 //99把97覆盖掉

}

fis.close();

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); //从0开始写len个

}

fis.close();

fos.close();

###20.10_IO流(定义小数组的标准格式)
 A:案例演示
     字节流一次读写一个字节数组复制图片和视频

FileInputStream fis = new FileInputStream("致青春.mp3");

FileOutputStream fos = new FileOutputStream("copy.mp3");

    byte[] arr = new byte[1024 * 8];   //8k

    int len;

    while((len = fis.read(arr)) != -1) { //如果忘记加arr,返回的就不是读取的字节个数,而是字节的码表值

fos.write(arr,0,len);

}

fis.close();

fos.close();

###20.11_IO流(BufferedInputStream和BufferOutputStream拷贝)(鸡蛋托)
 A:缓冲思想
     字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，
     这是加入了数组这样的缓冲区效果，java本身在设计的时候，
     也考虑到了这样的设计思想(装饰设计模式)，所以提供了字节缓冲区流
 B.BufferedInputStream
     BufferedInputStream内置了一个缓冲区(数组)
     从BufferedInputStream中读取一个字节时
     BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个
     程序再次读取时, 就不用找文件了, 直接从缓冲区中获取
     直到缓冲区中所有的都被使用过, 才重新从文件中读取8192个
 C.BufferedOutputStream
     BufferedOutputStream也内置了一个缓冲区(数组)
     程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中
     直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里
 D.拷贝的代码

FileInputStream fis = new FileInputStream("致青春.mp3"); //创建输入流对象,关联致青春.mp3

FileOutputStream fos = new FileOutputStream("copy.mp3"); //创建输出流对象,关联copy.mp3

BufferedInputStream bis = new BufferedInputStream(fis); //创建缓冲区对象,对输入流进行包装让其变得更加强大

BufferedOutputStream bos = new BufferedOutputStream(fos);

    int b;

    while((b = bis.read()) != -1) {

bos.write(b);

}

bis.close();

bos.close();   //只关装饰后的对象即可

 E.小数组的读写和带Buffered的读取哪个更快?
     定义小数组如果是8192个字节大小和Buffered比较的话
     定义小数组会略胜一筹,因为读和写操作的是同一个数组
     而Buffered操作的是两个数组

###20.12_IO流(flush和close方法的区别)
 flush()方法
     用来刷新缓冲区的,刷新后可以再次写出 
 close()方法
     具备刷新的功能,在关闭流之前,就会先刷新一次缓冲区,将缓冲区的字节全都刷新到文件上,再关闭,close方法刷完之后就不能写了

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("致青春.mp3"));

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.mp3"));

    int b;

    while((b = bis.read()) != -1) {

bos.write(b);

}

//bos.flush();

bis.close();

bos.close();

###20.13_IO流(字节流读写中文) 
 字节流读取中文的问题
     字节流在读中文的时候有可能会读到半个中文,造成乱码

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();

字节流写出中文的问题
     字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组 
     写出回车换行 write("\r\n".getBytes());

FileOutputStream fos = new FileOutputStream("zzz.txt");

fos.write("我读书少,你不要骗我".getBytes());

fos.write("\r\n".getBytes());

fos.close();

###20.14_IO流(流的标准处理异常代码1.6版本及其以前)
 try finally嵌套

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();

}

}

###20.15_IO流(流的标准处理异常代码1.7版本)
 try close

    try(

FileInputStream fis = new FileInputStream("xxx.txt");

FileOutputStream fos = new FileOutputStream("yyy.txt");

MyClose mc = new MyClose();

){ //大括号执行完后自动关闭close

int b;

while((b = fis.read()) != -1) {

fos.write(b);

}

}

    class MyClose implements AutoCloseable {

public void close() {

System.out.println("我关了");

}

}

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

###20.16_IO流(图片加密)
     给图片加密
   一个数被异或两次就是其本身

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("copy.jpg"));

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy2.jpg"));

    int b;

    while((b = bis.read()) != -1) {

bos.write(b ^ 123); //将写出的字节异或上一个数,这个数就是密钥,解密的时候再次异或就可以了

}

bis.close();

bos.close();

###20.17_IO流(拷贝文件)
 在控制台录入文件的路径,将文件拷贝到当前项目下
    * 分析:

1,定义方法对键盘录入的路径进行判断,如果是文件就返回

2,在主方法中接收该文件

3,读和写该文件

    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对象返回

* 1,返回值类型File

* 2,参数列表无

*/

    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;

}

}

}

###20.18_IO流(录入数据拷贝到文件)
 将键盘录入的数据拷贝到当前项目下的text.txt文件中,键盘录入数据当遇到quit时就退出
   * 分析:

1,创建键盘录入对象

2,创建输出流对象,关联text.txt文件

3,定义无限循环

4,遇到quit退出循环

5,如果不quit,就将内容写出

6,关闭流

//1,创建键盘录入对象

Scanner sc = new Scanner(System.in);

//2,创建输出流对象,关联text.txt文件

FileOutputStream fos = new FileOutputStream("text.txt");

System.out.println("请输入数据:");

//3,定义无限循环

    while(true) {

String line = sc.nextLine(); //将键盘录入的数据存储在line中

//4,遇到quit退出循环

       if("quit".equals(line)) {

  break;

}

//5,如果不quit,就将内容写出

fos.write(line.getBytes()); //字符串写出必须转换成字节数组

fos.write("\r\n".getBytes());

}

//6,关闭流

fos.close();

###20.19_day20总结
 把今天的知识点总结一遍。

1,拷贝文件的四种方式,推荐用哪种,不推荐用哪种,弊端是什么

2,标准的异常处理代码,1.6及其以前的,1.7版本的

3,三个课堂练习自己做一遍