java map add_JAVA基础之Map接口

个人理解：

个人感觉Map接口以后会经常用到，可以很清晰地查找某个对象，要熟悉其四种遍历方法。特别注意其键值对的键不能是重复的，有想定义有序存取的话，可以使用LinkedHashMap集合。不过定义自定义对象时，要复写其对象的hashCode和equals方法。静态导入的话，不用编辑器的话可以使用下。再定义方法时有多个参数的话，可以使用可变参数，不过只能一个且在最后面。Collections的工具类可以对数据进行升序和打乱顺序。集合是可以嵌套的。

详见https://blog.csdn.net/zhangqunshuai/article/details/80660974

一、Map接口概述：

Map接口下的集合与Collection接口下的集合存储数据的不同在于：

Map中的集合，元素是以键值对的形式存在的，但是集合中不能包含重复的键，值可以重复，每个键只能对应一个值。常用集合为HashMap集合、LinkedHashMap集合(有序)。

二、常用方法：

1、get()：获取指定键对应的值；

2、put():将指定的键与值对应起来，并添加到集合中，返回对应的值，无的话返回null;

3、remove()：移除

三、Map集合遍历键找值方式：

keySet() 返回此key所在的Set集合

importjava.util.HashMap;importjava.util.Iterator;importjava.util.Map;importjava.util.Set;public classDemo01 {public static voidmain(String[] args) {

Map map=new HashMap();

map.put("1","a");

map.put("2","a");

map.put("3","b");

map.put("3","c");//删除元素

map.remove("3");//System.out.println(map.get("3"));//ketset遍历集合//1.获取所有key的set集合

/*Set set=map.keySet();

//2.遍历set集合取到每一个key

for(String key:set){

//3.根据每个key获取每个值

System.out.println(key+"...."+map.get(key));

}*/

//使用迭代器遍历//1.获取所有key的集合

Set set=map.keySet();//2.获取迭代器对象

Iterator it=set.iterator();//3.判断容器中是否有值

while(it.hasNext()){//获取每一个key值

String key=it.next();//根据每一个key值获取每一个Value值

System.out.println(key+"..."+map.get(key));

}

四、Entry键值对对象：Map.Entry

1、在Map类设计时，提供了一个嵌套接口(又定义一个接口)：Entry。Entry将键值对的对应关系封装成了对象。即键值对对象。

2、方法：

getKey()    返回Entry对象中的键

getValue()  返回Entry对象中的值

entrySet()     用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回

3、Map集合遍历键值对方式：

importjava.util.HashMap;importjava.util.Iterator;importjava.util.Map;importjava.util.Set;public classDemo02 {public static voidmain(String[] args) {

Map map=new HashMap();

map.put("1","a");

map.put("2","a");

map.put("3","b");

map.put("3","c");//entrySet遍历(增强for遍历)//1.获取所有结婚证对象存在的Set集合；

/*Set> set=map.entrySet();

//2.遍历所有结婚证取到每一个结婚证

for(Map.Entry entry:set){

//3.通过每一个结婚证对象获取key

String key=entry.getKey();

//4.通过每一个结婚证对象获取value;

String value=entry.getValue();

System.out.println(key+"...."+value);

}*/

//迭代器遍历

Set> set=map.entrySet();

Iterator> it=set.iterator();while(it.hasNext()){

Map.Entry entry=it.next();

String key=entry.getKey();

String value=entry.getValue();

System.out.println(key+"..."+value);

}

五、HashMap存储自定义类型键值：

1、当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法。

2、如果要保证map中存放的key和取出的顺序一致，可以使用LinkedHashMap集合来存放。

importjava.util.Iterator;importjava.util.LinkedHashMap;importjava.util.Map;importjava.util.Set;public classDemo04 {public static voidmain(String[] args) {

Map map=new LinkedHashMap();

map.put("java0322", new Person("熊三",33));

map.put("java0222", new Person("熊大",22));

map.put("java0611", new Person("熊三",33));//遍历(entrySet迭代器)//获取集合

Set> set=map.entrySet();//获取迭代器对象

Iterator> it=set.iterator();//循环判断下个元素是否有值

while(it.hasNext()){//获取每个对象

Map.Entry entry=it.next();//获取key

String key=entry.getKey();//获取value

Person value=entry.getValue();

System.out.println(key+"..."+value);

}

}

}

六、静态导入：

在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。在源码中经常会出现静态导入。

静态导入格式：

import static XXX.YYY;   导入后YYY可直接使用。

packagecom.oracle.demo02;import staticjava.lang.System.out;import staticjava.lang.Math.PI;public classDemo01 {public static voidmain(String[] args) {

out.println("你好");

out.print("Hello");

out.println(2*PI);

}

}

七、可变参数：

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：

修饰符 返回值类型 方法名(参数类型... 形参名){  }

其实这个书写完全等价与

修饰符 返回值类型 方法名(参数类型[] 形参名){  }

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。

packagecom.oracle.demo02;public classDemo02 {public static voidmain(String[] args) {int sum=add(1,2,3,5,6,11,33,44);

System.out.println(sum);

}//写方法，计算整数参数的和

public static int add(int...a){int sum =0;/*for(int i:a){

sum=sum+i;

}*/

for(int i=0;i

sum=sum+a[i];

}returnsum;

}

}

add方法在同一个类中，只能存在一个。因为会发生调用的不确定性

注意：如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置。

八、Collections集合工具类：

shuffle()    随机置换(只能传list)

sort()    集合元素升序排列

importjava.util.ArrayList;importjava.util.Collections;public classDemo03 {public static voidmain(String[] args) {

ArrayList arr=new ArrayList();

arr.add("a");

arr.add("b");

arr.add("c");

arr.add("d");for(String s:arr){

System.out.print(s+" ");

}

System.out.println();//打乱集合中元素顺序

Collections.shuffle(arr);for(String s:arr){

System.out.print(s+" ");

}

System.out.println();//排序

Collections.sort(arr);for(String s:arr){

System.out.print(s+" ");

}

}

}

九、集合嵌套：

集合嵌套，仅仅是集合内容又是集合，如Collection集合嵌套、Collection集合与Map集合相互嵌套、Map集合嵌套。

packagecom.oracle.demo02;importjava.util.HashMap;importjava.util.Iterator;importjava.util.Map;importjava.util.Set;importcom.oracle.demo01.Person;public classDemo04 {public static voidmain(String[] args) {

HashMap> map=new HashMap>();//第一个小map

HashMap map1=new HashMap();

map1.put(new Person("袁一鸣",21), "java0322");

map1.put(new Person("韩振宇",21), "java0322");//第二个小map

HashMap map2=new HashMap();

map2.put(new Person("孙鹏坤",24), "java0929");

map2.put(new Person("李瑞",21), "php0705");//向大的map存数据

map.put("java班", map1);

map.put("php班", map2);//1、遍历//获取大map中所有的key的所在的Set集合

/*Set bigkeys=map.keySet();

//遍历所有key

for(String bigkey:bigkeys){

//根据bigkey获取小map的对象

HashMap smallmap=map.get(bigkey);

//获取小map所有的key所在的set集合

Set smallkeys=smallmap.keySet();

//遍历小map的key

for(Person smallkey:smallkeys){

//根据smallkey获取对应的value值

System.out.println(bigkey+"..."+smallkey+"..."+smallmap.get(smallkey));

}

}*/

//2、使用迭代器遍历//获取大的Key集合

/*Set bigkeys=map.keySet();

//获取迭代器对象

Iterator bigkey=bigkeys.iterator();

//判断

while(bigkey.hasNext()){

//获取迭代器中每个key值

String bigkey1=bigkey.next();

//根据bigkey1获取小的对象

HashMap smallmap=map.get(bigkey1);

//获取小的key的集合

Set smallkeys=smallmap.keySet();

//获取迭代器对象

Iterator smallkey=smallkeys.iterator();

//判断

while(smallkey.hasNext()){

//获取每个小key

Person smallkey1=smallkey.next();

System.out.println(bigkey1+"..."+smallkey1+"..."+smallmap.get(smallkey1));

}

}*/

//3、entrySet遍历(增强for遍历)//获取大的键值对所在的集合

/*Set>> bigkeys=map.entrySet();

//增强for循环遍历

for(Map.Entry> entry:bigkeys){

//通过每个键值对获取每个大key

String bigkey=entry.getKey();

//获取每个小Map

HashMap smallmap=entry.getValue();

//获取每个小map的小key所在的集合

Set> smallkeys=smallmap.entrySet();

//循环

for(HashMap.Entry smallkey:smallkeys){

//获取每个小key

Person smallkey1=smallkey.getKey();

//获取每个value

String value =smallkey.getValue();

System.out.println(bigkey+"..."+smallkey+"..."+value);

}

}*/

//4、entrySet迭代器遍历//获取大的键值对所在的集合

Set>> bigmaps=map.entrySet();//获取迭代器对象

Iterator>> bigmap=bigmaps.iterator();//判断

while(bigmap.hasNext()){//获得每一个键值对

Map.Entry> bigmap1=bigmap.next();//获取大key

String bigkey=bigmap1.getKey();//获取小map

HashMap smallmap=bigmap1.getValue();//获取小的键值对所在的集合

Set> smallkeys=smallmap.entrySet();//获取迭代器对象

Iterator> smallkey=smallkeys.iterator();//判断

while(smallkey.hasNext()){//获取小键值对

HashMap.Entry smallkey1=smallkey.next();//获取小key

Person smallkey2=smallkey1.getKey();//获取小value

String value=smallkey1.getValue();

System.out.println(bigkey+"..."+smallkey1+"..."+value);

}

}

}

}

十、集合继承体系的面向对象思想

1、接口：用来明确所有集合中该具有的功能，相当于在定义集合功能标准；

2、抽象类：把多个集合中功能实现方式相同的方法，抽取到抽象类实现，具体集合不再遍写，继承使用即可；

3、 具体类：继承抽象类，实现接口，重写所有抽象方法，达到具备指定功能的集合。每个具体集合类，根据自身的数据存储结构方式，对接口中的功能方法，进行不同方式的实现。