黑马程序员------集合框架之Map

------- <a href="http://www.itheima.com"target="blank">android培训</a>、<a href="http://www.itheima.com"target="blank">java培训</a>、期待与您交流！ ----------

集合框架之map集合

Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。

         1，添加。

              put(Kkey, V value) //将指定的值与此映射中的指定键关联（可选操作）。（当存储的键相同时，新值会替换旧值，并将旧值返回。如果键没有重复，返回null）。

              putAll(Map<?extends K,? extends V> m) //从指定映射中将所有映射关系复制到此映射中（可选操作）。此处加了泛型限定

         2，删除。

              clear()//清空

              remove(Object key) //删除指定键的映射关系。

         3，判断。

              containsValue(Object value) //是否包含value

              containsKey(Objectkey) //是否包含key

              isEmpty()//集合是否为空

         4，获取。

              get(Object key) //通过指定键获取对应的值。如果返回null，可以判断该键不存在。当(在hashmap集合中，是可以存储null键null值的。)

              size()//返回长度

              values()//获取map集合中的所有的值。

               entrySet()

               keySet()

代码示例：

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

		//添加元素,若出现添加时相同的键，后添加的值会覆盖原有键对应值。
		//并会返回被覆盖的值。
		System.out.println("put:"+map.put("01","zhangsan1"));
		System.out.println("put:"+map.put("01","wnagwu"));
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
        //判断集合中是否包含对于指定键022的映射关系
		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"));//通过指定键获取对应的值
		
		//获取map集合中所有的值。
		Collection<String> coll = map.values();

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

	}
}

Map

         |--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。

         |--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。

         |--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

Map集合和Collection集合比较：

Collection一次存一个元素；Map一次存一对元素。

Collection是单列集合；Map是双列集合。

Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。

特点：保证map集合中键的唯一性。

**map集合的两种取出方式：**

原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。

         所以可以迭代方式取出所有的键，再根据get方法。获取每一个键对应的值。

2，Set<Map.Entry<k,v>>entrySet：将map集合中的映射关系存入到了set集合中，

                                     而这个关系的数据类型就是：Map.Entry

                                     Entry其实就是Map中的一个static内部接口。

                                     为什么要定义在内部呢？

                                     因为只有有了Map集合，有了键值对，才会有键值的映射关系。

                                     关系属于Map集合中的一个内部事物。

                                     而且该事物在直接访问Map集合中的元素。

方式1，Set<k> keySet代码示例

import java.util.*;
class MapDemo2 
{
	public static void main(String[] args) 
	{
		Map<String,String> map = new HashMap<String,String>();
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		map.put("01","zhangsan1");
		map.put("04","zhangsan4");
//先获取map集合的所有键的Set集合,keySet();
		Set<String> keySet = map.keySet();

		//有了Set集合。就可以获取其迭代器。
		Iterator<String> it = keySet.iterator();
		while(it.hasNext())
		{
			String key = it.next();
			//有了键可以通过map集合的get方法获取其对应的值。
			String value = map.get(key);
			System.out.println("key:"+key+",value:"+value);
		}
	}
}

方式2，Set<Map.Entry<k,v>> entrySet示例：

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

		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		map.put("01","zhangsan1");
		map.put("04","zhangsan4");

		//将Map集合中的映射关系取出。存入到Set集合中。
		Set<Map.Entry<String,String>> entrySet = map.entrySet();//返回值类型是Set集合
        //迭代取出
		Iterator<Map.Entry<String,String>> it = entrySet.iterator();

		while(it.hasNext())
		{
			Map.Entry<String,String> me = it.next();
			String key = me.getKey();//获取键
			String value = me.getValue();//获取值
			System.out.println(key+":"+value);
		}
   }
}

TreeMap代码示例：（涉及到两种比较方式）

/*

需求：对学生对象的年龄进行升序排序。

因为数据是以键值对形式存在的。

所以要使用可以排序的Map集合。TreeMap。

*/

import java.util.*;
class Student implements Comparable<Student>//方式1
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	
	public int compareTo(Student s)
	{
		int num = new Integer(this.age).compareTo(new Integer(s.age));

		if(num==0)
			return this.name.compareTo(s.name);
		return num;
	}

	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return name+":"+age;
	}
}


class StuNameComparator implements Comparator<Student>//方式2，<>中存放参与比较的对象
{
	public int compare(Student s1,Student s2)
	{
		int num = s1.getName().compareTo(s2.getName());
		if(num==0)//主要条件相同，比较次要条件
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));

		return num;
	}
}


public class  MapTest2
{
	public static void main(String[] args) 
	{
		TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());
//优先按此进行排序，让容器自身具备比较性
		tm.put(new Student("blisi3",23),"nanjing");
		tm.put(new Student("lisi1",21),"beijing");
		tm.put(new Student("alisi4",24),"wuhan");
		tm.put(new Student("lisi1",21),"tianjin");
		tm.put(new Student("lisi2",22),"shanghai");

		Set<Map.Entry<Student,String>> entrySet = tm.entrySet();//将映射关系取出到Set集合中 
		Iterator<Map.Entry<Student,String>> it = entrySet.iterator(); 
		while(it.hasNext())
		{
			Map.Entry<Student,String> me = it.next();
			Student stu = me.getKey();
			String addr = me.getValue();
			System.out.println(stu+":::"+addr);
		}
	}
}

实质就可以看成，是对map集合中的键进行排序

分析总结：如果TreeMap不指定排序器，默认将按key值进行升序排序，但此时这个key值是Student自定义对象，自身并无比较性，就需要按照要求定义排序规则（继承Comparable接口或定义比较器继承Compatator接口）进行排序。