Map 接口
----|HashMap -------------implements Map
----|LinkedHashMap -------------extends HashMap
----|Hashtable -------------implements Map
----|treeMap -------------implements Map
Map 接口
----|HashMap 线程不安全,效率高。
允许null键和null值,是基于哈希表的Map接口实现。
哈希表的作用是用来保证键的唯一性的
----|LinkedHashMap:是基于Map接口的哈希表和链接列表实现,
由哈希表保证键的唯一性
由链表保证键盘的有序(存储和取出的顺序一致)
----|Hashtable:线程安全,效率低。不允许null键和null值
----|treeMap 是基于红黑树的Map接口的实现。
一.Map集合
定义:将键映射到值的对象。key是唯一不重复,每一个key只能对应一个value
常用方法:
1:添加或者修改功能
- V put(K key,V value):添加元素 /修改元素,并返回修改前元素的值
2:删除功能
- void clear():移除所有的键值对元素
- V remove(Object key):删除键对应的元素,并把值返回
3:判断功能
- boolean containsKey(Object key):判断集合是否包含指定的键
- boolean containsValue(Object value):判断集合是否包含指定的值
- boolean isEmpty():判断集合是否为空
4:获取功能
- Set< Map.Entry< K,V>> entrySet():遍历
- V get(Object key):根据键获取值
- Set< K> keySet():获取集合中所有键的集合
- Collection< V> values():获取集合中所有值的集合
5:长度功能
- int size():返回集合中的键值对的对数
public static void main(String[] args) {
Map<String, String> map=new HashMap<String,String>();
// 添加元素
System.out.println("-----------put-----------------");
System.out.println(map.put("1", "11"));
System.out.println(map.put("1", "111"));
map.put("2", "2");
map.put("3", "4");
map.put("4", "4");
map.put("5", "5");
System.out.println(map);
System.out.println("-----------containsKey判断集合是否包含指定的键-----------------");
System.out.println(map.containsKey("1"));
System.out.println("-----------containsValue判断集合是否包含指定的键-----------------");
System.out.println(map.containsValue("111"));
System.out.println("-----------isEmpty()判断集合是否为空-----------------");
System.out.println(map.isEmpty());
System.out.println("-----------size():返回集合中的键值对的对数-----------------");
System.out.println("size:"+map.size());
System.out.println("-----------keySet:获取key的集合Set<T>-----------------");
Set<String> set=map.keySet();
for (String s : set) {
System.out.print(s+":"+map.get(s)+" ");
}
System.out.println();
System.out.println("-----------values:获取value的Collection<T>-----------------");
Collection<String> value=map.values();
for (String s : set) {
System.out.print(s+":"+" ");
}
System.out.println();
System.out.println("-----------Set<Entry<String, String>>-----------------");
Set<Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
System.out.print(entry.getKey()+":"+ entry.getValue()+" ");
}
System.out.println();
System.out.println("-----------remove根据键删除键值对元素,并把值返回-----------------");
System.out.println("romove:"+map.remove("1"));
System.out.println(map);
System.out.println("-----------clear移除所有的键值对元素-----------------");
map.clear();
System.out.println(map);
}
输出:
-----------put-----------------
null
11
{3=4, 2=2, 1=111, 5=5, 4=4}
-----------containsKey判断集合是否包含指定的键-----------------
true
-----------containsValue判断集合是否包含指定的键-----------------
true
-----------isEmpty()判断集合是否为空-----------------
false
-----------size():返回集合中的键值对的对数-----------------
size:5
-----------keySet:获取key的集合Set<T>-----------------
3:4 2:2 1:111 5:5 4:4
-----------values:获取value的Collection<T>-----------------
3: 2: 1: 5: 4:
-----------Set<Entry<String, String>>-----------------
3:4 2:2 1:111 5:5 4:4
-----------remove根据键删除键值对元素,并把值返回-----------------
romove:111
{3=4, 2=2, 5=5, 4=4}
-----------clear移除所有的键值对元素-----------------
{}
二.Map实现类
HashMap:
- 线程不安全,效率高。允许null键和null值
- 是基于哈希表的Map接口实现。哈希表的作用是用来保证键的唯一性的。
- 常用实例化方法:
new HashMap< Object, Object>();
Hashtable:
- 线程安全,效率低。不允许null键和null值
LinkedHashMap:
- 是基于Map接口的哈希表和链接列表实现,有序
- 由哈希表保证键的唯一性
- 由链表保证键盘的有序(存储和取出的顺序一致)
- 常用实例化方法:
new LinkedHashMap< Object, Object>();
System.out.println("-----------LinkedHashMap唯一性 有序----------------");
//LinkedHashMap测试 由哈希表保证键的唯一性 由链表保证键盘的有序(存储和取出的顺序一致)
LinkedHashMap<String, String> lMap=new LinkedHashMap<String, String>();
// 创建并添加元素
lMap.put("11", "11");
lMap.put("22", "22");
lMap.put("33", "33");
lMap.put("44", "44");
lMap.put("55", "55");
// 遍历
Set<String> set2 = lMap.keySet();
for (String key : set2) {
String value2 = lMap.get(key);
System.out.println(key + "---" + value2);
}
输出:
-----------LinkedHashMap唯一性 有序----------------
11---11
22---22
33---33
44---44
55---55
treeMap:
- TreeMap:是基于红黑树的Map接口的实现。
- 构造方法:
TreeMap() 使用键的自然顺序构造一个新的、空的树映射。
TreeMap(Comparator< ? super K> comparator) 构造一个新的、空的树映射,该映射根据给定比较器进行排序
自然顺序:
如果key是自定义的类,该类需要实现Comparator接口,基本类型都有实现该接口;
//构造方法摘要
//TreeMap() 使用键的自然顺序构造一个新的、空的树映射。
//TreeMap(Comparator<? super K> comparator) 构造一个新的、空的树映射,该映射根据给定比较器进行排序
System.out.println("--------------基本类型key自然排序----------------");
TreeMap<String, String> tm=new TreeMap<String, String>();
tm.put("1", "1");
tm.put("2", "2");
tm.put("5", "5");
tm.put("4", "4");
tm.put("3", "3");
Set<String> set=tm.keySet();
for (String key : set) {
String value=tm.get(key);
System.out.println(key+"----"+value);
}
System.out.println("--------------自定义的类key自然排序----------------");
TreeMap<Student, String> tm2=new TreeMap<Student, String>();
Student s1 = new Student("abc", 27);
Student s2 = new Student("abc", 29);
Student s3 = new Student("bcd", 23);
Student s4 = new Student("efd", 27);
Student s5 = new Student("cfd", 22);
Student s6 = new Student("cdf", 40);
Student s7 = new Student("bed", 22);
tm2.put(s1, "1");
tm2.put(s2, "2");
tm2.put(s3, "3");
tm2.put(s4, "4");
tm2.put(s5, "5");
tm2.put(s6, "6");
tm2.put(s7, "7");
Set<Student> set2=tm2.keySet();
for (Student key : set2) {
String value=tm2.get(key);
System.out.println(key+"----"+value);
}
输出:
--------------基本类型key自然排序----------------
1----1
2----2
3----3
4----4
5----5
--------------基本类型key自然排序----------------
Student [name=bed, age=22]----7
Student [name=cfd, age=22]----5
Student [name=bcd, age=23]----3
Student [name=abc, age=27]----1
Student [name=efd, age=27]----4
Student [name=abc, age=29]----2
Student [name=cdf, age=40]----6
比较排序:
System.out.println("--------------比较器排序----------------");
//TreeMap(Comparator<? super K> comparator) 构造一个新的、空的树映射,该映射根据给定比较器进行排序
TreeMap<Student, String> tm3=new TreeMap<Student, String>(new Comparator<Student>() {
public int compare(Student s1, Student s2) {
//先按名字比较
int num1=s1.getName().compareTo(s2.getName());
//年龄比较
int num2=num1==0?s1.getAge()-s2.getAge():num1;
return num2;
};
});
tm3.put(s1, "1");
tm3.put(s2, "2");
tm3.put(s3, "3");
tm3.put(s4, "4");
tm3.put(s5, "5");
tm3.put(s6, "6");
tm3.put(s7, "7");
Set<Student> set3=tm3.keySet();
for (Student key : set3) {
String value=tm3.get(key);
System.out.println(key+"----"+value);
}
输出:
--------------比较器排序----------------
Student [name=abc, age=27]----1
Student [name=abc, age=29]----2
Student [name=bcd, age=23]----3
Student [name=bed, age=22]----7
Student [name=cdf, age=40]----6
Student [name=cfd, age=22]----5
Student [name=efd, age=27]----4
Student 类
/*
* 如果一个类的元素要想能够进行自然排序,就必须实现自然排序接口
*/
public class Student implements Comparable<Student> {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = 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;
}
@Override
public int compareTo(Student s) {
//按照年龄排序
int num1= this.getAge()-s.getAge();
////如果年龄相同,按名字排序
int num2=num1==0?(this.getName().compareTo(s.getName())):num1;
return num2;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}