精华内容
下载资源
问答
  • HashMap和Hashtable,TreeMap的区别

    千次阅读 2017-09-13 14:05:57
    1.HashMap和Hashtable以及TreeMap都实现了Map接口; 2.HashMap和TreeMap是非线程安全的,而Hashtable是线程安全的,因为Hashtable里的方法使用Synchronize关键字修饰的; 3.因为HashTable使用了Synchronize关键字...

    1.HashMap和Hashtable以及TreeMap都实现了Map接口;
    2.HashMap和TreeMap是非线程安全的,而Hashtable是线程安全的,因为Hashtable里的方法使用Synchronize关键字修饰的;
    3.因为HashTable使用了Synchronize关键字修饰,其性能比较差;而且HashMap中的key和value值都能为null值Hashtable中的key和value值都不能为null

    4、TreeMap中的数据是根据key值对象中的对比方法(comparaTo)的运行结果进行。而HashMap 和Hashtable的key值分布都是以哈希分布的方式存放 ,同时TreeMap也是线程不同步的

    展开全文
  • HashMap TreeMap Hashtable LinkedHashMap 区别

    千次阅读 2015-09-27 14:18:18
    map是java中最常用的数据结构之一,在这篇文中,我将说明如何使用不同类型的maps,比如:HashMapTreeMapHashTable和LinkedHashMap。 Map概览 在java SE 中有4个Map常用的实现,分别是HashMapTreeMap,...

    map是java中最常用的数据结构之一,在这篇文中,我将说明如何使用不同类型的maps,比如:HashMap,TreeMap,HashTable和LinkedHashMap。

    Map概览


    在java SE 中有4个Map常用的实现,分别是HashMap,TreeMap,HashTable和LinkedHashMap。用一句话来描述这四个实分别是:

    HashMap是hash table的一个实现,它中的键值是无序的。

    TreeMap是基于红黑树结构的一个实现,它是根据key来排序的。

    LinkedHashMap保留了插入的顺序。

    HashTabe是同步的,与HashMap相比,它有个同步的开销,因此如果程序是线程安全的,那么HashMap是个不错的选择。

    HasMap

    如果HashMap的key是自己定义的对象,那么equals()和hashCode()需要同样遵守规则:
    class Dog {
    	String color;
     
    	Dog(String c) {
    		color = c;
    	}
    	public String toString(){	
    		return color + " dog";
    	}
    }
     
    public class TestHashMap {
    	public static void main(String[] args) {
    		HashMap<Dog, Integer> hashMap = new HashMap<Dog, Integer>();
    		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<Dog, Integer> entry : hashMap.entrySet()) {
    			System.out.println(entry.getKey().toString() + " - " + entry.getValue());
    		}
    	}
    }

    输出的结果:
    4
    white dog - 5
    black dog - 15
    red dog - 10
    white dog - 20

    注意:我们错误的添加了两个“white dogs”,但是HashMap都接受了,这并没有意义,因为现在很疑惑到底有多少个白狗

    对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不允许有两个相同的元素,默认情况下,hashcode()和equals()方法在对象的实现时使用,默认hashcode()方法给不同对象不同的整数,equals()方法只有在两个引用指向同一对象时才会返回true。

    TreeMap

    TreeMap是根据key进行排序的,让我们先来看看下边这个例子来理解什么事根据key排序
    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 TestTreeMap {
    	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<Dog, Integer> treeMap = new TreeMap<Dog, Integer>();
    		treeMap.put(d1, 10);
    		treeMap.put(d2, 15);
    		treeMap.put(d3, 5);
    		treeMap.put(d4, 20);
     
    		for (Entry<Dog, Integer> entry : treeMap.entrySet()) {
    			System.out.println(entry.getKey() + " - " + entry.getValue());
    		}
    	}
    }

    输出的结果:

    Exception in thread "main" java.lang.ClassCastException: collection.Dog cannot be cast to java.lang.Comparable
    	at java.util.TreeMap.put(Unknown Source)
    	at collection.TestHashMap.main(TestHashMap.java:35)

    因为TreeMaps是根据key来排序的,这个对象key必须能够互相比较,这就是为什么Dog要实现Comparable接口。例如,你利用String作为key,因为String实现了Comparable接口。
    现在我们重新定义Dog,来实现comparable接口:
    class Dog implements Comparable<Dog>{
    	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 TestTreeMap {
    	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<Dog, Integer> treeMap = new TreeMap<Dog, Integer>();
    		treeMap.put(d1, 10);
    		treeMap.put(d2, 15);
    		treeMap.put(d3, 5);
    		treeMap.put(d4, 20);
     
    		for (Entry<Dog, Integer> entry : treeMap.entrySet()) {
    			System.out.println(entry.getKey() + " - " + entry.getValue());
    		}
    	}
    }

    输出结果:

    red dog - 10
    black dog - 15
    white dog - 20

    它是根据键值进行排序的,例如dog的大小,
    如果Dog d4 = new Dog("white",10),被替代为Dog d4 = new Dog("white", 40);输出结果则是
    white dog - 20
    red dog - 10
    black dog - 15
    white dog - 5

    Hashtable 

    来自java DOC的解释:

    HashMap类大致相当于Hashtable,除了它是不同步的和允许是空值的之外。

    LisnkedHashMap

    LinkedHashMap是HashMap的子类,这意味着 它集成了HashMap的特点,除此之外,LinkedHashMap保留了插入时的顺序。让我们用LinkedHashMap代替HashMap,来看看刚才代码的实现:

    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 TestHashMap {
    	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<Dog, Integer> linkedHashMap = new LinkedHashMap<Dog, Integer>();
    		linkedHashMap.put(d1, 10);
    		linkedHashMap.put(d2, 15);
    		linkedHashMap.put(d3, 5);
    		linkedHashMap.put(d4, 20);
     
    		for (Entry<Dog, Integer> entry : linkedHashMap.entrySet()) {
    			System.out.println(entry.getKey() + " - " + entry.getValue());
    		}		
    	}
    }

    输出结果:
    red dog - 10
    black dog - 15
    white dog - 20
    和使用HashMap不同的是,HashMap的插入顺序是没有被保持的。

    red dog - 10
    white dog - 20
    black dog - 15

    原文链接:http://www.programcreek.com/2013/03/hashmap-vs-treemap-vs-hashtable-vs-linkedhashmap/



    //下边是自己加的判断为空的情况

    map == null 是指没有引用的对象。
    map.size() == 0 指map中没有元素。是一个空的集合。
    要判断map是空的。要先判断是不是null 再看size。

    展开全文
  • HashMap和Hashtable以及TreeMap的区别

    千次阅读 2016-12-19 11:47:27
    而且前段时间面试,一般情况下面试官喜欢问HashMap和Hashtable的主要区别,其用意是想问被面试者这俩那个是线程安全的。但是HashMap和Hashtable之间的差别不止线程安全那么简单。两者的主要区别如下: 相同点:都...

        最近用到了这三种集合类,由于不是很熟练,所以想整理下。而且前段时间面试,一般情况下面试官喜欢问HashMap和Hashtable的主要区别,其用意是想问被面试者这俩那个是线程安全的。但是HashMap和Hashtable之间的差别不止线程安全那么简单。两者的主要区别如下:

    相同点:都实现了Map接口,都是轻量级的实现。两者采用的Hash算法几乎一样,所以性能不会有很大的差异。

    1.语法上面的区别:

    1)HashMap允许键值为空,Hashtable不允许。

    2)HashMap包含了containsvalue和containsKey,不包含有contains。

    2.安全方面的区别

    HashTable支持线程安全的,而HashMap不支持线程同步,是非线程安全的。因此,HashMap相对来说效率可能会高于Hashtable。

    3.源码级别的区别

    Hashtable,hash数组默认的大小是11,增加的方式是old*2+1,而HashMap中,hash数组的默认大小是16,而且一定是2的指数。

    相较于HashMap和HashTable,TreeMap是利用红黑树来实现的,实现了SortMap接口,能够对保存的记录根据键进行排序。所以一般需要排序的情况下是选择TreeMap来进行。


    展开全文
  • mapmap基本操作,hashmaphashtable区别,hashmap需要注意的点转载,hashmap,linkedmap,treemap一些总结hashmap和treemap区别 map基本操作,hashmaphashtable区别,hashmap需要注意的点 map存储的是k-v键值对...

    map基本操作,hashmap与hashtable区别,hashmap需要注意的点

      map存储的是k-v键值对映射的数据
           实现子类:
               HashMap:数组+链表(1.7) 数组+链表+红黑树(1.8)
               LinkedHashMap:链表
               TreeMap:红黑树
           基本api操作:
               增加:
                   put(k,v)    添加元素
               查找:
                   isEmpty      判断是否为空
                   size        返回map的大小
                   containsKey
                   containsValue
                   get
               删除:
                   clear 清空集合中的所有元素
                   remove:删除指定元素
                   
          Map.entry:表示的是K-V组合的一组映射关系,key和value成组出现
          
          hashmap跟hashtable的区别:
           1、hashmap线程不安全,效率比较高,hashtable线程安全,效率低
           2、hashmap中key和value都可以为null,(只允许一个key为null),hashtable不允许为空
           
           hashmap中需要注意点:
           a:为什么hashmap初始值为2的N次幂,
               1、2的N次幂减1的二进制为...11111,这样在进行hash(key)操作的时候,可以把
               取余运算转换成与运算,&要比取模运算效率要高
               hash & (initCapacity-1)
               2、在扩容之后涉及到元素的迁移过程,如果hashmap初始值为2的N次幂,迁移的
               时候只需要判断原key值得二进制的前一位是0或者是1即可(比如第一次扩容,本
               来只看后四位,因为16-1=15的二进制是01111,扩容是乘2,即左移一位,所以要
               看11111,后四位还是1,所以只需要看原本key值二进制的倒数第5位是0是1即可)
                   如果是0,表示新数组和就数组的下标位置不变,如果是1,只需要将索引位置加上旧的数组的长度值即为新数组的下标
           b: 如果在hashmap同一位置有8个Node,为了提高查询效率,在7个的时候就开始讲这条链表转化为红黑树
           c:扩容操作是table.length*2,左移一位
           d: hashmap在构造函数中没有申请地址空间,在put函数中才申请了地址空间。
           e:扩容后元素迁移时,同一个位置的顺序会反过来(头插法)
           f: 扰动函数:return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);使计算哈希
           值得时候包含了低16位和高16位的特征,从而使哈希值更加不确定来减少碰撞的频率
           g:HashMap默认初始容量为16,负载因子loadFactor为0.75,也就是说只能存储12个元素,当put第13个元素时就需要resize数组将容量扩充到32。
           h:简单翻译一下就是在理想情况下,使用随机哈希码,节点出现的频率在hash桶中遵循泊松分布,同时给出了桶中元素个数和概率的对照表。当桶中元素到达8个的时候,概率已经变得非常小,也就是说用0.75作为加载因子,每个碰撞位置的链表长度超过8个是几乎不可能的。
           i:static class Node<K,V> implements Map.Entry<K,V> {
    			  final int hash;
    			  final K key;
      			volatile V val;
     			 volatile Node<K,V> next;
     			 ...
    			}
    			value和next指针使用了volatile来保证其可见性
    
     
    

    concurrenthashmap和hashtable区别

    1. concurrenthashmap的内部实现和hashmap大部分操作是相同的,例如:
    • 初始化【默认大小16,2的n次幂,这样hash(key)操作的时候,可以把取余运算转换成与运算,&要比取模运算效率要高,hashcode & (initCapacity-1)】,
    • 扩容【扩容因子默认0.75:简单翻译一下就是在理想情况下,使用随机哈希码,节点出现的频率在hash桶中遵循泊松分布,同时给出了桶中元素个数和概率的对照表。当桶中元素到达8个的时候,概率已经变得非常小,也就是说用0.75作为加载因子,每个碰撞位置的链表长度超过8个是几乎不可能的。
    • 链表向红黑树的转变【如果在hashmap同一位置有8个Node,为了提高查询效率,在7个的时候就开始讲这条链表转化为红黑树】等。
    1. ConcurrentHashmap大量使用了CAS方法,大大降低锁带来的性能消耗。 在ConcurrentHashMap中还定义了三个原子操作,用于对指定位置的节点进行操作。这三种原子操作被广泛地使用在ConcurrentHashMap的get和put等方法中。
    // 获取tab数组的第i个node
    static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
        return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
    }
    // 利用CAS算法设置i位置上的node节点。在CAS中,会比较内存中的值与你指定的这个值是否相等,如果相等才接受
    static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                        Node<K,V> c, Node<K,V> v) {
        return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
    }
    // 利用volatile方法设置第i个节点的值,这个操作一定是成功的。
    static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
        U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
    }
    

    JDK8中ConcurrentHashMap的实现使用的是锁分离思想,只是锁住的是一个node,而锁住Node之前的操作是基于在volatile和CAS之上无锁并且线程安全的。

    concurrentHashmap是如何实现线程安全的

    –init–:在put函数中会进行init操作,这里可能存在线程安全问题,即多个线程对同一个map同时进行初始化。因此ConcurrentHashMap在进行初始化数组的时候使用了乐观锁CAS操作来决定到底哪个线程有资格进行初始化,其他线程只能等待,主要使用的方法有:

    • volatile变量(sizeCtl):它是一个标记位,用来告诉其他线程这个坑位有没有人在,其线程间的可见性由volatile保证。
    • CAS操作:CAS操作保证了设置sizeCtl标记位的原子性,保证了只有一个线程能设置成功。

    –put–:该容器减小了锁的粒度,若Hash完美不冲突的情况下,可以同时支持n个线程同时put操作,n为Node数组大小,在默认大小16下,可以支持最大同时16个线程无竞争同时操作且线程安全。当hash冲突严重时,Node链表越来越长,将导致严重的锁竞争,此时会进行扩容,将Node进行再散列,下面会介绍扩容的线程安全性。总结一下用到的并发技巧:

    • 减小锁粒度:将Node链表的头结点作为锁,若在默认大小16的情况下,将有16把锁,大大减小了锁金正,这样可以将串行的部分大大缩小,在理想情况下,线程的put操作都为并行操作。同时直接锁住头结点,保证了线程安全。
    • Unsafe的getObjectVolatile方法:此方法确保获取到的值是最新的。

    –扩容–:在扩容时,ConcurrentHashMap支持多线程并发扩容,在扩容过程中同时支持get查数据,若有线程put数据,还会帮助一起扩容,这种无阻塞算法,将并行最大化的设计,堪称一绝。

    • 在进行迁移时要分低位Node和高位Node,低位Node链表放入原下标处,高位Node则需要加上原Node数组的长度。这样就可以保证高位Node在迁移到新的Node数组中依然可以使用hash算法散列到对应的下标的数组中了。
    • 最后将原Node数组中对应下标Node对象设置为fwd标记Node,表示该节点迁移完成,到这里,一个节点的迁移就完成了,将进行下一个节点的迁移。
    • 迁移过程中的get操作:在get操作的源码中,会判断Node中的hash是否小于0,是否还记得我们的占位Node,其hash为MOVED,为常量值-1,所以此时判断线程正在迁移,委托给fwd占位Node去查找值,

    总结:ConcurrentHashMap运用各类CAS操作,将扩容操作的并发性能实现最大化,在扩容过程中,就算有线程调用get查询方法,也可以安全的查询数据,若有线程进行put操作,还会协助扩容,利用sizeCtl标记位和各种volatile变量进行CAS操作达到多线程之间的通信、协助,在迁移过程中只锁一个Node节点,即保证了线程安全,又提高了并发性能。

    转载,hashmap,linkedmap,treemap一些总结

    一些转自https://www.jianshu.com/p/57d3497ca720的总结

    Map主要用于存储健值对,根据键得到值,因此不允许键重复(重复会覆盖),但允许值重复。

    1. HashMap

    Hashmap是一个最常用的Map,它根据键的HashCode值存储数据,根据键可以直接获取它的值,具有很快的访问速度。遍历时,取得数据的顺序是完全随机的;

    HashMap最多只允许一条记录的键为Null;允许多条记录的值为Null;

    HashMap不支持线程的同步(非线程安全),即任一时刻可以有多个线程同时写HashMap,可能会导致数据的不一致;

    同步,可以用Collections的synchronizedMap方法使HashMap具有同步的能力,或者使用ConcurrentHashMap。

    在Map中插入、删除和定位元素,HashMap是最好的选择。

    AbstractMap抽象类,(HashMap继承AbstractMap)覆盖了equals()和hashCode()方法以确保两个相等映射返回相同的哈希码。如果两个映射大小相等、包含同样的键且每个键在这两个映射中对应的值都相同,则这两个映射相等。

    HashMap():构建一个空的哈希映像

    HashMap(Map m):构建一个哈希映像,并且添加映像m的所有映射

    HashMap(int initialCapacity):构建一个拥有特定容量的空的哈希映像

    HashMap(int initialCapacity, float loadFactor):构建一个拥有特定容量和加载因子的空的哈希映像

    1. HashTable

    HashTable与HashMap类似,它不允许记录的键或者值为空;

    支持线程的同步(线程安全),即任一时刻只有一个线程能写HashTable,因此导致了Hashtable在写入时会比较慢。

    1. LinkedHashMap

    LinkedHashMap是HashMap的一个子类;

    LinkedHashMap保存了记录的插入顺序,在用Iterator遍历LinkedHashMap时,先得到的记录肯定是先插入的;

    在遍历的时候会比HashMap慢,不过有种情况例外,当HashMap容量很大,实际数据较少时,遍历起来可能会比LinkedHashMap慢,因为LinkedHashMap的遍历速度只和实际数据有关,和容量无关,而HashMap的遍历速度和他的容量有关。

    1. TreeMap

    TreeMap实现SortMap接口,能够把它保存的记录根据键排序,默认是按键值的升序排序,也可以指定排序的比较器。当用Iterator遍历TreeMap时,得到的记录是排过序的。

    TreeMap取出来的是排序后的键值对。但如果您要按自然顺序或自定义顺序遍历键,那么TreeMap会更好。

    TreeMap基于红黑树实现。TreeMap没有调优选项,因为该树总处于平衡状态。

    非线程安全

    TreeMap():构建一个空的映像树

    TreeMap(Map m):构建一个映像树,并且添加映像m中所有元素

    TreeMap(Comparator c):构建一个映像树,并且使用特定的比较器对关键字进行排序

    TreeMap(SortedMap s):构建一个映像树,添加映像树s中所有映射,并且使用与有序映像s相同的比较器排序

    1. 总结及注意

    HashSet是通过HashMap实现的,TreeSet是通过TreeMap实现的,只不过Set用的只是Map的key;

    Map的key和Set都有一个共同的特性就是集合的唯一性。TreeMap更是多了一个排序的功能。

    hashCode和equal(),HashMap因为无需排序所以只需要关注定位和唯一性即可。

    hashCode是用来计算hash值的,hash值是用来确定hash表索引的;

    hash表中的一个索引处存放的是一张链表,所以还要通过equal方法循环比较链上的每一个对象才可以真正定位到键值对应的Entry;

    put时,如果hash表中没定位到,就在链表前加一个Entry;如果定位到了,则更换Entry中的value,并返回旧value。

    由于TreeMap需要排序,所以需要一个Comparator为键值进行大小比较。当然也是用Comparator定位的。

    Comparator可以在创建TreeMap时指定;

    如果创建时没有确定,那么就会使用key.compareTo()方法,这就要求key必须实现Comparable接口;

    TreeMap是使用Tree数据结构实现的,所以使用compare接口就可以完成定位。

    Collection没有get()方法来取得某个元素,只能通过iterator()遍历元素。

    一般使用ArrayList,用LinkedList构造堆栈stack、队列queue。

    LinkedList是由列表实现的List。对顺序访问进行了优化,向List中间插入与删除得开销不大,随机访问则相对较慢(可用ArrayList代替)。它具有方法addFirst()、addLast()、getFirst()、getLast()、removeFirst()、removeLast(),这些方法(没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。

    Map中元素,可以将key序列、value序列单独抽取出来。

    使用keySet()抽取key序列,将map中的所有keys生成一个Set。

    使用values()抽取value序列,将map中的所有values生成一个Collection。

    hashmap和treemap区别

    Map:在数组中是通过数组下标来对 其内容进行索引的,而Map是通过对象来对 对象进行索引的,用来 索引的对象叫键key,其对应的对象叫值value;

    1、HashMap是通过hashcode()对其内容进行快速查找的;HashMap中的元素是没有顺序的;

    TreeMap中所有的元素都是有某一固定顺序的,如果需要得到一个有序的结果,就应该使用TreeMap;
    

    2、HashMap和TreeMap都不是线程安全的;

    3、HashMap继承AbstractMap类;覆盖了hashcode() 和equals() 方法,以确保两个相等的映射返回相同的哈希值;

     TreeMap继承SortedMap类;他保持键的有序顺序;
    

    4、HashMap:基于hash表实现的;使用HashMap要求添加的键类明确定义了hashcode() 和equals() (可以重写该方法);为了优化HashMap的空间使用,可以调优初始容量和负载因子;

     TreeMap:基于红黑树实现的;TreeMap就没有调优选项,因为红黑树总是处于平衡的状态;
    

    5、HashMap:适用于Map插入,删除,定位元素;

     TreeMap:适用于按自然顺序或自定义顺序遍历键(key);
    
    展开全文
  • 前言:HashMapHashtableTreeMap都是java.util.Map接口的实现类,都是通过key-value存储。不同的是,TreeMap同时又实现了SortMap接口,能够把它保存的记录根据键排序。WeakHashMap是HashMap的一个子类。 ...
  • HashMapHashTable和TreeMap 是Map接口下三个重要的集合类。 树默认的是红黑树算法 HashMap 默认的初始化大小是16 static final int DEFAULT_INITIAL_CAPACITY = 1 &lt;&lt; 4; 最大容量是2的30...
  • 一、HashMap(数组+链表+红黑树) 1、HashMap根据键的hashCode值存储数据,大多数情况下可以直接定位到它的值,因而具有很快的访问速度,但遍历顺序却是不确定的。 2、HashMap最多只允许一条记录的键为null,允许多...
  • TreeMap是 有序的,HashMap和HashTable是无需的 HashTable的方法是同步的,HashMap的方法不是同步的,这是两者最主要的区别。这就意味着HashTable是线程安全的,HashMap不是线程安全的。HashMap效率较高,HashTable...
  • 它有四个实现类,分别是HashMap Hashtable LinkedHashMap 和TreeMap. Map主要用于存储健值对,根据键得到值,因此不允许键重复(重复了覆盖了),但允许值重复。 Hashmap 是一个最常用的Map,它根据键的HashCode值存储...
  • Java为数据结构中的映射定义了一个接口java.util.Map,包括3个实现类:HashMap、HashTable和TreeMapHashMap和HashTable都采用hash法进行索引,但二者还有一些区别。 HashMap HashTable 安全性 不...
  • HashMap HashTable TreeMap WeakHashMap 有哪些区别 java中java.util.Map接口中,包含有:HashMap,HashTable,TreeMap。Map是用来存储键值对的数据结构,在数组中通过数组下标来对其内容索引的,而在Map中,则是...
  • HashMapHashTable和TreeMap有什么不同 答案 HashMap允许使用 null 值和 null 键,不保证映射的顺序恒久不变。 迭代HashMap 实例所需时间与其容量及当前关系数量大小成比例。HashMap 的实例有两个参数影响其性能:...
  • HashMapHashTable和TreeMap都是map接口的子类,而在Map中我们通过对象来对对象进行索引,用来索引的对象叫做key,其对应的对象叫做value。这就是我们平时说的键值对。put时有相同的key,会覆盖该key对应的值。 ...
  • HashMap HashTable TreeMap

    2018-03-02 14:05:05
    V)键值对形式的存储结构,在编程中经常被用到,常用的实现类有:HashMap, HashTable, TreeMap.HashMap的实现原理:HashMap是数组链表的结合体。从图中可以看出,HashMap底层就是一个数组结构,数组中的每一项又.....
  • HashMap和Hashtable探究

    2017-04-29 09:40:45
    java.util包中有一个Map接口,...其中Hashtable显得有点异样,本文主要探究HashMap和Hashtable的不同。HashMap和Hashtable?继承不同 从上图可以看出,HashMap继承自Map接口的一个实现类AbstractMap,而Hashtable则继承
  • java为数据结构中的映射定义了一个接口java.util.Map,而HashMap Hashtable和TreeMap就是它的实现类。Map是将键映射到值的对象,一个映射不能包含重复的键;每个键最多只能映射一个一个值。 Hashmap是一个最常用的...
  • Java为数据结构中的映射定义了一个接口java.util.Map,它有四个实现类,分别是HashMapHashTable、LinkedHashMap和TreeMap。本节实例主要介绍这4中实例的用法和区别 关键技术剖析: Map用于存储键值对,根据键得到...
  • 有关HashMapHashTable、LinkedHashMap和TreeMap用法和区别 Java为数据结构中的映射定义了一个接口java.util.Map,它有四个实现类,分别是HashMapHashTable、LinkedHashMap和TreeMap。本节实例主要介绍这4...
  •  这里面介绍的很详细。...1.hashmaphashtable  都是基于哈希表实现的,每个元素都是一个key--value对,对内部通过单链表解决冲突问题,容量不足时会自动增长,实现了Serializable接口,它支持序列化,实...
  • 它有四个实现类,分别是HashMapHashTable、LinkedHashMap和TreeMap。本节实例主要介绍这4中实例的用法和区别。 关键技术剖析: Map用于存储键值对,根据键得到值,因此不允许键重复,值可以重复。 l (1)...
  • Hashtable LinkedHashMap 和TreeMap.  Map主要用于存储健值对,根据键得到值,因此不允许键重复(重复了覆盖了),但允许值重复。 Hashmap 是一个最常用的Map,它根据键的HashCode值存储数据,根据键可以直接获取它...
  • Java为数据结构中的映射定义了一个接口java.util.Map,它包括3个实现类:HashMapHashTable和TreeMap。 Map是用来存储键值对的数据结构,在数组中通过数组下标来对其内容索引的,而在Map中,则是通过对象来进行...
  • java为数据结构中的映射定义了一个接口java.util.Map,它包括3个实现类:HashMapHashTable和TreeMap。Map是用来存储键值对应的数据结构,在数组的下标来对应其内容索引的,而在Map中,则是通过对象来进行索引,...
  • HashMap HashTable

    2018-07-02 15:19:02
    HashMap HashTable ConcurrentHashMap LinkedHashMap TreeMap1)hashMap可以空键空值, 基于hash算法2)hashTable不允许空键, 基于线程安全(利用synchronized进行方法同步)3)ConcurrentHashMap不允许有空...

空空如也

空空如也

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

hashmap和hashtable和treemap