day07 线程间通信 线程池     Lambda表达式

一.线程间通信

  (1)线程间通信:

        多个线程在处理同一个资源, 但是多个线程的处理动作却不相同(线程的任务不同, 需要协调合作)

(2) 等待唤醒机制

        wait/notify, 就是"线程间的一种协作机制", 用于实现线程间通信

    方法:

          .Object类:

        // 成员方法 (只能通过"锁对象"调用)

        void notify(): 随机唤醒在同一个锁对象上的某一个处于等待状态的线程

        void notifyAll(): 唤醒所有在同一个锁对象上处于等待状态的线程

        void wait(): 让当前线程处于无限等待状态, 同时释放锁

二,线程池

    (1) 概念:一个容纳多个线程的容器(集合)

    (2) 线程池的代码实现

           Executors类: 线程池工厂类, 用于创建和管理线程池

        静态方法:

             static ExecutorService newFixedThreadPool(int nThreads): 创建固定数量线程的线程池(常用)

       ExecutorService接口:真正执行任务的线程池服务

成员方法;

  Future submit(Runnable task): 提交一个Runnable任务

        void shutdown(): 通知线程执行完任务后关闭. 如不调此方法, 则线程执行完任务后仍在运行以便重复使用

   线程池的创建和使用步骤:

        1. 使用Executors的静态方法 newFixedThreadPool(int nThreads) 创建线程池ExecutorService

        2. 创建一个任务类, 实现Runnable接口, 重写run()方法

        3. 调用ExecutorService对象的 submit(Runnable task) 方法, 传递任务给线程池, 执行任务

        4. 调用ExecutorService对象的 shutdown() 方法, 销毁线程池 (不建议执行)

  三,函数式编程思想: Lambda表达式

      (1) 特点:简化代码编写 (使用 λ Lambda表达式, 简化匿名内部类的代码),

           面向对象: 注重对象调用方法(语法格式)

          函数式: 注重输入什么(参数), 得到什么结果(运行代码)

     (2) Lambda标准格式

        Lambda表达式的3个部分:

           1. 一些参数 ()

                接口中抽象方法的参数列表. 没参数就空着; 有参数就写, 多个参数        用逗号分隔

         2. 一个箭头 ->

                将参数传递给方法体

        3. 一段代码 {}

                重写接口抽象方法的方法体

(3) Lambda省略格式和使用前提

      1  省略原则:可推导的都可省略

      2  可以省略的部分:

        1. (参数列表): 参数"类型"可以省略 (a, b) -> {}

        2. (参数列表): 如果参数只有1个, 则"类型"和"小括号"都可以省略  a -> sout(a)

        3. {一些代码}: 如果只有一条代码, 则"大括号", "return", "分号"都可以"一起省略"

(4) 函数式接口

        函数式接口: "有且仅有一个抽象方法的接口"

(5) 1. Lambda只能用于接口, 且"接口中有且仅有一个抽象方法"(也称为"函数式接口")

        普通类, 抽象类不能用

    2. 使用Lambda必须具有上下文推断

        接口中只能有一个抽象方法, 才能推断出来重写的是这个抽象方法

    简而言之: 参数类型必须是函数式接口

                              day08 File类 递归笔记

一.File类

     (1)注解;"文件"和"目录"的路径名的抽象表现形式, 主要用于文件和目录的创建, 查找和删除等操作

    (2) 绝对路径

            以盘符开始的路径

        如: "D:\\a\\hi.txt"

  (3) 相对路径

       不以盘符开始的简化路径. IDEA项目, 相对于项目的根目录

        如: "a\\1.mp3", "123.txt"

        "d:\\t"

(4) 构造方法

    File File(String pathname): 根据 路径字符串 封装一个File对象

    File File(String parent, String child): 根据 父路径字符串 和 子路径字符串 封装File对象

   File(File parent, String child): 根据 父路径的File对象 和 子路径 封装File   对象

(5) 获取方法

     String getAbsolutePath(): 返回此File的绝对路径名字符串

    String getPath(): 获取File对象的封装路径 (创建对象时传入的路径)

    String getName(): 获取File对象的文件名或目录名  d:\a\b\c\aaa.txt

    long length(): 获取File表示的"文件"大小的字节byte数 (不能获取目录的大小)

(6) 创建删除方法

   boolean createNewFile(): 当文件不存在时, 创建一个新的空文件

   boolean delete(): 删除由此File表示的文件或目录.

   boolean mkdir(): 创建File表示的目录

  boolean mkdirs(): 创建File表示的多级目录

(7) 遍历目录方法

    String[] list(): 获取当前File目录下的所有子文件或目录的名字数组

File[] listFiles(): 获取当前File目录中的所有子文件或目录的File对象数组

