day19学习笔记

一、回顾

 

1.集合的工具类 Collections 
  public static  int binarySearch(List> list, T key)
  查找指定字符的索引值
  public static  void copy(List dest, List src)
  克隆
  public static  void fill(List list,T obj)
  使用指定元素替换指定列表中的所有元素
  public static > 
  T max(Collection coll) 最大值
  public static > 
  T min(Collection coll) 最小值
  public static void reverse(List list) 控制反转
  public static void shuffle(List list) 随机置换
  public static > void sort(List list) 排序
  public static void swap(List list,int i,int j) 在指定列表的指定位置处交换元素
2.File对象
   ==>>构造方法:
        public File(File parent,String child)
        public File(String pathname)
        public File(String parent,String child)
   ==>>常用的方法
       <创建>
          public boolean createNewFile() 创建文件
          public boolean mkdir() 创建目录(一级)
          public boolean mkdirs()创建目录(多级)
       <删除>
        public boolean delete() 删除文件以及空的文件夹
       <重命名与剪切>
          public boolean renameTo(File dest)
       <得到性>
         public String getName() 获取文件的名称
         public String getPath() 获取构造方法中路径
         public String getParent() 获取父路径
         public String getAbsolutePath() 获取绝对路径
         public long length() 获取文件内容的长度
       <判断性>
         public boolean exists() 判断文件是否存在
         public boolean isFile() 判断是否是文件
         public boolean isDirectory() 判断是否是文件夹
       <过滤>
          public String[] list() 获取当前目录下所有文件路径
          public String[] list(FilenameFilter filter) 获取当前目录下所有过滤后文件路径
3.递归
    特点: 方法反复自己调用自己
    注意点:
      A.方法反复自己调用自己 参数会变小
      B.递归调用避免栈内存溢出    

二、IO

2.1 简介

I:Input 输入  O:Output 输出  用于不同设备来进行数据交互
2.使用场景:
   A.文件copy复制
   B.文件上传与下载
   C.即时通讯(微信聊天)
3.分类:
   按照流向划分: 输入流与输出流
   按照类型划分: 字节流与字符流
4.输入流与输出流解释
5.字节流与字符流解释
6.字节流: 
    A.万物皆字节  电脑上任何资源都可以使用字节表示 
    B.字节流用于操作图片 音频  视频
    C.分类:字节输入流与字节输出流
 7.字符流
    A.字符流=字节流+编码表 字符流的底层也是使用字节流来进行操作 只是通过编码表进行转换(将字节转换字符)
    B.字符流用于操作纯文本内容
    C.分类:字符输入流与字符输出流
 8.IO注意事项
    A.所有的流资源都在使用java.io包下
    B.使用流资源的时候 可能产生异常 处理异常:抛出 与捕获
    C.使用完流资源 需要关闭资源 因为流资源比较消耗内存
    
    

 

三、OutputStream

3.1 简介

1.此抽象类是表示输出字节流的所有类的超类
  A.OutputStream 是一个抽象类
  B.OutputStream是字节流的所有类的超类

3.2 常用方法

方法名称	方法描述
public void close()	关闭资源
public void flush()	刷新(将缓冲区的数据刷新到硬盘中)
public abstract void write(int b)	一个一个字节写入
public void write(byte[] b)	一次写入多个字节
public void write(byte[] b, int off, int len)	一次写入指定长度的字节

3.3 子类

 

 

四、FileOutputStream

4.1 简介

A.文件输出流是用于将数据写入 File
B.FileOutputStream 用于写入诸如图像数据之类的原始字节的流。要写入字符流，请考虑使用 FileWriter

4.2 构造方法

构造方法名称	构造方法描述
public FileOutputStream(File file)	创建一个向指定 File 对象表示的文件中写入数据的文件输出流
public FileOutputStream(File file, boolean append)	创建一个向指定 File 对象表示的文件中写入数据的文件输出流(如果为 true，则将字节写入文件末尾处，而不是写入文件开始处)
public FileOutputStream(Stringname)	创建一个向具有指定名称的文件中写入数据的输出文件流
public FileOutputStream(String name, boolean append)	创建一个向具有指定 name 的文件中写入数据的输出文件流(如果为 true，则将字节写入文件末尾处，而不是写入文件开始处)

4.3 构造方法三件事

A.实例化FileOutputStream对象
B.创建一个空的文件
C.将FileOutputStream 指向创建的空文件

4.4 使用步骤

A.实例化 FileOutputStream对象
B.调用写的方法
C.关闭流资源

4.5 一个一个字节写入

package com.qf.test02;
​
import java.io.FileOutputStream;
import java.io.IOException;
​
public class Test01 {
    public static void main(String[] args) throws IOException {
        //实例化FileOutputStream对象
        FileOutputStream fos   = new FileOutputStream("d:\a\a.txt");
        //调用写的方法
        fos.write(97);
        fos.write(98);
        fos.write(99);
        //关闭资源
        fos.close();
    }
}
​

4.6 一次写入多个字节

