Java Map.entry案例详解

   Map.entrySet() 这个方法返回的是一个Set<Map.Entry<K,V>>,Map.Entry 是Map中的一个接口,他的用途是表示一个映射项(里面有Key和Value),而Set<Map.Entry<K,V>>表示一个映射项的Set。Map.Entry里有相应的getKey和getValue方法,即JavaBean,让我们能够从一个项中取出Key和Value。

下面是遍历Map的四种方法:

public static void main(String[] args) {

  Map<String, String> map = new HashMap<String, String>();
  map.put("1", "value1");
  map.put("2", "value2");
  map.put("3", "value3");

  //第一种:普遍使用,二次取值
  System.out.println("通过Map.keySet遍历key和value:");
  for (String key : map.keySet()) {
   System.out.println("key= "+ key + " and value= " + map.get(key));
  }

  //第二种
  System.out.println("通过Map.entrySet使用iterator遍历key和value:");
  Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
  while (it.hasNext()) {
   Map.Entry<String, String> entry = it.next();
   System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
  }

  //第三种:推荐,尤其是容量大时
  System.out.println("通过Map.entrySet遍历key和value");
  for (Map.Entry<String, String> entry : map.entrySet()) {
   System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
  }

  //第四种
  System.out.println("通过Map.values()遍历所有的value,但不能遍历key");
  for (String v : map.values()) {
   System.out.println("value= " + v);
  }
 }

下面是HashMap的源代码:

首先HashMap的底层实现用的时候一个Entry数组

/**
     * The table, resized as necessary. Length MUST Always be a power of two.
     */
   transient Entry[] table; //声明了一个数组
   ........
   public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];//初始化数组的大小为DEFAULT_INITIAL_CAPACITY(这里是16)
        init();
    }

再来看一下Entry是在什么地方定义的,继续上源码,我们在HashMap的源码的674行发现了它的定义,原来他是HashMap的一个内部类,并且实现了Map.Entry接口,以下有些地方是转载

static class Entry<K,V> implements Map.Entry<K,V> {
    final K key;
    V value;
    Entry<K,V> next;
    final int hash;  

    /**
     * Creates new entry.
     */
    Entry(int h, K k, V v, Entry<K,V> n) {
        value = v;
        next = n;
        key = k;
        hash = h;
    }  

    public final K getKey() {
        return key;
    }  

    public final V getValue() {
        return value;
    }  

    public final V setValue(V newValue) {
 V oldValue = value;
        value = newValue;
        return oldValue;
    }  

    public final boolean equals(Object o) {
        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry e = (Map.Entry)o;
        Object k1 = getKey();
        Object k2 = e.getKey();
        if (k1 == k2 || (k1 != null && k1.equals(k2))) {
            Object v1 = getValue();
            Object v2 = e.getValue();
            if (v1 == v2 || (v1 != null && v1.equals(v2)))
                return true;
        }
        return false;
    }  

    public final int hashCode() {
        return (key==null   ? 0 : key.hashCode()) ^
               (value==null ? 0 : value.hashCode());
    }  

    public final String toString() {
        return getKey() + "=" + getValue();
    }  

    /**
     * This method is invoked whenever the value in an entry is
     * overwritten by an invocation of put(k,v) for a key k that's already
     * in the HashMap.
     */
    void recordAccess(HashMap<K,V> m) {
    }  

    /**
     * This method is invoked whenever the entry is
     * removed from the table.
     */
    void recordRemoval(HashMap<K,V> m) {
    }
}  

