Map

Map接口-----不是Collection接口的子接口
　　Map存放数据的方式采用键值对的方式，类似与生活中目录(键)和内容(值)
　　常见的实现类:
　　　　HashMap**：采用键-值对的方式进行存放.
　　　　　　键(键的集合是就是set集合):唯一,无序,如果键重复,将发生覆盖
　　　　　　值:无序 不唯一(Collection)
　　　　　　构造函数:
　　　　　　　　HashMap() 构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
　　　　　　　　HashMap(int initialCapacity) 构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。
　　　　　　常用的方法:
　　　　　　　　增:
　　　　　　　　　　put(K key, V value)***:在此映射中关联指定值与指定键。
　　　　　　　　删:
　　　　　　　　　　remove(Object key):从此映射中移除指定键的映射关系（如果存在）。
　　　　　　　　　　clear():移除全部元素
　　　　　　　　改:
　　　　　　　　查:
　　　　　　　　　　get(Object key)***: 返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
　　　　　　　　其他方法:
　　　　　　　　　　size()**:返回容器中键值对个数。
　　　　　　　　　　containsKey(Object key)**:如果此映射包含对于指定键的映射关系，则返回 true。
　　　　　　　　　　containsValue(Object key):如果此映射包含对于指定值的映射关系，则返回 true。
　　　　　　　　　　keySet()** :返回容器中键的集合,本质就是一个set集合
　　　　　　　　　　values()**:返回值的集合,本质是一个Collection集合

　　　　---LinkedHashMap:
　　　　　　有序(位置顺序)的HashMap 速度快
　　　　Hashtable:
　　　　TreeMap:

public class TestMap {
    public static void main(String[] args) {
        //String:键的类型  String:值的类型
        Map<String,String> map = new HashMap<String,String>();
        map.put("andy", "刘德华");
        map.put("tony", "梁朝伟");
        map.put("edison", "陈冠希");
        map.put("edison", "陈冠希2");//如果键重复,将发生覆盖
//        map.remove("tony");//通过键将指定的元素移除
        System.out.println(map.get("andy"));//通过键获取对应的值
        System.out.println(map.get("tony"));
        System.out.println(map.get("edison"));
        System.out.println("键值对个数:"+map.size());
        System.out.println("键是否包含edison:"+map.containsKey("edison"));
        System.out.println("键是否包含李小龙:"+map.containsValue("李小龙"));
        //获取map中键的集合
        Set<String> keyset = map.keySet();
        for (String key : keyset) {
            System.out.println(key);
        }
        //获取map中值的集合
        Collection<String> values = map.values();
        for (String value: values) {
            System.out.println(value);
        }
    }
}

putAll(Map<? extends K,? extends V> m)
　　将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。
Set<Map.Entry<K,V>> entrySet():返回此映射所包含的映射关系的 Set 视图。
Map.Entry:代表一个键值对。
　　getKey() :返回与此项对应的键。
　　getValue() :返回与此项对应的值。
Map的遍历方式:
　　方式1:通过键进行遍历
　　　　a.先获取键的集合;b.遍历键的集合 ; c.根据键获取对应的值
　　方式2:通过键值对进行遍历***
　　　　a.先获取键值对的集合;b.遍历键值对; c.从键值对中获取键和值

public class TestMap2 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("java", "java核心技术");
        map.put("oracle", "Oracle核心技术");
        System.out.println(map);//调用map.toString();
        Map<String,String> map2 = new HashMap<String,String>();
        map2.put("html", "深入浅出HTML");
        map2.put("js", "深入浅出javascript");
        map.putAll(map2);//将map2中的内容添加到map中
        System.out.println(map2);
        System.out.println(map);
        System.out.println("----------------------------");
        //遍历方式1: a.先获取键的集合;b.遍历键的集合 ; c.根据键获取对应的值
        Set<String> keys = map.keySet();//获取键的集合
        for (String key : keys) {
            String value = map.get(key);
            System.out.println("key="+key+",value="+value);
        }
        System.out.println("**********************");
        //遍历方式2: a.先获取键值对的集合;b.遍历键值对; c.从键值对中获取键和值
//        Set entrySet = map.entrySet();
//        for (Object object : entrySet) {
//            Map.Entry entry = (Map.Entry)object;//
//            Object key = entry.getKey();
//            Object value=entry.getValue();
//            System.out.println("key="+key+",value="+value);
//        }
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for (Entry<String, String> entry : entrySet) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println("key="+key+",value="+value);
        }
        //遍历方式3:遍历值的集合
    }
}

Hashtable:采用hash表进行存储，继承了Directory
　　此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。
HashMap和Hashtable的区别:
　　1、Hashtable在JDK1.1已经存在，继承了Directory类，默认初始容量11
　　　　HashMap实现了Map接口，默认初始容量16
　　2、HashMap中键和值都可以为null,如果键相同将方式覆盖(如果多个键值为null,后边的将覆盖前边的)
　　　　Hashtable中键和值都不能为null,如果键或值为null将发生空指针异常
　　3、Hashtable是基于线程的安全,在多线程中使用;而HashMap是非线程安全的，效率较高
　　　　常用方法与HashMap相同

public class HashMapAndHashtable {
    public static void main(String[] args) {
        HashMap hashMap = new HashMap();
        hashMap.put(null, "123");
        hashMap.put("abc", null);
        hashMap.put(null, null);
        System.out.println(hashMap);
        
        Hashtable hashtable = new Hashtable();
        hashtable.put(null, "123");//出现空指针异常
        hashtable.put("abc",null);
        System.out.println(hashtable);
    }
}

