collection集合的全部都已经结束，但是我们发现他都是单列存在的集合，map则是双列存在的集合。
如图：
它是键值存在的集合，键是唯一的，但是值可以不唯一，但是必须一对一唯一。也就是不能重复的。
Map接口中常用集合概述（它的键对，其实就是两个泛型）
通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。
l HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。常用
l LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
l 注意：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。
如前文，集合
①创建对象
Map<string，interger> map=new hashmap <string，integer>();
②常用方法
③遍历重要
它的遍历方式非常特殊。
1.
2.
3.但因为它是通过返回一个set集合，借用set集合的遍历方法进行遍历，也就是说它可以用for或者迭代器Iterator来使用，两两配合，总共有四个方法
代码如下
package com.oracle.demo01;
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集合 hashmap是子类
Map<String,String> map=new HashMap<String,String>();
map.put("a", "123");
map.put("b", "456");
map.put("c", "123");
map.put("a", "147");
//重复的键值存储不了，但会把原先的覆盖掉
//get方法返回的是value值
System.out.println(map.get("a"));
//遍历
//第一种，通过map的keySet（）方法，调取key，通过key获取所有的set。
//keySet+增强for
//1、获取所有key所在的Set集合
//多态
Set<String>set =map.keySet();
//增强for遍历set集合
System.out.println("-----------------------------------keyset()方法+增强for-");
for(String key:set){
System.out.println(key+"..."+map.get(key));
System.out.println("-----------------------------------keyset+Iterator-");
//第二种：keySet +Iterator
Set<String> set1=map.keySet();
//遍历 用变量名.方法名（）
Iterator<String> iterator=set1.iterator();
while(iterator.hasNext()){
String key1=iterator.next();
System.out.println(key1+map.get(key1));
//创建map集合 hashmap是子类
}
}
}
}
package com.oracle.demo01;
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集合
Map<Integer,String>map=new HashMap<Integer,String>();
//put增加内容
map.put(1, "司南");
map.put(2, "周戎");
map.put(3, "楚慈");
//遍历
//1.entrySet+增强for
//1.获取所有结婚证entry对象
System.out.println("==================entrySet+增强for");
Set<Map.Entry<Integer,String>> set=map.entrySet();
//2.遍历结婚证集合获取每一个结婚证entry对象
for(Map.Entry<Integer,String> entry :set){
//因为有返回值，所以接收一下
/* int key=entry.getKey();
String value=entry.getValue();*/
System.out.println(entry.getKey()+"..."+entry.getValue());
}
//entry+Iterator
System.out.println("==================entry+Iterator");
//1.获取所有结婚证对象所在的set集合
Set<Map.Entry<Integer, String>> set2=map.entrySet();
//2.获取iterator对象 这里需要提前声明泛型，要不后面需要向下转换
Iterator<Map.Entry<Integer, String>> it=set2.iterator();
//3.遍历循环
while(it.hasNext()){
//获取每一个结婚证对象这里必须要带有map.entry<>因为这才是里面返回的泛型
Map.Entry<Integer, String> entry1=it.next();
int key1=entry1.getKey();
String value1=entry1.getValue();
System.out.println(key1+"..."+value1);
}
}
}
这里的hashmap集合如果泛型是自定义类，和set一样，需要重写hashcode和equals方法。就不多说了。（因为他是返回set的缘故）也因为hashset的缘故，它的LinkedHashMap也是保证顺序的集合呢。
比较少见的方法
1.静态导入
import static XXXimport static java.lang.System.out;.YYY; 导入后YYY可直接使用。
import static java.lang.System.out;
//导入静态
out.println("lalla");
2.可变参数
修饰符 返回值类型 方法名(参数类型... 形参名){ }
代码案例：
package com.oracle.demo02;
import static java.lang.System.out;
public class Demo01 {
public static void main(String[] args) {
//导入静态
out.println("lalla");
System.out.println(add(1,2));
System.out.println(add(2,3,4));
System.out.println(add(2,3,4,5));
System.out.println(add(2,3,4,5,6));
}
//写一个方法，计算求和,方法类型可以
public static int add(int ...a){//double...b){//可变参数，int [] a数组，如果有另外的可变参数，需要把它写在后面，如果是限定死的参数， 就可以写在前面，好处就是可以无限制的传递参数，但一个里面只能写一个、
int sum=0;
for(int s:a){
sum=sum+s;
}
return sum;
}
/*public static int add(int a,int b,int c){
return a+b;
}*/
}
3.collections集合的工具类
好了，篇幅有点长，下一篇单纯补充两个案例。