进阶-IO流

基本概念

什么是IO？

I:Input O:Output
通过IO可以完成硬盘文件的读和写。
图解：

IO流的分类？

有多种分类方式：
按照流的方向进行分类：
以内存为参照物，
向内存中去，叫做输入（Input），或者叫做读（Read）。
从内存中出来，叫做输出（Output），或者叫做写（Write）。

按照读取数据方式不同进行分类：
按照字节的方式读取数据：一次读取一个字节byte，等同于一次读取8个二进制位。
这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文件等….
eg:假设文件file1.txt，采用字节流的话是这样读的：
a中国bc张三fe
第一次读：一个字节，正好读到’a’
第二次读：一个字节，正好读到’中’字符的一半。
第三次读：一个字节，正好读到’中’字符的另外一半。

按照字符的方式读取数据：一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，
这种流不能读取：图片、声音、视频等文件。只能读取纯文本文件，连word文件都无法读取。
eg: 假设文件file1.txt，采用字符流的话是这样读的：
a中国bc张三fe
第一次读：’a’字符（’a’字符在windows系统中占用1个字节。）
第二次读：’中’字符（’中’字符在windows系统中占用2个字节。）

综上所述：流的分类
输入流，输出流
字节流，字符流

1. Java中的IO流都已经写好了，我们程序员不需要关心。

我们最主要还是掌握，在java中已经提供了哪些流，每个流的特点是什么，
每个流对象上的常用方法有哪些？

java中所有的流都是在：java.io.*;下。

java中主要还是研究：怎么new流对象。
调用流对象的哪个方法是读，哪个方法是写。

JAVA IO流中的四大家族

四大家族的首领：
java.io.InputStream 字节输入流
java.io.OutputStream 字节输出流

java.io.Reader 字符输入流
java.io.Writer 字符输出流

四大家族的首领都是抽象类。(abstract class)

所有的流都实现了：
java.io.Closeable接口，都是可关闭的，都有close()方法。
流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，
不然会耗费(占用)很多资源。养成好习惯，用完流一定要关闭。

所有的输出流都实现了：
java.io.Flushable接口，都是可刷新的，都有flush()方法。
养成一个好习惯，输出流在最终输出之后，一定要记得flush()刷新一下。
这个刷新表示将通道/管道当中剩余未输出的数据强行输出完（清空管道！）。
刷新的作用就是清空管道。
注意：如果没有flush()可能会导致丢失数据。

注意：在java中只要“类名”以Stream结尾的都是字节流。以“Reader/Writer”结尾的都是字符流。

java.io包下需要掌握的流有16个

1. 文件专属：

字节流：byte[]
java.io.FileInputStream（掌握）
java.io.FileOutputStream（掌握）

字符流：char[]
java.io.FileReader
java.io.FileWriter

1. 转换流：（将字节流转换成字符流）

java.io.InputStreamReader
java.io.OutputStreamWriter

1. 缓冲流专属：

java.io.BufferedReader
java.io.BufferedWriter
java.io.BufferedInputStream
java.io.BufferedOutputStream

1. 数据流专属：

java.io.DataInputStream
java.io.DataOutputStream

1. 标准输出流：

java.io.PrintWriter
java.io.PrintStream（掌握）

1. 对象专属流：（序列化与反序列化）

java.io.ObjectInputStream（掌握）
java.io.ObjectOutputStream（掌握）

————⭐字节流⭐————————

FileInputStream（读）⭐

知识点

1. 文件字节输入流，万能的，任何类型的文件都可以采用这个流来读。