LinkedHashMap继承了HashMap,采用的hash表(查询快)+链表的结构(添加删除快，有序)进行存储。
　　有序(位置顺序)
　　HashMap:无序(位置顺序)

public class TestLinkedHashMap {
    public static void main(String[] args) {
        LinkedHashMap<String, String> linkedHashMap = new LinkedHashMap<String,String>();
        linkedHashMap.put("jack", "杰克");
        linkedHashMap.put("rose","柔丝");
        linkedHashMap.put("lucky","莱克");
//        System.out.println(linkedHashMap);
//        Set<Entry<String,String>> entrySet = linkedHashMap.entrySet();
//        for (Entry<String, String> entry : entrySet) {
//            System.out.println(entry.getKey()+"---"+entry.getValue());
//        }
        Iterator<Entry<String,String>> iter = linkedHashMap.entrySet().iterator();
        while(iter.hasNext()){
            Entry<String,String> entry = iter.next();
            System.out.println(entry.getKey()+"----"+entry.getValue());
        }
    }
}

TreeMap:实现了Map接口，采用红黑数(二叉树)的方式存放数据
　　特点:
　　　　有序(自然顺序)
　　构造函数:
　　　　TreeMap():使用键的自然顺序构造一个新的、空的树映射。

public class TestTreeMap {
    public static void main(String[] args) {
        TreeMap<Integer,String> treeMap = new TreeMap<Integer,String>();
        treeMap.put(101, "天字一号房");
        treeMap.put(102, "天字二号房");
        treeMap.put(9, "地字二号房");
        System.out.println(treeMap);
        
    }
}

TreeMap(): 使用键的自然顺序构造一个新的、空的树映射。
TreeMap(Comparator<? super K> comparator): 构造一个新的、空的树映射，该映射根据给定比较器进行排序。

public class Teacher implements Comparable<Teacher>{
    private int id;
    private String name;
    private int age;
    public Teacher() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Teacher(int id,String name, int age) {
        super();
        this.id=id;
        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;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + id;
        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;
        Teacher other = (Teacher) obj;
        if (age != other.age)
            return false;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "Teacher [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
    /**
     * 比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。 
     */
    @Override
    public int compareTo(Teacher o) {
        return -(this.id-o.id);//降序
    }
    
}

import java.util.Comparator;

public class AgeCommpartor implements Comparator<Teacher> {
    /**
     * 比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。
     */
    @Override
    public int compare(Teacher o1, Teacher o2) {
//        return o1.getAge()-o2.getAge();//升序
        return -(o1.getAge()-o2.getAge());//降序
    }

}

public class TestTreeMap2 {
    public static void main(String[] args) {
        //利用姓名做键
//        TreeMap<String,Teacher> treeMap = new TreeMap<String,Teacher>();
//        Teacher t1 = new Teacher(1,"aa",25);
//        Teacher t2 = new Teacher(2,"bb",24);
//        Teacher t3 = new Teacher(3,"cc",26);
//        treeMap.put(t1.getName(), t1);
//        treeMap.put(t2.getName(), t2);
//        treeMap.put(t3.getName(), t3);
//        Set<Entry<String,Teacher>> entrySet = treeMap.entrySet();
//        for (Entry<String, Teacher> entry : entrySet) {
//            System.out.println(entry.getKey()+"===="+entry.getValue());
//        }
        //利用Teacher对象做键
        TreeMap<Teacher,String> treeMap = new TreeMap<Teacher,String>();
        Teacher t1 = new Teacher(1,"aa",25);
        Teacher t3 = new Teacher(3,"cc",26);
        Teacher t2 = new Teacher(2,"bb",24);
        treeMap.put(t1,t1.getName());
        treeMap.put(t2,t2.getName());
        treeMap.put(t3,t3.getName());
        Set<Entry<Teacher,String>> entrySet = treeMap.entrySet();
        for (Entry<Teacher,String > entry : entrySet) {
            System.out.println(entry.getKey()+"===="+entry.getValue());
        }
        System.out.println("********************************************");
        AgeCommpartor ageCommpartor = new AgeCommpartor();
        TreeMap<Teacher,String> treeMap2 = new TreeMap<Teacher,String>(ageCommpartor);
        Teacher t11 = new Teacher(1,"aa",25);
        Teacher t12 = new Teacher(2,"bb",24);
        Teacher t13 = new Teacher(3,"cc",21);
        treeMap2.put(t11,t11.getName());
        treeMap2.put(t12,t12.getName());
        treeMap2.put(t13,t13.getName());
        Set<Entry<Teacher,String>> entrySet2 = treeMap2.entrySet();
        for (Entry<Teacher,String > entry : entrySet2) {
            System.out.println(entry.getKey()+"===="+entry.getValue());
        }
        
    }
}

Collection:接口
Collections:工具类,提供了一下操作Collection集合的静态方法:
　　sort():排序
　　reverse():反转指定列表中元素的顺序。
　　binarySearch():使用二分搜索法搜索指定列表，以获得指定对象
　　....
Collection和Collections的关系类似于Array和Arrays的关系

public class TestCollections {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(10);
        list.add(15);
        list.add(1);
        list.add(30);
        System.out.println("排序前:"+list);
        Collections.sort(list);//排序(升序)
        System.out.println("排序后:"+list);
        int index = Collections.binarySearch(list, 10);//二分法查找(前提是集合元素必须有序)
        System.out.println(index);
        Collections.reverse(list);
        System.out.println("反转:"+list);//反转不是倒序,将最后一个元素变换到第一个元素,倒数第二个元素变换成第二个元素...
    }
}