Map集合

1:Map
(1)将键映射到值的对象。

    一个映射不能包含重复的键；每个键最多只能映射到一个值。

       键值对的方式存在
(2)Map和Collection的区别?

    A:Map 存储的是键值对形式的元素，键唯一，值可以重复。夫妻对
    B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。光棍
(3)Map接口功能概述
A:添加功能   put();
B:删除功能   remove(key);
C:判断功能   

            containsKey(key);判断是否包含key键

            containsValue(value);判断是否包含值
D:获取功能

            get(key);

            values();

E:长度功能

            size();
(4)Map集合的遍历
   A:键找值
      a:获取所有键的集合
      b:遍历键的集合,得到每一个键
      c:根据键到集合中去找值

  B:键值对对象找键和值
      a:获取所有的键值对对象的集合
      b:遍历键值对对象的集合，获取每一个键值对对象
      c:根据键值对对象去获取键和值
hashMap 无序唯一
代码体现：
Map<String,String> hm = new HashMap<String,String>();

hm.put("it002","hello");
hm.put("it003","world");
hm.put("it001","java");

//方式1 键找值
Set<String> set = hm.keySet();
for(String key : set) {
String value = hm.get(key);
System.out.println(key+"---"+value);
}

//方式2 键值对对象找键和值
Set<Map.Entry<String,String>> set2 = hm.entrySet();
for(Map.Entry<String,String> me : set2) {
String key = me.getKey();
String value = me.getValue();
System.out.println(key+"---"+value);
}
(5)案例
A:统计一个字符串中每个字符出现的次数

String str="abcdefabcdefabcdef";

//将字符串转化为字符数组
char[] c=str.toCharArray();

//创建map集合
Map<String,Integer> map=new LinkedHashMap<String,Integer>();

//遍历字符数组
for (int i = 0; i < c.length; i++)
{
/*已经存在
* 给value加一
* 不存在
* 给集合key值
* */
if (map.containsKey(String.valueOf(c[i])))
{
//修改
map.put(String.valueOf(c[i]),map.get(String.valueOf(c[i]))+1);
}
else{
map.put(String.valueOf(c[i]),1);
}
}
//方法一
Set<Map.Entry<String,Integer>> set=map.entrySet();
for (Map.Entry<String,Integer> mapkey : set)
{
System.out.println(mapkey);
}

B:集合的嵌套遍历

a:多层嵌套

Map<String,LinkedHashMap<Integer,LinkedHashMap<Integer,String>>> map=new LinkedHashMap<String,LinkedHashMap<Integer,LinkedHashMap<Integer,String>>>();

LinkedHashMap<Integer,String> map2=new LinkedHashMap<Integer,String>();
LinkedHashMap<Integer,LinkedHashMap<Integer,String>> map1=new LinkedHashMap<Integer,LinkedHashMap<Integer,String>>();
map.put("1", map1);
map1.put(1, map2);
map2.put(1, "str");
Set<Map.Entry<String,LinkedHashMap<Integer,LinkedHashMap<Integer,String>>>> set=map.entrySet();
Set<Entry<Integer,LinkedHashMap<Integer,String>>> set2 = map1.entrySet();
Set<Entry<Integer,String>> set3 = map2.entrySet();
for (Map.Entry<String,LinkedHashMap<Integer,LinkedHashMap<Integer,String>>> mapkey : set)
{System.out.println(mapkey);
for (Entry<Integer, LinkedHashMap<Integer, String>> map1key : set2)
{System.out.println(map1key);
for (Entry<Integer, String> map2key : set3)
{
System.out.println(map2key);
}
}

}

输出结果:

1={1={1=str}}
1={1=str}
1=str

TreeMap  有序唯一

TreeMap<Integer,String> map=new TreeMap<Integer, String>(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return -1;
}
});
map.put(1, "str");
map.put(2, "str");
map.put(4, "str");
map.put(3, "str");
map.put(5, "str");
Set<Entry<Integer,String>> set = map.entrySet();
for (Entry<Integer, String> map2key : set)
{
System.out.println(map2key);
}

输出：

5=str
3=str
4=str
2=str
1=str

默认排序是升序，加上比较器会按照自己的方式进行排序