精华内容
下载资源
问答
  • 与hashMap基本等价,区别:不允许允许键、值都是null   LinkedHashMap 1.在HashMap基础上保证插入数据的一致性(插入顺序) 2. 允许键、值都是null , 如果键重复,就直接执行值覆盖  3. 读写速度...

    HashMap

    1.允许键、值都是null(键只允许一个,值可以多个)

    2.键重复,就直接执行值覆盖

    3.顺序是不确定的

    4.超过初始容量,将以二倍递增,大数据情况下内存开销大

    5.不支持线程同步,如果需要做同步,需要使用Collections的synchronizedMap方法使HashMap具有同步的能力

    6.读写速度和容量有关

     

    HashTable

    与hashMap基本等价,区别:不允许允许键、值都是null

     

    LinkedHashMap

    1.在HashMap基础上保证插入数据的一致性(插入顺序)

    2. 允许键、值都是null , 如果键重复,就直接执行值覆盖 

    3. 读写速度和数据有关

     

    TreeMap

    在JDK1.8之前或者之后,都直接或间接的实现了SortedMap(排序)接口,把插入的数据默认按照键值得升序排列,也可以指定比较器(Comparator)

     

     

    TreeMap使用

    1.按照键的升序、降序排序

    import java.util.*;
    import java.util.Comparator;
    import java.util.TreeMap;
    public class Main {
    
        public static void main(String[] args) {
            TreeMap<String, User> treeMap = new TreeMap<String, User>(
                    new Comparator<String>() {
                        public int compare(String obj1, String obj2) {
                            // 降序排序
                            // return obj2.compareTo(obj1);
    
                            // 升序排序
                            return obj1.compareTo(obj2);
                        }
                    });
    
    
            treeMap.put("c", new User(12, "44"));
            treeMap.put("a", new User(15, "42"));
            treeMap.put("d", new User(10, "48"));
            treeMap.put("b", new User(19, "86"));
    
            //获取所有的键
            Set<String> keySet = treeMap.keySet();
            for (String key :
                    keySet) {
                //键值排序结果
                System.out.println("key == " + key + "  value = " + treeMap.get(key));
            }
    
        }
    }

    输出:

    key == a  value = User{age=15, score=42}

    key == b  value = User{age=19, score=86}

    key == c  value = User{age=12, score=44}

    key == d  value = User{age=10, score=48}

     

    2.自定义比较器,比较值

    import java.util.*;
    import java.util.Map.Entry;
    
    public class Main2 {
    
        public static void main(String[] args) {
            TreeMap<String, User> treeMap = new TreeMap<String, User>(
                    new Comparator<String>() {
                        public int compare(String obj1, String obj2) {
                            // 降序排序
                            // return obj2.compareTo(obj1);
    
                            // 升序排序
                            return obj1.compareTo(obj2);
                        }
                    });
    
    
            treeMap.put("c", new User(12, "44"));
            treeMap.put("a", new User(15, "42"));
            treeMap.put("d", new User(10, "48"));
            treeMap.put("b", new User(19, "86"));
    
    
            //这里将map.entrySet()转换成list
            List<Entry<String,User>> list = new ArrayList<Entry<String,User>>(treeMap.entrySet());
            //然后通过比较器来实现排序
            Collections.sort(list,new Comparator<Entry<String,User>>() {
                //升序排序
                public int compare(Entry<String, User> o1,
                                   Entry<String, User> o2) {
                    return o1.getValue().getScore().compareTo(o2.getValue().getScore());
                }
    
            });
    
            for(Entry<String,User> mapping:list){
                //键值排序结果
                System.out.println("key == " + mapping + "  value = " + mapping.getValue().toString());
            }
        }
    }

    输出:

    key == a=User{age=15, score=42}  value = User{age=15, score=42}
    key == c=User{age=12, score=44}  value = User{age=12, score=44}
    key == d=User{age=10, score=48}  value = User{age=10, score=48}
    key == b=User{age=19, score=86}  value = User{age=19, score=86}

     

    HashMap、HashTable、LinkedHashMap使用比较简单,根据应用场景使用就好!!!

    展开全文
  • hashmap hashtable linkedhashmap treemap区别

    hashmap

    继承dictionary;线程不同步。如果想使用同步可以使用collections.syschronizedMap或者concurrentHashMap进行同步,允许一个键为null,随机读取数据,读取速度快

     @Test
    	public void testHashMap() {
    		HashMap<Integer, String> map = new HashMap<Integer, String>();
    		// 在map中存入10000个键值对
    		long start = System.currentTimeMillis();
    		for (int i = 0; i < 100000; i++) {
    			map.put(i, "hashvalue " + i);
    		}
    		long end = System.currentTimeMillis();
    		long insertTime=end-start;
    		start = System.currentTimeMillis();
    		// 输出结果
    		for (Integer key : map.keySet()) {
    			System.out.println("key:" + key.valueOf(key) + "  value:"
    					+ map.get(key));
    		}
    		end = System.currentTimeMillis();
    		System.out.println("size:" + map.size());
    		System.out.println("输入花费总时间:" + (insertTime));
    		System.out.println("输出花费总时间:" + (end - start));
    		
    		map.clear();
    		map.put(null, "测试键可以为null");
    		System.out.println(map.get(null));
    	}
    

    
    

    结论:

    从程序结果中可以看出,读取的数据是随机的。一个键可以为null

    hashtable

    继承dictionary;线程同步。不允许为null, 

    @Test
    	public void testHashtable() {
    		Hashtable<Integer, String> map = new Hashtable<Integer, String>();
    		// 在map中存入10000个键值对
    		long start = System.currentTimeMillis();
    		for (int i = 0; i < 100000; i++) {
    			map.put(i, "hashvalue " + i);
    		}
    		long end = System.currentTimeMillis();
    		long insertTime=end-start;
    		start = System.currentTimeMillis();
    		// 输出结果
    		for (Integer key : map.keySet()) {
    			System.out.println("key:" + key.valueOf(key) + "  value:"
    					+ map.get(key));
    		}
    		end = System.currentTimeMillis();
    		System.out.println("size:" + map.size());
    		System.out.println("输入花费总时间:" + (insertTime));
    		System.out.println("输出花费总时间:" + (end - start));
    		map.clear();
    		map.put(null, "测试键可以为null");
    		System.out.println(map.get(null));
    	}
    

    结论:

    读取数据使用散列方式排列,键不能为空,编译可以通过。运行会包空指针异常

    linkedhashmap

    保存了记录的插入顺序,也是按顺序排列的,


    @Test
    	public void testLinkedHashMap() {
    		LinkedHashMap<Integer, String> map = new LinkedHashMap<Integer, String>();
    		// 在map中存入10000个键值对
    		long start = System.currentTimeMillis();
    		for (int i = 0; i < 100000; i++) {
    			map.put(i, "hashvalue " + i);
    		}
    		long end = System.currentTimeMillis();
    		long insertTime = end - start;
    		start = System.currentTimeMillis();
    		// 输出结果
    		for (Integer key : map.keySet()) {
    			System.out.println("key:" + key.valueOf(key) + "  value:"
    					+ map.get(key));
    		}
    		end = System.currentTimeMillis();
    		System.out.println("size:" + map.size());
    		System.out.println("输入花费总时间:" + (insertTime));
    		System.out.println("输出花费总时间:" + (end - start));
    		map.clear();
    		map.put(null, "测试键可以为null");
    		System.out.println(map.get(null));
    	}
    

    
    

    结论:

    Linkedhashmap输出的顺序和输入的相同按顺序排列,Linkedhashmap继承hashmap 所有他的键可以有一个值为null,

    treemap

    采用的是红黑树算法的实现。按自然排序的升序进行排序。

    @Test
    	public void testTreeMap() {
    		TreeMap<Integer, String> map = new TreeMap<Integer, String>();
    		// 在map中存入10000个键值对
    		long start = System.currentTimeMillis();
    		for (int i = 0; i < 100000; i++) {
    			map.put(i, "hashvalue " + i);
    		}
    		long end = System.currentTimeMillis();
    		long insertTime = end - start;
    		start = System.currentTimeMillis();
    		// 输出结果
    		for (Integer key : map.keySet()) {
    			System.out.println("key:" + key.valueOf(key) + "  value:"
    					+ map.get(key));
    		}
    		end = System.currentTimeMillis();
    		System.out.println("size:" + map.size());
    		System.out.println("输入花费总时间:" + (insertTime));
    		System.out.println("输出花费总时间:" + (end - start));
    		map.clear();
    		map.put(null, "测试键可以为null");
    		System.out.println(map.get(null));
    	}
    



    Treemap的键不能为null 查询出来的数据是按顺序排列输出


    展开全文
  • HashMap LinkedHashMap TreeMap区别

    顾名思义LinkedHashMap是比HashMap多了一个链表的结构。与 HashMap相比LinkedHashMap维护的是一个具有双重链表的HashMap,LinkedHashMap支持2中排序一种是插入排序,一种 是使用排序,最近使用的会移至尾部例如 M1 M2 M3 M4,使用M3后为 M1 M2 M4 M3了,LinkedHashMap输出时其元素是有顺序的,而HashMap输出时是随机的,如果Map映射比较复杂而又要求高效率的话,最好使用 LinkedHashMap,但是多线程访问的话可能会造成不同步,所以要用Collections.synchronizedMap来包装一下,从而实 现同步。其实现一般为:
        Map<String String> map = Collections.synchronizedMap(new LinkedHashMap(<String String));

    HashMap,LinkedHashMap,TreeMap都属于Map

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

    HashMap 是一个最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值,具有很快的访问速度。HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;HashMap不支持线程的同步,即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步,可以用 Collections的synchronizedMap方法使HashMap具有同步的能力。
    LinkedHashMap LinkedHashMap也是一个HashMap,但是内部维持了一个双向链表,可以保持顺序
    TreeMap 不仅可以保持顺序,而且可以用于排序
    HashMap例子:
        
    public
     
    static
     
    void
     main(String[] args) {
    Map
    < String, String > map = new HashMap < String, String > ();
    map.put(
    " a3 " , " aa " );
    map.put(
    " a2 " , " bb " );
    map.put(
    " b1 " , " cc " );
    for (Iterator iterator = map.values().iterator(); iterator.hasNext();) {
    String name
    = (String) iterator.next();
    System.out.println(name);
    }
    }

    LinkedHashMap例子:

        
    public
     
    static
     
    void
     main(String[] args) {
    Map
    < String, String > map = new LinkedHashMap < String, String > ();
    map.put(
    " a3 " , " aa " );
    map.put(
    " a2 " , " bb " );
    map.put(
    " b1 " , " cc " );
    for (Iterator iterator = map.values().iterator(); iterator.hasNext();) {
    String name
    = (String) iterator.next();
    System.out.println(name);
    }
    }

    TreeMap例子:

        
    public
     
    static
     
    void
     main(String[] args) {
    Map
    < String, String > map = new TreeMap < String, String > ( new Comparator < Object > (){
    Collator collator
    = Collator.getInstance();
    public int compare(Object o1, Object o2) {
    CollationKey key1
    = collator.getCollationKey(o1.toString());
    CollationKey key2
    = collator.getCollationKey(o2.toString());
    return key1.compareTo(key2);
    // return collator.compare(o1, o2);
    }});
    map.put(
    " a3 " , " aa " );
    map.put(
    " a2 " , " bb " );
    map.put(
    " b1 " , " cc " );
    for (Iterator iterator = map.values().iterator(); iterator.hasNext();) {
    String name
    = (String) iterator.next();
    System.out.println(name);
    }
    }

     

    运行这三个例子,体会一下它们之间的区别。

    展开全文
  • 与HashMap相比LinkedHashMap维护的是一个具有双重链表的HashMap,LinkedHashMap支持两种排序:一种是插入排序,一种是使用排序,最近使用的会移至尾部例如 M1 M2 M3 M4,使用M3后为 M1 M2 M4 M3了。   ...

    LinkedHashMap是比HashMap多了一个链表的结构。与HashMap相比LinkedHashMap维护的是一个具有双重链表的HashMap,LinkedHashMap支持两种排序:一种是插入排序,一种是使用排序,最近使用的会移至尾部例如 M1 M2 M3 M4,使用M3后为 M1 M2 M4 M3了。

     

    LinkedHashMap输出时其元素是有顺序的,而HashMap输出时是随机的,如果Map映射比较复杂而又要求高效率的话,最好使用LinkedHashMap,但是多线程访问的话可能会造成不同步,所以要用Collections.synchronizedMap来包装一下,从而实现同步。其实现一般为:

    Map<String Object> map = Collections.synchronizedMap(new LinkedHashMap(<String Object));

     

    HashMap,LinkedHashMap,TreeMap都属于Map:

     

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

     

    HashMap 是一个最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值,具有很快的访问速度。HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;HashMap不支持线程的同步,即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步,可以用 Collections的synchronizedMap方法使HashMap具有同步的能力。

     

    LinkedHashMap也是一个HashMap,但是内部维持了一个双向链表,可以保持顺序。

     

    TreeMap 不仅可以保持顺序,而且可以用于排序 HashMap。

     

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

     

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

     

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

     

    一般情况下,我们用的最多的是HashMap,在Map 中插入、删除和定位元素,HashMap 是最好的选择。但如果要按自然顺序或自定义顺序遍历键,那么TreeMap会更好。如果需要输出的顺序和输入的相同,那么用LinkedHashMap 可以实现,它还可以按读取顺序来排列。

     

    List是一个接口,而ArrayList是一个类。 ArrayList继承并实现了List。List list = new ArrayList();这句创建了一个ArrayList的对象后把上溯到了List。此时它是一个List对象了,有些ArrayList有但是List没有的属性和方法,它就不能再用了。而ArrayList list=new ArrayList();创建一对象则保留了ArrayList的所有属性。

    为什么一般都使用 List list = new ArrayList() ,而不用 ArrayList alist = new ArrayList()呢? 

    问题就在于List有多个实现类,现在你用的是ArrayList,也许哪一天你需要换成其它的实现类,如 LinkedList或者Vector等等,这时你只要改变这一行就行了:List list = new LinkedList(); 其它使用了list地方的代码根本不需要改动。假设你开始用 ArrayList alist = new ArrayList(), 这下你有的改了,特别是如果你使用了 ArrayList特有的方法和属性。

     

    举例说明三者区别如下所示:

    package com.map.test;
    
    import java.text.CollationKey;
    import java.text.Collator;
    import java.util.Comparator;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.LinkedHashMap;
    import java.util.Map;
    import java.util.TreeMap;
    
    public class MapTestDemo {
    	
    	public void hashMapTest () {
    		
    		Map<String, Object> map = new HashMap<String, Object>();
    		map.put("a3", "aa");
    		map.put("a2", "bb");
    		map.put("b1", "cc");
    		for (Iterator<Object> iterator = map.values().iterator(); iterator.hasNext();) {
    			Object name =  iterator.next();
    			System.out.println(name);
    		}
    		
    	}
    	
    	public void linkedHashMapTest () {
    		
    		Map<String, Object> map = new LinkedHashMap<String, Object>();
    		map.put("a3", "aa");
    		map.put("a2", "bb");
    		map.put("b1", "cc");
    		for (Iterator<Object> iterator = map.values().iterator(); iterator.hasNext();) {
    		Object name =  iterator.next();
    		System.out.println(name);
    		}
    		
    	}
    	
    	public void treeMapTest () {
    		
    		Map<String, Object> map = new TreeMap<String, Object> (new Comparator<Object>(){
    			
    			Collator collator = Collator.getInstance(); 
    			public int compare(Object o1, Object o2) {
    				
    				CollationKey key1 = collator.getCollationKey(o1.toString());
    				CollationKey key2 = collator.getCollationKey(o2.toString());
    				return key1.compareTo(key2);
    			
    			}
    			
    		});
    		
    		map.put("a3", "aa");
    		map.put("a2", "bb");
    		map.put("b1", "cc");
    		for (Iterator<Object> iterator = map.values().iterator(); iterator.hasNext();) {
    			
    			Object name =  iterator.next();
    			System.out.println(name);
    			
    		}			
    		
    	}
    	
    	public static void main(String[] args) {
    		
    		MapTestDemo d = new MapTestDemo();
    		d.hashMapTest();
    		d.linkedHashMapTest();
    		d.treeMapTest();
    		
    	}
    	
    }
    

     

    运行结果如下所示:


     

    不同的遍历方式(输出Key及Value)如下所示:

    package com.map.test;
    import java.util.Iterator;
    import java.util.LinkedHashMap;
    import java.util.Map;
    
    public class mapTestExample {
    	
    	public static void main(String args[]) {
    	   System.out.println("*************************LinkedHashMap*************");
    	   Map<String,String> map = new LinkedHashMap<String,String>();
    	   map.put("first", "apple");
    	   map.put("second", "banana");
    	   map.put("third","pear");
    	   
    	   for (Iterator it =  map.keySet().iterator();it.hasNext();)
    	   {
    	    String key = (String) it.next();
    	    System.out.println( key+"="+ map.get(key));
    	   }
    	   
    	}
    
    }

     

    运行结果如下图所示:


     

    参考文章:

    http://hi.baidu.com/chssheng2007/item/220de1151b39275c2b3e22cb
    http://www.cnblogs.com/hubingxu/archive/2012/02/21/2361281.html

    http://wenwen.sogou.com/z/q472138423.htm

     

    展开全文
  • 在遍历的时候会比HashMap慢,不过有种情况例外,当HashMap容量很大,实际数据较少时,遍历起来可能会比LinkedHashMap慢,因为LinkedHashMap的遍历速度只和实际数据有关,和容量无关,而HashMap的遍历速度和他的容量...
  • 1. LinkedHashMap如何实现有序访问?   LinkedHashMap继承了HashMap,但比 hashMap 多维护了一个双向链表,它的内部Entry除了保存当前对象的引用外,还保存了before和after两个引用,从而在哈希表的基础上又构成了...
  • 它有四个实现类,分别是HashMap Hashtable LinkedHashMap 和TreeMap Map主要用于存储健值对,根据键得到值,因此不允许键重复(重复了覆盖了),但允许值重复。---------------------------------------------------...
  • HashMap和LinkedHashMap区别 参考:https://blog.csdn.net/a822631129/article/details/78520111 java为数据结构中的映射定义了一个接口java.util.Map;它有四个实现类,分别是HashMap Hashtable Li...
  • HashMap Hashtable LinkedHashMap TreeMap WeakHashMap 和ConcurrentMap 区别 java为数据结构中的映射定义了一个接口java.util.Map;它有四个实现类,分别是HashMap Hashtable LinkedHashMapTreeMap. Map主要...
  • ArrayList、LinkedList、Vector的区别和实现原理 存储结构 ArrayList和Vector是按照顺序将元素存储(从下标为零开始),删除元素时,需要使部分元素位移,默认初始容量都是10 ArrayList和Vector是基于数组实现的,...
  • import java.util.HashMap;  import java.util....import java.util.LinkedHashMap;  import java.util.Map;  import java.util.TreeMap;  import java.util.Map.Entry;      public class
  • HashMap和Hashtable的区别 HashMap和Hashtable都实现了Map接口,但决定用哪一个之前先要弄清楚它们之间的分别。主要的区别有:线程安全性,同步(synchronization),以及速度。 HashMap几乎可以等价于Hashtable,...
  • 1.有序的Map 集合 LinkedHashMap 在开发中,HashMap 集合是我们使用的, 但是它是无序的集合,有时用起来比较痛苦. 我们希望 存的顺序是什么,取的时候也是什么顺序. LinkHashMap 就可以满足我们的需求. HashMap //...
  • LinkedHashMap,String> linkedHashMap = new LinkedHashMap(); linkedHashMap.put(11,"a"); linkedHashMap.put(12,"c"); linkedHashMap.put(13,"b"); linkedHashMap.put(6,"d"); linkedHashMap.put(100,"e"); ...
  • java.util.Map实现类:HashMap、Hashtable、LinkedHashMapTreeMap Map:主要用于存储键值对。根据键得到值,不允许键重复(重复会覆盖),但允许值重复 HashMap 一个最常用的Map,根据键的HashCode值存储数据,...
  • 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 class testMap { /** * @pa
  • 它有四个实现类,分别是HashMap Hashtable LinkedHashMapTreeMap. Map主要用于存储健值对,根据键得到值,因此不允许键重复(重复了覆盖了),但允许值重复。 Hashmap 是一个最常用的Map,它根据键的HashCode值...
  • public static void main(String[] args) { // 创建集合 Map<String, String> map = new HashMap<>(); //添加元素 map.put("1001","张三"); map.put("1002","李四"); map.put("1003","王五");...}
  • HashMap LinkedHashMap TreeMap什么时候用

    千次阅读 2013-04-03 12:10:26
    HashMap 是线程不安全的哈希表,...LinkedHashMap:是一个维持双向链表,是一个有序的Map,怎么put的进去的输出时怎么取出,FIFO的顺序 TreeMap: 在需要排序的时候使用,在一个map放入很多数据,需要按照什么规则
  • HashMap,LinkedHashMap,TreeMap都属于Map。  1.基本含义 Map 主要用于存储键(key)值(value)对,根据键得到值,因此键不允许键重复,但允许值重复。  HashMap 是一个最常用的Map,它根据键的 HashCode 值...
  • package Map; import java.io.FileInputStream; import java.io.IOException; import java.util.Properties; public class PropertiesTest { public static void main(String[] args) { FileInputStream fis &#...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,354
精华内容 11,341
关键字:

linkedhashmaptreemap区别