22.Map

TreeMap集合（重点）

1.1 基本使用
Map接口：下面的实现类都实现了存储键值对的特点
存储特点： key无序，且唯一；value允许重复; 如果key重复，那么value会覆盖之前的
Map的实现类HashMap: 通过hash算法实现存储
通过源码分析可知：具体实现与HashSet一致的，因为HashSet就是通过HashMap完成的存储

public class Test1 {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("bb", 11);
        map.put("aa", 11);
        map.put("bb", 22);
        
        //常用方法：
        System.out.println(map.get("aa"));  //11
        System.out.println(map.containsKey("bb"));  //true
        System.out.println(map.containsValue(22));  //true
        Collection<Integer> coll = map.values();    //把所有value放到集合中
        System.out.println(coll);
        System.out.println(map);
        System.out.println(map.size());  //长度2
        
        //----遍历:无下标不能使用基本for-----
        //for(int i=0;i<map.size();i++) {}
        
        //Map集合进行遍历的是两个值，不能直接使用增强for遍历
        //for(Object o:map) {}
        
        //-------间接遍历： keySet--------
        Set<String> keys = map.keySet();
        for(String key:keys) {
            System.out.println(key+"-->"+map.get(key));
        }
        
        //-------间接遍历： entrySet--------
        Set <Entry<String, Integer>> set = map.entrySet();
        for(Entry<String, Integer> entry:set) {
            System.out.println(entry.getKey()+"==>"+entry.getValue());
        }
    }
}

1.2 HashMap存储自定义对象
hashMap存储自定义对象，验证存储原理
注意：后续的map存储的key往往是String类型，此处，为了验证原理，所以key存储了自定义对象

class Student{
    String name;
    public Student(String name) {
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "Student [name=" + name + "]";
    }

    //如果我们认为属性一致，则为同一个对象，则需要重写hashCode与equals
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    
}
public class Test2 {
    public static void main(String[] args) {
        Map<Student, Integer> map = new HashMap<Student, Integer>();
        map.put(new Student("zs"), 13);
        map.put(new Student("ls"), 15);
        map.put(new Student("zs"), 18);
        
        System.out.println(map);
        
        
        //扩展说明：移除一个对象
        map.remove(new Student("ls"));  //移除时，重写了equals，也可以针对属性一致去移除
        
        System.out.println(map);
    }
}

2. TreeMap集合

2.1 基本使用
TreeMap: Map接口的实现类
存储特点： key可排序，唯一     如果key重复，新的value替换旧的
分析TreeMap的存储原理：二叉树算法
说明：和TreeSet类似，因为TreeSet的具体实现是通过TreeMap完成的

public class Test1 {
    public static void main(String[] args) {
        Map<String, Integer> map = new TreeMap<String, Integer>();
        map.put("cc", 11);
        map.put("bb", 33);
        map.put("aa", 22);
        map.put("cc", 44);
        System.out.println(map);
        
        //循环遍历：
        Set<String> keys = map.keySet();
        for(String key:keys) {
            System.out.println(key+"-->"+map.get(key));
        }
        
        Set<Entry<String, Integer>> set = map.entrySet();
        for(Entry<String, Integer> entry:set) {
            System.out.println(entry.getKey()+"==>"+entry.getValue());
        }
    }
}

2.2 TreeMap存储自定义对象
验证原理：
TreeMap存储自定义对象，查看结果
结果会报错
解决方式：
1. 自然排序法--->实现Comparable接口
2. 比较器法----->构造方法传比较器对象（匿名内部类）

class Person implements Comparable<Person>{
    String name;
    int    age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(Person o) {
        //比较规则：先比较姓名的升序，姓名相同，再比较年龄的降序
        if(this.name.equals(o.name)) {
            return o.age-this.age;
        }else {
            return this.name.compareTo(o.name);
        }
        
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    
    
    
}
public class Test2 {
    public static void main(String[] args) {
        //Map<Person, Integer> map = new TreeMap<Person, Integer>();
        
        Map<Person, Integer> map = new TreeMap<Person, Integer>(new Comparator<Person>() {

            @Override
            public int compare(Person o1, Person o2) {
                //比较规则：先比较姓名的升序，姓名相同，再比较年龄的降序
                if(o1.name.equals(o2.name)) {
                    return o2.age-o1.age;
                }else {
                    return o1.name.compareTo(o2.name);
                }
                
            }
        });
        map.put(new Person("zs", 13), 66);
        map.put(new Person("ls", 13), 66);
        map.put(new Person("zs", 36), 11);
        map.put(new Person("zs", 13), 25);
        System.out.println(map);
    }
}

2.3 其他类的相关操作
其他类的比较及操作:
HashMap VS Hashtable
HashMap: 不安全，但效率高的集合，key和value可以使用null
Hashtable:线程安全，效率低的集合，key和value都不能使用null

Properties: 是Hashtable的子类，常用于加载配置信息中

HashMap VS TreeMap
从执行效率方面考虑，肯定选择HashMap效率更高
如果需要实现排序，才选择TreeMap

public class Test1 {
    public static void main(String[] args) throws FileNotFoundException, IOException {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("aa", 11);
        map.put(null, 33);
        map.put("cc", null);
        System.out.println(map);
        
        Map<String, Integer> map2 = new Hashtable<String, Integer>();
        map2.put("aa", 11);
        //map2.put(null, 33);
        //map2.put("cc", null);
        System.out.println(map2);
        
        //Properties: 之前在System类中使用过
        //Properties properties = System.getProperties();  //获取系统的配置属性
        
        //加载配置文件信息：  user.properties
        Properties properties = new Properties();
        //new一个IO流的子类对象，加载到Properties中，这样properties就有值了
        properties.load(new FileInputStream("user.properties"));
        //往往key为已知的，获取value值
        System.out.println(properties.getProperty("name"));
        
    }
}

总结：

Collection（根接口）（子孙存储单个对象）				Map接口（子孙存储键值对）
						List子接口		Set子接口		HashMap实现类：（HashMap实现）
存储特点：有序，可重复				存储特点：key无序，唯一
实现类		实现类		存储原理：Hash算法
ArrayList：		HashSet（HashMap实现）		key唯一：重写hashCode与equals
存储原理：数组扩容		存储特点：无序，唯一
		存储原理：hash算法		TreeMap实现类（TreeMap实现）
LinkedList：		重写hashCode与equals		存储特点：key可排序，唯一
存储原理：双向链表		TreeSet：（TreeMap实现）		存储原理:二叉树
		存储特点：可排序，唯一		性能方面HashMap更快
性能PK：		存储原理：二叉树		实现TreeMap排序方式：
ArrayList：		性能方面HashSet更快		1.自然排序法
定位与向后追加快		实现TreeSet排序方式：		2.比较器法
LinkedList		1.自然排序法
连续位置的添加和删除		2.比较器法