2020/7/15 java Map接口 静态导入 可变参数 collections集合工具类

1 判断集合元素唯一的原理

1.1 ArrayList的contains方法判断元素是否重复原理

ArrayList的contains方法会使用调用方法时，传入的元素的equals方法依次与集合中的旧元素所比较，从而根据返回的布尔值判断是否有重复元素。此时，当ArrayList存放自定义类型时，由于自定义类型在未重写equals方法前，判断是否重复的依据是地址值，所以如果想根据内容判断是否为重复元素，需要重写元素的equals方法。

1.2 HashSet的add/contains等方法判断元素是否重复原理

Set集合不能存放重复元素，其添加方法在添加时会判断是否有重复元素，有重复不添加，没重复则添加。

HashSet集合由于是无序的，其判断唯一的依据是元素类型的hashCode与equals方法的返回结果。规则如下：

先判断新元素与集合内已经有的旧元素的HashCode值

l 如果不同，说明是不同元素，添加到集合。

l 如果相同，再判断equals比较结果。返回true则相同元素；返回false则不同元素，添加到集合。

所以，使用HashSet存储自定义类型，如果没有重写该类的hashCode与equals方法，则判断重复时，使用的是地址值，如果想通过内容比较元素是否相同，需要重写该元素类的hashcode与equals方法。

2 Map接口

2.1 Map接口概述

Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

l Map中常用的集合为HashMap集合、LinkedHashMap集合。

2.2 Map接口中常用集合概述

HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

l LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

l 注意：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

2.3 Map接口中的常用方法

put方法：将指定的键与值对应起来，并添加到集合中

get方法：获取指定键(key)所对应的值(value)

remove方法：获取指定键(key)所对应的值(value)

2.4 Map集合遍历键找值方式

1.获取Map集合中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键

2.遍历键的Set集合，得到每一个键

3.根据键，获取键所对应的值

代码演示：

public class MapDemo {
    public static void main(String[] args) {
        //创建Map对象
        Map<String, String> map = new HashMap<String,String>();
        //给map中添加元素
        map.put("邓超", "孙俪");
        map.put("李晨", "范冰冰");
map.put("刘德华", "柳岩");
        //获取Map中的所有key
        Set<String> keySet = map.keySet();
        //遍历存放所有key的Set集合
        Iterator<String> it =keySet.iterator();
        while(it.hasNext()){
            //得到每一个key
            String key = it.next();
            //通过key获取对应的value
            String value = map.get(key);
            System.out.println(key+"="+value);
        }
    }
}

2.5 Entry键值对对象

在Map类设计时，提供了一个嵌套接口：Entry。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

 Entry是Map接口中提供的一个静态内部嵌套接口。

 getKey()方法：获取Entry对象中的键

 getValue()方法：获取Entry对象中的值

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

2.6 Map集合遍历键值对方式

1.获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回

2.遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象

3.通过键值对(Entry)对象，获取Entry对象中的键与值

代码演示

public class MapDemo {
    public static void main(String[] args) {
        //创建Map对象
        Map<String, String> map = new HashMap<String,String>();
        //给map中添加元素
        map.put("邓超", "孙俪");
        map.put("李晨", "范冰冰");
map.put("刘德华", "柳岩");
        //获取Map中的所有key与value的对应关系
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        //遍历Set集合
        Iterator<Map.Entry<String,String>> it =entrySet.iterator();
        while(it.hasNext()){
            //得到每一对对应关系
            Map.Entry<String,String> entry = it.next();
            //通过每一对对应关系获取对应的key
            String key = entry.getKey();
            //通过每一对对应关系获取对应的value
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }
    }
}

注意：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了

2.7 静态导入

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

静态导入格式：

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

2.8 可变参数

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

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

等效于

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

jdk1.5以后。出现了简化操作... 用在参数上，称之为可变参数。

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

2.9 Collections集合工具类

2.10 集合嵌套

集合嵌套并不是一个新的知识点，仅仅是集合内容又是集合，如Collection集合嵌套、Collection集合与Map集合相互嵌套、Map集合嵌套。

ArrayList嵌套 ArrayList

ArrayList< ArrayList<String> >

Collection< ArrayList<Integer> >

 Map嵌套 ArrayList

HashMap<String, ArrayList<Person>>

ArrayList< HashMap<String, String>>

 Map集合嵌套

HashMap<String, HashMap<String,String>>

HashMap<String, HashMap<Person,String>>

Map集合套Map集合演示

四种遍历方法

package ocom.oracle.demo02;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import ocom.oracle.demo01.Person;

public class Demo03 {
    public static void main(String[] args) {
        HashMap<String, HashMap<Person,String>> oracle=new HashMap<String, HashMap<Person,String>>();
         HashMap<Person,String> java0512=new  HashMap<Person,String>();
         java0512.put(new Person("小红",18),"优秀");
         java0512.put(new Person("小白",20),"不及格");
         HashMap<Person,String> java0715=new  HashMap<Person,String>();
         java0715.put(new Person("小绿",25),"良好");
         java0715.put(new Person("小黑",23),"及格");
         oracle.put("java0512", java0512);
         oracle.put("java0715", java0715);
         for(String a:oracle.keySet()){
             System.out.print(a);
             for(Person b:oracle.get(a).keySet()){
                 System.out.print(b+oracle.get(a).get(b));
             }
             System.out.println();
         }
         Iterator<String> aa=oracle.keySet().iterator();
         while(aa.hasNext()){
            String  bb=aa.next();
            System.out.println(bb);
            Iterator<Person> cc=oracle.get(bb).keySet().iterator();
            while(cc.hasNext()){
                Person dd=cc.next();
                System.out.println(dd+oracle.get(bb).get(dd));
            }
            
            for(Map.Entry<String, HashMap<Person,String>> aaa:oracle.entrySet()){
                System.out.println(aaa.getKey());
                for(Map.Entry<Person,String> vvv:aaa.getValue().entrySet()){
                    System.out.println(vvv.getKey()+"..."+vvv.getValue());
                }
            }
             Iterator<Map.Entry<String,HashMap<Person,String>>> qqq=oracle.entrySet().iterator();
             while(qqq.hasNext()){
                 Map.Entry<String,HashMap<Person,String>> mm=qqq.next();
                 System.out.println(mm.getKey());
                 Iterator<Map.Entry<Person,String>>  ww=mm.getValue().entrySet().iterator();
                 while(ww.hasNext()){
                     Map.Entry<Person,String> eee=ww.next();
                     System.out.println(eee.getKey()+".."+eee.getValue());
                 }
             }
         }
         
    }
}