java第十五天_Map集合，

Map集合：

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

当有映射关系的元素时，考虑建立Map集合。

方法摘要：

 

1.添加：如果添加时，出现相同的键。那么后添加的值会覆盖原有键对应值，并且put方法会返回被覆盖的值。

put(K key,V value)

putAll(Map< ? Extends k, ? extends V> m)

2.删除

clear( )

remove ( Object key)

3.判断

containValue ( Object value)

containsKey ( Object key)

isEmpty ( )

4.获取

get ( Object key )：可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。

size ( )

values ( )

 

entrySet ( )

keySet ( )

Map体系：和Set很像。Set底层就是使用了Map集合。

Map

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

|——HashMap：底层是哈希表数据结构，允许使用null键null值。该集合是不同步的。JDK1.2。效率高。

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

 

Map集合的两种取出方式：

Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。

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

图解：

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

entrySet()方法将map集合中的映射关系取出。这个关系就是Map.Entry类型。那么关系对象Map.Entry获取到后，就可以通过Map.Entry中getKey和getValue方法获取关系中的键和值

图解：

代码：

 

//import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo 
{
	/**
	 * @map方法的演示。
	 */
	public static void main(String[] args) 
	{
		Map<String,String> map=new HashMap<String,String>();//Map不是一个具体的集合类。
		//添加元素。
		map.put("01","zhangsan1");
		map.put("02", "zhangsan02");
		map.put("03", "zhangsan03");
		//System.out.println(map.put("03", "zhangsan033"));//map后添加的值会覆盖以前的值，并且会返回被覆盖的值。
		map.put("04", null);
		//删除元素。
		//System.out.println(map.remove("02"));
		//map.clear();//clear()没有返回值
		//获取元素
		//System.out.println(map.get("04"));//根据指定键获取值，如果没有这个键值对，返回null。
		//Collection<String> coll=map.values(); //获取map中的值。将这些值存到Collection集合中。
		//取出元素
		//第一种方法，将map的键值存到set集合中。迭代取出key值，再根据键值取出值。
		/*Set<String> keyset=map.keySet();
		for(Iterator<String> it=keyset.iterator();it.hasNext();)//
		{
			String key=it.next();
			String value=map.get(key);
			System.out.println("key="+key+",value="+value);
		}*/
		//第二种方法。将Map的映射关系取出。存入到Set集合中。
		Set<Map.Entry<String, String>> entry=map.entrySet();
		for(Iterator<Map.Entry<String, String>> it=entry.iterator();it.hasNext();)
		{
			Map.Entry<String, String> me=it.next();
			String key=me.getKey();
			String value=me.getValue();
			System.out.println(key+":"+value);
		}
		
		//System.out.println(coll);
	}
}

package day16;


import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class StudentMap
{
	/**
	 * @Map中装Student对象为key，相应地址为value。
	 */
	public static void main(String[] args) 
	{
		HashMap<Student,String> hm=new HashMap<Student,String>();
		hm.put(new Student("zhangsan01",20), "beijing");
		hm.put(new Student("zhangsan01",20), "beijing");
		hm.put(new Student("zhangsan02",22), "shanghai");
		hm.put(new Student("zhangsan03",23), "tianjin");
		Set<Map.Entry<Student,String>> hs=hm.entrySet();
		for(Iterator<Map.Entry<Student,String>> it=hs.iterator();it.hasNext();)
		{
			Map.Entry<Student, String> me=it.next();
			Student stu=me.getKey();
			String add=me.getValue();
			System.out.println(stu+"^"+add);			
		}
	}
}
class Student implements Comparable<Student>
{
	private String name;
	private int 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;
	}
	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(this.age));
		if(num==0)
			return this.name.compareTo(s.name);
		return num;
	}
	public int hashCode()//要重写hashCode方法。尽量让每个元素的返回值不同。
	{
		return name.hashCode()+age*10;
	}
	public boolean equals(Student s)//重写equals方法。
	{
		return this.name.equals(s.name)&&(this.age==s.age);
	}
	public String toString()//打印对象需要调用这个方法。
	{
		return name+":"+age;
	}
}

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class CharCount 
{
	/**
	 * @统计字符串中字母出现的次数并存入集合	 */
	public static void main(String[] args) 
	{
		String str="aldjflasdfoqwnieonvaospnfieo";
		System.out.println(charCount(str));
	}
	public static String charCount(String str)
	{
		char[] chs=str.toCharArray();
		TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
		int count=0;
		for(int x=0;x<chs.length;x++)
		{
			if(!(chs[x]>='a'&&chs[x]<='z'||chs[x]>='A'&&chs[x]>='Z'))
				continue;
			Integer value=tm.get(chs[x]);
			if(!(value==null))
			{
				count=value;
			}
			count++;
			tm.put(chs[x], count);
			/*if(value==null)
			{
				tm.put(chs[x], 1);
			}
			else
			{
				value++;
				tm.put(chs[x], value);
			}*/
			count=0;
		}
		StringBuffer sb=new StringBuffer();
		Set<Map.Entry<Character,Integer>> entryset=tm.entrySet();
		for(Iterator<Map.Entry<Character,Integer>> it=entryset.iterator();it.hasNext();)
		{
			Map.Entry<Character,Integer> me=it.next();
			Character ch=me.getKey();
			Integer in=me.getValue();
			sb.append(ch+"("+in+")");
		}
		return sb.toString();
	}
}