collection集合--Map

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。

4、判断:

  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

}

}

原文地址:https://www.cnblogs.com/layuechuquwan/p/11438917.html

时间: 2024-10-15 16:26:38

collection集合--Map的相关文章

我所理解Java集合框架的部分的使用(Collection和Map)

所谓集合,就是和数组类似--一组数据.java中提供了一些处理集合数据的类和接口,以供我们使用. 由于数组的长度固定,处理不定数量的数据比较麻烦,于是就有了集合. 以下是java集合框架(短虚线表示接口,长虚线表示抽象类,实线表示类,箭头表示实现接口或者继承)(在网络上找的图,不知道原作者,侵权请联系我删除)(总之,关系很复杂,所以不用记得这个图,只是用来吓吓人而已的). 下面贴上个人理解之精简版之Collection(集)和Map(地图?暂且这么理解吧),话说思维导图蛮好用,以下是两幅思维导图

JAVA集合详解(Collection和Map接口)

在Java的util包中有两个所有集合的父接口Collection和Map,它们的父子关系:            java.util        +Collection 这个接口extends自 --java.lang.Iterable接口           +List 接口               -ArrayList 类              -LinkedList 类              -Vector 类     此类是实现同步的 +Queue 接口         

初识Java集合框架(Iterator、Collection、Map)

1. Java集合框架提供了一套性能优良.使用方便的接口和类,它们位于java.util包中 注意: 既有接口也有类,图中画实线的是类,画虚线的是接口 使用之前须要到导入java.util包 List和Set是Collection的子接口,ArrayList和LinkedList是List的两个实现类,HashSet和TreeSet是Set的两个实现类 重点:ArrayList.LinkedList和HashSet Map接口对应的集合是以K-V键值对的方式存储数据的,不同于Collection

【java读书笔记】——Collection集合之六大接口(Collection、Set、List、Map、Iterator和Comparable)

两个月之前准备软考时,简单的从理论上总结了最经常使用的数据结构和算法,比方:线性表,链表,图.在进行java开发时,jdk为我们提供了一系列对应的类来实现主要的数据结构.jdk所提供的容器API位于java.util包内.本文主要是通过简单的介绍Collection集合,向读者简单阐述各个类的基本定义以及其作用,为后面的学习做一下铺垫. 首先,我们先看一下Collection集合的基本结构: 1.Collection接口 Collection是最基本集合接口,它定义了一组同意反复的对象.Coll

Collection集合 和 Map

Collection |--List:元素是有序的,元素可以重复.因为该集合体系有索引.|--ArrayList:底层的数据结构使用的是数组结构.特点:查询速度很快.但是增删稍慢.线程不同步. List集合特有的迭代器.ListIterator是Iterator的子接口. List两种取出方式:1循环,2迭代 |--LinkedList:底层使用的链表数据结构.特点:增删速度很快,查询稍慢.线程不同步.|--Vector:底层是数组数据结构.线程同步.被ArrayList替代了.因为效率低. 在

Collection集合之六大接口(Collection、Set、List、Map、Iterator和Comparable)

两个月之前准备软考时,简单的从理论上总结了最常用的数据结构和算法,比如:线性表,链表,图.在进行Java开发时,jdk为我们提供了一系列相应的类来实现基本的数据结构.jdk所提供的容器API位于java.util包内.本文主要是通过简单的介绍Collection集合,向读者简单阐述各个类的基本定义以及其作用,为后面的学习做一下铺垫. 首先,我们先看一下Collection集合的基本结构: 1.Collection接口 Collection是最基本集合接口,它定义了一组允许重复的对象.Collec

Java Collection、Map集合总结

1.Java中的Collection集合总结 Collection |---List(存储有序,可重复) |---ArrayList 底层数据结构是数组,查询快,增删慢. 线程不安全.效率高 |---Vector 底层数据结构是数组,查询快,增删慢. 线程安全.效率低. |---LinkedList 底层数据结构是链表,查询慢,增删快. 线程不安全,效率高 |---Set(存储无序,元素唯一) |---HashSet 底层数据结构是哈希表. 依赖hashCode()和equals()两个方法进行

java.util.Map按照key值合并的value的Collection 集合中。

用java实现把多个map的内容合并的一个resultMap中 代码大致如下 /** * @author Shalf */ public class MapUtil { /** * 把partMap数据合并放到resultMap中. * @param resultMap * @param partMap */ public static <T, F, K extends Collection<F>> void merge2ResultMap(Map<T, K> resu

java集合:Collection和Map的介绍

Collection集合://java.util.Collection List接口:    List集合包括List接口以及List接口的所有实现类.List集合中的元素允许重复,元素的顺序就是插入的顺序 List接口常用的实现类:  ArrayList 和 LinkedList ?  ArrayList类:实现了可变的数组允许保存所有元素,包括null,并可以根据索引位置对集合进行快速的随机访问:缺点是向指定的索引位置插入对象或删除对象的速度较慢. ?  LinkedList类采用链表结构保