Map集合的特点?
1、可以存储键值对的元素。
2、将键映射到值的对象。
3、一个映射不能包含重复的键,每个键最多只能映射到一个值。
4、Map是一个接口。
Map集合和Collection集合的区别?
1、Map集合存储元素是成对出现的,Map集合的键是唯一的,值是可重复的
1、Collection集合存储元素是单独出现的,Collection的子体系Set是唯一的,List是可重复的。
2、Map集合的数据结构只针对键有效,跟值无关。
2、Collection集合的数据结构是针对元素有效。
HashMap | LinkedHashMap | TreeMap |
基于哈希表的Map接口 | Map 接口的哈希表和链接列表 | 红黑树的Map接口 |
保证键的唯一性 | 保证键的唯一性,具有可预知的迭代顺序(添加的顺序和输出的顺序完全一致) | 保证键的排序和唯一性 |
添加功能
V put(K key, V value) :添加元素。
如果键是第一次存储,就直接存储元素,返回null。如果键不是第一次存储,就用值把以前的值替换掉,返回以前的值。
删除功能
void clear():移除所有的键值对元素。
V remove(Object key) :根据键删除键值对元素,返回删除的值。
判断功能
boolean containsKey(Object key) :判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty():判断集合是否为空
获取功能
V get(Object key):根据键获取值
Set keySet():获取集合中所有键的集合
Collection values():获取集合中所有值得集合
长度功能
int size() :返回集合中键值对的对数
V put(K key, V value) 方法。返回值为V类型
map是如何做到当键的唯一性的呢?一个键只对应一个值。
通过put方法,当添加的元素的键相同的时候,值会覆盖已经存在的那个值。
public class MapDemo {
public static void main(String[] args) {
//创建集合对象
Map<String, String> map = new HashMap<String, String>();
//添加元素
//如果键是第一次存储,就直接存储元素,返回null
//如果键不是第一次存储,就用值把以前的值替换掉,返回以前的值。(键已经存在,值就覆盖)
System.out.println(map.put("梨梨", "21")); //null
System.out.println(map.put("梨梨", "22")); //21
//输出集合元素
System.out.println(map); //{梨梨=22}
}
}
基本方法的使用介绍:
remove方法:
public class MapDemo {
public static void main(String[] args) {
//创建集合对象
Map<String, String> map = new HashMap<String, String>();
//添加元素
map.put("梨梨", "21");
map.put("熊熊", "22");
map.put("菜菜", "12");
map.put("哈哈", "2");
//删除元素。传入键,返回对应的值,若键不存在,返回null
System.out.println("remove:" + map.remove("梨梨")); //remove:21
System.out.println("remove:" + map.remove("lili")); //remove:null
System.out.println("containsKey:" + map.containsKey("菜菜")); //containsKey:true
System.out.println("size:" + map.size()); //3
System.out.println("isEmpty:" + map.isEmpty()); //isEmpty:falses
//输出集合元素
System.out.println(map); //{哈哈=2, 熊熊=22, 菜菜=12}
}
}
get方法
public class MapDemo {
public static void main(String[] args) {
//创建集合对象
Map<String, String> map = new HashMap<String, String>();
//创建元素并添加元素
map.put("梨梨", "21");
map.put("熊熊", "22");
map.put("菜菜", "12");
map.put("哈哈", "2");
//根据键获取值
System.out.println("get:" + map.get("菜菜")); //get:12
//获得所有键的集合
Set<String> keySet = map.keySet();
//遍历所有键
for(String key : keySet){
System.out.println(key);
}
System.out.println("-------");
//获取所有值的集合
Collection<String> values = map.values();
for(String value:values){
System.out.println(value);
}
}
}
输出:
get:12
-------
哈哈
梨梨
熊熊
菜菜
-------
2
21
22
12
HashMap类
HashMap:是基于哈希表的Map接口实现,哈希表的作用是用来保证键的唯一性。
键和值都是String
public class MapDemo4 {
public static void main(String[] args) {
//创建集合对象
HashMap<String, String> hm = new HashMap<String, String>();
//创建元素并添加元素
hm.put("梨梨", "美丽");
hm.put("熊熊", "帅气");
hm.put("菜菜", "乖巧");
hm.put("哈哈", "搞笑");
hm.put("梨梨", "大方"); //会覆盖上面的"美丽"
Set<String> keySet = hm.keySet();
for(String key : keySet){
String value = hm.get(key);
System.out.println(key + "=" + value);;
}
}
}
输出:
哈哈=搞笑
梨梨=大方
熊熊=帅气
菜菜=乖巧
键是Integer值是String
public class MapDemo4 {
public static void main(String[] args) {
//创建集合对象
HashMap<Integer, String> hm = new HashMap<Integer, String>();
//创建元素并添加元素
hm.put(001 , "美丽");
hm.put(002 , "帅气");
hm.put(003 , "乖巧");
hm.put(004 , "搞笑");
hm.put(007 , "大方"); //会覆盖上面的"美丽"
//遍历
Set<Integer> keySet = hm.keySet();
for(Integer key : keySet){
String value = hm.get(key);
System.out.println(key + "=" + value);;
}
//集合的元素的字符串表示,不是遍历
System.out.println(hm);
}
}
输出:
1=美丽
2=帅气
3=乖巧
4=搞笑
7=大方
{1=美丽, 2=帅气, 3=乖巧, 4=搞笑, 7=大方}
键是String值是Student
public class MapDemo4 {
public static void main(String[] args) {
//创建集合对象
HashMap<Integer, Student> hm = new HashMap<Integer, Student>();
//创建元素
Student stu1 = new Student("梨梨", 21);
Student stu2 = new Student("菜菜", 3);
Student stu3 = new Student("熊熊", 22);
Student stu4 = new Student("哈哈", 1);
//添加元素
hm.put(001, stu1);
hm.put(002, stu2);
hm.put(004, stu3);
hm.put(005, stu4);
//遍历
Set<Integer> keySet = hm.keySet();
for(Integer key:keySet){
Student stu = hm.get(key);
System.out.println(key + "=" + stu.getName() + "," + stu.getAge());
}
}
}
输出:
1=梨梨,21
2=菜菜,3
4=熊熊,22
5=哈哈,1
键是Student值是String
Student类如下:
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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;
}
}
public class HashMapDemp2 {
public static void main(String[] args) {
//创建集合对象
HashMap<Student, String> hm = new HashMap<Student, String>();
//创建元素
Student stu1 = new Student("梨梨", 21);
Student stu2 = new Student("菜菜", 3);
Student stu3 = new Student("熊熊", 22);
Student stu4 = new Student("哈哈", 1);
Student stu5 = new Student("梨梨", 21);
hm.put(stu1, "001");
hm.put(stu2, "002");
hm.put(stu3, "003");
hm.put(stu4, "004");
hm.put(stu5, "005");
Set<Student> keySet = hm.keySet();
for(Student key:keySet){
String value = hm.get(key);
System.out.println(key.getName() + "," + key.getAge() + "," + value);
}
}
}
输出:
梨梨,21,001
熊熊,22,003
梨梨,21,005
菜菜,3,002
哈哈,1,004
如果两个Student对象的成员变量值都相同,则为同一个对象。可以看成是同一个键,键相同,则值覆盖。而上面的代码却达不到这个效果。
为了达到这个效果,可以采用以下方法:
在Student类中加入这些代码即可达到效果。
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
输出:
熊熊,22,003
梨梨,21,005
哈哈,1,004
菜菜,3,002
LinkedHashMap
Map 接口的哈希表和链接列表实现,具有可预知的迭代顺序。
public class LinkedHashMapDemo {
public static void main(String[] args) {
//创建集合对象
LinkedHashMap<String, String> hm = new LinkedHashMap<String, String>();
//创建并添加元素
hm.put("123", "you");
hm.put("234", "are");
hm.put("345", "very");
hm.put("234", "good");
hm.put("345", "!");
//遍历
Set<String> keySet = hm.keySet();
for(String key:keySet){
String value = hm.get(key);
System.out.println(key + "=" + value);
}
}
}
输出:
123=you
234=good
345=!
可以发现输出是有序的,什么顺序输入进去,就按照什么顺序输出来。
并且,当键相同时,值也被覆盖了。
TreeMap
是基于红黑树的Map接口的实现,可以保证键的排序和唯一性。
public class TreeMapDemo {
public static void main(String[] args) {
//创建集合对象
TreeMap<String, String> tm = new TreeMap<String, String>();
//创建元素并添加元素
tm.put("hello", "你好");
tm.put("very", ",");
tm.put("you", "你");
tm.put("very", "非常");
tm.put("nice", "棒");
//遍历集合
Set<String> keySet = tm.keySet();
for(String key:keySet){
String value = tm.get(key);
System.out.println(key + "," + value);
}
}
}
输出:
hello,你好
nice,棒
very,非常
you,你
可以发现,当键相同时,值进行了覆盖。
并且,还对键进行了排列。
键是Student对象,值是String
传入参数,指明排序的方法。
public class TreeMaoDemo2 {
public static void main(String[] args) {
//创建集合对象
//输出排序的方法
TreeMap<Student1, String> tm = new TreeMap<Student1, String>(new Comparator<Student1>() {
@Override
public int compare(Student1 s1, Student1 s2) {
int num = s1.getAge() - s2.getAge();
int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
return num2;
}
});
//创建学生对象
Student1 stu1 = new Student1("梨梨", 21);
Student1 stu2 = new Student1("菜菜", 3);
Student1 stu3 = new Student1("熊熊", 22);
Student1 stu4 = new Student1("哈哈", 1);
Student1 stu5 = new Student1("菜菜", 18);
tm.put(stu1, "l");
tm.put(stu2, "la");
tm.put(stu3, "lal");
tm.put(stu4, "lala");
tm.put(stu5, "lalal");
//遍历集合
Set<Student1> keySet = tm.keySet();
for(Student1 key:keySet){
String value = tm.get(key);
System.out.println(key.getAge() + "," + key.getName() + "," + value );
}
}
}
输出:
1,哈哈,lala
3,菜菜,la
18,菜菜,lalal
21,梨梨,l
22,熊熊,lal
HashMap集合中嵌套HashMap。
很简单。也就是第一层循环获得键对应的值,这个值又是一个集合,再循环的到这个集合对应的键和值既可以了。
/*
* 衣服
* 001 男装
* 上衣 20
* 裤子 12
* 001 女装
* 裙子 30
* 裤子 20
*/
public class HashMapDemo3 {
public static void main(String[] args) {
//创建集合对象
HashMap<String, HashMap<String, Integer>> clothes = new HashMap<String, HashMap<String,Integer>>();
//创建男装对象
HashMap<String,Integer> manClothes = new HashMap<String, Integer>();
manClothes.put("上衣", 20);
manClothes.put("裤子", 12);
//把男装添加到大集合
clothes.put("001", manClothes);
//创建女装对象
HashMap<String,Integer> womanClothes = new HashMap<String, Integer>();
womanClothes.put("裙子", 30);
womanClothes.put("裤子", 20);
//把女装添加到大集合
clothes.put("002", womanClothes);
//遍历集合
Set<String> clothesKeySet = clothes.keySet();
for(String cloth:clothesKeySet){
System.out.println(cloth);
//键对应的值又是一个集合。同样的方式遍历就可以了
HashMap<String, Integer> clothesMap = clothes.get(cloth);
Set<String> clothesValueSet = clothesMap.keySet();
for(String clothesValueKey:clothesValueSet){
Integer clothesValueValue = clothesMap.get(clothesValueKey);
System.out.println("\t"+clothesValueKey+"---"+clothesValueValue);
}
}
}
}
输出:
001
上衣---20
裤子---12
002
裤子---20
裙子---30
HashMap集合的元素是ArrayList
/*
*
* 男歌手
* 周杰伦
* 陈奕迅
* 女演员
* 赵丽颖
* 孙俪
* 女歌手
* 张碧晨
* 张靓颖
*
*
*/
public class HashMapDemo4 {
public static void main(String[] args) {
//创建集合对象
HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();
//创建元素集合1
ArrayList<String> array1 = new ArrayList<String>();
array1.add("周杰伦");
array1.add("陈奕迅");
//创建元素集合1
ArrayList<String> array2 = new ArrayList<String>();
array2.add("赵丽颖");
array2.add("孙俪");
//创建元素集合1
ArrayList<String> array3 = new ArrayList<String>();
array3.add("张碧晨");
array3.add("张靓颖");
//把键值对添加到HashMap中
hm.put("男歌手", array1);
hm.put("女演员", array2);
hm.put("女歌手", array3);
Set<String> keySet = hm.keySet();
for(String key:keySet){
System.out.println(key);
//键对应的值是一个ArrayList集合,所以用ArrayList接收
ArrayList<String> value = hm.get(key);
for(String s:value){
System.out.println("\t" + s);;
}
}
}
}
输出:
女歌手
张碧晨
张靓颖
男歌手
周杰伦
陈奕迅
女演员
赵丽颖
孙俪
ArrayList集合的元素是HashMap
public class ArrayListDemo {
public static void main(String[] args) {
//创建集合对象
ArrayList<HashMap<String, String>> arrayList = new ArrayList<HashMap<String,String>>();
//创建元素1
HashMap<String, String> hm1 = new HashMap<String, String>();
hm1.put("梨梨", "可爱");
hm1.put("菜菜", "任性");
//创建元素1
HashMap<String, String> hm2 = new HashMap<String, String>();
hm2.put("熊大", "暖男");
hm2.put("熊二", "傻萌");
//创建元素1
HashMap<String, String> hm3 = new HashMap<String, String>();
hm3.put("熊芭比", "帅气");
hm3.put("熊北鼻", "可爱");
//把元素添加到ArrayList中
arrayList.add(hm1);
arrayList.add(hm2);
arrayList.add(hm3);
//遍历(arrayList中的类型都是HashMap<>类型)
for(HashMap<String, String> hm : arrayList){
//根据值(HashMap)获取对应的键和值
Set<String> keySet = hm.keySet();
for(String key : keySet){
String value = hm.get(key);
System.out.println(key + "," + value);
}
}
}
}
输出:
梨梨,可爱
菜菜,任性
熊二,傻萌
熊大,暖男
熊北鼻,可爱
熊芭比,帅气