5.Java 基础知识 (其三)

文章目录

• Java 基础知识 (其三)
• • 知识点四十二 : Lambda表达式
  • 知识点四十三 : 异常
  • • ① 异常 快速入门
    • ② 异常 try.catch方式处理异常
    • ③ 异常 声明抛出异常
  • 知识点四十四 : File类
  • • ① File类 构造方法
    • ② File类 创建功能
    • ③ File类 判断功能
    • ④ File类 获取功能
    • ⑤ File类 删除功能
  • 知识点四十五 : IO流
  • • ① 字节输出流 快速入门
    • ② 字节输出流 解决IO流异常问题
    • ③ 字节输出流 创建空文件
    • ----------------------------------------
    • ① 字节输入流 一次读取一个字节
    • ② 字节输入流 一次读取一个字节数组
    • ③ 字节输入流 拷贝文本文件
    • ④ 字节输入流 图片加密
    • ----------------------------------------
    • ① 字节缓冲流 快速入门
    • ② 字节缓冲流 拷贝视频文件

Java 基础知识 (其三) 知识点四十二 : Lambda表达式

---

1.函数式编程思想介绍:
  函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”,而我们要学习的Lambda表达式就是函数式思想的体现
  
2.Lambda表达式标准格式:
  (形式参数) -> {代码块}
  
3.Lambda表达式省略模式:
  省略的格式:
    ==test((int x,int y) -> {return x+y;});==省略为 test((x,y) -> x+y );
  省略的规则:
    • 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
    • 如果参数有且仅有一个，那么小括号可以省略
    • 如果代码块的语句只有一条，可以省略大括号和分号，和return关键字
  
4.总结:
  - 组成Lambda表达式的三要素：形式参数，箭头，代码块
  - Lambda表达式必须要有接口, 且接口中有且仅有一个抽象方法
  - 必须要有上下文环境才能推导出Lambda对应的接口
    使用场景1:直接当做接口的子类对象使用.
    使用场景2:作为方法的实参进行传递.
  - Lambda表达式和匿名内部类之间的区别是什么?
    (1) 所需类型不同
      Lambda表达式:接口
      匿名内部类:接口,类(普通类,抽象类均可)
    (2) 使用限制不同
      Lambda表达式:有且只能有一个抽象方法
      匿名内部类:不限制
    (3) 实现原理不同
      Lambda表达式:编译之后,不会产生新的.class字节码文件.
      匿名内部类:编译之后,会产生新的.class字节码文件.

---

package com.itheima.demo06_lambda;

// 自定义接口Animal
public interface Animal {
    // 吃饭
    void eat();
}

package com.itheima.demo06_lambda;


// 案例:Lambda表达式 快速入门
public class AnimalTest {
    public static void main(String[] args) {
        

        // 具体需求:并在main方法中, 调用AnimalTest#show()方法
        // 方式一:普通做法,搞一个类实现Animal接口,这里传一个具体的子类对象.
        // show(new Cat());


        // 方式二:采用匿名内部类(体现面对对象思想)
        // 即 我们需要传入Animal接口的子类对象,且该子类对象还是我们自己new出来的.
        show(new Animal() {
            @Override
            public void eat() {
                System.out.println("匿名内部类,动物吃饭!");
            }
        });

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

        // 方式三(推荐):采用Lambda表达式实现,体现的是函数式编程思想.
        // 即 我们告诉程序做什么,至于怎么做,交给JVM自己甄别.
        show(() -> {
            System.out.println("匿名内部类,动物吃饭!");
        });
    }

