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();
}
}import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class OneVsMany
{
/**
* @Map集合中一個鍵對應多個值。
*/
public static void main(String[] args)
{
HashMap<String,List<Student>> hm=new HashMap<String,List<Student>>();
List<Student> yure=new ArrayList<Student>();
List<Student> jiuye=new ArrayList<Student>();
hm.put("yure", yure);
hm.put("jiuye", jiuye);
yure.add(new Student("zhangsan",1));
yure.add(new Student("zhangsan2",2));
jiuye.add(new Student("zhangsan3",3));
jiuye.add(new Student("zhangsan4",4));
Set<Map.Entry<String,List<Student>>> mapentry=hm.entrySet();
for(Iterator<Map.Entry<String,List<Student>>> it=mapentry.iterator();it.hasNext();)
{
Map.Entry<String,List<Student>> me=it.next();
String str=me.getKey();
List<Student> li=me.getValue();
System.out.println(str);
getInfo(li);
}
}
public static void getInfo(List<Student> i)
{
for(Iterator<Student> it=i.iterator();it.hasNext();)
{
Student s=it.next();
System.out.println(s);
}
}
}