collection集合--Map

Posted 2022-09-14 layuechuquwan

Map（键值对、键唯一、值不唯一）

核心：　　Map集合中存储的是键值对，键不能重复，值可以重复。根据键得到值，对map集合遍历时先得到键的set集合，对set集合进行遍历，得到相应的值。

l  Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。

l  Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。

l  Collection中的集合称为单列集合，Map中的集合称为双列集合。

l  需要注意:      

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

.                       Map集合中包含HashMap(怎么存不一定怎么取)和LinkHahMap(怎么存就怎么取)

HashMap

数组方式存储key/value，线程非安全，允许null作为key和value，key不可以重复，value允许重复，不保证元素迭代顺序是按照插入时的顺序，key的hash值是先计算key的hashcode值，然后再进行计算，每次容量扩容会重新计算所以key的hash值，会消耗资源，要求key必须重写equals和hashcode方法

.HashMap<K,V>(泛型:键,值):存取数据才有的哈希表结果,元素怎么存不一定怎么取,由于要保证键的唯一不重复,需要重写键的hashcode()和equals()方法

　　默认初始容量16，加载因子0.75，扩容为旧容量乘2，查找元素快，如果key一样则比较value，如果value不一样，则按照链表结构存储value，就是一个key后面有多个value；

方法

1、添加：

　　V put(K key, V value) （可以相同的key值，但是添加的value值会覆盖前面的，返回值是前一个，如果没有就返回null）

　　putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中（可选操作）。

2、删除

　　remove() 删除关联对象，指定key对象

　　clear() 清空集合对象

3、获取

　　value get(key) 可以用于判断键是否存在的情况。当指定的键不存在的时候，返回的是null。

４、判断：

　　boolean isEmpty() 长度为0返回true否则false

　　boolean containsKey(Object key) 判断集合中是否包含指定的key

　　boolean containsValue(Object value) 判断集合中是否包含指定的value

4、长度：

　Int size（）

Hashtable

　　Hashtable与HashMap类似，是HashMap的线程安全版，它支持线程的同步，即任一时刻只有一个线程能写Hashtable，因此也导致了Hashtale在写入时会比较慢，它继承自Dictionary类，不同的是它不允许记录的键或者值为null，同时效率较低。

LinkedHashMap

LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先得到的记录肯定是先插入的，在遍历的时候会比HashMap慢，有HashMap的全部特性

Entry键值对对象Map.Entry<K,V>

思路

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

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

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

 

getKey()    返回Entry对象中的键

getValue()  返回Entry对象中的值

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

 

 

 

遍历

核心思想：利用key键关联

 

第一种：KeySet()
　　将Map中所有的键存入到set集合中。因为set具备迭代器。所有可以迭代方式取出所有的键，再根据get方法。获取每一个键对应的值。 keySet():迭代后只能通过get()取key 。
　　取到的结果会乱序，是因为取得数据行主键的时候，使用了HashMap.keySet()方法，而这个方法返回的Set结果，里面的数据是乱序排放的。

代码展示：

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集合

     Map<String,String> mp= new   HashMap<String,String>();

/*向map存值:map.put("","");Map集合的取值方式:map.get(key)
*/

         mp.put("a", "123");

         mp.put("adin", "1234");

         mp.put("b", "789");

       /*  mp.put("a", "147");重复数据，key存不进去，但value值会覆盖掉，map不能存重复值的键,如果存了重复键，那么后来键对应的值会覆盖前面键的值,但是值可以重复存入,一个键只能对应一个值*/

        // System.out.println(mp.get("a"));

         /*遍历  。遍历不能用增强for:因为Map集合的泛型有俩,不知道遍历哪一个;

*不能用迭代器:因为Map集合没有迭代器对象,迭代器只存在于Collection集合中;不能用普通for:因为没有下标*/

 

//只能用 keyset+增强for的方法

/*思路是：通过增强for遍历key所在的集合,得到每一个key再通过map.get(key)的方式找到key所对应的value的值*/

         //首先获取key所在的set集合

         Set<String> set=mp.keySet();        

         //然后增强for遍历set集合

         for(String k: set) 

                  //get取值

                  System.out.println(k+"..."+mp.get(k));

         

        

         //keyset+iterator

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

         Set<String> set2=mp.keySet();

         //获取迭代器对象,泛型就写和key一样的类型

         Iterator<String> it=set2.iterator();

         while(it.hasNext()) 

                  //接值返回，获取值，遍历key

                  String key=it.next();

                  System.out.println(key+".."+mp.get(key));  /*//因为迭代器是一直向后走,*不能往前走,所以外面得顶一个变量接一下,然后遍历这个变量
 */               

         

         



 

 