既然这样那我们再看一下Map.Entry这个接口是怎么定义的,原来他是Map的一个内部接口并且定义了一些方法

  interface Entry<K,V> {
    /**
 * Returns the key corresponding to this entry.
 *
 * @return the key corresponding to this entry
        * @throws IllegalStateException implementations may, but are not
        *         required to, throw this exception if the entry has been
        *         removed from the backing map.
 */
K getKey();  

    /**
 * Returns the value corresponding to this entry.  If the mapping
 * has been removed from the backing map (by the iterator's
 * <tt>remove</tt> operation), the results of this call are undefined.
 *
 * @return the value corresponding to this entry
        * @throws IllegalStateException implementations may, but are not
        *         required to, throw this exception if the entry has been
        *         removed from the backing map.
 */
V getValue();  

    /**
 * Replaces the value corresponding to this entry with the specified
 * value (optional operation).  (Writes through to the map.)  The
 * behavior of this call is undefined if the mapping has already been
 * removed from the map (by the iterator's <tt>remove</tt> operation).
 *
        * @param value new value to be stored in this entry
        * @return old value corresponding to the entry
        * @throws UnsupportedOperationException if the <tt>put</tt> operation
        *         is not supported by the backing map
        * @throws ClassCastException if the class of the specified value
        *         prevents it from being stored in the backing map
        * @throws NullPointerException if the backing map does not permit
        *         null values, and the specified value is null
        * @throws IllegalArgumentException if some property of this value
        *         prevents it from being stored in the backing map
        * @throws IllegalStateException implementations may, but are not
        *         required to, throw this exception if the entry has been
        *         removed from the backing map.
        */
V setValue(V value);  

/**
 * Compares the specified object with this entry for equality.
 * Returns <tt>true</tt> if the given object is also a map entry and
 * the two entries represent the same mapping.  More formally, two
 * entries <tt>e1</tt> and <tt>e2</tt> represent the same mapping
 * if<pre>
        *     (e1.getKey()==null ?
        *      e2.getKey()==null : e1.getKey().equals(e2.getKey()))  &&
        *     (e1.getValue()==null ?
        *      e2.getValue()==null : e1.getValue().equals(e2.getValue()))
        * </pre>
 * This ensures that the <tt>equals</tt> method works properly across
 * different implementations of the <tt>Map.Entry</tt> interface.
 *
 * @param o object to be compared for equality with this map entry
 * @return <tt>true</tt> if the specified object is equal to this map
 *         entry
        */
boolean equals(Object o);  

/**
 * Returns the hash code value for this map entry.  The hash code
 * of a map entry <tt>e</tt> is defined to be: <pre>
 *     (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^
 *     (e.getValue()==null ? 0 : e.getValue().hashCode())
        * </pre>
 * This ensures that <tt>e1.equals(e2)</tt> implies that
 * <tt>e1.hashCode()==e2.hashCode()</tt> for any two Entries
 * <tt>e1</tt> and <tt>e2</tt>, as required by the general
 * contract of <tt>Object.hashCode</tt>.
 *
 * @return the hash code value for this map entry
 * @see Object#hashCode()
 * @see Object#equals(Object)
 * @see #equals(Object)
 */
int hashCode();
   }  

看到这里的时候大伙儿估计都明白得差不多了为什么HashMap为什么要选择Entry数组来存放key-value对了吧,因为Entry实现的Map.Entry接口里面定义了getKey(),getValue(),setKey(),setValue()等方法相当于一个javaBean,对键值对进行了一个封装便于后面的操作,从这里我们其实也可以联想到不光是HashMap,譬如LinkedHashMap,TreeMap 等继承自map的容器存储key-value对都应该使用的是Entry只不过组织Entry的形式不一样,HashMap用的是数组加链表的形式,LinkedHashMap用的是链表的形式,TreeMap应该使用的二叉树的形式,不信的话上源码

LinkedHashMap:

/**
    * The head of the doubly linked list.
    */
/定义了链头
   private transient Entry<K,V> header;  

初始化链表的方法:

void init() {
    header = new Entry<K,V>(-1, null, null, null);
    header.before = header.after = header;
}  

TreeMap:

//定义根节点
 private transient Entry<K,V> root = null;  

再看他的put方法,是不是很面熟(二叉排序树的插入操作)

public V put(K key, V value) {
    Entry<K,V> t = root;
    if (t == null) {
 // TBD:
 // 5045147: (coll) Adding null to an empty TreeSet should
 // throw NullPointerException
 //
 // compare(key, key); // type check
        root = new Entry<K,V>(key, value, null);
        size = 1;
        modCount++;
        return null;
    }
    int cmp;
    Entry<K,V> parent;
    // split comparator and comparable paths
    Comparator<? super K> cpr = comparator;
    if (cpr != null) {
        do {
            parent = t;
            cmp = cpr.compare(key, t.key);
            if (cmp < 0)
                t = t.left;
            else if (cmp > 0)
                t = t.right;
            else
                return t.setValue(value);
        } while (t != null);
    }
    else {
        if (key == null)
            throw new NullPointerException();
        Comparable<? super K> k = (Comparable<? super K>) key;
        do {
            parent = t;
            cmp = k.compareTo(t.key);
            if (cmp < 0)
                t = t.left;
            else if (cmp > 0)
                t = t.right;
            else
                return t.setValue(value);
        } while (t != null);
    }
    Entry<K,V> e = new Entry<K,V>(key, value, parent);
    if (cmp < 0)
        parent.left = e;
    else
        parent.right = e;
    fixAfterInsertion(e);
    size++;
    modCount++;
    return null;
}  

