2021年8月13日

昨天的回顾

1.TreeSet

Set接口的实现类，底层是二叉树。在进行集合数据的存储的时候值是唯一，不可重复的，而且对存储的值进行了自然排序

开发中很少用。

TreeSet<String> its = new TreeSet<String>();

its.add("1");

its.add("78");

TreeSet这个泛型如果放的是对象的话，不能直接进行自然排序的，会报错。

让类去实现一个接口Comparable，重写方法compareTo这个方法，对对象中的属性进行自然排序的

2.匿名内部类

抽象的匿名内部类

接口匿名内部类

咱们之前讲过抽象类和接口不能直接实例化，但是现在可以实例化，但是一定要注意

在实例化的时候重写未实现的方法。

3.Map集合

存的是键值对形式的数据

有键 有值

Map接口下面有哪些重要的方法

增：put()

删：remove（）

改:put()

查:

size()

isEmpty()

keySet() 获取键 ，然后返回的是Set集合

values() 获取值 返回是Collection集合

get(K key);通过键获取值

今天的内容

1.File类

2.IO流【重点】

1.File类

1.1File类的介绍

File这个类sun公司给java成员提供的一个处理文件和文件夹的类

现在想想面向对象是啥？专门的对象做转门的事儿

路径问题：【重要】

404 就是找不到当前文件路径

相对路径:

得有参照物

我在你隔壁，参照物是你

./代表当前目录

../相对于当前目录的上一级目录

../../相对于当前目录的上两级目录

../../../相对于当前目录的上三级目录

绝对路径:

磁盘的根路径

C:\Users\wangbo\Desktop\zz2109\day19\code

京贺在我前面坐，这个是相对路径还是绝对路径？ 相对路径

京贺在地球中国河南郑州二七区航海中路60号海为科技c区12层13教室第一排从南边数第5个逗比 这个是相对路径还是绝对路径？ 绝对路径

个人建议，咱们以后在写路径：

使用 /

1./支持windows和Linux

2.\ z支持windows系统，但是不支持Linux系统

新学一个类咱们首先要看官方手册

File这个类是专门处理文件和文件夹的类

很轻松，是个人就会。为啥这样说？学构造方法，学方法就可以。

File类的构造方法,目的 怎么实例化对象

File(String pathName);

根据对应的文件路径，创建出来对应的文件对象或者文件夹对象

File(String parent, String child);

C:\Users\wangbo\Desktop\zz2109\day19\code

根据文件指定的父级目录，和子目录创建一个文件对象或者文件夹对象

File(File file, String chiles);

1.2使用File类创建文件或者文件夹

咱们以后会使用这些方法做文件上传，比如开发中头像上传

很多的网站和app都是实名认证的，现在需要上传身份证正反面，这个就是文件上传的功能

是需要使用到File类下面的方法的

boolean createNewFile();创建文件方法，返回值是布尔类型的数据

【注意事项】:

1.操作文件的路径不存在，返回false

2.硬盘坏了，报错

3.文件已经存在的时候，就返回false

boolean mkdir();

boolean mkdirs();

通过file对象，创建的文件夹是保存的路径地址

boolean renameTo(File file);

通过文件对象，重命名 移动等

package com.qfedu.a_file;
​
import java.io.File;
import java.io.IOException;
​
public class Demo2 {
    public static void main(String[] args) throws IOException {
        File file = new File("c:/aaa/2.txt");
        //file.createNewFile()这个方法有可能出现异常
        //使用java代码创建的一个文件
        System.out.println(file.createNewFile());
        
        File file2 = new File("C:/aaa/bbb");
        System.out.println(file2.mkdir());//只能创建一级目录
        File file3 = new File("c:/aaa/ccc/eee/fff");
        System.out.println(file3.mkdirs());//创建多级目录  层级比较深了
        File file4  = new File("c:/aaa/2.txt");
        File file5 = new File("C:/aaa/bbb/你大爷还是你大爷.txt");
        System.out.println(file4.renameTo(file5));//移动并重命名
        
    }
}
​