(8)判断方法

        boolean exists(): 判断File对象代表的文件或目录是否实际存在

        boolean isDirectory(): 判断File表示的是否为目录

        boolean isFile(): 判断File表示的是否为文件

二 递归

   递归思想:

        遇到一个问题时, 将该问题拆解成可以解决的小问题, 如果解决不了, 继续拆解为更小的问题. 如果小问题解决了, 大问题也就能够解决

实现递归的方式;

      方法内部调用方法自己

递归的分类

直接递归:方法自己调用方法

简介递归:A方法调用B方法,B方法调用方法,C方法调用A方法

递归时的注意事项:

    1. 递归要有限定条件(出口), 保证递归能够停止(就是在某种情况下方法不再调用自己), 否则会栈内存溢出

    2. 递归次数不能太多, 否则会栈内存溢出

    3. 构造方法不能递归

递归的使用前提:

        调用方法时, 方法的主体不变, 但每次传递的参数值不同, 可以使用递归

三 FileFilter文件过滤器的原理和使用

    boolean accept(File pathName): true则会将参数的File对象加入返回的File[], false则不加入

java.io.FilenameFilter接口:

        boolean accept(File dir, String name): true则会将参数的File对象加入返回的File[], false则不加入

                              day09 字节流 字符流 Properties

一 IO 流

    概念:

file:///G:/CloudNotes/627285191@qq.com/a21685c70e444347aaece374710dd028/%25E5%25B1%258F%25E5%25B9%2595%25E6%2588%25AA%25E5%259B%25BE.jpg

            IO流: 输入(Input)输出(Output)流

            流: 数据

           输入: 从硬盘(文件)读取到内存(Java程序)

           输出: 从内存(Java程序)写入到硬盘(文件)

二 字节输出流 OutputStream和FileOutputStream

       OutputStream抽象类:字节输出流(字节输出流父类)

      成员方法: void close() ：释放资源

                       void flush() ：刷新缓冲区

                      abstract void write(int b): 一次写一个字节

                      void  write(byte[] b): 一次写一个字节数组

                      void write(byte[] b, int offset, int len): 一次写一个字节数组的一部分

     FileOutputStream类: 文件字节输出流

     构造方法:   FileOutputStream(String name): 通过文件路径创建文件字节输出流

                        FileOutputStream(File file): 通过File对象创建文件字节输出流

  三 字节输出流: 续写, 换行

             FileOutputStream(String name, boolean append): 通过文件路径创建流, true可以续写

            FileOutputStream(File file, boolean append): 通过File对象创建流, true可以续写

            换行符:

        Windows系统: "\r\n"

        Linux系统: "\n"

        MacOS系统: "\r"

四,字节输入流 InputStream和FileInputStream

        InputStream抽象类: 字节输入流 (顶层类)

      成员方法 :   void close(): 释放资源

                         int read(): 一次读一个字节

                        int read(byte[] b): 一次读一个字节数组

     FileInputStream类: 文件字节输入流

        构造方法:  FileInputStream(String name): 使用文件路径创建文件字节输入流

                         FileInputStream(File file): 使用File对象创建文件字节输入流

     四 字节输入流:一次读取一个字节的原理

        

file:///G:/CloudNotes/627285191@qq.com/d0d7f8da8114434f8db09ab890e2bfff/%25E5%25B1%258F%25E5%25B9%2595%25E6%2588%25AA%25E5%259B%25BE1.jpg

   五,字符输出流: flush与close区别

      区别:

        flush(): 刷新缓冲区 (将数据从内存中写入到磁盘)

        close(): 刷新缓冲区, 并释放资源. 关闭流后不能再用同一个流对象操作

        flush() 可以省略, 只用 close()来 刷新并释放资源

六,字符输出流: 其他方法  

   oid write(char[] cbuf): 写一个字符数组

abstract void write(char[] b, int off, int len): 写一个字符数组的一部分

void write(String str): 写一个字符串

  void write(String str, int off, int len): 写一个字符串的一部分

七字符输出流: 续写, 换行

    FileWriter(File file, boolean append): 通过File对象创建流. 第二个参数为true可以续写

    FileWriter(String fileName, boolean append): 通过文件路径创建流. 第二个参数为true可以续写

八 IO异常处理

