容器：TreeMap实现类，Properties实现类，Collections工具类，HashMap的线程不安全问题

容器

1. LinkedList实现类

TreeMap的底层结构是红黑树，特点是有序（默认升序排序）不可重复，根据key实现去重和排序，如果key存储的是自定义引用类型数据，需要实现内部比较器或外部比较器。

代码：

import java.util.Objects;
import java.util.TreeMap;

public class TreeMapDemo {
    public static void main(String[] args) {
        TreeMap<Person,Integer> map = new TreeMap<>((o1, o2) -> o1.getAge()-o2.getAge());
        map.put(new Person("abc",18),101);
        map.put(new Person("bc",23),102);
        map.put(new Person("ac",20),103);
        map.put(new Person("cd",22),104);
        map.put(new Person("cd",18),105);
        //使用内部比较器
        //System.out.println(map);//{Person{name='abc', age=18}=101, Person{name='ac', age=20}=103, Person{name='bc', age=23}=102, Person{name='cd', age=22}=105}
        //使用外部比较器
        System.out.println(map);//{Person{name='abc', age=18}=105, Person{name='ac', age=20}=103, Person{name='cd', age=22}=104, Person{name='bc', age=23}=102}
    }
}

class Person implements Comparable<Person>{
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    //重写toString方法
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }
    //重写hashcode方法
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    //重写compareTo方法
    @Override
    public int compareTo(Person o) {
        return this.getName().compareTo(o.getName());
    }
}

2. Properties实现类

properties实现类存储的键值对为String类型，一般用作配置文件。配置文件即文件中指定一些程序执行过程中需要的数据，帮助实现软编码，软编码即经常修改的数据与源代码分离开，避免经常修改操作源代码，.properties和.xml文件常作为配置文件。

properties作为配置文件使用的步骤：

• src下新建一个file文件，名字为xxxx.properties
• 在配置文件中定义键值对为字符串的数据（注意不加" "和 ; ）
• 程序中定义一个properties对象，通过对象.load(流)指定从某一个资源中加载数据，使用指定的流
• 对象.getProperty (key) 返回字符串打印输出

properties文件：

username=scott
pwd=123456

代码：

import java.io.IOException;
import java.util.Properties;
public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
        Properties pro = new Properties();
        //加载.properties文件
        pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
        //获得键对应的值
        System.out.println(pro.get("username"));
        System.out.println(pro.get("pwd"));
    }
}

3. Collections工具类

Collections工具类中提供了一些操作List的方法，例如排序翻转等。

常用方法：

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

public class CollectionsDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(6);
        list.add(1);
        list.add(4);
        list.add(7);
        list.add(2);
        list.add(6);
        System.out.println(list);//[5, 6, 1, 4, 7, 2, 6]
        //sort(List<T> list) 根据其元素的natural ordering ，将指定列表按升序排序
        Collections.sort(list);
        System.out.println(list);//[1, 2, 4, 5, 6, 6, 7]
        //binarySearch(List<? extends Comparable<? super T>> list, T key) 使用二进制搜索算法在指定列表中搜索指定对象
        System.out.println(Collections.binarySearch(list,4));//2
        //shuffle(List<?> list) 使用默认的随机源随机置换指定的列表
        Collections.shuffle(list);
        System.out.println(list);//[1, 2, 7, 4, 6, 5, 6]
        //reverse(List<?> list) 反转指定列表中元素的顺序
        Collections.reverse(list);
        System.out.println(list);//[6, 5, 6, 4, 7, 2, 1]
        //fill(List<? super T> list, T obj) 用指定的元素替换指定列表的所有元素
        Collections.fill(list,10);
        System.out.println(list);//[10, 10, 10, 10, 10, 10, 10]
    }
}

4. HashMap线程不安全的问题

如何解决HashMap线程不安全的问题，给出了如下三种方案：

• 使用Hashtable，这是线程安全的HashMap，Hashtable是同步的
• 使用Collections类中的synchronizedMap()方法，返回一个线程安全的HashMap
• （推荐）使用juc包（高级并发编程包）下的ConcurrentHashMap，这是一个线程安全的Hash表，实现线程安全效果好，效率高