entrySet（）
Set<Map.Entry<K,V>> entrySet() //返回此映射中包含的映射关系的 Set 视图。（一个关系就是一个键-值对），就是把(key-value)作为一个整体一对一对地存放到Set集合当中的。Map.Entry表示映射关系。entrySet()：迭代后可以e.getKey()，e.getValue()两种方法来取key和value。返回的是Entry接口。

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<Integer,String>map=new HashMap<Integer,String>();

          map.put(1, "英短");

          map.put(2, "三花");

          map.put(3, "乌龙");

         //entryset+增强for

          //获取所有结婚对象

          Set<Map.Entry<Integer,String>> set=map.entrySet();

/*这里的entry是map类的成员内部类,通过外部成员名.内部成员名<>的方式调用
这里是把map的所有的键和值都封装成一个个的entry对象,在把这些entry对象存到一个Set集合里面,
然后通过增强for遍历set集合里的每一个entry对象,*/

          //2.遍历 增强for遍历set集合里的每一个entry对象

          for(Map.Entry<Integer,String> entry:set) 

 

    /*这里的增强for的泛型
就写set里的泛型就是map的entry对象,得到每个entry对象后再定义向下类型的变量来接收key和value值,通过entry.getkey()得键,entry.getvalue()得值
*/

  

                   int key=entry.getKey();

                   String value=entry.getValue();

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

          

//迭代器遍历

   /*在定义完map集合并把entry对象赋值到Set集合后,定义迭代器对象Iterator<Map.entry<String,String>> it=set.iterator;这里泛型和set的一样,获取到
**/

          //enttryset+Inteator 遍历这里定义个entry对象接收it.next()遍历后得到的entry对象,然后通过
                   entry.getkey()得键;entry.getvalue()得值*/

          //集合获取每一个entry对象

          Set<Map.Entry<Integer,String>> set2=map.entrySet();

          //获取迭代器对象

          Iterator<Map.Entry<Integer,String>> it=set2.iterator();

          //循环遍历

          while(it.hasNext())

                  Map.Entry<Integer,String>  entry=it.next();

                  int key =entry.getKey();

                  String value=entry.getValue();

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

          

         

         

 

 

HashMap存储自定义类型键值

package com.oracle.Demo01;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

 

public class demo03 

    public static void main(String[] args) 

           Map<Person,String>  map=new HashMap<Person,String>();

//如果key存的是重复值那么就需要要自定义类里面重写Equals方法和hascode方法,如果是值那么就不用了,因为可以存重复值
                        map.put(键，值, );

           map.put(new Person("大咪",12), "java0611");

           map.put(new Person("小咪",10), "java0611");

           map.put(new Person("大咪",12), "java0611");

           //

           //遍历;

//通过增强for得到每一个key值然后通过.get()方法得到value值

           Set<Person> set=map.keySet();

           for(Person p:set) 

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

/* Person [name=大咪, age=12]..java0611

*Person [name=小咪, age=10]..java0611*/

           

 

           遍历的方式有两种,

1.通过keyset()方法把key值都存到一个Set集合里面;

再通过增强for(通过得到的key值，在用.get(key)方法得到value值
2.通过keyset()方法把key值都存到一个set的集合里面用过迭代器(itaretor)得到每一个key值,再通过.get(key)方法得到value值

 

entry()方法遍历:

通过.entry()方法得到set集合对象把map里的每一对key和value封装成一个对象,通过变量对象后用.getkey()和.getvalue()方法来得到值,

1.增强for遍历:for(对象的类型<> 变量名:对象所在的set集合)得到每一个set封装的enty对象;通过entry对象.getkey()和.getvalue()方法得到相应的值然后打印;
2.通过迭代器遍历:把Map中的每一个entry对象封装到Set集合里面,定义迭代器对象,泛型是entry对象,再用while进行遍历,得到的it.next()
实际上就是entry对象,再通过.getkey()和.getvalue()得到相应的key和value