集合的笼统介绍之map

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集合的工具类

好了，篇幅有点长，下一篇单纯补充两个案例。