精华内容
下载资源
问答
  • HashMap HashTable TreeMap

    2018-03-02 14:05:05
    转载自:http://blog.csdn.net/Lucky_bo/article/details/46880519Java中的接口Map由于是(K, V)键值对形式的存储结构,在编程中经常被用到,常用的实现类有:HashMap, HashTable, TreeMap.HashMap的实现原理:...

    转载自:http://blog.csdn.net/Lucky_bo/article/details/46880519


    Java中的接口Map由于是(K, V)键值对形式的存储结构,在编程中经常被用到,常用的实现类有:HashMap, HashTable, TreeMap.

    HashMap的实现原理:

    HashMap是数组和链表的结合体。从图中可以看出,HashMap底层就是一个数组结构,数组中的每一项又是一个链表。当新建一个HashMap的时候,就会初始化一个数组。 
    这里写图片描述

    HashMap是基于hashing的原理,我们使用put(key, value)存储对象到HashMap中,使用get(key)从HashMap中获取对象。当我们给put()方法传递键和值时,我们先对键调用hashCode()方法,返回的hashCode用于找到bucket位置来储存Entry对象。

    延伸: 
    1.“当两个对象的hashcode相同会发生什么? 
    有equals()和hashCode()两个方法,两个对象就算hashcode相同,但是它们可能并不相等因为hashcode相同,所以它们的bucket位置相同,‘碰撞’会发生。因为HashMap使用LinkedList存储对象,这个Entry(包含有键值对的Map.Entry对象)会存储在LinkedList中。

    2.如果两个键的hashcode相同,将如何获取值对象? 
    当我们调用get()方法,HashMap会使用键对象的hashcode找到bucket位置,找到bucket位置之后,会调用keys.equals()方法去找到LinkedList中正确的节点,最终找到要找的值对象。

    3.如果HashMap的大小超过了负载因子(load factor)定义的容量,怎么办? 
    默认的负载因子大小为0.75,也就是说,当一个map填满了75%的bucket时候,和其它集合类(如ArrayList等)一样,将会创建原来HashMap大小的两倍的bucket数组,来重新调整map的大小,并将原来的对象放入新的bucket数组中。这个过程叫作rehashing,因为它调用hash方法找到新的bucket位置。

    HashMap与 HashTable, Treemap的区别 
    (一)HashMap 
    1.HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null; 
    2.HashMap不支持线程的同步,即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步,可以用 Collections的synchronizedMap方法使HashMap具有同步的能力,或者使用ConcurrentHashMap。

    (二)HashTable 
    1.不允许记录的键或者值为空; 
    2.它支持线程的同步,即任一时刻只有一个线程能写Hashtable,因此也导致了 Hashtable在写入时会比较慢。

    (三)TreeMap 
    1.不支持线程的同步; 
    2.基于红黑树(Red-Black tree)的 NavigableMap 实现。该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法。 
    3.TreeMap实现SortedMap接口,能够把它保存的记录根据键排序,默认是按键值的升序排序,也可以指定排序的比较器,当用Iterator 遍历TreeMap时,得到的记录是排过序的。

    附上其他博主实现的HashMap的代码:

    Entry.java

    //Entry.java
    public class Entry<K,V>{
        final K key;
        V value;
        Entry<K,V> next;//下一个结点
    
        //构造函数
        public Entry(K k, V v, Entry<K,V> n) {
            key = k;
            value = v;
            next = n;
        }
    
        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 Entry))
                return false;
            Entry e = (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();
        }
    
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51

    MyHashMap.java

    //MyHashMap.java
    
    //保证key与value不为空
    public class MyHashMap<K, V> {
        private Entry[] table;//Entry数组表
        static final int DEFAULT_INITIAL_CAPACITY = 16;//默认数组长度
        private int size;
    
        // 构造函数
        public MyHashMap() {
            table = new Entry[DEFAULT_INITIAL_CAPACITY];
            size = DEFAULT_INITIAL_CAPACITY;
        }
    
        //获取数组长度
        public int getSize() {
            return size;
        }
    
        // 求index
        static int indexFor(int h, int length) {
            return h % (length - 1);
        }
    
        //获取元素
        public V get(Object key) {
            if (key == null)
                return null;
            int hash = key.hashCode();// key的哈希值
            int index = indexFor(hash, table.length);// 求key在数组中的下标
            for (Entry<K, V> e = table[index]; e != null; e = e.next) {
                Object k = e.key;
                if (e.key.hashCode() == hash && (k == key || key.equals(k)))
                    return e.value;
            }
            return null;
        }
    
        // 添加元素
        public V put(K key, V value) {
            if (key == null)
                return null;
            int hash = key.hashCode();
            int index = indexFor(hash, table.length);
    
            // 如果添加的key已经存在,那么只需要修改value值即可
            for (Entry<K, V> e = table[index]; e != null; e = e.next) {
                Object k = e.key;
                if (e.key.hashCode() == hash && (k == key || key.equals(k))) {
                    V oldValue = e.value;
                    e.value = value;
                    return oldValue;// 原来的value值
                }
            }
            // 如果key值不存在,那么需要添加
            Entry<K, V> e = table[index];// 获取当前数组中的e
            table[index] = new Entry<K, V>(key, value, e);// 新建一个Entry,并将其指向原先的e
            return null;
        }
    
    }
    
    
    展开全文
  • hashmap hashtable treemap

    2017-07-28 19:32:21
    Ø HashMap可以允许存在一个为null的key和任意个为null的value,但是HashTable中的key和value都不允许为null Ø Hashtable的方法是同步的,而HashMap的方法不是   public static void main(String args[]){   ...

    Map接口

    Map接口储存一组成对的键-值对象,提供key(键)到value(值)的映射,Map中的key不要求有序,不允许重复。value同样不要求有序,但可以重复 。

    Entry =Key-Value (键值对)

    Map接口中键和值一一映射. 可以通过键来获取值

    1.Map集合里保存着两组值:

               一组用于保存Map里的key

               一组用于保存Map里的value

    2.key和value可是任何引用类型的数据,key和value都可以为null

    3.key不允许重复,即同一个Map对象的任何两个key通过equals方法比较总是返回false

    4.key和value之间存在单向一对一关系,即通过指定的key,总能找到唯一的、确定的value

    5.所有的key放在一起来看,它们就组成了一个Set集合(无序、不重复),Map提供了一个keySet()方法用于返回Map所有key组成的Set集合

    Map中包括一个内部类:Entry

    Entry类封装了一个key-value对象,Entry包含三个方法

    我们可以把Map理解成一个特殊的Set,只该Set里包含的集合元素是Entry对象,而不是普通的对象,在Map集合中使用 entrySet方法返回一个Entry对象集合

    Hashhap

    HashMap实现了Map接口,继承AbstractMap,它是基于哈希表的 Map 接口的实现(保证键的唯一性),

    以key-value的形式存在


    初始容量:表示哈希表中桶的数量,初始容量是创建哈希表时的容量,就是集合的容量

    加载因子:哈希表在其容量自动增加之前可以达到多满的一种尺度,它衡量的是一个散列表的空间的使用程度,负载因子越大表示散列表的装填程度越高,反之愈小。

     HashMap

    HashMap是引用数据类型

    通过 new 关键字在 Heap 堆中申请空间

    保存其中元素的空间,按照hash码,预设好一个个的空间

    这个空间就是 HashBucket(哈希桶)

    每个桶有自己的Hash编号


    例子:

    public staticvoid main(String args[]){ 

            Map<String,String> maps = newHashMap<String,String>();

            maps.put("A", "苏州");

            maps.put("B", "南京");

            maps.put("C", "无锡");

            for(Map.Entry<String, String>entry:maps.entrySet()){

                 System.out.println(entry.getKey()+"=====>"+entry.getValue());

            }

        }

    Map集合的遍历:

          1、通过内部类Entry进行遍历

          2、通过迭代器进行遍历,先获得Entry的Set集合

          3、通过keySet方法获得键的Set集合,通过遍历键取值

          4、通过map.values()获得所有值,但是不能获得键

    Hashtable:是Map接口的另外一个实现类,和HashMap用法类似,亦有区别

    Ø  Hashtable出现于JDK1.0,HashTable基于Dictionary类(建议学生课下研究Dictionary,扩大知识面)

    Ø  HashMap可以允许存在一个为null的key和任意个为null的value,但是HashTable中的key和value都不允许为null

    Ø  Hashtable的方法是同步的,而HashMap的方法不是

      public static void main(String args[]){ 

       Hashtable<String,Object> table = new Hashtable<String, Object>();  

             //添加元素 

             table.put("A", "中国"); 

              table.put("B", "美国"); 

            table.put("C", "俄罗斯"); 

           for(Map.Entry<String,Object> entry:table.entrySet()){

        System.out.println(entry.getKey()+"------------->"+entry.getValue());

            }           

           System.out.println("===================================="); 

             //通过Enumeration来遍历Hashtable 

             Enumeration<String> enu =table.keys(); 

            while(enu.hasMoreElements()){ 

              String key =enu.nextElement();

                  System.out.println("Enumeration:"+table.keys()+"===>"+key+"====>"+table.get(key)); 

           }  }

     

     

    Ø  TreeMap 是一个有序的key-value集合,它是通过红黑树实现的

    Ø  TreeMap 继承于AbstractMap,所以它是一个Map,即一个key-value集合

    Ø  TreeMap 实现了NavigableMap接口,意味着它支持一系列的导航方法,比如返回有序的key集合

    Ø  TreeMap 实现了Cloneable接口,意味着它能被克隆

    Ø  TreeMap 实现了Java.io.Serializable接口,意味着它支持序列化

     

     

     




    展开全文
  • HashMap HashTable TreeMap 和 WeakHashMap 有哪些区别 java中java.util.Map接口中,包含有:HashMap,HashTable,TreeMap。Map是用来存储键值对的数据结构,在数组中通过数组下标来对其内容索引的,而在Map中,则是...

    HashMap HashTable TreeMap 和 WeakHashMap 有哪些区别

    java中java.util.Map接口中,包含有:HashMap,HashTable,TreeMap。Map是用来存储键值对的数据结构,在数组中通过数组下标来对其内容索引的,而在Map中,则是通过对象来进行索引的,用来索引的对象叫做key,其对应的对象叫做value

    HashMap是一个最常用的Map,它根据键的HashCode值存储数据,根据键可以直接获取它的值,具有很快的访问速度,具有很快的访问速度。由于HashMap和HashTable都采用了hash法进行索引,因此二者具有很多相似之处,它们主要有如下一些区别:

    1.HashMap是HashTable的轻量级实现(非线程安全的实现),它们都完成了Map接口,主要区别在于HashMap允许key和value都为null(但是最多只允许一条记录的键为null,不允许多条记录的值为null),而HashTable不允许!

    2.HashMap把HashTablecontains方法去掉了,改成containsvalue和containsKey,因为contains方法容易让人引起误解。HashTable继承自Dictionary类,而HashMap是Java1.2引进的Map interface的一个实现。

    3.HashTable的方法是线程安全的,而HashMap不支持线程同步,所以它不是线程安全的。在多个线程访问 HashTable时,不需要开发人员对他进行同步,而对于HashMap而言开发人员必须提供额外的同步机制,所以就效率而言HashMap可能高于HashTable

    4.HashTable使用EnumerationHashMap使用Iterator

    5.HashTableHashMap采用的hash/rehash算法几乎一样,所以性能不会有很大的差异

    6.在HashTable中,hash数组默认的大小是11,增加的方式是old×2+11HashMap中,hash数组的默认大小是16而且一定是2的指数

    7.hash值的使用不同,HashTable直接使用对象的hashCode

    以上3种类型中,使用最多的是HashMapHashMap里面存入的键值对在取出时没有固定的顺序,是随机的。一般而言在Map中插入删除和定位元素,HashMap是最好的选择。由于TreeMap实现了SortMap接口,能够把它保存的记录根据键排序,因此取出来的是排序后的键值对,如果需要按自然顺序或自定义顺序遍历键,那么TreeMap会更好。LinkedHashMap是HashMap的一个子类,如果需要输出的顺序和输入的相同,那么用LinkedHashMap可以实现,它还可以按照读取顺序来排列。
    WeakHashMap与HashMap类似,二者的不同之处在与WeakHashMap中的key采用的是"弱引用"的方式,只要WeakHashMap中的key不再被外部引用,它就可以被垃圾回收器回收。而HashMap采用的是"强引用方式",当HashMap中的key没有被外部引用时,只有在这个keyHashMap中删除后,才可以被垃圾回收器回收。

    补充说明

    1.HashTable上下文中,同步是指什么?
    同步就意味着在一个时间点,只能有一个线程可以修改hash表,任何线程在执行HashTable的更新操作前都需要获取对象锁,其他线程则等待锁的释放

    2.实现HashMap的同步
    HashMap可以通过 Map m = Collections.synchronizedMap(new HashMap()) 来达到同步的效果,具体而言,该方法返回一个同步的Map,该Map封装了底层的HashMap的所有方法,使得底层的HashMap即使是在多线程的环境中也是安全的!

    展开全文
  • Map是一个重要的数据结构,本篇文章将介绍如何使用不同的Map,如HashMapTreeMapHashTable和LinkedHashMap。Map概览Java中有四种常见的Map实现,HashMapTreeMapHashTable和LinkedHashMap,我们可以使用一句话...

    Map是一个重要的数据结构,本篇文章将介绍如何使用不同的Map,如HashMap,TreeMap,HashTable和LinkedHashMap。

    Map概览

    2bf45c5f200bebab8dda22f977aeffa5.png

    Java中有四种常见的Map实现,HashMap,TreeMap,HashTable和LinkedHashMap,我们可以使用一句话来描述各个Map,如下:

    HashMap:基于散列表实现,是无序的;TreeMap:基于红黑树实现,按Key排序;LinkedHashMap:保存了插入顺序;Hashtable:是同步的,与HashMap类似;HashMap

    如果HashMap的Key是自己定义的对象,那么一般需要覆盖equals()和hashCode()方法,且要遵循他们之间的约定。

    package simplejava;

    import java.util.HashMap;

    import java.util.Map.Entry;

    class Dog {

    String color;

    Dog(String c) {

    color = c;

    }

    public String toString() {

    return color + " dog";

    }

    }

    public class Q26 {

    public static void main(String[] args) {

    HashMap hashMap = new HashMap();

    Dog d1 = new Dog("red");

    Dog d2 = new Dog("black");

    Dog d3 = new Dog("white");

    Dog d4 = new Dog("white");

    hashMap.put(d1, 10);

    hashMap.put(d2, 15);

    hashMap.put(d3, 5);

    hashMap.put(d4, 20);

    //print size

    System.out.println(hashMap.size());

    //loop HashMap

    for (Entry entry : hashMap.entrySet()) {

    System.out.println(entry.getKey().toString() + " - " +

    entry.getValue());

    }

    }

    }

    结果输出:

    4

    white dog - 5

    red dog - 10

    white dog - 20

    black dog - 15

    注意,我们不小心添加了两个"white dogs“,但是HashMap仍然存储它。这是不合理的,现在我们困惑到底有多少条白狗存入了HashMap,5还是20呢。

    其实,Dog类应该是这样定义的:

    class Dog {

    String color;

    Dog(String c) {

    color = c;

    }

    public boolean equals(Object o) {

    return ((Dog) o).color.equals(this.color);

    }

    public int hashCode() {

    return color.length();

    }

    public String toString() {

    return color + " dog";

    }

    }

    结果输出:

    3

    red dog - 10

    white dog - 20

    black dog - 15

    原因是因为HashMap不允许两个相同的元素存入,默认情况下,Object的hashCode()和equals()会被用于判断两个对象是否相同。默认的hashCode()方法对于不同的对象会返回不同的值,而equals()方法只有当两个引用相等,即指向同一个对象的时候才返回true。如果你不是很清楚,可以自己检验下hashCode()和equals()之间的关系。

    举个例子,可以检验下HashMap中最常用的方法,如iteration,print等。

    TreeMap

    TreeMap是按key排序的,让我们先看下如下代码,了解其“按key排序”思想。

    package simplejava;

    import java.util.Map.Entry;

    import java.util.TreeMap;

    class Dog {

    String color;

    Dog(String c) {

    color = c;

    }

    public boolean equals(Object o) {

    return ((Dog) o).color.equals(this.color);

    }

    public int hashCode() {

    return color.length();

    }

    public String toString() {

    return color + " dog";

    }

    }

    public class Q26 {

    public static void main(String[] args) {

    Dog d1 = new Dog("red");

    Dog d2 = new Dog("black");

    Dog d3 = new Dog("white");

    Dog d4 = new Dog("white");

    TreeMap treeMap = new TreeMap();

    treeMap.put(d1, 10);

    treeMap.put(d2, 15);

    treeMap.put(d3, 5);

    treeMap.put(d4, 20);

    for (Entry entry : treeMap.entrySet()) {

    System.out.println(entry.getKey() + " - " + entry.getValue());

    }

    }

    }

    结果输出:

    Exception in thread "main" java.lang.ClassCastException: simplejava.Dog cannot be cast to java.lang.Comparable

    at java.util.TreeMap.compare(TreeMap.java:1188)

    at java.util.TreeMap.put(TreeMap.java:531)

    at simplejava.Q26.main(Q26.java:34)

    由于TreeSet是基于Key排序的,所以作为key的对象需要相互比较,这就是为什么key需要实现Comparable接口。举个例子,你可以使用字符串作为Key,因为String已经实现了Comparable接口。

    现在,让我们改变一下Dog,让它可比较,如下:

    package simplejava;

    import java.util.Map.Entry;

    import java.util.TreeMap;

    class Dog implements Comparable {

    String color;

    int size;

    Dog(String c, int s) {

    color = c;

    size = s;

    }

    public String toString() {

    return color + " dog";

    }

    @Override

    public int compareTo(Dog o) {

    return o.size - this.size;

    }

    }

    public class Q26 {

    public static void main(String[] args) {

    Dog d1 = new Dog("red", 30);

    Dog d2 = new Dog("black", 20);

    Dog d3 = new Dog("white", 10);

    Dog d4 = new Dog("white", 10);

    TreeMap treeMap = new TreeMap();

    treeMap.put(d1, 10);

    treeMap.put(d2, 15);

    treeMap.put(d3, 5);

    treeMap.put(d4, 20);

    for (Entry entry : treeMap.entrySet()) {

    System.out.println(entry.getKey() + " - " + entry.getValue());

    }

    }

    }

    结果打印:

    red dog - 10

    black dog - 15

    white dog - 20

    在这个例子中,我们是按dog的size来排序的;

    如果"Dog d4 = new Dog("white", 10);"被替换成"Dog d4 = new Dog("white",40);",结果将输出如下信息:

    white dog - 20

    red dog - 10

    black dog - 15

    white dog - 5

    这是因为当前TreeMap使用compareTo()去比较key,不同的size意味着不同的dogs。

    HashTable

    参考java文档:HashMap与HashTable基本类似,除了非同步和允许null外。

    LinkedHashMap

    LinkedHashMap是HashMap的子类,意味着它继承了HashMap的特性,除此之外,LinkedHashMap还保存了插入顺序。

    让我们使用同样的代码,然后将HashMap替换成LinkedHashMap,如下:

    package simplejava;

    import java.util.LinkedHashMap;

    import java.util.Map.Entry;

    class Dog {

    String color;

    Dog(String c) {

    color = c;

    }

    public boolean equals(Object o) {

    return ((Dog) o).color.equals(this.color);

    }

    public int hashCode() {

    return color.length();

    }

    public String toString() {

    return color + " dog";

    }

    }

    public class Q26 {

    public static void main(String[] args) {

    Dog d1 = new Dog("red");

    Dog d2 = new Dog("black");

    Dog d3 = new Dog("white");

    Dog d4 = new Dog("white");

    LinkedHashMap linkedHashMap = new LinkedHashMap();

    linkedHashMap.put(d1, 10);

    linkedHashMap.put(d2, 15);

    linkedHashMap.put(d3, 5);

    linkedHashMap.put(d4, 20);

    for (Entry entry : linkedHashMap.entrySet()) {

    System.out.println(entry.getKey() + " - " + entry.getValue());

    }

    }

    }

    输出结果:

    red dog - 10

    black dog - 15

    white dog - 20

    如果我们使用HashMap,结果如下,区别在于没有保存插入顺序:

    red dog - 10

    white dog - 20

    black dog - 15

    总结

    以上所述是小编给大家介绍的HashMap vs TreeMap vs Hashtable vs LinkedHashMap的相关知识,希望对大家有所帮助,如果大家有任何疑问欢迎给我留言,小编会及时回复大家的!

    展开全文
  • 一类是保存双列数据的Map接口,常见的实现类为Hashmap , Hashtable TreeMap,Properties Map 接口的特点 Hashmap 底层结构 Hashmap 源码 Hashtable 底层结构 Hashtable 源码 **Hashmap Hashtable 对比 ** ...
  • java为数据结构中的映射定义了一个接口java.util.Map,而HashMap HashtableTreeMap就是它的实现类。Map是将键映射到值的对象,一个映射不能包含重复的键;每个键最多只能映射一个一个值。  Hashmap 是一个最...
  • Map: HashMap HashTable TreeMap WeakHashMap HashMap,HashTable,TreeMap都是Map的实现类。 Map是用来存储键值对的数据结构,在数组中通过下标对其内容索引,在Map中,是通过对象来进行索引,用来索引的对象就是...
  • HashMap允许设置key和value为null,key存放是乱序的,不支持线程的同步,即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步,可以用 Collections的synchronizedMap方法使HashMap具有同步...
  • 目录 第9讲 | 对比HashtableHashMapTreeMap有什么不同? 典型回答 考点分析 知识扩展 Map 整体结构 有序 Map HashMap 源码分析 容量、负载因子和树化 精选...
  • 1.HashMap HashTable 是基于hash表实现的 ,而Treee
  • 第1部分 Map概括 Map 是“键值对”映射的抽象接口。 AbstractMap 实现了Map中的绝大部分函数接口。它减少了“Map的实现类”的重复编码。...HashMap, Hashtable, TreeMap, WeakHashMap这4个类是“键值对”映
  • 4.TreeMap 是一个有序的key-value集合,它是通过红黑树实现的。    红黑树是二叉树的一种,每个节点要么是红的,要么是黑色的,根节点是红色的,红色节点的两个儿子一定是黑色的, 每个叶结点(叶结点即指树...
  • 1.TreeMap会对键进行排序,linkedHashmap 键怎么进去,怎么出来 hashMap键和值都没有顺序 ,如果hashMap的键是自定义的对象,则要实现hashcode()和equals(); equals()只有两个引用指向同一个对象时,才会返回true, ...
  • 第1部分 Map概括 Map 是“键值对”映射的抽象接口。 AbstractMap 实现了Map中的绝大部分函数接口。它减少了“Map的实现类”的重复编码。...HashMap, Hashtable, TreeMap, WeakHashMap这4个类是“键值对”映
  • 1.HashMap 是一个最常用的Map,它根据键的HashCode值存储数据,根据键可以直接获取它的值,具有很快的访问速度,遍历时,取得数据的顺序是完全随机的。 HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;...
  • http://kaworu.jpn.org/kaworu/2008-04-10-2.php
  • hashmap hashtable linkedhashmap treemap的区别
  • HashMapHashtable的区别 HashMapHashtable都实现了Map接口,但决定用哪一个之前先要弄清楚它们之间的分别。主要的区别有:线程安全性,同步(synchronization),以及速度。 HashMap几乎可以等价于Hashtable,...
  • 它有四个实现类,分别是HashMap Hashtable LinkedHashMap 和TreeMap. Map主要用于存储健值对,根据键得到值,因此不允许键重复(重复了覆盖了),但允许值重复。 Hashmap 是一个最常用的Map,它根据键的HashCode值存储...
  • java为数据结构中的映射定义了一个接口java.util.Map,四个实现类分别是:HashMap Hashtable LinkedHashMap TreeMap 。 Map的实现类,键不允许重复,键重复时值就会被覆盖;值允许重复。 HashMap: 1.最多允许一条键...
  • import java.util.HashMap;  import java.util.Hashtable;  import java.util.LinkedHashMap;  import java.util.Map;  import java.util.TreeMap;  import java.util.Map.Entry;      public...
  • HashMap 1.允许键、值都是null(键只允许一个,值可以多个) 2.键重复,就直接执行值覆盖 3.顺序是不确定的 4.超过初始容量,将以二倍递增,大数据情况下内存开销大 ...HashTablehashMap基本等...
  • JAVASE基础模块二十六(Map集合 HashMap LinkedHashMap Hashtable TreeMap) MaP集合 在生活中 有一种数据比较常见 比如一个 学号—学生 “s001”----------“张三” “s002”----------“张四” “s003”-------...
  • HashMap Hashtable LinkedHashMap TreeMap WeakHashMap 和ConcurrentMap 区别 java为数据结构中的映射定义了一个接口java.util.Map;它有四个实现类,分别是HashMap Hashtable LinkedHashMap 和TreeMap. Map主要...
  • Hashmap 是一个最常用的Map,它根据键的HashCode值存储数据,根据键可以直接获取它的值,具有很快的访问速度,遍历时,取得数据的顺序是完全随机的。 HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;...
  • Hashtable LinkedHashMap 和TreeMap.  Map主要用于存储健值对,根据键得到值,因此不允许键重复(重复了覆盖了),但允许值重复。 Hashmap 是一个最常用的Map,它根据键的HashCode值存储数据,根据键可以直接获取它...
  • 主要介绍了HashMap vs TreeMap vs Hashtable vs LinkedHashMap的相关知识,非常不错,具有一定的参考借鉴价值,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,867
精华内容 1,546
关键字:

hashmaphashtabletreemap