2. 字节的方式，完成输入的操作，完成读的操作（硬盘—>内存）。

   使用步骤

   public class FileInputStreamTest01 {
    public static void main(String[] args) {
        //先创建fis，防止空指针异常。
        FileInputStream fis = null;
        try {
            // 创建文件字节输入流对象
            // 文件路径：D:\course\JavaProjects\02-JavaSE\temp （IDEA会自动把\编程\\，因为java中\表示转义）
            // 以下都是采用了：绝对路径的方式。
            //FileInputStream fis = new FileInputStream("D:\\course\\JavaProjects\\02-JavaSE\\temp");
            // 写成这个/也是可以的。
            fis = new FileInputStream("D:/course/JavaProjects/02-JavaSE/temp");
            // 开始读
            int readData = fis.read(); // 这个方法的返回值是：读取到的“字节”本身。
            System.out.println(readData); //97
            readData = fis.read();
            System.out.println(readData); //98
            readData = fis.read();
            System.out.println(readData); //99
            readData = fis.read();
            System.out.println(readData); //100
            readData = fis.read();
            System.out.println(readData); //101
            readData = fis.read();
            System.out.println(readData); //102
            // 已经读到文件的末尾了，再读的时候读取不到任何数据，返回-1.
            readData = fis.read();
            System.out.println(readData);//-1
            readData = fis.read();
            System.out.println(readData);//-1
            readData = fis.read();
            System.out.println(readData);//-1
        } catch (FileNotFoundException e) {
            e.printStackTrace();//捕获的是FileInputStream相关的异常
        } catch (IOException e) {
            e.printStackTrace();//捕获的是read相关的异常
        } finally {
            // 在finally语句块当中确保流一定关闭。
            if (fis != null) { // 避免空指针异常！
                // 关闭流的前提是：流不是空。流是null的时候没必要关闭。
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
   }

   使用循环改写以上代码： ```java package allTest;

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

public class FileInputStreamTest01 { public static void main(String[] args) { FileInputStream fis = null; //第一步 try { //第二步，然后快捷键生成try..catch fis = new FileInputStream(“C:\Users\Administrator\Desktop\JAVA笔记\Mu.txt”);

        while (true){
            int readDate=fis.read();
            if (readDate==-1){
                break;
            }
            System.out.println(readDate);
        }
        ⭐⭐//改造while循环
        //第六步：通过read读取数据，快捷键生成catch
        int readDate = 0;
        while(readDate = fis.read()!= -1){
            System.out.println(readDate);
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally { //第三步：手写finally
        if (fis!=null){ //第四步：判断fis是否为空
            try {
                fis.close(); //第五步：关闭流，快捷键生成try catch
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

}

**分析以上程序的缺点：**<br />一次读取一个字节byte，这样内存和硬盘交互太频繁，基本上时间/资源都耗费在交互上了。<br />能不能一次读取多个字节呢？可以！
**使用byte[]数组进行改写：**
```java
package com.bjpowernode.java.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
int read(byte[] b)
    一次最多读取 b.length 个字节。
    减少硬盘和内存的交互，提高程序的执行效率。
    往byte[]数组当中读。
 */
public class FileInputStreamTest03 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            // 相对路径的话呢？相对路径一定是从当前所在的位置作为起点开始找！
            // IDEA默认的当前路径是哪里？工程Project的根就是IDEA的默认当前路径。
            //fis = new FileInputStream("tempfile3");
            //fis = new FileInputStream("chapter23/tempfile2");
            //fis = new FileInputStream("chapter23/src/tempfile3");
            fis = new FileInputStream("chapter23/src/com/bjpowernode/java/io/tempfile4");
            // 开始读，采用byte数组，一次读取多个字节。最多读取“数组.length”个字节。
            byte[] bytes = new byte[4]; // 准备一个4个长度的byte数组，一次最多读取4个字节。
            // 这个方法的返回值是：读取到的字节数量。（不是字节本身）
            int readCount = fis.read(bytes);
            System.out.println(readCount); // 第一次读到了4个字节。
            // 将字节数组全部转换成字符串
            //System.out.println(new String(bytes)); // abcd
            // 不应该全部都转换，应该是读取了多少个字节，转换多少个。
            System.out.println(new String(bytes,0, readCount));
            readCount = fis.read(bytes); // 第二次只能读取到2个字节。
            System.out.println(readCount); // 2
            // 将字节数组全部转换成字符串
            //System.out.println(new String(bytes)); // efcd
            // 不应该全部都转换，应该是读取了多少个字节，转换多少个。
            System.out.println(new String(bytes,0, readCount));
            readCount = fis.read(bytes); // 1个字节都没有读取到返回-1
            System.out.println(readCount); // -1
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

⭐FileInputStream最终版

package IO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStreamTest04 {
    public static void main(String[] args) {
        //第一步：创建fis= null
        FileInputStream fis = null;
        //第二步：创建对象，选择要读取的文件。使用快捷键生成try catch
        try {
            fis = new FileInputStream("chapter23/src/IO/mu");
            //第五步：使用read读取字节。
            //创建byte数组
            byte[] bytes = new byte[4];
            /*while(true){
                int readCount = fis.read(bytes);
                if(readCount == -1){
                    break;
                }
                // 把byte数组转换成字符串，读到多少个转换多少个。
                System.out.print(new String(bytes, 0, readCount));
            }*/
            //改写以上while循环
            int readCount = 0;
            //-1:读不到数据时，返回-1
            while ((readCount = fis.read(bytes))!= -1){    // 这个方法的返回值是：读取到的字节数量。（不是字节本身）
                //将byte数组转换为String并输出。
                System.out.print(new String(bytes,0,readCount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {      //第三步：写finally，用来关闭流
            if (fis!=null){     //第四步：使用if判断fis是否为空，不为空则关闭。
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileInputStream其他常用方法

1. int available(): 返回流当中剩余的没有读到的字节数量。
   1. 作用：可以不需要使用whlie循环直接输出数据。
2. long skip(long n): 跳过几个字节不读。

使用available()改写程序：这种方法不适合太大的文件，因为byte[]不可以太大、

package IO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStreamTest05 {
    public static void main(String[] args) {
        //第一步：创建fis= null
        FileInputStream fis = null;
        //第二步：创建对象，选择要读取的文件。使用快捷键生成try catch
        try {
            fis = new FileInputStream("chapter23/src/IO/mu");
            ⭐⭐
            //通过available()方法获取剩余的字节数。从开头获取，就是总字节数。
            fis.available();
            //第五步：使用read读取字节。
            //创建byte数组
            byte[] bytes = new byte[fis.available()];
            //读取数组
            fis.read(bytes);
            System.out.println(new String(bytes));
            ⭐⭐
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {      //第三步：写finally，用来关闭流
            if (fis!=null){     //第四步：使用if判断fis是否为空，不为空则关闭。
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileOutputStream（写）⭐

知识点

1. 文件字节输出流，负责写。
2. 字节的方式，完成输出的操作，完成写的操作（内存—>硬盘）。

   使用步骤

   ```java package IO;

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

public class FileOutputStreamTest01 { public static void main(String[] args) { FileOutputStream fos = null; try { ⭐//若myfile文件不存在，会自动创建。 //fos = new FileOutputStream(“myfile”);

       ⭐//若文件存在，则会将原文件清空，再写入。 谨慎使用！！！
        //fos = new FileOutputStream("chapter23/src/IO/mu");
        ⭐// 以追加的方式在文件末尾写入。不会清空原文件内容。 建议使用！
        fos = new FileOutputStream("chapter23/src/IO/mu",true);
        //写
        byte[] bytes = {97,98,99};
        //将bytes数组全部写出
        fos.write(bytes);
        // 将byte数组的一部分写出！
        fos.write(bytes,0,1);
        //写字符串
        String s = "穆徐";
        //将字符串转换为数组--getBytes()
        byte[] bytes1 = s.getBytes();
        fos.write(bytes1);
        ⭐// 写完之后，最后一定要刷新⭐
        fos.flush();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (fos!=null){
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

}

<a name="RPcFt"></a>
### 文件复制
<a name="zEClS"></a>
#### 原理
![image.png](https://cdn.nlark.com/yuque/0/2021/png/2858485/1620281857883-f3d9ec35-803f-4dbe-8f5b-32fdedd1b9f7.png#clientId=uc7aad4b8-5a8a-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=340&id=u24a12d84&margin=%5Bobject%20Object%5D&name=image.png&originHeight=680&originWidth=1169&originalType=binary&ratio=1&rotation=0&showTitle=false&size=88186&status=done&style=none&taskId=u3803bce6-2f9e-4f56-b19d-ea18e2fe0bd&title=&width=585)
<a name="DlBie"></a>
#### 代码
1. 使用FileInputStream + FileOutputStream完成文件的拷贝
1. 拷贝的过程应该是一边读，一边写。
1. 使用字节流拷贝文件的时候，文件类型随意，万能的。
```java
package IO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Copy01 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            // 创建一个输入流对象
            fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\testmu\\test.txt");
            // 创建一个输出流对象
            fos = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\testmuu\\test.txt");
           ⭐ // 最核心的：一边读，一边写 ⭐
            byte[] bytes = new byte[1024*1024]; //1MB(一次最多拷贝1Mb）
            int readCount = 0;
            while ((readCount = fis.read(bytes))!= -1){
                fos.write(bytes,0,readCount);        
            }
            //输出流，最后一定要flush()一下，记住，谢谢。
            fos.flush();
        }
        catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //分开try，因为如果一起try的时候，一个出现异常，可能会影响到另一个流的关闭。
            if (fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

—————-字符流——————————-

FileReader（读）

知识点

1. 文件字符输入流，只能读取普通文本。
2. 读取文本内容时，比较方便，快捷。

   使用步骤

   ```java package IO;

import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException;

public class FileReaderTest01 { public static void main(String[] args) { FileReader fr = null; try { fr = new FileReader(“myfile”);

        char[] chars = new char[4]; //一次最多读取4个字符。
  /*      读
        int readCount = fr.read(chars);
        System.out.println(new String(chars,0,readCount)); //ab穆徐
  */
    int readCount = 0;
    while ((readCount=fr.read(chars))!=-1){
        System.out.print(new String(chars,0,readCount));
    }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (fr!=null){
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

}

<a name="zoJzA"></a>
### FileWrite（写）
<a name="IhVun"></a>
#### 知识点
1. 文件字符输出流。写。
1. 只能输出普通文本。
<a name="ssGG1"></a>
#### 使用步骤
```java
package IO;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriteTest01 {
    public static void main(String[] args) {
        FileWriter fw = null;
        try {
            fw = new FileWriter("NBA",true);
            char[] chars = {'詹','姆','斯'};
            fw.write(chars);
            //优点，可以直接写字符串，不通过数组。
            fw.write("，科比布莱恩特");
            //刷新
            fw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fw!=null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

文件复制

代码

package IO;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Copy02 {
    public static void main(String[] args) {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader("C:\\Users\\Administrator\\Desktop\\testmu\\test.txt");
            fw = new FileWriter("C:\\Users\\Administrator\\Desktop\\testmuu\\new.txt");
            //一边读一边写
            char[] chars = new char[1024*512];
            int readCount = 0;
            while ((readCount=fr.read(chars))!=-1){
                fw.write(chars,0,readCount);
            }
            //刷新
            fw.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e){
            e.printStackTrace();
        }finally {
            if (fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fw!=null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

—————-缓冲流 转换流——————-

BufferedReader

知识点

1. 带有缓冲区的字符输入流。
2. 使用这个流的时候不需要自定义char[]数组或者byte[]数组。自带缓冲

   使用步骤

   readLine()的使用 ```java package IO;

import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException;

public class BufferedReaderTest01 { public static void main(String[] args) { FileReader fr = null; BufferedReader br = null;

    try {
        fr = new FileReader("NBA");
        ⭐//当一个流的构造方法中需要一个流的时候，这个被传进来的流叫做：节点流。
        //外部负责包装的这个流，叫做：包装流，还有一个名字叫做：处理流。
        //当前这个程序来说：   节点流： FileReader
        //                  包装流/处理流：BufferedReader
        ⭐
        br = new BufferedReader(fr);
      /*  //readLine()   读一行
        String one=br.readLine();
        System.out.println(one);
        //readLine() 再读一行
        String two=br.readLine();
        System.out.println(two);
      */
        //使用while循环改写，读不到就返回Null，所以
        String s = null;
        // readLine()读取一个文本行，但不带换行符。
        while ((s=br.readLine())!=null){
            System.out.println(s);
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (br != null){
            try {
                //对于包装流来说，只需要关闭最外层流就行，里面的节点流会自动关闭。
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

}

<a name="aVbdL"></a>
### InputStreamReader
<a name="tFR7K"></a>
#### 原理
（FileInputStream(字节） -> FileReader(字符)）
<a name="Xq51x"></a>
#### 代码
```java
package IO;
import java.io.*;
public class InputStreamReaderTest01 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        InputStreamReader isr = null;
        BufferedReader br=null;
        try {
            //字节流
            fis=new FileInputStream("NBA");
            /*将fis转换为字符流
            * isr是包装流，fis是节点流。
            * */
            isr = new InputStreamReader(fis);
            /*
            * 这个构造方法只能传字符流，不能传字节流。
            * isr是节点流，br是包装流。
            * */
            br = new BufferedReader(isr);
            ⭐//合并以上三行代码
            br = new BufferedReader(new InputStreamReader(new FileInputStream("NBA")));
            String s =null;
            while ((s=br.readLine())!=null){
                System.out.println(s);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

BufferedWriter

知识点

1. 带有缓冲的字符输出流。

   使用步骤

   ```java package IO;

import java.io.BufferedWriter; import java.io.FileWriter; import java.io.IOException;

public class BufferedWriterTest01 { public static void main(String[] args) { FileWriter fw = null; BufferedWriter bw = null;

    try {
        fw = new FileWriter("LJ",true);
        bw = new BufferedWriter(fw);
        bw.newLine();//写入一个行分隔符
        bw.write("勒布朗");
        bw.newLine(); 
        bw.write("詹姆斯");
        bw.flush();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if (bw!=null){
            try {
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

}

<a name="eRSFJ"></a>
## -----------数据流---------------------
<a name="TOQOQ"></a>
### DataOutputStream
<a name="cBEb7"></a>
#### 知识点
1. 数据专属的流。
1. 这个流可以将数据连同数据的类型一并写入文件。
1. 注意：这个文件不是普通文本文档。（这个文件使用记事本打不开。）
<a name="b88P0"></a>
#### 使用步骤
```java
package com.bjpowernode.java.io;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
/*
java.io.DataOutputStream：数据专属的流。
这个流可以将数据连同数据的类型一并写入文件。
注意：这个文件不是普通文本文档。（这个文件使用记事本打不开。）
 */
public class DataOutputStreamTest {
    public static void main(String[] args) throws Exception{
        // 创建数据专属的字节输出流
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data"));
        // 写数据
        byte b = 100;
        short s = 200;
        int i = 300;
        long l = 400L;
        float f = 3.0F;
        double d = 3.14;
        boolean sex = false;
        char c = 'a';
        // 写
        dos.writeByte(b); // 把数据以及数据的类型一并写入到文件当中。
        dos.writeShort(s);
        dos.writeInt(i);
        dos.writeLong(l);
        dos.writeFloat(f);
        dos.writeDouble(d);
        dos.writeBoolean(sex);
        dos.writeChar(c);
        // 刷新
        dos.flush();
        // 关闭最外层
        dos.close();
    }
}

DateInputStream

知识点

1. 数据字节输入流。
2. DataOutputStream写的文件，只能使用DataInputStream去读。并且读的时候你需要提前知道写入的顺序。
3. 读的顺序需要和写的顺序一致。才可以正常取出数据。

   使用步骤

   ```java package com.bjpowernode.java.io;

import java.io.DataInputStream; import java.io.FileInputStream;

/* DataInputStream:数据字节输入流。 DataOutputStream写的文件，只能使用DataInputStream去读。并且读的时候你需要提前知道写入的顺序。 读的顺序需要和写的顺序一致。才可以正常取出数据。

*/ public class DataInputStreamTest01 { public static void main(String[] args) throws Exception{ DataInputStream dis = new DataInputStream(new FileInputStream(“data”)); // 开始读 byte b = dis.readByte(); short s = dis.readShort(); int i = dis.readInt(); long l = dis.readLong(); float f = dis.readFloat(); double d = dis.readDouble(); boolean sex = dis.readBoolean(); char c = dis.readChar();

    System.out.println(b);
    System.out.println(s);
    System.out.println(i + 1000);
    System.out.println(l);
    System.out.println(f);
    System.out.println(d);
    System.out.println(sex);
    System.out.println(c);
    dis.close();
}

}

<a name="p1NDN"></a>
## -----------标准输出流-----------------
<a name="n2q54"></a>
### PrintStream
<a name="rGdCw"></a>
#### 知识点
1. 标准的字节输出流。默认输出到控制台。
1. 标准输出流不需要手动close()关闭。
1. 回顾之前System类使用过的方法和属性
System.gc();     建议启动垃圾回收器<br />System.currentTimeMillis();  获取自1970年1月1日到系统当前时间的总毫秒数。<br />       PrintStream ps2 = System.out; <br />       System.exit(0);    退出JVM。<br />       System.arraycopy(....);   数组拷贝
<a name="K0zSz"></a>
#### 使用步骤
```java
package IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
public class PrintStreamTest01 {
    public static void main(String[] args) {
        //联合起来写
        System.out.println("LJ");
        //分开写
        PrintStream ps = System.out; //返回一个PrintStream类型
        ps.println("KB");
        ps.println("AD");
        // 可以改变标准输出流的输出方向吗？ 可以
        try {
            // 标准输出流不再指向控制台，指向“log”文件。
       PrintStream  ps2 = new PrintStream(new FileOutputStream("log"));
            // 修改输出方向，将输出方向修改到"log"文件。
            System.setOut(ps2);
            System.out.println("LJ");
            System.out.println("KB");
            ps2.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

应用：日志工具

package com.bjpowernode.java.io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
日志工具
 */
public class Logger {
    /*
    记录日志的方法。
     */
    public static void log(String msg) {
        try {
            // 指向一个日志文件
            PrintStream out = new PrintStream(new FileOutputStream("log.txt", true));
            // 改变输出方向
            System.setOut(out);
            // 日期当前时间
            Date nowTime = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
            String strTime = sdf.format(nowTime);
            System.out.println(strTime + ": " + msg);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}
package com.bjpowernode.java.io;
public class LogTest {
    public static void main(String[] args) {
        //测试工具类是否好用
        Logger.log("调用了System类的gc()方法，建议启动垃圾回收");
        Logger.log("调用了UserService的doSome()方法");
        Logger.log("用户尝试进行登录，验证失败");
        Logger.log("我非常喜欢这个记录日志的工具哦！");
    }
}

—————-File类——————————-

知识点

1. File类和四大家族没有关系，所以FIle类不能完成文件的读和写。
2. File对象代表什么？
   1. 文件和目录路径名的抽象表示形式。
   2. C:\Drivers 这是一个File对象
   3. C:\Drivers\Lanealtekeadme.txt 也是File对象。
   4. 一个File对象有可能对应的是目录，也可能是文件。
   5. File只是一个路径名的抽象表示形式。

3. 需要掌握File类中常用的方法

   常用方法

4. f1.exists()：判断f1文件是否存在

5. createNewFile(): 以文件形式新建
6. mkdir():以目录形式创建
7. mkdirs():以多层目录形式创建
8. getParent()：获取文件的上级目录，父目录。
9. getAbsolutePath()：获取文件的绝对路径。 ```java package IO;

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

public class FileTest01 { public static void main(String[] args) { File file = new File(“D:\笔记\mu”); 🍎//判断文件是否存在 System.out.println(file.exists());

    🍎// 如果 D:\笔记\mu 不存在，则以文件的形式创建出来
  /*  if (!file.exists()){
        try {
             // 以文件形式新建
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }*/
    🍎// 如果 D:\笔记\mu 不存在，则以目录的形式创建出来
    if (!file.exists()){
        // 以目录的形式新建。
        file.mkdir();
    }
    🍎//创建多层目录
    File f1 = new File("D:/N/B/A");
    if (!f1.exists()){
        //以多层目录的形式新建。
        f1.mkdirs();
    }
    File f2 = new File("D:\\笔记\\yuque-desktop\\locales");
    🍎//获取文件的父路径
    String parentPath =f2.getParent();
    System.out.println(parentPath); // D:\笔记\yuque-desktop
    🍎//返回一个File类型
    File parentFile=f2.getParentFile();
    System.out.println(parentFile.getAbsolutePath());
    File f3 = new File("NBA");
    🍎//获取绝对路径
    System.out.println("绝对路径:"+f3.getAbsolutePath());
}

}

7. **getName()：**获取文件名。
7. **isDirectory()：**判断是否是一个目录。
7. **isFile()：**// 判断是否是一个文件
7. **lastModified()：**获取文件最后一次修改时间：这个毫秒是从1970年到文件最后一次修改时间 的总毫秒数。
   1. System._currentTimeMillis_()：获取从1970年到现在的总毫秒数。
11. **length() ：**获取文件大小：单位是字节。
```java
package IO;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
public class FileTest02 {
    public static void main(String[] args) {
        File f1 = new File("D:\\笔记\\mu\\xuyoubo.txt");
        //获取文件名
        System.out.println("文件名："+f1.getName());
        // 判断是否是一个目录
        System.out.println(f1.isDirectory()); //false
        // 判断是否是一个文件
        System.out.println(f1.isFile()); //true
        // 获取文件最后一次修改时间
        long haoMiao=f1.lastModified();// 这个毫秒是从1970年到文件最后一次修改时间 的总毫秒数。
        System.out.println(haoMiao);
        //将毫秒数转换成日期
        Date time = new Date(haoMiao);
//        Date time2 = new Date(1000);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String strTime = sdf.format(time);
//        String t2 = sdf.format(time2);
        System.out.println(strTime);  //2021-05-07 14:33:47
//        System.out.println(t2);
        // 获取文件大小
        System.out.println(f1.length()); //单位是字节 36字节
    }
}

1. listFiles()： 获取当前目录下所有的子文件。 ```java package IO;

import java.io.File;

public class FileTest03 { public static void main(String[] args) { File f1 = new File(“C:\Users\Administrator\Desktop\Study_two\chapter23\src\IO”); // 获取当前目录下所有的子文件。 File[] files=f1.listFiles(); //foreach for (File f: files) { //获取文件名 // System.out.println(f.getName()); //获取绝对路径 System.out.println(f.getAbsolutePath()); } } }

<a name="qv4ND"></a>
### getPath()与getAbsolutePath()的区别
**getPath与getAbsolutePath()的区别：**<br />相对路径时：<br />                 getPath输出相对路径<br />                 getAbsolutePath输出绝对路径
绝对路径时：     都输出绝对路径<br />   
<a name="JBtEx"></a>
## -----------目录拷贝--------------------
<a name="QXcdW"></a>
### 代码
[目录拷贝代码](https://blog.csdn.net/weixin_44989186/article/details/116501727)
<a name="GlCuh"></a>
## -----------对象专属流----------------
<a name="rs2ju"></a>
### 原理
![image.png](https://cdn.nlark.com/yuque/0/2021/png/2858485/1620392783750-03deb95d-80f4-4584-8e8b-9a9e83060a63.png#clientId=ucd49bffe-5737-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=339&id=u5d9db1f3&margin=%5Bobject%20Object%5D&name=image.png&originHeight=677&originWidth=1300&originalType=binary&ratio=1&rotation=0&showTitle=false&size=218966&status=done&style=none&taskId=ua0b7ba27-9677-44fc-9f51-dd5f67707e8&title=&width=650)
<a name="E60Dg"></a>
### 知识点
1. java.io.NotSerializableException:Student对象不支持序列化！！！！ 需要 implements接口.
2. 参与序列化和反序列化的对象，必须实现Serializable接口。
3. 注意：通过源代码发现，**Serializable接口只是一个标志接口：**
public interface Serializable {  <br /> }<br />这个接口当中什么代码都没有。<br />那么它起到一个什么作用呢？<br />起到标识的作用，标志的作用，java虚拟机看到这个类实现了这个接口，可能会对这个类进行特殊待遇。                          <br />Serializable这个标志接口是给java虚拟机参考的，java虚拟机看到这个接口之后，<br />会为该类自动生成 一个序列化版本号。
4. **序列化版本号有什么用？**
 java.io.InvalidClassException:        <br />com.bjpowernode.java.bean.Student;<br />        local class incompatible:<br />            stream classdesc serialVersionUID = -684255398724514298（十年后）,<br />            local class serialVersionUID = -3463447116624555755（十年前）
  java语言中是采用什么机制来区分类的？<br />第一：首先通过类名进行比对，如果类名不一样，肯定不是同一个类。<br />第二：如果类名一样，再怎么进行类的区别？靠序列化版本号进行区分。
小鹏编写了一个类：com.bjpowernode.java.bean.Student implements Serializable<br />胡浪编写了一个类：com.bjpowernode.java.bean.Student implements Serializable<br />**自动生成序列化版本号的好处：**<br />不同的人编写了同一个类，但“这两个类确实不是同一个类”。这个时候序列化版本就起上作用了。<br />        对于java虚拟机来说，java虚拟机是可以区分开这两个类的，因为这两个类都实现了Serializable接口，<br />都有默认的序列化版本号，他们的序列化版本号不一样。所以区分开了。
**自动生成序列化版本号的缺陷：**<br />这种自动生成的序列化版本号缺点是：一旦代码确定之后，不能进行后续的修改，<br />因为只要修改，必然会重新编译，此时会生成全新的序列化版本号，<br />这个时候java虚拟机会认为这是一个全新的类。（这样就不好了！）    
<a name="snFG2"></a>
#### 最终结论
凡是一个类实现了Serializable接口，建议给该类提供一个固定不变的序列化版本号。<br />这样，以后这个类即使代码修改了，但是版本号不变，java虚拟机会认为是同一个类。<br />    **手写序列号**：private static final long serialVersionUID = 1L; <br />              [手写序列号快捷键](https://www.cnblogs.com/zouhong/p/12975929.html)
<a name="mARxX"></a>
### 序列化与反序列化一个对象
**Student类**
```java
package bean;
import java.io.Serializable;
public class Student implements Serializable {
    // Java虚拟机看到Serializable接口之后，会自动生成一个序列化版本号。
    // 这里没有手动写出来，java虚拟机会默认提供这个序列化版本号。
    // 建议将序列化版本号手动的写出来。不建议自动生成
    private static final long serialVersionUID = 1L; 
    private int no;
    //transient 表示 游离的 使name不参与序列化与反序列化
    private transient String name;
     // 过了很久，Student这个类源代码如果发生改动了。
    // 源代码改动之后，需要重新编译，编译之后生成了全新的字节码文件。
    // 并且class文件再次运行的时候，java虚拟机生成的序列化版本号也会发生相应的改变。
    public int getNo() {
        return no;
    }
    public void setNo(int no) {
        this.no = no;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Student() {
    }
    public Student(int no, String name) {
        this.no = no;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}

ObjectOutPutStream类

package IO;
import bean.Student;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class ObjectOutPutStreamTest01 {
    public static void main(String[] args) throws IOException {
        Student s1 = new Student(23,"LJ");
        //序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Students"));
        //序列化对象
        oos.writeObject(s1);
        oos.flush();
        oos.close();
    }
}

ObjectInputStream类

package IO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
public class ObjectInputStreamTest01 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("students"));
        //开始反序列化，读
        Object obj=ois.readObject();
        //反序列化回来是一个学生对象，所以会调用学生对象的toString方法。
        System.out.println(obj);
        ois.close();
    }
}

序列化与反序列化多个对象

User类

package bean;
import java.io.Serializable;
public class User implements Serializable {
    private String username;
    private String password;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public User() {
    }
    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

ObjectOutputStream类

package IO;
import bean.User;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
/*
一次序列化多个对象呢？
    可以，可以将对象放到集合当中，序列化集合。
提示：
    参与序列化的ArrayList集合以及集合中的元素User都需要实现 java.io.Serializable接口。
    ArrayList已自己实现。
 */
public class ObjectOutputStreamTest02 {
    public static void main(String[] args) throws IOException {
        List<User> list = new ArrayList<>();
        list.add(new User("23","LJ"));
        list.add(new User("24","KB"));
        list.add(new User("3","AD"));
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("users"));
        // 序列化一个集合，这个集合对象中放了很多其他对象。
        oos.writeObject(list);
        oos.flush();
        oos.close();
    }
}

ObjectInputStream类

package IO;
import bean.User;
import java.io.*;
import java.util.List;
public class ObjectInputStreamTest02 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("users"));
       /* Object o=ois.readObject();
        System.out.println(o instanceof List);*/
       List<User> list = (List<User>) ois.readObject();
        for (User u:
             list) {
            System.out.println(u);
        }
    }
}

———IO+Properties联合使用—————————

知识点

1. IO流：文件的读和写。
2. Properties:是一个Map集合，key和value都是String类型。

   代码

   ```java package bean;

import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.util.Properties;

/* IO+Properties的联合应用。 非常好的一个设计理念： 以后经常改变的数据，可以单独写到一个文件中，使用程序动态读取。 将来只需要修改这个文件的内容，java代码不需要改动，不需要重新 编译，服务器也不需要重启。就可以拿到动态的信息。

类似于以上机制的这种文件被称为配置文件。
并且当配置文件中的内容格式是：
    key1=value
    key2=value
的时候，我们把这种配置文件叫做属性配置文件。
java规范中有要求：属性配置文件建议以.properties结尾，但这不是必须的。
这种以.properties结尾的文件在java中被称为：属性配置文件。
其中Properties是专门存放属性配置文件内容的一个类。

/ public class IoPropertiesTest01 { public static void main(String[] args) throws IOException { / Properties是一个Map集合，key和value都是String类型。 想将userinfo文件中的数据加载到Properties对象当中。 */ // 新建一个输入流对象 FileReader reader = new FileReader(“chapter23/src/bean/userinfo.properties”);

    //新建一个Map集合
    Properties p1 = new Properties();
    // 调用Properties对象的load方法将文件中的数据加载到Map集合中。
    p1.load(reader); // 文件中的数据顺着管道加载到Map集合中，其中等号=左边做key，右边做value
    //通过key获取value
    String username=p1.getProperty("username");
    System.out.println(username);
    String password = p1.getProperty("password");
    System.out.println(password);
    String level = p1.getProperty("level");
    System.out.println(level);
}

}

——-properties文件——— username=admin

password=123456

key相同会覆盖

password=45678

不建议使用冒号

level:vip

<a name="OQQvH"></a>
# 进阶-多线程
<a name="fioSn"></a>
## 基本概念
<a name="Bpi3D"></a>
### 什么是进程？什么是线程？
1. 进程是一个应用程序（1个进程是一个软件）。
1. 线程是一个进程中的执行场景/执行单元。
1. 一个进程可以启动多个线程。
1. 对于java程序来说，当在DOS命令窗口中输入：
   1. java HelloWorld 回车之后。
   1. 会先启动JVM，而JVM就是一个进程。
   1. JVM再启动一个主线程调用main方法。
   1. 同时再启动一个垃圾回收线程负责看护，回收垃圾。
   1. 最起码，现在的java程序中至少有两个线程并发，
   1. 一个是垃圾回收线程，一个是执行main方法的主线程。
<a name="itygH"></a>
### 进程与线程的关系
1. 举个例子：
阿里巴巴--->进程<br />马云--->阿里巴巴的一个线程<br />蔡崇信--->阿里巴巴的一个线程<br />京东--->进程<br />强东--->京东的一个线程<br />奶茶--->京东的一个线程
**进程**可以看做是现实生活当中的公司。<br />**线程**可以看做是公司当中的某个员工。
2. 进程A和进程B的内存独立不共享。
阿里巴巴和京东资源不会共享的！
<a name="QAdky"></a>
### 多线程并发的理解
3. 线程A和线程B呢？
在java语言中：<br />线程A和线程B，堆内存和方法区内存共享。<br />但是栈内存独立，一个线程一个栈。<br />eg：<br />假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，<br />各自执行各自的，这就是**多线程并发**。
eg：<br />火车站，可以看做是一个进程。<br />火车站中的每一个售票窗口可以看做是一个线程。<br />我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。<br />所以多线程并发可以提高效率。
4. java中之所以有多线程机制，目的就是为了提高程序的处理效率。
5. 使用了多线程机制之后，main方法结束，程序会结束么？
main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈
6. 对于单核的CPU来说，真的可以做到真正的多线程并发吗？
对于**多核**的CPU电脑来说，真正的多线程并发是没问题的。<br />4核CPU表示同一个时间点上，可以真正的有4个进程并发执行。
什么是真正的多线程并发？<br />t1线程执行t1的，t2线程执行t2的。<br />t1不会影响t2，t2也不会影响t1。这叫做真正的多线程并发。
单核的CPU表示只有一个大脑：<br />不能够做到真正的多线程并发，但是可以做到给人一种**“多线程并发”的感觉。**<br />对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，<br />但是由于CPU的处理速度极快，多个线程之间频繁切换执行，<br />给人的感觉是：多个事情同时在做！<br />eg：<br />线程A：播放音乐<br />线程B：运行魔兽游戏<br />线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行。<br />给我们的感觉是同时并发的。
7. 分析以下程序有几个线程？
![image.png](https://cdn.nlark.com/yuque/0/2021/png/2858485/1620526711116-ccb64b72-1190-4993-9885-c7c3cd10aa13.png#clientId=u71c4058d-4614-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=517&id=uf9b2dd93&margin=%5Bobject%20Object%5D&name=image.png&originHeight=689&originWidth=529&originalType=binary&ratio=1&rotation=0&showTitle=false&size=265110&status=done&style=none&taskId=u9986ee47-243a-4474-a566-80712be4f7f&title=&width=397)![image.png](https://cdn.nlark.com/yuque/0/2021/png/2858485/1620526807138-8d8d8f71-114c-4d05-898b-b29a5d991e7e.png#clientId=u71c4058d-4614-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=226&id=rC6X5&margin=%5Bobject%20Object%5D&name=image.png&originHeight=452&originWidth=569&originalType=binary&ratio=1&rotation=0&showTitle=false&size=17394&status=done&style=none&taskId=uafe9c766-c1a0-4efd-8032-669b2809ffc&title=&width=285)<br />答：一个！只要一个主线程 主栈。没有分支线程！
<a name="SUyHY"></a>
### 图解
**堆和方法区共享，栈独立。**<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/2858485/1620525000598-18a554c9-ae9d-4c34-aab1-ba1575169717.png#clientId=u71c4058d-4614-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=506&id=u69c579e6&margin=%5Bobject%20Object%5D&name=image.png&originHeight=675&originWidth=1269&originalType=binary&ratio=1&rotation=0&showTitle=false&size=140218&status=done&style=stroke&taskId=u50c72619-171f-44fc-be1f-8111e882a2c&title=&width=952)
<a name="g2fyH"></a>
## 实现线程的方式
java支持多线程机制。并且java已经将多线程实现了，我们只需要继承就行了。
<a name="gWxDt"></a>
### 第一种方式
编写一个类，直接继承java.lang.Thread，重写run方法。
**start()方法**：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。                <br />这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。<br />线程就启动成功了。<br />                     启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。
<a name="VCd44"></a>
#### 代码               
```java
package Thread;
/**
 * 实现线程的第一种方式：
 *      编写一个类，直接继承java.lang.Thread，重写run方法。
 *       怎么创建线程对象？
 *          new就行了。
 *       怎么启动线程呢？
 *          调用线程对象的start()方法。
 *        注意：
 *          方法体当中的代码永远都是自上而下的顺序依次逐行执行的。
 *
 */
public class ThreadTest01 {
    public static void main(String[] args) {
        // 这里是main方法，这里的代码属于主线程，在主栈中运行。
        // 新建一个分支线程对象
        MyThread m = new MyThread();
            //t.run();  假的这种方法不会启动线程，不会分配新的分支栈。（用这种方法还是单线程）
        /*
        start()方法：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。
        这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。
        启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。
        run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。
         */
        //启动线程
        m.start();
        // 这里的代码还是运行在主线程中。
        for (int i = 0; i <1000 ; i++) {
            System.out.println("主线程--->"+i);
        }
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        // 编写程序，这段程序运行在分支线程中（分支栈）。
        for (int i = 0; i <1000 ; i++) {
            System.out.println("分支线程--->"+i);
        }
    }
}

图解

run()

start()

第二种方式

代码

编写一个类，实现java.lang.Runnable接口，实现run方法。

package Thread;
public class ThreadTest02 {
    public static void main(String[] args) {
        // 创建一个可运行的对象
        MyRunnable r = new MyRunnable();
        // 将可运行的对象封装成一个线程对象
        Thread t = new Thread(r);
        //合并以上代码
        Thread t = new Thread(new MyRunnable());
        //启动线程
        t.start();
        for (int i = 0; i <1000 ; i++) {
            System.out.println("主线程--->"+i);
        }
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <1000 ; i++) {
            System.out.println("分支线程--->"+i);
        }
    }
}

匿名内部类实现第二种方式

代码

package com.bjpowernode.java.thread;
/*
采用匿名内部类可以吗？
 */
public class ThreadTest04 {
    public static void main(String[] args) {
        // 创建线程对象，采用匿名内部类方式。
        // 这是通过一个没有名字的类，new出来的对象。
        Thread t = new Thread(new Runnable(){
            @Override
            public void run() {
                for(int i = 0; i < 100; i++){
                    System.out.println("t线程---> " + i);
                }
            }
        });
        // 启动线程
        t.start();
        for(int i = 0; i < 100; i++){
            System.out.println("main线程---> " + i);
        }
    }
}

注意

第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活。

第三种方式（JDK8新特性）

这种方式实现的线程可以获取线程的返回值。
之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。

思考：
系统委派一个线程去执行一个任务，该线程执行完任务之后，
可能会有一个执行结果，我们怎么能拿到这个执行结果呢？
使用第三种方式：实现Callable接口方式。

代码

package com.bjpowernode.java.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask; // JUC包下的，属于java的并发包，老JDK中没有这个包。新特性。
/*
实现线程的第三种方式：
    实现Callable接口
    这种方式的优点：可以获取到线程的执行结果。
    这种方式的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低。
 */
public class ThreadTest15 {
    public static void main(String[] args) throws Exception {
        ⭐
        // 第一步：创建一个“未来任务类”对象。
        // 参数非常重要，需要给一个Callable接口实现类对象。
        FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception { // call()方法就相当于run方法。只不过这个有返回值
                // 线程执行一个任务，执行之后可能会有一个执行结果
                // 模拟执行
                System.out.println("call method begin");
                Thread.sleep(1000 * 10);
                System.out.println("call method end!");
                int a = 100;
                int b = 200;
                return a + b; //自动装箱(300结果变成Integer)
            }
        });
        ⭐
        // 创建线程对象
        Thread t = new Thread(task);
        // 启动线程
        t.start();
        // 这里是main方法，这是在主线程中。
        // 在主线程中，怎么获取t线程的返回结果？
        // get()方法的执行会导致“当前线程阻塞”
        Object obj = task.get();
        System.out.println("线程执行结果:" + obj);
        // main方法这里的程序要想执行必须等待get()方法的结束
        // 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果
        // 另一个线程执行是需要时间的。
        System.out.println("hello world!");
    }
}

线程的生命周期

1. 新建状态：采用 new语句创建完成
2. 就绪状态：执行 start 后
3. 运行状态：占用 CPU 时间，执行run方法。
4. 阻塞状态：执行了 wait 语句、执行了 sleep 语句和等待某个对象锁， 等待输入的场合。

5. 死亡状态：run()方法结束。

   线程的常用方法

   知识点

6. 获取当前线程对象: Thread t = Thread.currentThread(); 静态方法

   返回值t就是当前线程。

7. 获取线程对象的名字: String name = 线程对象.getName();

8. 修改线程对象的名字：线程对象.setName(“线程名字”);

9. 当线程没有设置名字的时候，默认的名字有什么规律？（了解一下）

Thread-0
Thread-1
Thread-2
Thread-3
…..

代码

public class ThreadTest05 {
    public void doSome(){
        // 这样就不行了
        //this.getName();
        //super.getName();
        // 但是这样可以
        String name = Thread.currentThread().getName();
        System.out.println("------->" + name);
    }
    public static void main(String[] args) {
        ThreadTest05 tt = new ThreadTest05();
        tt.doSome();
        //currentThread就是当前线程对象
        // 这个代码出现在main方法当中，所以当前线程就是主线程。
        Thread currentThread = Thread.currentThread();
        System.out.println(currentThread.getName()); //main
        // 创建线程对象
        MyThread2 t = new MyThread2();
        // 设置线程的名字
        t.setName("t1");
        // 获取线程的名字
        String tName = t.getName();
        System.out.println(tName); //Thread-0
        MyThread2 t2 = new MyThread2();
        t2.setName("t2");
        System.out.println(t2.getName()); //Thread-1\
        t2.start();
        // 启动线程
        t.start();
    }
}
class MyThread2 extends Thread {
    public void run(){
        for(int i = 0; i < 100; i++){
            // currentThread就是当前线程对象。当前线程是谁呢？
            // 当t1线程执行run方法，那么这个当前线程就是t1
            // 当t2线程执行run方法，那么这个当前线程就是t2
            Thread currentThread = Thread.currentThread();
            System.out.println(currentThread.getName() + "-->" + i);
            //System.out.println(super.getName() + "-->" + i);
            //System.out.println(this.getName() + "-->" + i);
        }
    }
}