1.3File删除文件或者文件夹

boolean delete();立即删除

void deleteOnExit();

程序退出以后才删除对应 的文件或者文件夹

删除：硬删除，直接从磁盘上面删除，不会保留到回收站

package com.qfedu.a_file;
​
import java.io.File;
import java.util.Scanner;
​
public class Demo3 {
    public static void main(String[] args) {
        File file = new File("c:/aaa/2.txt");
        System.out.println(file.delete());
        
        File file2 = new File("c:/aaa/4.txt");
        file2.deleteOnExit();//程序结束以后才会删除
        new Scanner(System.in).nextInt();
    }
}
​

1.4File对象的一些判断方法

boolean isFile();是不是普通文件

boolean isDirectory();是不是文件夹（目录）

boolean isHidden();是不是隐藏文件

boolean isAbsolute();是不是绝对路径

boolean exits();对应的文件或者文件夹是否存在

package com.qfedu.a_file;
​
import java.io.File;
​
​
​
public class Demo4 {
    public static void main(String[] args) {
        System.out.println(new File("C:/aaa/1.txt").isFile());//true
        System.out.println(new File("c:/aaa/1.txt").isDirectory());//false
        System.out.println(new File("c:/aaa").isDirectory());//true
        System.out.println(new File("c:/aaa/1.txt").isHidden());//false
        System.out.println(new File("C:/aaa").isAbsolute());//true
        System.out.println(new File("./Demo1").isAbsolute());//false
        System.out.println( new File("c:/aaa/1.txt").exists());//true
    }
}
​

1.5返回String类型的数据的方法

String getName();获取文件或者文件夹的名字

String getPath();获取当前创建File对象的路径

String getParent();获取当前文件对象的父级目录

String getAbsolutePath();获取绝对路径

package com.qfedu.a_file;
​
import java.io.File;
​
import javax.sound.midi.Soundbank;
​
public class Demo5 {
    public static void main(String[] args) {
        String path = "c:/aaa/bbb/1.txt";
        File file = new File(path);
        System.out.println(file.getName());//  1.txt
        System.out.println(file.getPath());//c:\aaa\bbb\1.txt
        System.out.println(file.getParent());//c:/aaa/bbb
        File file2 = new File("./");
        System.out.println(file2.getAbsolutePath());
        //C:\Users\wangbo\eclipse-workspace\day19_wb\.
    }
}
​

1.6返回是long类型数据的方法

long length();获取文件占用硬盘的字节数

long lastModified();获取当前文件最后的修改时间，这个时间是时间戳

package com.qfedu.a_file;
​
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.*;
​
public class Demo6 {
    public static void main(String[] args) {
        File file = new File("c:/aaa/1.txt");
        System.out.println(file.length());//返回的是字节数
        //一个英文字母占1个字节   一个中文字符占2个字节，还有可能占3个字节
        System.out.println(file.lastModified());//返回的是一个时间戳
        //1628824871402  从1970年的1月1日0:0:0到  2021年8月13日  11:21:11
        //扩展
        //时间戳  这个数值换算成咱们时间，看不懂
        //对客户不友好，怎么办？换算成北京时间
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");
        String formatString = simpleDateFormat.format(new Date(file.lastModified()));
        System.out.println(formatString);
    }
}
​

1.7文件列表方法

static File[] listRoots(); 只适用于windows系统。获取当前盘符下面的所有的类对象

String[] list();

获取当前文件夹对象下面所有的子文件和子文件夹对象

package com.qfedu.a_file;
​
import java.io.File;
​
public class Demo7 {
​
    public static void main(String[] args) {
        File[] files = File.listRoots();
        //数组，遍历
        for(File file : files) {
            System.out.println(file);
        }
        String pathString = "C:\\Program Files\\Java\\jdk1.8.0_241";
        File file = new File(pathString);
        String[] liStrings =  file.list();
        for (String string : liStrings) {
            System.out.println(string);
        }
        
        
    }
}
​