    // 2.在测试类AnimalTest中定义show(Animal an)方法, 实现调用Animal#eat()方法.
    public static void show(Animal an){
        an.eat();
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
匿名内部类,动物吃饭!
------------------
匿名内部类,动物吃饭!

进程已结束,退出代码0

知识点四十三 : 异常 ① 异常 快速入门

---

异常简介:
  
  1.概述:
    Java中的异常指的是程序出现不正常的情况.
  
  2.分类:
    Throwable : 类, 异常的最顶层类, 所有的异常都是它儿子.
      1.Error: 表示错误, 例如: 服务器宕机, 数据库崩溃, 这些异常一般和我们的代码没关系, 也不需要我们(程序员)处理.
      2.Exception: 表示异常, 这个才是我们常说的异常.
        - 编译期异常: 发生在编译期间的异常, 不处理, 程序编译通不过.
              非RuntimeException及其子类, 都叫: 编译期异常.
  
        - 运行时异常: 发生在运行期间的异常, 不处理, 程序也能通过编译.
              指的是RuntimeException及其子类.
  
  3.JVM默认处理异常的方式:
    采用"抛出异常(即: throws)的方式实现, 会将异常的类型, 异常的描述信息, 以及异常出现的位置打印到控制台上.
    并终止程序的运行.

---

package com.itheima.demo01_exception;

import java.text.SimpleDateFormat;

//案例: 演示异常入门案例.
public class Demo01 {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        System.out.println(a / b);      // 运行时才报错(除零异常)

        System.out.println("Hello World!");

        SimpleDateFormat sdf = new SimpleDateFormat();
        //sdf.parse("2020年");             // 编译期时就报错(转换异常)
    }
}

② 异常 try.catch方式处理异常

---

try.catch.finally语句
  
  格式:
    try{
      //可能出问题的代码
    } catch(Exception e) {
      //走这里, 说明程序出现异常了, 所以这里写的基本上都是解决方案.
      e.printStackTrace(); //该方法会将异常的类型, 描述信息及位置打印到控制台上.
    } finally {
      //这里的代码正常情况下永远都会执行, 一般是用来释放资源的.
    }
  