ok,明白了各种Map的底层存储key-value对的方式后,再来看看如何遍历map吧,这里用HashMap来演示吧

Map提供了一些常用方法,如keySet()、entrySet()等方法,keySet()方法返回值是Map中key值的集合;entrySet()的返回值也是返回一个Set集合,此集合的类型为Map.Entry。

so,很容易写出如下的遍历代码

1.  Map map = new HashMap();  

         Irerator iterator = map.entrySet().iterator();  

         while(iterator.hasNext()) {  

                 Map.Entry entry = iterator.next();  

                 Object key = entry.getKey();  

                 //  

         }  

     2.Map map = new HashMap();   

         Set  keySet= map.keySet();  

         Irerator iterator = keySet.iterator;  

         while(iterator.hasNext()) {  

                 Object key = iterator.next();  

                 Object value = map.get(key);  

                 //  

         }
另外,还有一种遍历方法是,单纯的遍历value值,Map有一个values方法,返回的是value的Collection集合。通过遍历collection也可以遍历value,如
[java] view plain copy
Map map = new HashMap();  

Collection c = map.values();  

Iterator iterator = c.iterator();  

while(iterator.hasNext()) {  

       Object value = iterator.next();   

到此这篇关于Java Map.entry案例详解的文章就介绍到这了,更多相关Java Map.entry内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java如何实现实体类转Map、Map转实体类

    实体类转Map.Map转实体类 1.创建entity(User.java) package com.jeff.entity; public class User { private String userName; private String password; private Integer age; public User() { super(); } public User(String userName, String password, Integer age) { super();

  • Java ConcurrentHashMap用法案例详解

    一.概念 哈希算法(hash algorithm):是一种将任意内容的输入转换成相同长度输出的加密方式,其输出被称为哈希值. 哈希表(hash table):根据设定的哈希函数H(key)和处理冲突方法将一组关键字映象到一个有限的地址区间上,并以关键字在地址区间中的象作为记录在表中的存储位置,这种表称为哈希表或散列,所得存储位置称为哈希地址或散列地址. 二.HashMap与HashTable 1,线程不安全的HashMap 因为多线程环境下,使用HashMap进行put操作会引起死循环,导致CP

  • java实现往hive 的map类型字段写数据

    往hive 的map类型字段写数据 该表的该字段类型是map<string,string> 对应类的该属性的类型需要定义成String,不可定义成Map<String,String> !! 方法1: 建表语句定义map的分隔符: row format delimited fields terminated by '|' collection items terminated by ',' map keys terminated by ':' NULL DEFINED AS '' 然

  • Java之HashMap案例详解

    概述 这篇文章,我们打算探索一下Java集合(Collections)框架中Map接口中HashMap的实现.Map虽然是Collctions框架的一部分,但是Map并没有实现Collection接口,而Set和List是实现Collection接口的. 简单来说,HashMap主要通过key存储value值,并且提供了添加,获取和操作存储value的方法.HashMap的实现基于HashTable. HashMap内部呈现 Key-value对在内部是以buckets的方式存储在一起,最终成为

  • Java8中List转Map(Collectors.toMap) 的技巧分享

    前言 在实际项目中我们经常会用到 List 转 Map 操作,在过去我们可能使用的是 for 循环遍历的方式.举个例子: 先定义类: // 简单对象 @Accessors(chain = true) // 链式方法 @lombok.Data class User { private String id; private String name; } 然后有这样一个 List: List<User> userList = Lists.newArrayList( new User().setId(

  • Java遍历Map四种方式讲解

    Java中遍历Map的四种方式 在java中所有的map都实现了Map接口,因此所有的Map(如HashMap, TreeMap, LinkedHashMap, Hashtable等)都可以用以下的方式去遍历. 方法一:在for循环中使用entries实现Map的遍历: /** * 最常见也是大多数情况下用的最多的,一般在键值对都需要使用 */ Map <String,String>map = new HashMap<String,String>(); map.put("

  • java中hashmap的底层数据结构与实现原理

    目录 Hash结构 HashMap实现原理 为何HashMap的数组长度一定是2的次幂? 重写equals方法需同时重写hashCode方法 总结 Hash结构 HashMap根据名称可知,其实现方法与Hash表有密切关系.在讨论哈希表之前,我们先大概了解下其他数据结构在新增,查找等基础操作执行性能. 数组:采用一段连续的存储单元来存储数据.对于指定下标的查找,时间复杂度为O(1):通过给定值进行查找,需要遍历数组,逐一比对给定关键字和数组元素,时间复杂度为O(n),当然,对于有序数组,则可采用

  • Java中详细解析Map接口

    目录 Map详解: Map基本操作: hashMap原理: Put方法: Get方法: Map的遍历: TreeMap LinkedHashMap: 对比下Hashmap.Hashtable和ConcurrentHashmap: 总结 Map详解: 先看图,便于宏观了解Map的地位. Map接口中键和值一一映射. 可以通过键来获取值. 给定一个键和一个值,你可以将该值存储在一个Map对象. 之后,你可以通过键来访问对应的值. 当访问的值不存在的时候,方法就会抛出一个NoSuchElementEx

  • Java Map.entry案例详解

       Map.entrySet() 这个方法返回的是一个Set<Map.Entry<K,V>>,Map.Entry 是Map中的一个接口,他的用途是表示一个映射项(里面有Key和Value),而Set<Map.Entry<K,V>>表示一个映射项的Set.Map.Entry里有相应的getKey和getValue方法,即JavaBean,让我们能够从一个项中取出Key和Value. 下面是遍历Map的四种方法: public static void main

  • Java Structs框架原理案例详解

    1 Struts2框架内部执行过程 Structs请求过程源码分析参考链接http://www.cnblogs.com/liuling/p/2013-8-10-01.html 从上图来看,整个框架的运行过程是围绕着核心过滤器StrutsPrepareAndExecuteFilter展开工作,深入到filter的源码会对理解有所帮助. 一个请求在Struts的处理中大概有以下几个步骤: 客户端初始化一个指向Servlet容器(Tomcat)的请求: 这个请求经过一系列的过滤器(Filter)例如A

  • Java getParameter方法案例详解

    html核心代码 <body> <font size = "5" color ="blue">圆面积计算</font><br> <form action = "home/CCarea" method = "post"> 请输入半径r:<input type="text" name = "radius" value = &q

  • Java DFA算法案例详解

    1.背景 项目中需要对敏感词做一个过滤,首先有几个方案可以选择: 直接将敏感词组织成String后,利用indexOf方法来查询. 传统的敏感词入库后SQL查询. 利用Lucene建立分词索引来查询. 利用DFA算法来进行. 首先,项目收集到的敏感词有几千条,使用a方案肯定不行.其次,为了方便以后的扩展性尽量减少对数据库的依赖,所以放弃b方案.然后Lucene本身作为本地索引,敏感词增加后需要触发更新索引,并且这里本着轻量原则不想引入更多的库,所以放弃c方案.于是我们选定d方案为研究目标. 2.

  • Java Assert.assertEquals案例详解

    junit.framework包下的Assert提供了多个断言方法. 主用于比较测试传递进去的两个参数. Assert.assertEquals();及其重载方法: 1. 如果两者一致, 程序继续往下运行. 2. 如果两者不一致, 中断测试方法, 抛出异常信息 AssertionFailedError . 查看源码, 以Assert.assertEquals(int expected, int actual)为例: /** * Asserts that two ints are equal. 断

  • Java AbstractMethodError原因案例详解

    背景 AbstractMethodError异常对于我来说还是比较不常遇见的,最近有幸遇到,并侥幸的解决了,在这里把此种场景剖析一番,进入正题,下面是AbstractMethodError在Java的异常机制中所处的位置: 现在明确了AbstractMethodError所具有的特性: 1.它是Error的子类,Error类及其子类都是被划分在非检查异常之列的,就是说这些异常不能在编译阶段被检查出来,只能在运行时才会触发. 2.通过API文档里面的解释大致得出的结论就是说A依赖于B,但是执行的时

  • Java DatabaseMetaData用法案例详解

    目录 一 . 得到这个对象的实例 二. 方法getTables的用法 三. 方法getColumns的用法 四.方法getPrimaryKeys的用法 五.方法.getTypeInfo()的用法 六.方法getExportedKeys的用法 一 . 得到这个对象的实例 Connection con ; con = DriverManager.getConnection(url,userName,password); DatabaseMetaData dbmd = con.getMetaData(

  • Java SSM配置文件案例详解

    先对Spring SpringMVC和Mybatis单独进行配置,最后对三者进行整合配置 Spring 实际使用中,一般会使用注解+xml配置来实现spring功能,其中xml配置对上文进行总结,配置内容如下 <?xml version="1.0" encoding="UTF-8"?> <!--在使用spring 相关jar包的时候进行配置 每个jar包对应一个xmlns和schemaLocation路径--> <!--格式基本相关 只

随机推荐