JAVA基础知识点19-Properties、Collection、如何处理HashMap的线程安全问题、四大内置函数式接口、多线程优缺点、线程和进程，并发和并行、线程的创建两种方法

Properties
 属性列表中的每个键及其对应的值都是一个字符串。
 Properties可以保存到流中或从流中加载。

 作为配置文件使用:
     1.在项目下定义一个文件xx.properties ->键值对的数据,默认都是字符串

 通过Properties实现软编码
 Properties作为配置文件特点: 可以存储简单的键值对数据,操作也简单

Properties pro = new Properties();

 

Collections 操作集合的工具类

void sort(List)  //对List容器内的元素排序,排序的规则是按照升序进行排序。
void shuffle(List) //对List容器内的元素进行随机排列
void reverse(List) //对List容器内的元素进行逆续排列
void fill(List, Object)  //用一个特定的对象重写整个List容器
int binarySearch(List, Object)//对于顺序的List容器，采用折半查找的方法查找特定对象

如何处理HashMap的线程安全问题:
    1.Hashtable
    2.使用Collections工具类的synchronizedMap(Map<K,V> m)  返回由指定映射支持的同步（线程安全）映射
    3.juc包下的ConcurrentHashMap使用线程安全的哈希表 ->推荐使用

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

public class CollectionsDemo02 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();

        list.add(5);
        list.add(1);
        list.add(2);
        list.add(4);
        list.add(3);

        System.out.println(list);

        // void shuffle(List) //对List容器内的元素进行随机排列
        Collections.shuffle(list);
        System.out.println(list);

        //翻转
        Collections.reverse(list);
        System.out.println(list);

        //升序
        Collections.sort(list);
        System.out.println(list);

        //二分法搜索
        System.out.println(Collections.binarySearch(list,9));

        //fill填充
        Collections.fill(list,null);
        System.out.println(list);

        //线程安全
        ConcurrentHashMap<String,Boolean> c = new ConcurrentHashMap();

        c.put("张三",false);
        c.put("李四",true);

        System.out.println(c.get("张三"));

    }
}

 

四大内置函数式接口
    消费型:  Consumer<T>
      void  accept(T t)  有来无回

    供给型: Supplier<T>
      T     get()   提供

    函数型: Function<T,R>
      R apply(T t)

    段言型: Predicate<T>
      boolean test(T t)

 想要调用方法使用时,行为作为参数,
    行为不确定(lambda),定义方法时就需要使用函数型接口作为形参类型-> 可以选择性 的使用内置函数型接口
    如果实参不使用lambda,形参可以为任意类型

方法引用:  简化Lambda表达式,是Lambda表达式的另一种表现形式
()->{}
    当lambda体{}的实现,已经存在其他功能实现过了,可以在lambda体重直接调用那个方法来实现
    这种情况就可以通过方法引用来简化这个lambda表达式的结构==> 通过方法引用来引用|调用已经写好方法来实现

语法:
    方法引用
        对象::成员方法  =>  ()->{对象.成员方法名 ();}
        类名:: 静态方法名
        类名::成员方法
    构造器引用
        类名::new

注意:
    当内部所引用的方法的参数列表与返回值与lambda重写的抽象方法的参数列表与返回值一一对应,这时候就可以使用方法引用
    当lambda参数列表只有一个参数,这个参数匹配lambda体{}重所调用的成员方法的对象存在--> 类名::成员方法名
    当lambda参数列表有多个参数,第一个参数匹配lambda体{}中所调用的成员方法的对象存在,第二参数开始匹配lambda体{}中所调用的成员方法的参数列表--> 类名::成员方法名

多线程:
    多任务执行,多条路径执行
    如果没有多任务执行需求,就不需要多线程

多线程的优点:
    资源利用率更好
    效率更高
多线程的缺点:
    程序设计复杂
    需要考虑可能会出现的数据不安全情况

线程和进程:
    进程:每个进程都有独立的代码和数据空间（进程上下文）
        进程间的切换会有较大的开销
        一个进程包含1~n个线程
        资源分配的最小单位

    线程: 线程之间开销小
          多个|一类线程共享进程的代码和数据空间
          每个线程有独立运行栈和程序计数器（PC）
          轻量级的进程
          cpu调度执行的最小单位

 并发和并行:
    并行一定是并发,而并发不一定是并行,也可能是串行
    并发: 一个时间段内,程序拥有处理多任务的能力
    并行: 一个时间段内,程序拥有同时处理多任务的能力


 多线程目标:
    创建与开启  ***
    线程状态
    线程安全    ***
    线程通信

 线程的创建方式:
    1.继承Thread类,重写run()方法,方法内定义线程体 + start()
    2.实现Runnable接口 ,重写run()方法,方法内定义线程体 + start() -->推荐
    3.Callable接口,重写call方法,方法中定义线程体-->了解

public class ThreadDemo06 extends Thread {
    /*
        定义线程体
     */
    @Override
    public void run() {
        for(int i = 1;i<=20;i++){
            System.out.println("一边敲代码..");
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        //创建一个线程
        ThreadDemo06 th = new ThreadDemo06();
        //开启线程
        //th.run();  方法的调用
        th.start();  //开启线程 jvm调用run()方法

        //默认主线程
        for(int i = 1;i<=20;i++){
            System.out.println("陪女朋友聊天..");
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

 

创建线程的第二种方式
    实现Runnable,重写run()方法
    接口是多实现,类是单继承
    实现资源共享

public class ThreadDemo07 implements Runnable{

    @Override
    public void run() {
        for(int i = 1;i<=20;i++){
            System.out.println("一边打游戏..");
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        //创建线程
        ThreadDemo07 th = new ThreadDemo07();
        Thread t = new Thread(th);

        //开启线程
        t.start();

        for(int i = 1;i<=20;i++){
            System.out.println("一边陪女朋友..");
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }
}