  特点:
    处理完之后, 代码会继续往下执行.

---

package com.itheima.demo01_exception;

//案例: 演示try.catch方式处理异常

public class Demo02 {
    public static void main(String[] args) {
        try{
            int a = 10;
            int b = 0;
            System.out.println(a / b);
        } catch (Exception e) {
            e.printStackTrace();    // 该方法会将异常的类型, 描述信息及位置打印到控制台上.
        }

        System.out.println("看看我执行了吗?");
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
java.lang.ArithmeticException: / by zero
	at com.itheima.demo01_exception.Demo02.main(Demo02.java:23)
看看我执行了吗?

进程已结束,退出代码0

③ 异常 声明抛出异常

package com.itheima.demo01_exception;

import java.text.SimpleDateFormat;

// 案例:演示throws方式处理异常.
public class Demo03 {
    public static void main(String[] args) throws Exception{ // 在main()方法中就将异常抛出

        SimpleDateFormat sdf = new SimpleDateFormat();
        sdf.parse("abc");       // 如果格式不对, 会报错: ParseException(转换异常)
        System.out.println("看看我执行了吗? ");  // 抛出异常后,程序终止,该语句不执行.
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
Exception in thread "main" java.text.ParseException: Unparseable date: "abc"
	at java.text.DateFormat.parse(DateFormat.java:366)
	at com.itheima.demo01_exception.Demo03.main(Demo03.java:10)

进程已结束,退出代码1

知识点四十四 : File类 ① File类 构造方法

---

File简介:
  
  概述:
    File就是用来描述文件或者文件夹的, 通过路径的形式描述.
  构造方法:
    public File(String pathName); 根据传入的路径, 获取对应的File对象.
    public File(String parent, String child); 根据传入的父目录和子文件名获取其对应的File对象.
    public File(File parent, String child); 根据传入的父目录对象和子文件名获取其对应的File对象.
  细节:
    1. 上述三种形式创建的文件(夹), 结果都是一样的.
    2. 之所以提供这么多的创建File对象的形式, 就是为了满足用户灵活多变的需求.
    3. 盘符不区分大小写, 写大写或者写小写都可以.
    4. 因为在Java中表示转移符, 所以如果写 右斜线需要写两个, 即: , 左斜线写一个就行了.

---

package com.itheima.demo02_file;

import java.io.File;

// 案例: File类构造方法.
public class Demo01 {
    public static void main(String[] args) {

        

        // 1. 演示  public File(String pathName); 根据传入的路径, 获取对应的File对象.
        File file1 = new File("D:\abc\1.txt");
        File file2 = new File("D:\abc\1.txt");
        System.out.println("file1: " + file1);
        System.out.println("file2: " + file2);
        System.out.println("-----------------");

        // 2. 演示  public File(String parent, String child);  根据传入的父目录和子文件名获取其对应的File对象.
        File file3 = new File("D:\abc\","1.txt");
        System.out.println("file3: " + file3);
        System.out.println("-----------------");

        // 3. 演示  public File(File parent, String child); 根据传入的父目录对象和子文件名获取其对应的File对象.
        File file4 = new File("D:\abc\");
        File file5 = new File(file4, "1.txt");
        System.out.println("file5: " + file5);
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
file1: D:abc1.txt
file2: D:abc1.txt
-----------------
file3: D:abc1.txt
-----------------
file5: D:abc1.txt

进程已结束,退出代码0

② File类 创建功能

---

File类中的成员方法:
  public boolean createNewFile(); 创建空文件, 文件不存在就创建返回true, 存在就不创建, 返回false.
  public boolean mkdir(); 创建单级文件夹, 其实是: make directory单词的缩写.
  public boolean mkdirs(); 创建多级文件夹.
  
小需求:
  创建: d:/ceshi/a/b/1.txt文件, 已知d:/ceshi目录存在, 但是 a/b/1.txt都不存在.
  
  思路:
    1. mkdirs() 创建aa/bb
    2. createNewFile() 创建1.txt

---

package com.itheima.demo02_file;

import java.io.File;
import java.io.IOException;

// 案例: 演示File类的创建功能.
public class Demo02 {
    public static void main(String[] args) throws IOException {
        // 需求1: 在D:ceshi文件夹下创建1.txt文件.
        File file1 = new File("d:/ceshi/1.txt");
        System.out.println(file1.createNewFile());
        System.out.println("-----------------------");

        // 需求2: 在D:ceshi文件夹下创建aabb文件夹
        File file2 = new File("d:/ceshi/aa/bb");
        System.out.println(file2.mkdirs());     // 结果为true,如果用file2.mkdir()结果为false,因为创建的是多级文件夹aa/bb,创建单级用.mkdir()为true
        System.out.println("-----------------------");
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
true
-----------------------
true
-----------------------

进程已结束,退出代码0

③ File类 判断功能

---

File类的判断功能:
  public boolean exists(); //判断指定的文件(夹)是否存在.
  public boolean isFile(); //判断给定的路径是否是文件, 默认包含了exists()方法的功能.
  public boolean isDirectory(); //判断给定的路径是否是文件夹, 默认包含了exists()方法的功能.

---

package com.itheima.demo02_file;
import java.io.File;

// 案例:演示File类的判断
public class Demo03 {
    public static void main(String[] args) {
        
        // 1.创建File对象.
        // 演示public boolean exists();            // 判断指定的文件(夹)是否存在.
        File file1 = new File("d:/ceshi/1.txt");
        System.out.println(file1.exists());
        System.out.println("-------------------");

        // 2.演示public boolean isFile();         // 判断给定的路径是否是文件.
        File file2 = new File("d:/ceshi/1.txt");
        System.out.println(file1.isFile());
        System.out.println("-------------------");

        // 3.演示public boolean isDirectory();    // 判断给定的路径是否是文件夹.
        File file3 = new File("d:/ceshi");
        System.out.println(file3.isDirectory());          // true,如果用的是file1.isDirectory()则输出false
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
true
-------------------
true
-------------------
true

④ File类 获取功能

---

File类的获取功能:
  public String getAbsolutePath(); //获取绝对路径.
  public String getPath(); //创建对象的时候用什么路径, 就获取什么路径, 一般是用于获取相对路径.
  public String getName(); //获取文件(夹)的名字.
  public String[] list(); //获取指定的目录下所有的 文件(夹) 的字符串数组形式.
  public File[] listFiles(); //获取指定的目录下所有的 文件(夹) 的File对象数组形式.

---

package com.itheima.demo02_file;

import java.io.File;

// 案例:演示File类的获取功能
public class Demo04 {
    public static void main(String[] args) {

        // 1.获取getAbsolutePath();获取绝对路径.
        File file1 = new File("day12/data/1.txt");          // 相对路径.
        System.out.println(file1.getAbsolutePath());        // 绝对路径.
        System.out.println(file1.getPath());                // 相对路径, 一般是相对于当前项目的路径来讲的.
        System.out.println("-------------------");

        // 2.public String getName();获取文件(夹)的名字.
        System.out.println(file1.getName());
        System.out.println("-------------------");

        // 3.public String[] list();获取指定的目录下所有的 文件(夹) 的字符串数组形式.
        File file2 = new File("d:/ceshi");
        String[] fileNames = file2.list();
        for (String fileName : fileNames) {
            System.out.println(fileName);
        }
        System.out.println("-------------------");

        // 4.public File[] listFiles();    //获取指定的目录下所有的 文件(夹) 的File对象数组形式.
        File[] listFiles = file2.listFiles();
        for (File listFile : listFiles) {
            System.out.println(listFile);
        }

    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
D:softwareCode0_CodeJavaSE代码黑马JAVAday12data1.txt
day12data1.txt
-------------------
1.txt
-------------------
1.txt
aa
-------------------
d:ceshi1.txt
d:ceshiaa

进程已结束,退出代码0

⑤ File类 删除功能

---

public boolean delete(); 删除文件或者文件夹.
  注意:
    1.如果是删除文件夹, 则该文件夹必须为空文件夹.
    2.Java中的删除不走回收站.

---

package com.itheima.demo02_file;
import java.io.File;


public class Demo05 {
    public static void main(String[] args) {
        
        //需求1: 删除 d:/ceshi/aa  文件夹
        File file1 = new File("d:/ceshi/aa");
        System.out.println(file1.delete());

        //需求2: 删除d:/ceshi/1.txt文件
        File file2 = new File("d:/ceshi/1.txt");
        System.out.println(file2.delete());

        //需求3: 删除d:/ceshi文件夹
        File file3 = new File("d:/ceshi");
        System.out.println(file3.delete());
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
false
true
false

进程已结束,退出代码0

知识点四十五 : IO流

---

1.概述:
  IO流就是用来处理设备间的数据传输问题的.
  解释: i 指的是 Input (输入), o 指的是 Output (输出).
  
2.应用场景:
  • 文件复制
  • 文件上传
  • 文件下载
  
3.分类:
  • 按照流向分
    1.输入流: 读取数据.(程序员读取文件中的数据)
    2.输出流: 写入数据.(程序员写入数据到文件中)
  
  • 按照操作分
    1.字节流: 以字节为单位来操作数据.
    2.字符流: 以字符为单位来操作数据.
  
4.总结:
  1.字节流能操作所有的文件类型.
   例如: 图片, 视频, 音频, 文本文件等.
  2.字符流只能操作纯文本文件.
  3.简单理解: 如果某个文件能用操作系统自带的记事本打开, 并且里边的内容你也能读得懂,
   就可以考虑使用字符流, 否则, 使用字节流.
  
5.流的分类:
  – 字节输出流
   解释: 以字节为单位, 来写入数据. 顶层抽象类是: OutputStream.
  – 字节输入流
   解释: 以字节为单位, 来读取数据. 顶层抽象类是: InputStream.
  – 字符输入流
   解释: 以字符为单位, 来读取数据. 顶层抽象类是: Reader.
  – 字符输出流
   解释: 以字符为单位, 来写入数据. 顶层抽象类是: Writer.

---

① 字节输出流 快速入门

---

FileOutputStream: 普通的字节输出流, 以字节为单位, 往文件中写数据.
  
  1.构造方法:
    public FileOutputStream(String path); 接收字符串形式的路径
    public FileOutputStream(File path); 接收File对象形式的路径.
    public FileOutputStream(String path, boolean append); 如果传true, 表示往文件中追加数据, false: 覆盖.
    public FileOutputStream(File path, boolean append); 如果传true, 表示往文件中追加数据, false: 覆盖.
  
  2.成员方法:
    public void write(int b); 一次写一个字节
    public void write(byte[] bys); 一次写一个字节数组
    public void write(byte[] bys, int start, int len); 一次写一个字节数组的一部分
    public void close(); 关闭流.
  
  3.注意问题:
    1.换行符: rn
    2.追加数据时FIleOutputStream构造方法中要传入true.

---

package com.itheima.demo03_outputstream;

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

// 案例:演示字节输出流入门.
public class Demo01 {
    public static void main(String[] args) throws IOException {

        // 1.创建FileOutputStream对象, 关联指定的目的地文件.
        // 解释: 往哪个文件中写数据, 哪个文件就叫: 目的地文件.
        // FileOutputStream fos = new FileOutputStream("day12/data/1.txt");                 // 默认覆盖
        FileOutputStream fos = new FileOutputStream("day12/data/1.txt", true);              // 接收字符串形式的路径,传true表示追加
        // FileOutputStream fos = new FileOutputStream(new File("day12/data/1.txt"));       // 接收File对象形式的路径


        // 2.往文件中写入字符'a', 'b', 'c'.
        // 方式一:  一次写一个字节
        fos.write(97);     // a 字母对应的ASCII码是97
        fos.write(98);     // b 字母对应的ASCII码是98
        fos.write(99);     // c 字母对应的ASCII码是99

        // 方式二: 一次写一个字节数组
        byte[] bys = {65, 66, 67};    // 对应的字母是A,B,C
        fos.write(bys);

        //方式三: 一次写一个字节数组的一部分
        byte[] bys2 = {65, 66, 67};
        fos.write(bys2,1, 1);   // 从索引1开始,只写1个元素

        // 3. 释放资源.
        fos.close();
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...

进程已结束,退出代码0

② 字节输出流 解决IO流异常问题

package com.itheima.demo03_outputstream;

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

// 案例:通过try.catch.finally语句解决IO流的异常问题.
public class Demo03 {
    public static void main(String[] args) {

        // 1.创建FileOutputStream对象, 关联指定的目的地文件.
        FileOutputStream fos = null;
        try{
            System.out.println(1/0);   // 可能会出现问题的代码
            fos = new FileOutputStream("day12/data/2.txt");

            // 2.往文件中写入10次hello, 每个hello占一行.
            for (int i = 0; i < 10; i++) {
                fos.write("hello".getBytes());
                fos.write("rn".getBytes()); // 写入换行符
            }
        }catch(Exception e) {
            // 出现问题的异常处理代码.
            e.printStackTrace();
        }finally{
            // 3.关闭流, 释放资源
            try {
                if (fos != null) {
                    fos.close();   // 快捷键: alt + enter
                    fos = null;    // GC会优先回收null对象.
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
java.lang.ArithmeticException: / by zero
	at com.itheima.demo03_outputstream.Demo03.main(Demo03.java:13)

进程已结束,退出代码0

③ 字节输出流 创建空文件

package com.itheima.demo03_outputstream;

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

// 案例:创建空文件
public class Demo05 {
    public static void main(String[] args) throws IOException {

        // 1.创建字节输出流, 关联目的地文件.
        FileOutputStream fos = new FileOutputStream("d:/abc/苍老师(4K无码).avi");

        // 2.创建字节数组, 长度为1024
        byte[] bys = new byte[1024];        //1024 byte = 1KB

        // 3.往目的地文件中写数据.
        for (int i = 0; i < 1024 * 1024; i++) {
            fos.write(bys);
        }

        // 4. 释放资源.
        fos.close();
        System.out.println("制造完成!");
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
制造完成!

进程已结束,退出代码0

---------------------------------------- ① 字节输入流 一次读取一个字节

---

FileInputStream: 普通的字节输入流, 以字节为单位读取数据.
  
  1.构造方法:
    public FileInputStream(String path);
    public FileInputStream(File path);
  
  2.成员方法:
    public int read(); 一次读一个字节, 并返回读取到的该字节的ASCII码值, 读不到返回-1
    public int read(byte[] bys); 一次读一个字节数组, 并返回读取到的有效字节数,并将读取到的数据封装到字节数组中, 读不到返回-1
    public void close();

---

package com.itheima.demo04_inputstream;

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

//案例: 字节输入流入门.

public class Demo01 {
    public static void main(String[] args) throws IOException {

        // 1.创建字节输入流对象, 封装数据源文件.    数据源文件必须存在, 不然报错.
        FileInputStream fis = new FileInputStream("day12/data/1.txt");

        // 2.一次读一个字节
        // 2.1 定义变量, 记录读取到的内容.
        int len = 0;
        
        while((len = fis.read()) != -1) {
            System.out.println(len);
        }

        // 3.关流.
        fis.close();
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
97
98
99
65
66
67
66

进程已结束,退出代码0

② 字节输入流 一次读取一个字节数组

package com.itheima.demo04_inputstream;

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

// 案例:字节输入流 一次读取一个字节数组.
public class Demo02 {
    public static void main(String[] args) throws IOException {
        
        // 1.创建字节输入流对象, 封装数据源文件(数据源文件必须存在, 不然报错).
        FileInputStream fis = new FileInputStream("day12/data/1.txt");
        
        // 2.一次读一个字节数组
        // 2.1 定义字节数组, 记录读取到的数据.
        byte[] bys = new byte[3];       		// 字节数组的长度: 一般是1024的整数倍.  初始值: 0, 0, 0
        int len = 0;                    		// 记录读取到的有效字节数.
        while((len = fis.read(bys)) != -1) {
            System.out.println(new String(bys,0, len ));
        }
        
        // 3.关流.
        fis.close();
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
abc
ABC
B

进程已结束,退出代码0

③ 字节输入流 拷贝文本文件

---

IO流的核心6步操作.
  1. 创建输入流对象, 关联数据源文件.
  2. 创建输出流对象, 关联目的地文件.
  3. 定义变量, 记录读取到的内容或者有效字节(符)数.
  4. 循环读取,只要条件满足就一直读, 并将读取到的内容赋值给变量.
  5. 将读取到的内容写入到目的地文件中.
  6. 关流, 释放资源.

---

package com.itheima.demo05_exercise;

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

//案例: 字节流拷贝文件文件.
public class Demo01 {
    public static void main(String[] args) throws IOException {
        // 拷贝文件方式一: 一次读写一个字节.
        // method01();

        // 拷贝文件方式二: 一次读写一个字节数组.
        // 1.创建输入流对象, 关联数据源文件.
        FileInputStream fis = new FileInputStream("day12/data/1.txt");

        // 2.创建输出流对象, 关联目的地文件.
        FileOutputStream fos = new FileOutputStream("day12/data/2.txt");

        // 3.定义变量, 记录读取到的内容或者有效字节(符)数.
        int len = 0;
        byte[] bys = new byte[1024];        // 一般是8KB

        // 4.循环读取,只要条件满足就一直读, 并将读取到的内容赋值给变量.
        while ((len = fis.read(bys)) != -1) {

            // 5.将读取到的内容写入到目的地文件中.
            fos.write(bys, 0, len);
        }

        // 6.关流, 释放资源.
        fis.close();
        fos.close();
        System.out.println("拷贝完成.");
    }

    public static void method01() throws IOException {
        // 1.创建输入流对象, 关联数据源文件.
        FileInputStream fis = new FileInputStream("day12/data/1.txt");

        // 2.创建输出流对象, 关联目的地文件.
        FileOutputStream fos = new FileOutputStream("day12/data/2.txt");

        // 3.定义变量, 记录读取到的内容或者有效字节(符)数.
        int len = 0;

        // 4.循环读取,只要条件满足就一直读, 并将读取到的内容赋值给变量.
        while ((len = fis.read()) != -1) {

            // 5.将读取到的内容写入到目的地文件中.
            fos.write(len);
        }
        // 6.关流, 释放资源.
        fis.close();
        fos.close();
        System.out.println("拷贝完成.");
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
拷贝完成.

进程已结束,退出代码0

④ 字节输入流 图片加密

---

核心规则:
  用位运算符之 位异或^, 它的规则是: 一个数字被同一个数字位异或两次, 值不变.
  a ^ b ^ b = a

---

package com.itheima.demo05_exercise;

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

//案例: 图片加密

public class Demo02 {
    public static void main(String[] args) throws IOException {
        
        System.out.println(5 ^ 5 ^ 10);     // 10
        System.out.println(2 ^ 3 ^ 3);      // 2

        // 1.创建输入流对象, 关联数据源文件.
        FileInputStream fis = new FileInputStream("day12/data/b.jpg");
        
        // 2.创建输出流对象, 关联目的地文件.
        FileOutputStream fos = new FileOutputStream("day12/data/c.jpg");
        
        // 3.定义变量, 记录读取到的内容或者有效字节(符)数.
        int len = 0;
        
        // 4.循环读取,只要条件满足就一直读, 并将读取到的内容赋值给变量.
        while ((len = fis.read()) != -1) {
            // 5.将读取到的内容写入到目的地文件中.
            fos.write(len ^ 5);             // 这里的5就是密钥
        }
        
        // 6.关流, 释放资源.
        fis.close();
        fos.close();
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
10
2

进程已结束,退出代码0

---------------------------------------- ① 字节缓冲流 快速入门

---

字节高效流简介:
  
  概述:
    字节缓冲流也叫缓冲字节流, 高效字节流, 字节高效流.
    字节高效流并不是直接用来读写数据的, 只是用来给普通的流增加一个缓冲区,具体的读写还是要由普通的字节流实现.
  
  构造方法:
    public BufferedInputStream(InputStream is); 字节缓冲输出流, 也叫缓冲字节输出流, 字节高效输出流, 高效字节输出流
    public BufferedOutputStream(OutputStream os);

---

package com.itheima.demo06_buffered_stream;

import java.io.*;

// 案例: 字节高效流入门.
public class Demo01 {
    public static void main(String[] args) throws IOException {
        
        // 1.通过字节缓冲输出流往文件中写一句话.
        // 1.1 普通的字节输出流, 用来往文件中写数据的.
        FileOutputStream fos = new FileOutputStream("day12/data/3.txt");
        // 1.2 高效的字节输出流, 封装 普通的字节输出流, 提供缓冲区.
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        bos.write("好好学习".getBytes());
        bos.close();

        // 2.通过字节缓冲输入流读取文件中的内容.
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("day12/data/3.txt"));
        int len = 0;
        while((len = bis.read()) != -1) {
            System.out.println(len);
        }
        bis.close();
    }
}

--------------------------------------------------
D:softwareCode6_JDK8binjava.exe ...
229
165
189
229
165
189
229
173
166
228
185
160

进程已结束,退出代码0

② 字节缓冲流 拷贝视频文件

---

读写速度从高到底分别是:
  1.高效流一次读写一个字节数组. 71毫秒
  2.普通流一次读写一个字节数组. 70毫秒 掌握
  3.高效流一次读写一个字节. 609毫秒 掌握
  4.普通流一次读写一个字节. 138550毫秒
  
注意:
  因为字节缓冲流提供的缓冲区的大小是: 8196个字节(8KB), 所以如果我们用 普通流一次读写一个字节数组的方式拷贝文件,
  且自定义的数组长度在 8196个字节, 那么可能会出现: 普通流一次读写一个字节数组的速度 > 高效流一次读写一个字节数组的速度

---

package com.itheima.demo05_exercise;

import java.io.*;

// 案例: 演示字节流拷贝视频文件的效率.
public class Demo03 {
    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();

        

        // 1.通过普通的字节流一次读写一个字节的形式实现.
        // method01();                   138550毫秒

        // 2.通过普通的字节流一次读写一个字节数组的形式实现.
        //method02();                     //70毫秒

        // 3.通过高效的字节流一次读写一个字节的形式实现.
        //method03();                      //609毫秒

        // 4.通过高效的字节流一次读写一个字节数组的形式实现.
        //method04();                     71毫秒


        long end = System.currentTimeMillis();
        System.out.println("拷贝时间为: " + (end - start));
    }



    public static void method01() throws IOException {

        // 1.创建输入流对象, 关联数据源文件.
        FileInputStream fis = new FileInputStream("day12/data/1.avi");

        // 2.创建输出流对象, 关联目的地文件.
        FileOutputStream fos = new FileOutputStream("day12/data/2.avi");

        // 3.定义变量, 记录读取到的内容或者有效字节(符)数.
        int len = 0;

        // 4.循环读取,只要条件满足就一直读, 并将读取到的内容赋值给变量.
        while ((len = fis.read()) != -1) {

            // 5.将读取到的内容写入到目的地文件中.
            fos.write(len);
        }

        // 6.关流, 释放资源.
        fis.close();
        fos.close();
    }

    public static void method02() throws IOException {
        // 1.创建输入流对象, 关联数据源文件.
        FileInputStream fis = new FileInputStream("day12/data/1.avi");
        
        // 2.创建输出流对象, 关联目的地文件.
        FileOutputStream fos = new FileOutputStream("day12/data/3.avi");
        
        // 3.定义变量, 记录读取到的内容或者有效字节(符)数.
        int len = 0;
        byte[] bys = new byte[8196];
        
        // 4.循环读取,只要条件满足就一直读, 并将读取到的内容赋值给变量.
        while ((len = fis.read(bys)) != -1) {
            
            // 5.将读取到的内容写入到目的地文件中.
            fos.write(bys, 0, len);
        }
        
        // 6.关流, 释放资源.
        fis.close();
        fos.close();
    }

    public static void method03() throws IOException {
        
        // 1.创建输入流对象, 关联数据源文件.
        FileInputStream fis = new FileInputStream("day12/data/1.avi");
        BufferedInputStream bis = new BufferedInputStream(fis);
        
        // 2.创建输出流对象, 关联目的地文件.
        FileOutputStream fos = new FileOutputStream("day12/data/4.avi");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        
        // 3.定义变量, 记录读取到的内容或者有效字节(符)数.
        int len = 0;
        
        // 4.循环读取,只要条件满足就一直读, 并将读取到的内容赋值给变量.
        while ((len = bis.read()) != -1) {
            
            // 5.将读取到的内容写入到目的地文件中.
            bos.write(len);
        }
        // 6.关流, 释放资源.
        bis.close();
        bos.close();
    }

    public static void method04() throws IOException {
        
        // 1.创建输入流对象, 关联数据源文件.
        BufferedInputStream bis = new BufferedInputStream( new FileInputStream("day12/data/1.avi"));
        
        // 2.创建输出流对象, 关联目的地文件.
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day12/data/5.avi"));
        
        // 3.定义变量, 记录读取到的内容或者有效字节(符)数.
        int len = 0;
        byte[] bys = new byte[8196];
        
        // 4.循环读取,只要条件满足就一直读, 并将读取到的内容赋值给变量.
        while ((len = bis.read(bys)) != -1) {
            
            // 5.将读取到的内容写入到目的地文件中.
            bos.write(bys, 0, len);
        }
        // 6.关流, 释放资源.
        bis.close();
        bos.close();
    }
}