4.12 TreeMap、Properties、Collections、Thread

4.12 TreeMap、Properties、Collections、Thread

TreeMap

​ 底层结构：红黑树

​ 特点：有序（默认升序排序），存放存储与内部真是存储的顺序是不一致的

​ 去重排序：根据key实现去重与排序，key中存放的数据的类型–>1)实现内部比较 器 2)实现外部比较器

​ 注意：以后有功能|结构需要实现排序的要想到使用比较器指定比较规则

public class TreeMapDemo01 {
    public static void main(String[] args) {
        //默认根据User类的内部比较器提供的比较方式进行比较排序
        //TreeMap<User,String> map = new TreeMap<>();

        //指定使用某种外部比较规则
        TreeMap<User,String> map = new TreeMap<>((o1, o2) -> o1.getPassword()-o2.getPassword());

        //map.put(null,null);  //treemap中存储键值对key不能为null

        //存储数据,在存储的时候才会比较,排序
        map.put(new User("abc",123),"新浪");
        map.put(new User("ab",188),"新浪");
        map.put(new User("bc",187),"新浪");
        map.put(new User("a",188),"新浪");
        map.put(new User("a",188),"点淘app");

        System.out.println(map);
    }
}

Properties

​ 1.Properties存储的是键值对数据，且都为字符串类型

​ 2.Properties类表示一组持久的属性，Properties可以保存到流中或从流中加载。 属性列表中的每个键及其对应的值都是一个字符串

​ 3.Properties根式作为配置文件的格式存在,键值对 都是字符串,简单
​ 程序从properties文件中读取数据:
​ void load(InputStream inStream) 从输入字节流中读取属性列表（键和元素 对）

​ 4.总结: Properties作为配置文件使用的步骤：

​ 1.src新建一个后缀为.properties的文件

​ 2.在配置文件中定义键值对为字符串的数据

​ 3.程序中定义一个Properties对象，通过对象.load（流）指定从某一个资源文 件中读取数据，使用指定的流

​ 4.对象.getProperty（key）

​ 5.配置文件：文件中指定一些程序执行，过程中需要的一些数据|参数|路径等帮 助我们实现软编码风格(经常修改的数据与源代码分离开,避免经常修改操作源 代码->硬编码)其中.properties,.xml经常作为配置文件

public class PropertiesDemo02 {
    public static void main(String[] args) throws IOException {
        Properties pro = new Properties();

        //新增方法
        pro.setProperty("123","456");

        System.out.println(pro.getProperty("123"));
        System.out.println(pro.getProperty("123"));

        String name = "";
        String pwd = "";

        //通过properties对象从配置文件中读取数据
        //指定从哪一个文件,通过哪个流加载
        pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));

        System.out.println(pro.getProperty("username"));
        System.out.println(pro.getProperty("password").length());
    }
}

//db.properties
username=hhh
password=123

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类型，这种类型是线程安全的HashMap，Hashtable是同步的， 如果不需要线程安全实现，建议使用HashMap代替Hashtable。如果需要线程安 全的高度并发实现，则建议使用ConcurrentHashMap代替Hashtable

​ 2.Collections -> static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 返回由 指定映射支持的同步（线程安全）映射。

​ 3.juc包(高级并发编程包) - > ConcurrentHashMap 线程安全的哈希表—>推荐,安 全性好效率高

Thread

​ 单线程：单个任务，一个执行路径，一个顺序流

​ 多线程：多任务执行，多个路径执行，多个顺序流

​ 多线程的优点：资源利用率更好，程序设计在某些情况下更简单，程序响应更快

​ 串行：在同一时间段内，多任务快速串行执行–>多线程

​ 并行：在同一时刻内，多任务同时执行

​ 进程和线程的区别：

​ 创建线程+开启线程的步骤：

​ 1.继承Thread，重写 run()+ start()

​

public class ThreadDemo01 extends Thread{
    public static void main(String[] args) {
        //创建线程
        ThreadDemo01 th = new ThreadDemo01();
        //开启线程
        th.start();
        //th.run(); 方法的调用

        //主线程
        for(int i=1;i<=20;i++){
            System.out.println("一边讲课");

            /*休息10ms*/
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /*
        定义线程体代码
     */
    @Override
    public void run() {
        for(int i=1;i<=20;i++){
            System.out.println("一边喝水");

            /*休息10ms*/
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

​ 2.实现Runnable，重写run()方法，方法的内部定义线程体，+start()

​ 接口实现的好处：可以多实现，类只能单继承，可以资源共享

public class Thread4 implements Runnable{
    public static void main(String[] args) {
        //线程的创建
        Thread4 thread4 = new Thread4();//先创建类的对象才能调用接口中的run方法
        Thread thread = new Thread(thread4);
        thread.start();
        for(int i=0;i<=50;i++){
            System.out.println("一边说话...");
        }
    }

    @Override
    public void run() {
        for(int i=0;i<=50;i++){
            System.out.println("吃饭");
        }
    }
}

​ 利用内部类

​

public class Thread5 {

    //内部类实现Runnable接口
    static class Inner1 implements Runnable{

        @Override
        public void run() {
            for(int i=0;i<=50;i++){
                System.out.println("一边打游戏...");
            }
        }
    }

    //内部类继承Thread
    static class Inner2 extends Thread{
        @Override
        public void run() {
            for(int i=0;i<=50;i++){
                System.out.println("一边打上厕所...");
            }
        }
    }

    public static void main(String[] args) {
        //匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<=50;i++){
                    System.out.println("一边陪女朋友...");
                }
            }
        }).start();

        //线程开启
        new Thread(new Inner1()).start(); //先创建Inner1的对象，将Inner1对象传给Thread用Thread(Runnable target)构造器创建Thread对象
        new Inner2().start(); //Inner继承Thread 直接调用父类的方法
    }
}