package com.qf.test02;
​
import java.io.FileOutputStream;
import java.io.IOException;
​
public class Test02 {
    public static void main(String[] args) throws IOException {
        //实例化FileOutputStream
        FileOutputStream fos  = new FileOutputStream("d:\a\3.txt");
        //定义一个字节数组
        byte[] b={97,98,99};
        //调用写的方法
        fos.write(b);
        //关闭资源
        fos.close();
    }
}
​

4.7 字节流写字符串

package com.qf.test02;
​
import java.io.FileOutputStream;
import java.io.IOException;
​
public class Test03 {
    public static void main(String[] args) throws IOException {
        //实例化FileOutputStream
        FileOutputStream  fos  =  new FileOutputStream("d:\a\5.txt",false);
        String str="飞哥今天过七夕节";
        //将字符串转换为字节数组
        byte [] b = str.getBytes();
        fos.write(b);
        //关闭资源
        fos.close();
​
    }
}
​

4.8 字节流写入原理

 

4.9 写入内容说明

1.使用OutputStream 写入的内容是  97  98  99    记事本 打开的内容是  a   b c
2.原因:
    使用记事本打开文件的时候   如果字节范围是0 -127  使用 ASCII码表来进行识别
    使用记事本打开文件的时候   如果超过这个范围  使用记事本默认的码表识别 默认的码表是GBK

五、InputStream

5.1 简介

1.此抽象类是表示字节输入流的所有类的超类
  A.InputStream 是一个抽象类
  B.InputStream是字节输入流的所有类的超类

5.2 常用方法

方法名称	方法描述
public void close()	关闭资源
public abstract int read()	一个一个字节读取
public int read(byte[] b)	一次读取多个字节放入到缓冲区数组
public int read(byte[] b, int off, int len)	一次读取指定字节数放入到缓冲区数组中

5.3 子类

 

六、FileInputStream

6.1简介

A.FileInputStream 从文件系统中的某个文件中获得输入字节  读取文件中字节(内容)
B.FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader

6.2 构造方法

构造方法名称	构造方法描述
public FileInputStream(File file)	通过打开一个到实际文件的连接来创建一个 FileInputStream
public FileInputStream(String name)	过打开一个到实际文件的连接来创建一个 FileInputStream

6.3 构造方法两件事

A.实例化FileInputStream 对象
B.将FileInputStream指向要操作的文件

6.4 使用步骤

A.实例化FileInputStream对象
B.调用读的方法
C.关闭资源
​

6.5 一个一个字节读取

package com.qf.test03;
​
import java.io.FileInputStream;
import java.io.IOException;
​
public class Test01 {
    public static void main(String[] args) throws IOException {
        //实例化FileInputStream对象
        FileInputStream  fis   = new FileInputStream("d:\a\b.txt");
        //调用读的方法
        int r1 = fis.read();
        System.out.println((char)r1);
        int r2 = fis.read();
        System.out.println((char)r2);
        int r3 = fis.read();
        System.out.println((char)r3);
        //关闭资源
        fis.close();
    }
}
​
​

6.6 读取原理

 

改造后的代码

package com.qf.test03;
​
import java.io.FileInputStream;
import java.io.IOException;
​
public class Test02 {
    public static void main(String[] args) throws IOException {
        //实例化FileInputStream
        FileInputStream  fis   = new FileInputStream("d:\a\b.txt");
        //使用循环进行读取
        int leng = -1;
        while ( (leng =fis.read()) !=-1) {
            System.out.println((char) leng);
        }
        //关闭资源
        fis.close();
    }
}
​
​

6.7 一次读取多个字节

package com.qf.test03;
​
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
​
public class Test03 {
    public static void main(String[] args) throws IOException {
        //实例化FileInputStream
        InputStream fis   = new FileInputStream("d:\a\b.txt");
        //定义一个缓冲区的数组
        byte [] b = new byte[2];
        //第一次读取
        int leng01 = fis.read(b);
        System.out.println(Arrays.toString(b));
        System.out.println(leng01);
        //第二次读取
        int leng02  = fis.read(b);
        System.out.println(Arrays.toString(b));
        System.out.println(leng02);
        //第三次读取
        int leng03 = fis.read(b);
        System.out.println(Arrays.toString(b));
        System.out.println(leng03);
​
        int leng04 = fis.read(b);
        System.out.println(Arrays.toString(b));
        System.out.println(leng04);
        //关闭流资源
        fis.close();
​
    }
}
​

6.8 一次读取多个字节的原理

 

改造之后代码

package com.qf.test03;
​
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
​
public class Test04 {
    public static void main(String[] args) throws IOException {
        //实例化FileInputStream
        FileInputStream fis  = new FileInputStream("d:\a\b.txt");
        //定义一个缓冲区的数组
        //定义缓冲区数组的大小是1024的倍数
        byte[] b = new byte[1024];
        int leng =-1;
        //使用循环来进行读取
        while ((leng= fis.read(b)) !=-1){
            //System.out.println(Arrays.toString(b));
            System.out.println(new String(b,0,leng));
        }
​
        //关闭资源
        fis.close();
​
    }
}
​

6.9 read() 与 read(b) 比较