2.IO流

IO流主要用作文件读写，其实电脑的功能就是在读写

2.1缓冲概念

看视频有点卡，等他一下，再缓冲一会儿

顺丰快递

上海===》郑州

快递有物流中转基地，到时间点，攒够以后再发

计算机读，存。计算机的cpu通过内存读取硬盘中的数据，不是一个字节一个字节读取的。

每次大概从硬盘中读取4kb。

为什么要读取4kb？

1.提高读取和存储的效率

2.保护磁盘

io流在操作文件的时候：

读取和写入数据，如果按照一个字节或者一个字符来出来的话，效率是非常低的，可以采用缓冲的概念。

1.读取数据，按照CPU通过内存区读取硬盘上的数据，读取的数据是4kb,缓冲到内存区，再从内存区取出来

磁盘-》内存-》数据展示

2.写入，先把数据放到内存中，然后再把内存写到磁盘中

数据-》内存-》磁盘

IO流也是分为两个 读的 流 写的流

2.2IO流的分类

参照物是内存，可以理解为是当前的应用程序（demo）
I
    input 输入  从硬盘读取数据存入到了内存中，这叫输入
O
    output 输出  从内存中写入数据到硬盘中，这叫输出
输入流（读）和输出流（写）
两种处理方式：
    字节流：
        按照字节为单位，处理当前文件
    字符流：
        首先按照字节读取或者写入数据，但是在操作过程中会有一个解码过程。如果解码不成功，就意味着咱们读取数据和写入数据失败了。容易失败
​
java给咱们提供了
    输入字节流
        InpuStream  它有一个子类  FileInputStream
    输出字节流
        OutputStream 他有一个子类  FileOutputStream
    

2.3缓冲流

所有的缓冲流都是没有读写功能的，一般作用域输入流和输出流上

字节输入缓冲流
    BufferedInputStream
字节输出缓冲流
    BufferedOutputStream

package com.qfedu.b_stream;
​
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
​
import com.sun.org.apache.bcel.internal.generic.NEW;
​
​
​
//FileInputStream  字节输入流
//从硬盘读取数据写入到内存中
//把c:/aaa/1.txt文件的内容 读取到咱们的内存中，内存就是咱们的应用程序
//也是咱们的demo
public class Demo1 {
    public static void main(String[] args) throws IOException {
        //1.在硬盘中找到对应的文件（里面有数据，等会把这个数据读取到内存中）
        File file = new File("c:/aaa/1.txt");
        //2.创建一个FileInputStream文件输入字节流对象,FileInputStream这个类
        //不具备缓冲的功能。
        FileInputStream fis = new FileInputStream(file);
        //3.BufferedInputStream  给FileInputStream添加了一个缓冲的功能，让他的效率提高
        BufferedInputStream bis = new BufferedInputStream(fis);
        
        //4.将内容读取到数组里面,这个数组就是缓冲数组
        //从该输入流读取最多4096字节的数据到字节数组。 此方法将阻塞，直到某些输入可用。起到一个缓冲的作用
        
​
        //5.写入到内存中在咱们代码数组
        byte[] buf = new byte[1024 * 4];//容器
        //buf 是字节数组，该数组统称1024的倍数，缓冲数组，用来保存读取到的数据
        //输入流：从硬盘-》内存（数组）
        int length = -1;
        while((length = bis.read(buf)) != -1) {
            System.out.println(length);
            System.out.println(new String(buf,0, length));
        }
        //不等-1 就证明你没有读完这个数据，while循环就不能停止
        //将字节数组重新构造成为一个新的字符
        //为了让大家看一下我确实从1.txt读取出来了
        //6.因为咱们io流失消耗电脑资源的，所以需要关闭,不影响代码执行
        bis.close();
        fis.close();
    }
​
}
​

