zoukankan      html  css  js  c++  java
  • HashMap和HashSet的区别。Array、Collection(List/Set/Queue)、Map。ArrayList,LinkedList,HashSet,HashMap

    面试中经常被问到HashMap与HashSet的区别。于是本渣静下心来总结了一下HashSet与HashMap的区别。

      先了解一下HashMap跟HashSet

     HashSet:

      HashSet实现了Set接口,它不允许集合中出现重复元素。当我们提到HashSet时,第一件事就是在将对象存储在

    HashSet之前,要确保重写hashCode()方法和equals()方法,这样才能比较对象的值是否相等,确保集合中没有

    储存相同的对象。如果不重写上述两个方法,那么将使用下面方法默认实现:

     public boolean add(Object obj)方法用在Set添加元素时,如果元素值重复时返回 "false",如果添加成功则返回"true"

    HashMap:

      HashMap实现了Map接口,Map接口对键值对进行映射。Map中不允许出现重复的键(Key)。Map接口有两个基本的实现

    TreeMap和HashMap。TreeMap保存了对象的排列次序,而HashMap不能。HashMap可以有空的键值对(Key(null)-Value(null))

    HashMap是非线程安全的(非Synchronize),要想实现线程安全,那么需要调用collections类的静态方法synchronizeMap()实现。

    public Object put(Object Key,Object value)方法用来将元素添加到map中。

    HashSet与HashMap的区别:

    HashMap HashSet
    实现了Map接口 实现Set接口
    存储键值对 仅存储对象
    调用put()向map中添加元素 调用add()方法向Set中添加元素
    HashMap使用键(Key)计算Hashcode

    HashSet使用成员对象来计算hashcode值,

    对于两个对象来说hashcode可能相同,

    所以equals()方法用来判断对象的相等性,

    如果两个对象不同的话,那么返回false

    HashMap相对于HashSet较快,因为它是使用唯一的键获取对象 HashSet较HashMap来说比较慢

    java集合使用——HashSet

    第一:HashSet的构造和增加元素

    集合中存放的是对象的引用。集合中元素的存储空间是自动开辟的,不像数组需要预先开辟内存。

    HashSet hashSet = new HashSet();
      hashSet.add(new Integer(1)); //向集合中添加一个整数
      hashSet.add("a"); //向集合中添加一个字符串
      int x[] = {1,2,3,4,5};
      hashSet.add(x); //向集合中添加一个数组
      Person p = new Person("张三", 23, "男", "研究生");
      hashSet.add(p); //向集合中添加一个自定义类的对象

    第二:HashSet的遍历

    所谓遍历就是按照某种顺序,对于集合中的每个元素访问一次并且仅一次,不重复也不遗漏。

    Iterator it = hashSet.iterator();
      while(it.hasNext()){
       Object obj = it.next();
       if(obj instanceof Integer){
        System.out.println("integer:"+obj);
       }
       if(obj instanceof String){
        System.out.println("String:"+obj);
       }
       if(obj instanceof int[]){
        System.out.println("integer:"+x[4]);
       }
       if(obj instanceof Person){
        System.out.println("Person:"+p.getName()+p.getAge()+p.getSex()+p.getEducation());
        
       }
      }

    输出结果是:

    integer:1
    integer:5
    String:a
    Person:张三23男研究生

    注意:(1)因为集合是无序的,所以输出结果也是无序的。

             (2)判断对象是否是数组 obj.getClass().isArray()。

             (3)判断对象是否是所属地类obj.getClass().getName()。

     第三:删除HashSet中的元素

    删除一个元素:hashSet.remove(Object);

    删除所有元素:hashSet.clear();

    第四:判断是否包含某个元素

    if(hashSet.contains(new String("a"))){
       System.out.println("String");
      }

     
     
     

    Java:集合,Array、Collection(List/Set/Queue)、Map的遍历,比如:ArrayList,LinkedList,HashSet,HashMap

    1. 概述

    1.1 Set接口  

    1. Set的每个元素元素不可重复,Set接口不保证维护元素的次序;set具有与Collection完全一样的接口,因此没有任何额外的功能,实际上Set就是Collection,只是行为不同。(这是继承与多态思想的典型应用:表现不同的行为)set不保存重复的元素。
    2. HashSet类: 为快速查找设计的Set,存入HashSet的对象必须定义hashCode(),它不保证集合的迭代顺序;  
    3. LinkedHashSet类: 具有HashSet的查询速度,且内部使用链表维护元素的顺序(插入的次序)。
    4. SortedSet接口有一个实现类:TreeSet(底层由平衡二叉树实现)
    5. TreeSet : 保存次序的Set, 底层为树结构。使用它可以从Set中提取有序的序列。

    1.2 List接口

    1.  List按对象进入的顺序保存对象,不做排序等操作;元素可重复、元素可为null、元素类型要相同。
    2.  ArrayList类:由Array实现的List,允许对元素进行快速随机访问,适合查询。但是向List中间插入与移除元素的速度很慢。ArrayList是非线程安全的,效率高;而Vector是基于线程安全的,效率低。ArrayList() 代表长度可以改变得数组???
    3.  LinkedList类:底层基于链表实现,链表内存是散乱的,每一个元素存储本身内存地址的同时还存储下一个元素的地址。链表增删快,查找慢。

      linkedlist具有下列方 法:addFirst(), addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(), 这些方法 (没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。

    1.3 Queue接口

    1. Queue用于模拟队列这种数据结构,实现“FIFO”等数据结构。通常,队列不允许随机访问队列中的元素。
    2. ArrayDeque类:为Queue子接口Deque的实现类,数组方式实现。
    3. LinkedList类:是List接口的实现类,同时它也实现了Deque接口(Queue子接口)。因此它也可以当做一个双端队列来用,也可以当作“栈”来使用。

    1.4 Map接口

    1.  添加、删除操作put/remove/putAll/clear
    2.  查询操作get/containsKey/containsValue/size/isEmpty
    3.  视图操作keySet/values/entrySet
    4.  Map.Entry接口(Map的entrySet()方法返回一个实现Map.Entry接口的对象集合)  getKey/getValue/setValue
    5. Map接口有三个实现类:HashMap,HashTable,LinkeHashMap 

      HashMap非线程安全,高效,支持null,HashMap就是使用对象的hashCode()进行快速查询的。

      HashTable线程安全,低效,不支持null 
      SortedMap有一个实现类:TreeMap 

    6. LinkedHashMap: 类似于HashMap,但是迭代遍历它时,取得“键值对”的顺序是其插入次序,或者是最近最少使用(LRU)的次序。只比HashMap慢一点。而在迭代访问时发而更快,因为它使用链表维护内部次序。
    7. TreeMap : 基于红黑树数据结构的实现。HashMap适合插入删除定位元素,TreeMap适合遍历元素。查看“键”或“键值对”时,它们会被排序(次序由Comparabel或Comparator决定)。TreeMap的特点在 于,你得到的结果是经过排序的。TreeMap是唯一的带有subMap()方法的Map,它可以返回一个子树。
    8. WeakHashMao :弱键(weak key)Map,Map中使用的对象也被允许释放: 这是为解决特殊问题设计的。如果没有map之外的引用指向某个“键”,则此“键”可以被垃圾收集器回收。
    9. IdentifyHashMap: : 使用==代替equals()对“键”作比较的hash map。专为解决特殊问题而设计。
    10. 几种不同的Map:HashMap, TreeMap, LinkedHashMap, WeakHashMap, IdentityHashMap。它们都有同样的基本接口Map,但是行为、效率、排序策略、保存对象的生命周期和判定“键”等价的策略等各不相同。

    1.5 List和Set接口自Collection接口,而Map不是继承的Collection接口

    Collection表示一组对象,这些对象也称为collection的元素;一些 collection允许有重复的元素,而另一些则不允许;一些collection是有序的,而另一些则是无序的;JDK中不提供此接口的任何直接实 现,它提供更具体的子接口(如 Set 和 List)实现;Map没有继承Collection接口,Map提供key到value的映射;一个Map中不能包含相同key,每个key只能映射一个value;Map接口提供3种集合的视图,Map的内容可以被当做一组key集合,一组value集合,或者一组key-value映射;

     Set和List都是jdk提供的集合接口,他们都是接口,实际上定义的是这种类型的集合的标注。 然后,对于接口肯定会有实现类,可能会有多个实现类。HashSet 是Set集合的实现类,所以可以写成Set s =new HashSet()。 ArrayList是List的实现类,可以写成List list = new ArrayList(); ArrayList list = new ArrayList()这么写是可以的,ArrayList可以被看成是普通的类。

    ArrayList list = new ArrayList();一般不这样用, 除非你要用到ArrayList里相对于接口没有的方法和属性


    遍历list各种方式总耗时:47
    遍历queue各种方式总耗时:47

    遍历set各种方式总耗时:31
    遍历array各种方式总耗时:0
    Map之Entry方式遍历耗时:15
    Map之keySet方式遍历耗时:31

    1.6. collection实现了java集合(set和list)的通用方法,容器存储的是单个元素。Map是键值对。

    list和set支持Iterator迭代器:

    List<String> list = new ArrayList<String>();
    Iterator it=list.iterator();
    while(it.hasNext()){
    System.out.println(it.next());
    }

    Set<String> set = new HashSet<String>();
    Iterator it1=set.iterator();
    while(it1.hasNext()){
    System.out.println(it.next());
    }

    3. 总结

     1.array查询最快,list/queue最慢:list/queue > set/map.KeySet > map.Entry >  array
     2.Map在Entry方式与keySet方式遍历时,耗时有着非常大的区别,原因应该是keySet方式遍历时再次调用map.get(key)方法造成的,当数据量大时,需要特别考虑。

    3.Array的搜索很慢。


    总结
    1. 如果涉及到堆栈,队列等操作,应该考虑用List;对于需要快速插入,删除元素,应该使用LinkedList;如果需要快速随机访问元素,应该使用ArrayList。
    2. 如果程序在单线程环境中,或者访问仅仅在一个线程中进行,考虑非同步的类,其效率较高,如果多个线程可能同时操作一个类,应该使用同步的类。
    3. 在除需要排序时使用TreeSet,TreeMap外,都应使用HashSet,HashMap,因为他们 的效率更高。
    4. 要特别注意对哈希表的操作,作为key的对象要正确复写equals和hashCode方法。
    5. 容器类仅能持有对象引用(指向对象的指针),而不是将对象信息copy一份至数列某位置。一旦将对象置入容器内,便损失了该对象的型别信息。
    6. 尽量返回接口而非实际的类型,如返回List而非ArrayList,这样如果以后需要将ArrayList换成LinkedList时,客户端代码不用改变。这就是针对抽象编程。
    注意:
    1、Collection没有get()方法来取得某个元素。只能通过iterator()遍历元素。
    2、Set和Collection拥有一模一样的接口。
    3、List,可以通过get()方法来一次取出一个元素。使用数字来选择一堆对象中的一个,get(0)...。(add/get)
    4、一般使用ArrayList。用LinkedList构造堆栈stack、队列queue。
    5、Map用 put(k,v) / get(k),还可以使用containsKey()/containsValue()来检查其中是否含有某个key/value。
    HashMap会利用对象的hashCode来快速找到key。
    6、Map中元素,可以将key序列、value序列单独抽取出来。
    使用keySet()抽取key序列,将map中的所有keys生成一个Set。
    使用values()抽取value序列,将map中的所有values生成一个Collection。
    为什么一个生成Set,一个生成Collection?那是因为,key总是独一无二的,value允许重复。

     1.7. 实例化: 

    接口可以被实例化的。。但是语法不是简单的 Set s = new Set(),而是 Set s = new Set(){{}};需要后面带方法体。这个也只是实例化接口的匿名子类而已,不算实例化接口。。。Set引用的是匿名类的实现,但set本身并没有被实例化。。
    Set和List是接口,HashSet是实现了Set接口的类,ArrayList是实现了List的类,接口不可以被实例化。new Set<String>() {}实例化一个匿名类,需要在{}里面实现Set接口的。

    List list = new ArrayList(); // 仅需修改后面的ArrayList为LinkedList,这种写法有一个好处就是:当想修改代码的时候,比如想用LinkedList,仅需要修改一处。
    接口是可以实例化或者不可以实例化,都是理解对的,只是角度不同。。站在源码的角度看,接口是可以实例化的,与类的实例化只有稍微差异,将来也是完全可以做到一样的语法。。当然,站在bytecode角度看,接口和类是俩个不同的东西,不能实例化。


    List<?>的?后如果不加extends或者super修饰的话,相当于List<? extends Object>,它是所有List<T>的父类。但在使用List<?>的实例时,方法参数中的泛型参数将无法适配任何实际变量,而返回值中的泛型参数将变为<? extends T>中的T(单独写<?>则取缺省值Object)。例如
    List<? extends Number> list = new ArrayList<Integer>(3); //容器List<? extends Number>是容器List<Integer>的父类
    //List<Number> list2 = new ArrayList<Integer>(3); //编译出错,容器List<Number>不是容器List<Integer>的父类。
    list.add(3); //编译出错。但去掉这行后后续代码能正确运行。
    final Number n = list.get(0);
    System.out.println(n);
    使用泛型通配符?可以把容器元素的继承关系推导到容器本身上,但限制了带泛型参数方法的使用。

    下面是一段代码用来遍历各种数组、集合、映射的。更多内容请参考:

    Java:集合,Collection接口框架图

    Java:集合,Map接口框架图

    Java:concurrent包下面的Collection接口框架图( CopyOnWriteArraySet, CopyOnWriteArrayList,ConcurrentLinkedQueue,BlockingQueue)

    Java:concurrent包下面的Map接口框架图(ConcurrentMap接口、ConcurrentHashMap实现类)

    2. 示范代码

    复制代码
    package com.clzhang.sample.collections;
    
    import java.util.*;
    
    import org.junit.Test;
    import org.junit.Before;
    import org.junit.After;
    
    /**
     * 测试遍历Array/Set/List/Queue/Map的类
     * @author acer
     *
     */
    public class CollectionMapTest {
        private static final int TOTAL_COUNT = 100000;
        
        private String[] array;
        private Set<String> set;
        private List<String> list;
        private Queue<String> queue;
        private Map<String, String> map;
    
        @Before
        public void init() {
            // 准备测试数据
            array = new String[TOTAL_COUNT];
            set = new HashSet<String>();
            list = new ArrayList<String>();
            queue = new LinkedList<String>();
            map = new HashMap<String, String>();
            
            for (int i = 0; i < TOTAL_COUNT; i++) {
                String key = "user" + i;
                String value = "pass" + i;
                
                array[i] = key;
                set.add(key);
                list.add(key);
                queue.add(key);
                map.put(key, value);
            }
        }
        
        @After
        public void destory() {
        }
    
        @SuppressWarnings("unused")
        @Test
        public void testArray() {
            long startTime = Calendar.getInstance().getTimeInMillis();
    
            // 老款遍历的方法
            for (int i = 0; i < array.length; i++) {
                String str = array[i];
            }
    
            // foreach遍历:JDK1.5之后的方法
            for (String str : array) {
                // 直接用了
            }
            
            System.out.println("遍历array各种方式总耗时:" + (Calendar.getInstance().getTimeInMillis() - startTime));
        }
        
        @SuppressWarnings("unused")
        @Test
        public void testSet() {
            long startTime = Calendar.getInstance().getTimeInMillis();
    
            // 迭代遍历
            Iterator<String> it = set.iterator();
            while (it.hasNext()) {
                String str = it.next();
            }
    
            // 迭代遍历的for方式;或者相对while循环而言,能够避免变量名错误
            for (Iterator<String> iter = set.iterator(); iter.hasNext();) {
                String str = iter.next().toString();
            }
    
            // foreach遍历:JDK1.5之后的方法
            for (String str : set) {
                // 直接用了,注意它是无序的
            }
    
            System.out.println("遍历set各种方式总耗时:" + (Calendar.getInstance().getTimeInMillis() - startTime));
        }
    
        @SuppressWarnings("unused")
        @Test
        public void testList() {
            long startTime = Calendar.getInstance().getTimeInMillis();
    
            // 老款遍历的方法
            for (int i = 0; i < list.size(); i++) {
                String str = list.get(i);
            }
    
            // 迭代遍历
            Iterator<String> iterator = list.iterator();
            while (iterator.hasNext()) {
                String str = iterator.next();
            }
    
            // 迭代遍历的for方式;相对while循环而言,能够避免变量名错误
            for (Iterator<String> iter = list.iterator(); iter.hasNext();) {
                String str = iter.next().toString();
            }
    
            // foreach遍历:JDK1.5之后的方法
            for (String str : list) {
                // 直接用了
            }
    
            System.out.println("遍历list各种方式总耗时:" + (Calendar.getInstance().getTimeInMillis() - startTime));
        }
    
        @SuppressWarnings("unused")
        @Test
        public void testQueue() {
            long startTime = Calendar.getInstance().getTimeInMillis();
    
            // 老款遍历的方法
            for (int i = 0; i < queue.size(); i++) {
                String str = list.get(i);
            }
    
            // 迭代遍历
            Iterator<String> iterator = queue.iterator();
            while (iterator.hasNext()) {
                String str = iterator.next();
            }
    
            // 迭代遍历的for方式;或者相对while循环而言,能够避免变量名错误
            for (Iterator<String> iter = queue.iterator(); iter.hasNext();) {
                String str = iter.next().toString();
            }
            
            // foreach遍历:JDK1.5之后的方法
            for (String str : queue) {
                // 直接用了
            }
    
            System.out.println("遍历queue各种方式总耗时:" + (Calendar.getInstance().getTimeInMillis() - startTime));
        }
    
        @SuppressWarnings("unused")
        @Test
        public void testMap() {
            long startTime = 0;
            
            // Entry方式的迭代遍历(Entry方式遍历时间短)
            startTime = Calendar.getInstance().getTimeInMillis();
            Iterator<Map.Entry<String, String>> iter1 = map.entrySet().iterator();
            while(iter1.hasNext()) {
                Map.Entry<String, String> entry = (Map.Entry<String, String>) iter1.next();
                
                String key = (String)entry.getKey();
                String value = (String)entry.getValue();
            }
            System.out.println("Map之Entry方式遍历耗时:" + (Calendar.getInstance().getTimeInMillis() - startTime));
    
            // Entry方式的foreach遍历,简单多了是不是,速度还贼快
            for (Map.Entry<String, String> entry : map.entrySet()) {
                String key = entry.getKey();
                String value = entry.getValue();
            }
    
            // keySet方式的迭代遍历(keySet方式遍历耗时多)
            startTime = Calendar.getInstance().getTimeInMillis();
            Iterator<String> iter2 = map.keySet().iterator();
            while (iter2.hasNext()) {
                String key = (String)iter2.next();
                String value = (String)map.get(key);
            }
            System.out.println("Map之keySet方式遍历耗时:" + (Calendar.getInstance().getTimeInMillis() - startTime));
            
            // keySet方式的foreach遍历,更简单,但速度慢
            for(String key: map.keySet()) {
                String value = (String)map.get(key);
            }
        }
    }
    复制代码

    输出:

    遍历set各种方式总耗时:31
    遍历list各种方式总耗时:47
    遍历queue各种方式总耗时:47
    遍历array各种方式总耗时:0
    Map之Entry方式遍历耗时:15
    Map之keySet方式遍历耗时:31

    3. 总结

     1.遍历数组速度最快;
     2.Map在Entry方式与keySet方式遍历时,耗时有着非常大的区别,原因应该是keySet方式遍历时再次调用map.get(key)方法造成的,当数据量大时,需要特别考虑。

  • 相关阅读:
    VB.NET中lambda的写法
    C#中DllImport用法和路径问题
    SQL*Loader 和 Data Pump
    批处理-函数定义及应用01
    Office 2010 KMS激活原理和案例分享
    Hyper-V架构与VMware ESXi的差异
    Tomcat免安装配置2
    Tomcat免安装配置
    域名解析过程
    内部类访问的局部变量必须加final
  • 原文地址:https://www.cnblogs.com/timssd/p/5975849.html
Copyright © 2011-2022 走看看