标准格式

               FileWriter fw = null;

    try {

        //IO流对象的创建, 操作等代码

        fw = new FileWriter("d:\\09_IOAndProperties\\g.txt", true);

        for (int i = 0; i <10 ; i++) {

            fw.write("HelloWorld"+i+"\r\n");

        }

    } catch (IOException e) {

        e.printStackTrace();

    } finally {

        // 释放资源

        if(fw != null){

            try {

                fw.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

九    JDK7和JDK9中IO异常处理的不同方式

   JDK7格式

               try (创建流对象语句，如果多个,使用';'隔开) {

                // 读写数据   

        } catch (IOException e) {

                e.printStackTrace();   

        }

JDK9格式

            FileWriter fw = new FileWriter("fw.txt");

    FileReader fr = new FileReader("fr.txt");

    try (fw; fr) {

        // IO操作

        int ch = fr.read();

        fw.write(ch);

    } catch (IOException e) {

        e.printStackTrace();

    }

十Properties集合

特性:双列集合  键和值都是String类型 继承Hashtable

   构

造方法: Properties(): 创建一个Properties集合

  成员方法: Object setProperty(String key, String value): 保存/替换键值对

String getProperty(String key): 通过键获取值. 键不存在返回null                  Set<String> stringPropertyNames(): 返回键的集合                  void store(OutputStream out, String comments): 将集合用字节流写入文件(不能中文),并写入注释                  void store(Writer writer, String comments): 将集合用字符流写入文件(可以中文),并写入注释                  void load(InputStream inStream): 从配置文件中通过字节流加载数据到Properties集合(不能中文)                  void load(Reader reader): 从配置文件中通过字符流加载数据到Properties集合(可以中文)

                                            

                             day10 缓冲流 转换流 序列化流 打印流

一,缓冲流的原理

         

file:///G:/CloudNotes/627285191@qq.com/b9743582e5424e36a4e2e78f62b16373/a50ca8ad4c7c4ca7b709bcccdf16881a.jpg

底层也是使用基本流(FileXxx)来读写

        但缓冲流内部定义了一个缓冲数组, 在读的时候类似于我们一次读一个数组的方式, 减少了磁盘操作次数, 提高了程序效率

二    缓冲字节输出流;BufferedOutputStream

       构造方法: BufferedOutputStream(OutputStream out): 使用基本流创建一个缓冲字节输出流

                      BufferedOutputStream(OutputStream out, int size): 使用基本流创建一个缓冲字节输出流, 设置缓冲区大小

三  缓冲字节输入流:BufferedInputStream

      构造方法: BufferedInputStream(InputStream in): 使用基本流创建一个缓冲字节输入流   

                       BufferedInputStream(InputStream in, int size): 使用基本流创建一个缓冲字节输入流, 设置缓冲区大小

四   缓冲字符输出流 BufferedWriter

       构造方法:  BufferedWriter(Writer out): 使用基本流创建一个缓冲字符输出流

                          BufferedWriter(Writer out, int size): 使用基本流创建一个缓冲字符输出流, 设置缓冲区大小

特有方法:    void newLine(): 写入一个换行符, 换行符自动根据当前系统确定

五  缓冲字符输入流 BuffrerdReader

     构造方法 :BufferedReader(Reader in): 使用基本流创建一个缓冲字符输入流

                      BufferedReader(Reader in, int size): 使用基本流创建一个缓冲字符输入流, 设置缓冲区大小

特有方法: String readLine(): 一次读一行字符串, "不包含换行符". 读到文件末尾返回null

六 转换流

                编码: 字符 -> 字节  'a' -> 97

                解码: 字节 -> 字符  97 -> 'a'

  OutputStreamWriter类介绍及使用

   构造方法: OutputStreamWriter(OutputStream out): 使用默认编码表创建转换流

                    OutputStreamWriter(OutputStream out, String charsetName): 使用指定编码表创建转换流

InputStreamReader类介绍及使用   

构造方法: InputStreamReader(InputStream in): 使用默认编码表创建转换流

                 InputStreamReader(InputStream in, String charsetName): 使用指定编码表创建转换流

七 序列化流(对象流)

     概述: 序列化: 内存中的对象转换为字节序列, 以流的方式写入到磁盘的文件中

               对象 -> 字节

           反序列化: 磁盘文件中的字节序列, 以流的方式读取到内存中变成对象

               字节 -> 对象

(1)  对象序列化流: ObjectOutputStream

构造方法:ObjectOutputStream(OutputStream out)

特有方法: void writeObject(Object obj): 将对象写出

(2) 对象反序列化流: ObjectInputStream

构造方法:ObjectInputStream(InputStream in)

特有方法:Object readObject(): 读取对象

八  transient瞬态关键字: 避免属性序列化

  概述: static 修饰的成员变量属于类不属于对象, 所以不能序列化

           transient 修饰的成员变量, 不能被序列化

九 打印流   PrintStream

    特点:  1. 只有输出流, 没有输入流

              2. PrintStream不会抛出IOException

              3. 有特殊方法 print(), println(), 可以输出任意类型的值, 原样输出

   构造方法:  

               PrintStream(File file): 创建字节打印流, 输出到一个文件

               PrintStream(OutputStream out): 创建字节打印流, 输出到一个字节输出流

              PrintStream(String fileName): 创建字节打印流, 输出到一个文件路径

到此一游。