package com.qfedu.b_stream;
​
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
​
//首先新建一个空的文件，然后写入数据到这个空文件上面
//从内存写入数据到文件中
//输出流
public class Demo2 {
    public static void main(String[] args) throws IOException {
        //从内存写入磁盘上面
        //1.创建对应的FIle类对象,写入数据到2.txt
        File file = new File("c:/aaa/2.txt");
        //2.创建对应的字节输出流对象
        FileOutputStream fos = new FileOutputStream(file);
        //3.创建对应的字节缓冲输出流对象
        //蒙一下FileOutputStream对应的缓冲流是谁？
        //FileOutputStream 就具备了缓冲功能了
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //4.写入数据
        //现在是字符串，怎么把字符串转为字节数组呢
        byte[] bytes = "明天就情人节了，很尴尬，我单身".getBytes();
        //这个方法写一个字节数组到文件中
        bos.write(bytes);
        
        //5.关闭流资源
        bos.close();
        fos.close();
        
    }
​
}
​

2.4综合案例

复制一个文件到另外一个地方

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("C:\\Users\\wangbo\\Desktop\\zz2109\\day03\\videop\\2if分支.wmv")));

package com.qfedu.b_stream;
​
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
​
​
​
public class Demo3 {
    public static void main(String[] args) throws IOException {
        //复制一个文件到另外一个文件夹下面
        copy1();
    }
    public static void copy1() throws IOException {
        long start = System.currentTimeMillis();//代码走到这个地方有个当前时间  毫秒
        //首先你得有一个视频源文件，将整个视频源文件从磁盘
        //读取内存，在从内存中写到另外一个文件上
        //既有读取，又有写入
        
        //1.暴力点，创建对应的缓冲字节输入流和输出流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("C:\\Users\\wangbo\\Desktop\\zz2109\\day03\\videop\\2if分支.wmv")));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("c:/aaa/2.wmv")));
        //2.准备字节数组，目的是作为缓冲区
        byte[] buf = new byte[1024 * 4];
        //关于这个缓冲区，我的建议是写8  * 1024或者  4 *1024
        //因为要考虑运行内存
        //有利就有弊。要考虑性价比
        int length = -1;
        //3.从磁盘写入到内存再写入到磁盘
        //请问大家一个问题哦?你知道你的视频是大于4096字节还是小于4096字节吗“？
        //如果视频大于了4096字节，你要使用循环了
        while((length = bis.read(buf))!= -1) {
            //1次读到 4096  一个循环我就赶紧写进去一次
            //12344657 buf  123
            //446  buf 
            //57 buf 
            bos.write(buf, 0, length);
            //4096个循环一次
        }
        //4.关闭资源
        bos.close();
        bis.close();
        long end = System.currentTimeMillis();//代码走到这个地方又是一个当前时间
        System.out.println(end - start);//332毫秒，复制一个视频需要耗费这么久的时间
        
    }
    //缓冲流，提高咱们读写的执行效率
    //下面我再来一个案例，这个案例我不加缓冲流了，大家看一下。中间的耗时
    public static void copy2() throws IOException {
        long start = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream(new File("C:\\Users\\wangbo\\Desktop\\zz2109\\day03\\videop\\2if分支.wmv"));
        FileOutputStream fos =  new FileOutputStream(new File("c:/aaa/2.wmv"));
        //这个没有带缓冲
        //没有带缓冲的话，还需要缓冲数组吗？不需要的
        int length = -1;
        while ((length = fis.read())!= -1) {
            fos.write(length);
            //一个字节循环一次  缓冲的是你的4096倍
        }
        fos.close();
        fis.close();
        long end = System.currentTimeMillis();
        System.out.println(end - start);//167277
    }
​
}
​

作业：找一些美照

进行复制，我要求使用缓冲字节流