A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 鹏鹏鹏鹏 初级黑马   /  2018-11-26 16:04  /  1098 人查看  /  1 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 鹏鹏鹏鹏 于 2018-11-26 16:06 编辑


                                                 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): 创建字节打印流, 输出到一个文件路径








1 个回复

倒序浏览
一个人一座城0.0 来自手机 中级黑马 2018-11-28 08:25:27
沙发
到此一游。
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马