黑马程序员-8 集合容器（Map&Collections）

Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
1，添加。
put(K key, V value)
putAll(Map<? extends K,? extends V> m)

2，删除。
clear()
remove(Object key)

3，判断。
containsValue(Object value)
containsKey(Object key)
isEmpty()

4，获取。
get(Object key)
size()
values()

entrySet()
keySet()

Map
|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

Set底层就是使用了Map集合。

import java.util.*;
class  MapDemo
{
    public static void main(String[] args) 
    {
        Map<String,String> map = new HashMap<String,String>();

        //添加元素,添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。
        //并put方法会返回被覆盖的值。
        System.out.println("put:"+map.put("01","zhangsan1"));
        System.out.println("put:"+map.put("01","wnagwu"));
        map.put("02","zhangsan2");
        map.put("03","zhangsan3");

        System.out.println("containsKey:"+map.containsKey("022"));
        //System.out.println("remove:"+map.remove("02"));

        System.out.println("get:"+map.get("023"));

        map.put("04",null);
        System.out.println("get:"+map.get("04"));
        //可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。        
        //获取map集合中所有的值。
        Collection<String> coll = map.values();

        System.out.println(coll);
        System.out.println(map);
    }
}

 

map集合的两种取出方式：
1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。
所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

import java.util.*;

public class MapSetDemo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("1", "aaaa");
        map.put("2", "bbbb");
        map.put("3", "cccc");

        Set<String> keySet = map.keySet();
        Iterator<String> it = keySet.iterator();
        while(it.hasNext()){
            String key = it.next();
            System.out.println(key +":" +map.get(key));
        }            
    }
}

 

2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，
而这个关系的数据类型就是：Map.Entry

Entry其实就是Map中的一个static内部接口。
为什么要定义在内部呢？
因为只有有了Map集合，有了键值对，才会有键值的映射关系。
关系属于Map集合中的一个内部事物。
而且该事物在直接访问Map集合中的元素。

import java.util.*;

public class MapEntryDemo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("1", "aaaa");
        map.put("2", "bbbb");
        map.put("3", "cccc");
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        Iterator<Map.Entry<String,String>> it = entrySet.iterator();
        while(it.hasNext()){
            Map.Entry<String,String> entry = it.next();
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + ":" + value);
        }            
    }
}

 

=============================================
TreeMap 可以排序的Map集合
示例

import java.util.*;

public class MapTest {
        
    public static void main(String[] arg){
        Person p1 = new Person("A",20);
        Person p2 = new Person("B",10);
        Person p3 = new Person("C",23);
        Person p4 = new Person("B",10);    
        TreeMap<Person, String> map = new TreeMap<Person, String>();
        map.put(p1,"a");
        map.put(p2,"b");
        map.put(p3,"c");
        map.put(p4,"d");
        System.out.println(map);
    }
}

class Person implements Comparable<Person>{
    String name;
    int age;
    Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object obj){
        if(!(obj instanceof Person))return false;
        Person p = (Person)obj;
        if(this.name == p.name && this.age == p.age)
            return true;
        else
            return false;
    }
    @Override
    public int hashCode(){
        return name.hashCode()+age*19;
    }
    @Override
    public String toString(){
        return this.name+"@"+this.age;
    }
    @Override
    public int compareTo(Person p) {
        int flag = new Integer(this.age).compareTo(new Integer(p.age));    
        if(flag == 0) return this.name.compareTo(p.name);
        else return flag;
    }
}

 

================================================
Collections:
集合框架的工具类。里面定义的都是静态方法。

Collections和Collection有什么区别？
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
它有两个常用的子接口，
List：对元素都有定义索引。有序的。可以重复元素。
Set：不可以重复元素。无序。

Collections是集合框架中的一个工具类。该类中的方法都是静态的
提供的方法中有可以对list集合进行排序，二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

重要方法：
sort：
public static <T extends Comparable<? super T>> void sort(List<T> list)根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此外，列表中的所有元素都必须是可相互比较的（也就是说，对于列表中的任何 e1 和 e2 元素，e1.compareTo(e2) 不得抛出 ClassCastException）。

shuffle
public static void shuffle(List<?> list)使用默认随机源随机更改指定列表的序列。
public static void shuffle(List<?> list,Random rnd)使用指定的随机源随机更改指定列表的序列。