Java筆記--Map集合
1.Map集合：該集合儲存鍵值對，一對一對往裡存，而且要保證
鍵的唯一性
1，新增
//當存入相同鍵的時候，新新增的值會覆蓋原有的值
//而且會返回該鍵對應的原來的值（被覆蓋的值）
void putAll(Map<? extends K,? extends V> m)；
2，刪除
void clear()；
3，判斷
boolean containsKey(Object key)；
boolean containsValue(Object value)；
boolean isEmpty()；
4，獲取
int size()；
Set<Map.Entry<K,V>> entrySet()；
2.Map
|--Hashtable:底層是雜湊表的資料結構，不可以存入null鍵、
和null值，該集合是執行緒同步的 ，JDK1.0，效率低
|--HashMap:底層是雜湊表資料結構，可以存入null鍵和null值
該集合是執行緒不同步的，JDK1.2，效率高
|--TreeMap：底層是二叉樹資料結構，執行緒不同步，可以用於
Map集合中的鍵進行排序。
注意：Map和Set很像，其實Set底層就是呼叫Map集合
Map基本方法演示
import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("01","張三01");
//當存入相同鍵的時候，新新增的值會覆蓋原有的值
//而且會返回該鍵對應的原來的值（被覆蓋的值）
System.out.println(map.put("01","新張三"));
map.put("02","張三02");
map.put("03","張三03");
//HashMap可以鍵入null值
map.put("04",null);
//HaspMap可以鍵入null鍵
map.put(null,"王五");
System.out.println(map.containsKey("02"));
System.out.println("原來" + map);
map.remove("02"); //刪除鍵為02的元素
System.out.println("現在" + map);
Collection<String> coll = map.values();
System.out.println(coll);
}
}
//執行效果
張三01
true
原來{null=王五, 01=新張三, 02=張三02, 03=張三03, 04=null}
現在{null=王五, 01=新張三, 03=張三03, 04=null}
[王五, 新張三, 張三03, null]
3.Map集合的取出方式
Map集合的取出原理：
將Map集合轉成Set集合，再通過迭代器取出
/*
keyset()方法：將map中所有的鍵存入到Set集合中。
因為Set具備迭代器，可以通過迭代的方式獲取所有的鍵，
再根據map集合的get()方法獲取每一個鍵對應的值
*/
import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("01","張三01");
map.put("02","張三02");
map.put("03","張三03");
//先獲取map集合中所有鍵的Set集合
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();
Set <Map,Entry<k,v>> entrySet();：將Map集合中的對映關係存入到了Set集合中，而這個關係的資料型別就是Map.Entry
關係物件Map.Entry獲取到後，就可以通過Map.Entry中getKey()和getValue()方法，獲取關係中的鍵和值
Map.Entry中Entry其實也是一個介面，它是Map介面中的一個內部介面
interface Map
{
public static interface Entry
{
public abstract Object getKey();
public abstract Object getValue();
}
}
class HashMap implements Map
{
class Hash implements Map.Entry
{
public abstract Object getKey() {}
public abstract Object getValue() {}
}
}
例項：
import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("01","張三01");
map.put("02","張三02");
map.put("03","張三03");
Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator<Map.Entry<String,String>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<String,String> me= it.next();
String value = me.getKey();
String key = me.getValue();
System.out.println("key : " + key + " value : " + value);
}
}
}
例項練習：
/*
需求：
1，描述學生
2，定義Map容器，將學生作為鍵，將學生地址作為值存入Map容器中
3，從Map容器中取出值
*/
import java.util.*;
class Student implements Comparable<Student>
{
private String name;
private int age;
private String addr;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
//通過hashCode()和equals()函式來保證元素在HashSet集合中元素的唯一性
public int hashCode()
{
return name.hashCode() + age * 34;
}
//姓名和年齡相同的視為同一個學生
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new ClassCastException();
Student stu = (Student)obj;
return this.name.equals(stu.name) && this.age == stu.age;
}
//讓元素本身具備可比較性，當資料結構為二叉樹時
public int compareTo(Student stu)
{
int num = this.name.compareTo(stu.name);
if(num == 0)
{
return new Integer(this.age).compareTo(new Integer(stu.age));
}
return num;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String toString()
{
return name + "--" + age;
}
}
class MapTest
{
public static void main(String[] args)
{
//取出元素的第一種方式
/*
Set<Student> keyset = hm.keySet();
Iterator<Student> it = keyset.iterator();
HashMap <Student,String> hm = new HashMap<Student,String>();
hm.put(new Student("f張三1",21),"北京");
hm.put(new Student("t張三1",21),"徐州");
hm.put(new Student("a張三2",22),"南京");
hm.put(new Student("c張三3",23),"上海");
hm.put(new Student("e張三4",24),"徐州"); while(it.hasNext())
{
Student stu = it.next();
String name = stu.getName();
int age = stu.getAge();
String addr = hm.get(stu);
System.out.println(name + "----" + age + "----" + addr);
}
*/
//取出元素的第二種方式
Set<Map.Entry<Student,String>> entrySet = hm.entrySet();
Iterator<Map.Entry<Student,String>> iter = entrySet.iterator();
while(iter.hasNext())
{
Map.Entry<Student,String> me = iter.next();
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu + "----" + addr);
}
}
}
例項練習二：
import java.util.*;
//比較器是先根據年齡排序，再根據姓名排序
class stuNameComparator implements Comparator<Student>
{
public int compare(Student s1,Student s2)
{
int num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
if(num == 0)
{
return s1.getName().compareTo(s2.getName());
}
return num;
}
}
class MapTest2
{
public static void main(String[] args)
{
TreeMap <Student,String> tm = new TreeMap<Student,String>(new
stuNameComparator());
tm.put(new Student("張三1",21),"北京");
tm.put(new Student("張三1",21),"徐州");
tm.put(new Student("張三2",22),"南京");
tm.put(new Student("張三3",23),"上海");
tm.put(new Student("張三4",24),"徐州");
Set<Map.Entry<Student,String>> entrySet = tm.entrySet();
Iterator<Map.Entry<Student,String>> iter = entrySet.iterator();
while(iter.hasNext())
{
Map.Entry<Student,String> me = iter.next();
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu + "----" + addr);
}
}
}
綜合練習
/*
練習：
“asdgjahgsasdasdasd”獲取該字串中字元出現的次數
希望列印結果：a(5)d(4)......
通過結果發現，每一個字母都有對應的次數
說明字母和次數之間都有對映關係
什麼時候使用Map集合？
當資料之間存在這種對映關係時，就要先想Map集合，Map集合中存放的就是對映關係
思路：
1，將字串轉化成字元陣列
2，定義一個TreeMap集合，因為列印結果的字母有順序
3，遍歷字元陣列
將每一個字母作為鍵去查Map集合
如果返回null，將字母和1存到map集合中
如果返回不是null，說明該字母在map集合中已經存在
那麼就獲取該次數並進行自增，然後將該字母和自增後的次數存入到map集合中，覆蓋原來鍵對應的值
4，將map集合中的資料變成指定的字串形式返回
*/
import java.util.*;
class MapTest3
{
public static void main(String[] args)
{
String str = MapTest3.charCount("asdfgaeretds");
System.out.println(str);
}
public static String charCount(String str)
{
TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
char[] chs = str.toCharArray(); //將字串轉換成字元陣列
//將鍵值對寫入到了Map集合中
for(int x = 0; x < chs.length; x++) //遍歷字元陣列中的每一個元素
{
Integer value = tm.get(chs[x]);
if(value == null)
{
tm.put(chs[x],1);
}
else
{
value++;
tm.put(chs[x],value);
}
}
//定義一個字元緩衝區
StringBuilder sb = new StringBuilder();
//遍歷TreeMap集合，將集合中的資料按規定格式傳入到字元緩衝區中
Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<Character,Integer> me = it.next();
char ch = me.getKey();
int value = me.getValue();
sb.append(ch + "(" + value + ")");
}
return sb.toString();
}
}