个人理解：
个人感觉Map接口以后会经常用到，可以很清晰地查找某个对象，要熟悉其四种遍历方法。特别注意其键值对的键不能是重复的，有想定义有序存取的话，可以使用LinkedHashMap集合。不过定义自定义对象时，要复写其对象的hashCode和equals方法。静态导入的话，不用编辑器的话可以使用下。再定义方法时有多个参数的话，可以使用可变参数，不过只能一个且在最后面。Collections的工具类可以对数据进行升序和打乱顺序。集合是可以嵌套的。
一、Map接口概述：
Map接口下的集合与Collection接口下的集合存储数据的不同在于：
Map中的集合，元素是以键值对的形式存在的，但是集合中不能包含重复的键，值可以重复，每个键只能对应一个值。常用集合为HashMap集合、LinkedHashMap集合（有序）。
二、常用方法：
1、get（）：获取指定键对应的值；
2、put():将指定的键与值对应起来，并添加到集合中，返回对应的值，无的话返回null;
3、remove（）：移除
三、Map集合遍历键找值方式：
keySet() 返回此key所在的Set集合
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class Demo01 { public static void main(String[] args) { Map<String,String> map=new HashMap<String,String>(); 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<String> set=map.keySet(); //2.遍历set集合取到每一个key for(String key:set){ //3.根据每个key获取每个值 System.out.println(key+"...."+map.get(key)); }*/ //使用迭代器遍历 //1.获取所有key的集合 Set<String> set=map.keySet(); //2.获取迭代器对象 Iterator<String> it=set.iterator(); //3.判断容器中是否有值 while(it.hasNext()){ //获取每一个key值 String key=it.next(); //根据每一个key值获取每一个Value值 System.out.println(key+"..."+map.get(key)); }
四、Entry键值对对象：Map.Entry<K,V>
1、在Map类设计时，提供了一个嵌套接口（又定义一个接口）：Entry。Entry将键值对的对应关系封装成了对象。即键值对对象。
2、方法：
getKey() 返回Entry对象中的键
getValue() 返回Entry对象中的值
entrySet() 用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回
3、Map集合遍历键值对方式：
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class Demo02 { public static void main(String[] args) { Map<String,String> map=new HashMap<String,String>(); map.put("1","a"); map.put("2","a"); map.put("3","b"); map.put("3","c"); //entrySet遍历（增强for遍历） //1.获取所有结婚证对象存在的Set集合； /*Set<Map.Entry<String,String>> set=map.entrySet(); //2.遍历所有结婚证取到每一个结婚证 for(Map.Entry<String, String> entry:set){ //3.通过每一个结婚证对象获取key String key=entry.getKey(); //4.通过每一个结婚证对象获取value; String value=entry.getValue(); System.out.println(key+"...."+value); }*/ //迭代器遍历 Set<Map.Entry<String,String>> set=map.entrySet(); Iterator<Map.Entry<String,String>> it=set.iterator(); while(it.hasNext()){ Map.Entry<String,String> 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集合来存放。
import java.util.Iterator; import java.util.LinkedHashMap; import java.util.Map; import java.util.Set; public class Demo04 { public static void main(String[] args) { Map<String,Person> map=new LinkedHashMap<String,Person>(); map.put("java0322", new Person("熊三",33)); map.put("java0222", new Person("熊大",22)); map.put("java0611", new Person("熊三",33)); //遍历（entrySet迭代器） //获取集合 Set<Map.Entry<String,Person>> set=map.entrySet(); //获取迭代器对象 Iterator<Map.Entry<String,Person>> it=set.iterator(); //循环判断下个元素是否有值 while(it.hasNext()){ //获取每个对象 Map.Entry<String, Person> entry=it.next(); //获取key String key=entry.getKey(); //获取value Person value=entry.getValue(); System.out.println(key+"..."+value); } } }
六、静态导入：
在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。在源码中经常会出现静态导入。
静态导入格式：
import static XXX.YYY; 导入后YYY可直接使用。
package com.oracle.demo02; import static java.lang.System.out; import static java.lang.Math.PI; public class Demo01 { public static void main(String[] args) { out.println("你好"); out.print("Hello"); out.println(2*PI); } }
七、可变参数：
在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：
修饰符 返回值类型 方法名(参数类型… 形参名){ }
其实这个书写完全等价与
修饰符 返回值类型 方法名(参数类型[] 形参名){ }
只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。
package com.oracle.demo02; public class Demo02 { public static void main(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<a.length;i++){ sum=sum+a[i]; } return sum; } }
add方法在同一个类中，只能存在一个。因为会发生调用的不确定性
注意：如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置。
八、Collections集合工具类：
shuffle() 随机置换（只能传list)
sort() 集合元素升序排列
import java.util.ArrayList; import java.util.Collections; public class Demo03 { public static void main(String[] args) { ArrayList<String> arr=new ArrayList<String>(); 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集合嵌套。
package com.oracle.demo02; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; import com.oracle.demo01.Person; public class Demo04 { public static void main(String[] args) { HashMap<String,HashMap<Person,String>> map=new HashMap<String,HashMap<Person,String>>(); //第一个小map HashMap<Person,String> map1=new HashMap<Person,String>(); map1.put(new Person("袁一鸣",21), "java0322"); map1.put(new Person("韩振宇",21), "java0322"); //第二个小map HashMap<Person,String> map2=new HashMap<Person,String>(); 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<String> bigkeys=map.keySet(); //遍历所有key for(String bigkey:bigkeys){ //根据bigkey获取小map的对象 HashMap<Person,String> smallmap=map.get(bigkey); //获取小map所有的key所在的set集合 Set<Person> smallkeys=smallmap.keySet(); //遍历小map的key for(Person smallkey:smallkeys){ //根据smallkey获取对应的value值 System.out.println(bigkey+"..."+smallkey+"..."+smallmap.get(smallkey)); } }*/ //2、使用迭代器遍历 //获取大的Key集合 /*Set<String> bigkeys=map.keySet(); //获取迭代器对象 Iterator<String> bigkey=bigkeys.iterator(); //判断 while(bigkey.hasNext()){ //获取迭代器中每个key值 String bigkey1=bigkey.next(); //根据bigkey1获取小的对象 HashMap<Person,String> smallmap=map.get(bigkey1); //获取小的key的集合 Set<Person> smallkeys=smallmap.keySet(); //获取迭代器对象 Iterator<Person> smallkey=smallkeys.iterator(); //判断 while(smallkey.hasNext()){ //获取每个小key Person smallkey1=smallkey.next(); System.out.println(bigkey1+"..."+smallkey1+"..."+smallmap.get(smallkey1)); } }*/ //3、entrySet遍历（增强for遍历） //获取大的键值对所在的集合 /* Set<Map.Entry<String,HashMap<Person,String>>> bigkeys=map.entrySet(); //增强for循环遍历 for(Map.Entry<String,HashMap<Person,String>> entry:bigkeys){ //通过每个键值对获取每个大key String bigkey=entry.getKey(); //获取每个小Map HashMap<Person,String> smallmap=entry.getValue(); //获取每个小map的小key所在的集合 Set<HashMap.Entry<Person,String>> smallkeys=smallmap.entrySet(); //循环 for(HashMap.Entry<Person,String> smallkey:smallkeys){ //获取每个小key Person smallkey1=smallkey.getKey(); //获取每个value String value =smallkey.getValue(); System.out.println(bigkey+"..."+smallkey+"..."+value); } }*/ //4、entrySet迭代器遍历 //获取大的键值对所在的集合 Set<Map.Entry<String,HashMap<Person,String>>> bigmaps=map.entrySet(); //获取迭代器对象 Iterator<Map.Entry<String,HashMap<Person,String>>> bigmap=bigmaps.iterator(); //判断 while(bigmap.hasNext()){ //获得每一个键值对 Map.Entry<String,HashMap<Person,String>> bigmap1=bigmap.next(); //获取大key String bigkey=bigmap1.getKey(); //获取小map HashMap<Person,String> smallmap=bigmap1.getValue(); //获取小的键值对所在的集合 Set<HashMap.Entry<Person,String>> smallkeys=smallmap.entrySet(); //获取迭代器对象 Iterator<HashMap.Entry<Person,String>> smallkey=smallkeys.iterator(); //判断 while(smallkey.hasNext()){ //获取小键值对 HashMap.Entry<Person,String> smallkey1=smallkey.next(); //获取小key Person smallkey2=smallkey1.getKey(); //获取小value String value=smallkey1.getValue(); System.out.println(bigkey+"..."+smallkey1+"..."+value); } } } }
十、集合继承体系的面向对象思想
1、接口：用来明确所有集合中该具有的功能，相当于在定义集合功能标准；
2、抽象类：把多个集合中功能实现方式相同的方法，抽取到抽象类实现，具体集合不再遍写，继承使用即可；
3、 具体类：继承抽象类，实现接口，重写所有抽象方法，达到具备指定功能的集合。每个具体集合类，根据自身的数据存储结构方式，对接口中的功能方法，进行不同方式的实现。
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/tech/pnotes/16579.html