Java笔记--Map集合

1.Map集合：该集合存储键值对，一对一对往里存，而且要保证

键的唯一性

1，添加

//当存入相同键的时候，新添加的值会覆盖原有的值

//而且会返回该键对应的原来的值（被覆盖的值）

V put(K key, V value)；

 

void putAll(Map<? extends K,? extends V> m)；

2，删除

void clear()；

V remove(Object key)；

3，判断

boolean containsKey(Object key)；

boolean containsValue(Object value)；

boolean isEmpty()；

4，获取

V get(Object key)；

int size()；

Collection<V> values()；

 

Set<Map.Entry<K,V>> entrySet()；

Set<K> keySet()；

 

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集合的取出方式

（1） Set<K> keySet()；方法

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();

}

}