A.read() 一个一个字节读取  效率低  read(b) 一次读取多个字节  效率高
B.read() 返回的是读取的数据 read(b) 返回的是读取的有效的字节个数

6.9.1 案例

step01 需求 将c盘中图片copy盘中

step02 分析

A.是字节输入流读取图片 FileInputStream  读
B.使用字节输出流写到d盘中 FileOutputStream 写

step03 代码

package com.qf.test03;
​
import java.io.*;
​
public class Test05 {
    public static void main(String[] args) throws IOException {
        //实例化输入流
        InputStream is = new FileInputStream("c:\admin\1.jpeg");
        //实例化输出流
        OutputStream os = new FileOutputStream("d:\a\1.jpeg");
        //定义一个缓冲区数组
        byte [] b = new byte[1024];
        //使用循环读取
        int leng=-1;
        while ((leng=is.read(b)) !=-1) {
            //写入
            os.write(b,0,leng);
        }
        //关闭资源
        os.close();
        is.close();
    }
}
​

七、高效流

7.1 简介

1. BufferedInputStream
   A.高效读
   B.在创建 BufferedInputStream 时，会创建一个内部缓冲区数组 默认缓冲区大小 8192
2. BufferedOutputStream
   A.高效写
   B.创建一个内部缓冲区数组 默认缓冲区大小 8192 
3.BufferedInputStream 与BufferedOutputStream 没有读写文件的功能  
  只是对象InputputStream与OutputStream的封装
4.高效的原因:
    高效读:每次读取8192个字节的数据放入到缓冲区数组  再从缓冲区数组(内存)中获取数据
          避免与磁盘进行多次交互 所以高效

7.2 构造方法

方法名称	方法描述
public BufferedOutputStream(OutputStream out)	创建一个新的缓冲输出流，以将数据写入指定的底层输出流
public BufferedInputStream(InputStream in)	创建一个 BufferedInputStream 并保存其参数，即输入流 in

7.3 高效读

package com.qf.test03;
​
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
​
public class Test06 {
    public static void main(String[] args) throws IOException {
        //实例化InputStream
        InputStream is = new FileInputStream("d:\a\b.txt");
        //实例化BufferedInputStream
        BufferedInputStream bis  = new BufferedInputStream(is);
        int leng=-1;
        //使用读取
        while ((leng= bis.read()) !=-1) {
            System.out.println((char) leng);
        }
        //关闭流资源
        bis.close();
        is.close();
        
    }
}
​

7.4 高效写

package com.qf.test03;
​
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
​
public class Test07 {
    public static void main(String[] args) throws IOException {
        OutputStream os = new FileOutputStream("d:\a\kk.txt");
        //实例化高效写
        BufferedOutputStream  bos   = new BufferedOutputStream(os);
        bos.write(97);
        bos.write(98);
        bos.write(99);
        //关闭资源
        bos.close();
        os.close();
    }
}
​

7.5 案例

step01 需求 使用高效流 将c盘中视频copy d盘

step02 分析

A. BufferedOutputStream 高效写
B. BufferedInputStream  高效读

step03 代码

package com.qf.test03;
​
import java.io.*;
​
public class Test08 {
    public static void main(String[] args) throws IOException {
        //实例化FileInputStream
        InputStream is = new FileInputStream("C:\Users\yyds\Desktop\广州第一阶段\day19\视频\01-回顾.mp4");
        //实例化BufferedInputStream
        BufferedInputStream  bis  = new BufferedInputStream(is);
        //实例化OutputStream
        OutputStream  os = new FileOutputStream("d:\a\1.mp4");
        //实例化 BufferedOutputStream
        BufferedOutputStream  bos  = new BufferedOutputStream(os);
        //使用循环读取
        int leng =-1;
        while ((leng=bis.read()) !=-1) {
            bos.write(leng);
        }
        //关闭资源  从下往上进行关闭
        bos.close();
        bis.close();
        os.close();
        is.close();
​
​
    }
}
​

八、关闭流资源

A.关闭流资源 必须从下往上进行关闭
B.关闭流资源需要在finally中进行关闭
C.关闭流资源之前 必须先进行非空判断

代码

package com.qf.test03;
​
import java.io.*;
​
public class Test09 {
    public static void main(String[] args) {
        InputStream is = null;
        BufferedInputStream bis = null;
        OutputStream os = null;
        BufferedOutputStream bos = null;
        try {
            //实例化FileInputStream
            is = new FileInputStream("C:\Users\yyds\Desktop\新建文件夹.rar");
            //实例化BufferedInputStream
            bis = new BufferedInputStream(is);
            //实例化OutputStream
            os = new FileOutputStream("d:\a\ww.rar");
            //实例化 BufferedOutputStream
            bos = new BufferedOutputStream(os);
​
            //使用循环读取
            int leng = -1;
            while ((leng = bis.read()) != -1) {
                bos.write(leng);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源 从下往上进行关闭
            try {
                if (bos !=null){
                    bos.close();
                }
                if (bis !=null) {
                    bis.close();
                }
                if (os !=null) {
                    os.close();
                }
​
                if (is !=null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
​

九、总结