Map List Set等集合类, 对象的会晤

一,java种集合关系图

Map List Set等集合类:

Collection            
   接口的接口      
          
 对象的汇集

一、概述

在JAVA的util包中有七个颇具集合的父接口Collection和Map,它们的父子关系:

+Collection
这些接口extends自 –java.lang.Iterable接口

 ├+List(接口
代表一如既往,可另行的汇集。列表)
 │├ ArreyList     (Class
数组,随机走访,没有共同,线程不安全)
 │├ Vector        (Class  数组              
    同步        线程全)
 │├ LinkedList    (Class  链表   插入删除  
没有一块   线程不安全)
 │└ Stack          (Class)
 └+Set(接口
不或然含重复的要素。仅收受一遍并做内部排序,集)
 │├ HashSet            (Class)
 │├ LinkedHashSet   (Class)
 │└ TreeSet       (Class)

+Map(接口)
 ├
+Map(接口 映射集合)
 │ ├
HashMap            (Class 不一起,线程不安全。除了不一致和允许行使null
键值之外,与Hashtable几乎相同)
 │ ├
Hashtable           (Class 同步   ,线程安全    。不允许实施null
键值)
 │ ├
+SortedMap 接口
 │ │ 
 ├
TreeMap         (Class)
 │ ├ WeakHashMap  
  (Class)

以下对很多接口和类的粗略表明:首先必须先说一下数组(Array)

壹 、成效高,但体量固定且不能动态改变。array还有一个缺点是,不能断定其中实际存有微微成分,length只是告诉大家array的体积。
② 、Java中有贰个Arrays类,专门用来操作array。
     arrays中具有一组static函数,
   
 equals():比较多个array是不是等于。array拥有相同成分个数,且独具对应成分两两相等。
     fill():将值填入array中。
     sort():用来对array进行排序。
     binarySearch():在排好序的array中检索成分。
     System.arraycopy():array的复制。

壹 、数组Array和汇集的区分:

1)
 数组是深浅固定的,并且同一个数组只可以存放类型一样的数量(基本类型/引用类型)
2)
JAVA集合可以存储和操作数目不定点的一组数据。

3)
 若程序时不精晓毕竟须要有个别对象,须要在空间欠缺时自动扩增体积,则必要动用容器类库,array不适用。

–List          子接口
有序 可重复

  –LinkedList
               接口已毕类  链表  插入删除  没有同台  线程不安全

二 set map list的区别  

都以汇集接口

  set --其中的值不允许再一次,无序的数据结构 
  list   --其中的值允许再一次,因为其为平稳的数据结构 
  map--成对的数据结构,健值必须有所唯一性(键无法同,否则值替换) 

List 按目的进入的依次保存对象,不做排序或编辑操作。

Set对每一种对象只接受五次,并动用自个儿之中的排序方法(寻常,你只关注某个成分是不是属于Set,而不关切它的次第–否则应该利用List)。

Map同样对各样成分保存一份,但那是根据”键”的,Map也有停放的排序,由此不关心成分添加的相继。如若添日币素的逐一对你很要紧,应该利用
LinkedHashSet或许LinkedHashMap.

Collection
是目的集合, Collection 有多个子接口 List 和 Set

List 可以经过下标
(1,2..)
来取得值,值可以另行

而 Set 只能经过游标来取值,并且值是无法再度的

ArrayList , Vector , LinkedList 是 List 的得以完毕类
ArrayList 是线程不安全的, Vector
是线程安全的,那八个类底层都以由数组达成的
LinkedList 是线程不安全的,底层是由链表完结的  

Map 是键值对聚集
HashTable 和 HashMap 是 Map 的兑现类
HashTable 是线程安全的,无法储存 null 值
HashMap 不是线程安全的,可以储存 null 值

  –ArrayList
                 接口完结类  数组  随机访问  没有一块
 线程不安全

  –Vector    
                 接口已毕类  数组               同步      
 线程安全

三、 Collections类和Collection接口

        
Collections是对准集合类的二个协助类,他提供一层层静态方法已毕对种种集合的物色、排序、线程安全化等操作。

 
   
 Collection是最基本的联谊接口,三个Collection代表一组Object,即Collection的要素(Elements)。一些
Collection允许同一的成分而另一部分十一分。一些能排序而另一对格外。Java SDK不提供直接接轨自Collection的
类,Java SDK提供的类都以继承自Collection的“子接口”如List和Set。

  全部已毕 Collection
接口的类都不可以不提供多个正规的构造函数:无参数的构造函数用于成立多个空的
Collection ,有二个 Collection 参数的构造函数用于成立多个新的 Collection
,那么些新的 Collection 与传播的 Collection
有一样的成分。后一个构造函数允许用户复制二个 Collection 。

集合类的遍历:遍历通用Collection:

  如何遍历 Collection
中的每多个因素?不论 Collection 的骨子里类型怎么着,它都辅助一个 iterator()
的点子,该措施重回一个迭代子,使用该迭代子即可逐一走访 Collection
中每贰个成分。典型的用法如下:

 

Iterator it = collection.iterator(); // 获得一个迭代子
  while(it.hasNext()) {
   Object obj = it.next(); // 得到下一个元素
}

由 Collection 接口派生的五个接口是 List 和 Set 。 List
按目的进入的次第保存对象,不做排序或编辑操作。 Set
对每种对象只接受一遍,并运用本人之中的排序方法 (
平时,你只关切有个别成分是或不是属于 Set, 而不关切它的依次–
否则应当利用 List) 。


    –Stack

肆 、 List接口,有序可另行的聚合

实际有二种List:
一种是中央的ArrayList,其独到之处在于随机走访成分,另一种是更强劲的LinkedList,它并不是为高效随机走访计划的,而是兼具一套更通用的格局。 

List :
次序是List最重视的特色:它保障维护元素特定的依次。List为Collection添加了不胜枚举行法,使得可以向List中间插入与移除元素(那只推荐LinkedList使用。)三个List可以生成ListIterator,使用它可以从八个方向遍历List,也得以从List中间插入和移除成分。 

1.
ArrayList类

1)
ArrayList落成了可变大小的数组。它同意具备因素,包罗null。ArrayList没有一起。
2)
size,isEmpty,get,set方法运营时刻为常数。可是add方法开发为分摊的常数,添加n个因素必要O(n)的时日。其余的点子运行时刻为线性。
3)
逐个ArrayList实例都有3个体积(Capacity),即用于存储成分的数组的轻重。这几个容积可趁着不断添加新因素而机关增加,但是增进算法
并从未定义。当必要插入大批量因素时,在插入前可以调用ensureCapacity方法来伸张ArrayList的容积以增加插入功用。
4) 和LinkedList一样,ArrayList也是非同步的(unsynchronized)。

5) 由数组完成的List。允许对元素举行高效随机访问,可是向List中间插入与移除成分的速度很慢。ListIterator只应该用来由后迈入遍历ArrayList,而不是用来插入和移除成分。因为那比LinkedList费用要大过多。
2. Vector类
  Vector卓殊接近ArrayList,可是Vector是一块的。由Vector创设的Iterator,就算和ArrayList创造的Iterator是如出一辙接口,不过,因为Vector是同台的,当三个Iterator被创建而且正在被应用,另一个线程改变了Vector的动静(例如,添加或删除了有个别要素),那时调用Iterator的法门时将抛出ConcurrentModificationException,因而必须捕获该特别。

3.
LinkedList类

  LinkedList贯彻了List接口,允许null成分。别的LinkedList提供额外的get,remove,insert方法在
LinkedList的首部或底部。如下列方法:addFirst(),
addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(),
这个方法
(没有在其它接口或基类中定义过)。那几个操作使LinkedList可被作为仓库(stack),队列(queue)或双向队列(deque)。
  注意LinkedList没有一并方法。如若多少个线程同时做客3个List,则必须团结达成访问同步。一种缓解办法是在创建List时协会三个协同的List:
  List list = Collections.synchronizedList(new LinkedList(…));

4.
Stack 类

  Stack继承自Vector,达成三个后进先出的库房。Stack提供七个附加的艺术使得Vector得以被用作储藏室使用。基本的push和pop方法,还有peek方法取得栈顶的因素,empty方法测试堆栈是或不是为空,search方法检测多少个成分在库房中的地方。Stack刚创建后是空栈。

用法:

package Test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class TestList {
    public static void main(String dd[]) {
        // new了一个存储list
        List l = new ArrayList();
        // 因为Collection framework只能存储对象所以new封装类
        l.add(new Integer(1));
        l.add(new Integer(2));
        l.add(new Integer(3));
        l.add(new Integer(4));

        Iterator it = l.iterator();
        //使用 迭代器(Iterator):
        // hasNext是取值取的是当前值.他的运算过程是判断下个是否有值如果有继续.
        while (it.hasNext()) {
            System.out.println("iterator:Element in list is :   " + it.next());
        }
        //用for循环和get()方法:
        for (int i = 0; i < l.size(); i++) {
            System.out.println("for:Element in list is :   " + l.get(i));
        }
    }
}

LinkedList

package Test;

import java.util.Iterator;
import java.util.LinkedList;

public class TestLinkedList {
    public static void main(String arg[]) {
        LinkedList ll = new LinkedList();// 声明LinkedList并实例化
        // 使用add()方法添加元素
        ll.add("a");
        ll.add("b");
        ll.add("c");
        // 使用Iterator迭代器遍历出集合的元素并打印
        Iterator it = ll.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("------------------");
        // 向链表头和尾分别添加x和z
        ll.addFirst("z");
        ll.addLast("x");
        // 遍历查看添加后的结果
        for (Iterator i = ll.iterator(); i.hasNext();) {
            System.out.println(i.next());
        }
    }
}

ArrayList和LinkedList的区别。

1.ArrayList是促成了依照动态数组的数据结构,LinkedList基于链表的数据结构。

2.对于随意访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要活动指针。

3.对此新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要活动数据。

假定熟练数据结构的同桌,就会须臾间驾驭,ArrayList就是线性表的依次表示,LinkedList就是线性表的链表表示。

–Set          
                   子接口  仅收受五次,并做内部排序  不可重复

五 、 Set接口,代表无序,不可重复的集合

      
 Set具有与Collection完全平等的接口,因而并未其余附加的机能,不像前边有八个不相同的List。实际上Set就是Collection,只是作为差别。(那是延续与多态思想的第一名应用:表现各异的表现。)Set不保留重复的要素(至于怎么判定成分相同则较为负责) 
Set :
存入Set的各种成分都不可以不是唯一的,因为Set不保留重复成分。出席Set的要素必须定义equals()方法以管教目的的唯一性。Set与Collection有一齐一样的接口。Set接口不保障维护成分的先后。 

1.
HashSet 

   
 为快速搜索设计的Set。存入HashSet的目标必须定义hashCode()。 
2.
TreeSet 

   
 保存次序的Set,
底层为树结构。使用它可以从Set中提取有序的队列。 
3.
LinkedHashSet 

   
 具有HashSet的查询速度,且其中接纳链表维护成分的逐一(插入的次序)。于是在行使迭代器遍历Set时,结果会按要素插入的程序彰显。

用法:

Set set=new HashSet();
    String s1=new String("hello");
    String s2=s1;
    String s3=new String("world");
    set.add(s1);
    set.add(s2);
    set.add(s3);
    System.out.println(set.size());//打印集合中对象的数目 为 2。
    Set 的 add()方法是如何判断对象是否已经存放在集合中?
    boolean isExists=false;
    Iterator iterator=set.iterator();
    while(it.hasNext())  {
        String oldStr=it.next();
        if(newStr.equals(oldStr)){
           isExists=true;
        }
    }

  –HashSet

六、 Map接口:映射

Map没有继续Collection接口, Map 提供 key 到 value
的炫耀,你可以通过“键”查找“值”。二个 Map 中无法蕴含相同的 key ,每种 key
只可以照射多少个 value 。 Map 接口提供3 种集合的视图, Map
的始末可以被用作一组 key 集合,一组 value 集合,或然一组 key-value
映射。

艺术 put(Object key,
Object value) 添加三个“值” ( 想要得东西 ) 和与“值”相关联的“键” (key) (
使用它来查找 ) 。方法get(Object key)
再次回到与给定“键”相关联的“值”。可以用 containsKey() 和 containsValue() 测试
Map 中是不是含有某些“键”或“值”。 标准的 Java 类库中带有了二种不一样的 Map :
HashMap, TreeMap, LinkedHashMap, WeakHashMap, IdentityHashMap
。它们都有同一的核心接口 Map
,但是作为、功效、排序策略、保存对象的生命周期和判断“键”等价的国策等各差异。

Map 同样对每一种成分保存一份,但那是基于 ” 键” 的, Map
也有内置的排序,因此不关心元素添加的依次。如果添美成分的次第对您很要紧,应该运用
LinkedHashSet 大概 LinkedHashMap.

履行效用是 Map 的三个大标题。看看 get()
要做什么事,就会知道为何在 ArrayList 中检索“键”是一定慢的。而那多亏
HashMap 提升速度的位置。 HashMap 使用了新鲜的值,称为“散列码” (hash
code)
,来顶替对键的悠悠搜索。“散列码”是“相对唯一”用以代表对象的int
值,它是经过将该对象的一些新闻进行更换而生成的(在底下计算二:必要的专注的地点有更进一步探索)。所有Java 对象都能发出散列码,因为 hashCode() 是概念在基类 Object 中的方法 。
HashMap 就是行使对象的 hashCode()
举行快捷查询的。此措施可以显然增进品质。

1.
 Hashtable类

  Hashtable继承Map接口,完成几个key-value映射的哈希表。任何非空(non-null)的对象都可看成key或许value。Hashtable是同步的。

  添加数据拔取 put(key,
value) ,取出数据应用get(key)
,那五个基本操作的年月支出为常数。
Hashtable 通过伊始化容积 (initial capacity) 和负载因子 (load factor)
三个参数调整品质。平时缺省的 load factor0.75
较好地落到实处了时光和空中的人均。增大 load factor
可以省去空间但相应的查找时间将附加,那会影响像get 和 put 那样的操作。
行使 Hashtable 的简要示例如下,将 1 ,2 ,3 放到 Hashtable
中,他们的 key 分别是 ”one” , ”two” , ”three” :
     Hashtable numbers =new Hashtable();
     numbers.put(“one”, new Integer(1));
     numbers.put(“two”, new Integer(2));
     numbers.put(“three”, new Integer(3));
  要取出二个数,比如 2 ,用相应的 key :
     Integer n =
(Integer)numbers.get(“two”);
     System.out.println(“two= ”+ n);
   由于作为 key 的目的将透过总括其散列函数来明确与之对应的 value
的职位,因而任何作为 key 的目的都不大概不兑现 hashCode 方法和 equals 方法。
hashCode 方法和 equals 方法继承自根类 Object ,假诺你用自定义的类当作
key 的话,要一定小心,依照散列函数的概念,如若七个对象相同,即
obj1.equals(obj2)=true ,则它们的 hashCode
必须一律,但一旦五个目标不一样,则它们的 hashCode
不必然不一致,尽管多个分裂目标的 hashCode
相同,那种景观叫做冲突,争辨会促成操作哈希表的日子支出增大,所以尽只怕定义好的
hashCode() 方法,能加快哈希表的操作。
  要是相同的目的有两样的 hashCode
,对哈希表的操作会油然则生意想不到的结果(期待的 get 方法重回null
),要防止那种题材,只需要牢记一条:要同时复写 equals 方法和 hashCode
方法,而不用只写其中三个。
   Hashtable 是共同的。

2.
 HashMap类

  HashMap和Hashtable类似,也是基于hash散列表的贯彻。差异之处在于
HashMap是非同步的,并且同意null,即null value和null key。,但是将HashMap视为Collection时
(values()方法可回到Collection),其迭代子操作时间支出和HashMap的容积成比例。由此,如若迭代操作的属性万分关键的话,不要
将HashMap的初叶化体量设得过高,或然load factor过低。

   LinkedHashMap
类:类似于 HashMap
,可是迭代遍历它时,取得“键值对”的各种是其插入次序,只怕是近些年至少使用
(LRU) 的先后。只比 HashMap
慢一点。而在迭代访问时发而更快,因为它应用链表维护内部次序。

3.  WeakHashMap类 (弱键(
weak key ))

  WeakHashMap是一种立异的HashMap,它是为竭泽而渔优秀题材安顿的,它对key进行“弱引用”,假若3个key不再被外表所引用,那么该key能够被GC回收。

4. TreeMap 类
据悉红黑树数据结构的落到实处。查看“键”或“键值对”时,它们会被排序 ( 次序由
Comparabel 或 Comparator 决定 ) 。 TreeMap
的特色在于,你得到的结果是因而排序的。 TreeMap 是唯一的盈盈 subMap()
方法的 Map ,它可以回来二个子树。

5. IdentifyHashMap

动用 == 代替 equals()
对“键”作相比较的 hash map 。专为化解特殊题材而安插。

 用法:

1
添加,删除操作:

    Object put(Object key, Object value): 向集合中加入元素
    Object remove(Object key):   删除与KEY相关的元素
    void putAll(Map t):   将来自特定映像的所有元素添加给该映像
    void clear(): 从映像中删除所有映射

 
  2 询问操作:
    Object get(Object key): 得到与根本字key相关的值
   
Map集合中的键对象分歧意再一次,也就说,任意多个键对象通过equals()方法相比较的结果都以false.
    可是可以将随意五个键独享映射到同二个值对象上。
    Conllections : 集合实用类
    Conllections提供了供JAVA集合实用的静态方法

    –LinkedHashSet

⑦ 、 怎样选拔

一 、容器类和Array的分别、择取
     
1)容器类仅能有所对象引用(指向对象的指针),而不是将目标消息copy一份至数列某地方。
      2)一旦将对象置入容器内,便损失了该目的的型别音讯。

2、
     1)
 在种种Lists中,最好的做法是以ArrayList作为缺省接纳。当插入、删除频仍时,使用LinkedList();
           Vector总是比ArrayList慢,所以要尽量幸免使用。
      2)
在各个Sets中,HashSet寻常优于HashTree(插入、查找)。唯有当需求发出一个通过排序的种类,才用TreeSet。
           HashTree存在的唯一理由:可以爱抚其内成分的排序状态。
      3) 在各个Maps中,HashMap用于高效搜索。
      4)  当成分个数固定,用Array,因为Array作用是最高的。

结论:最常用的是ArrayList,HashSet,HashMap,Array。而且,大家也会意识二个原理,用TreeXXX都是排序的。

注意:

① 、Collection没有get()方法来得到某些成分。只可以通过iterator()遍历成分。
贰 、Set和Collection拥有一模一样的接口。
三 、List,可以透过get()方法来五遍取出二个要素。使用数字来选拔一堆对象中的1个,get(0)…。(add/get)
肆 、一般采纳ArrayList。用LinkedList构造堆栈stack、队列queue。

⑤ 、Map用 put(k,v) /
get(k),还足以应用containsKey()/containsValue()来检查其中是不是包罗有些key/value。
      HashMap会利用目的的hashCode来迅速找到key。
    *     hashing          
哈希码就是将目标的信息通过一些变更形成五个无比的int值,这么些值存储在三个array中。
         
我们都知道全部存储结构中,array查找速度是最快的。所以,可以加速查找。
      
         
发生碰撞时,让array指向五个values。即,数组每一个地方上又变更八个梿表。

⑥ 、Map中成分,可以将key种类、value连串单独抽取出来。 应用keySet()抽取key连串,将map中的全部keys生成壹个Set。
动用values()抽取value体系,将map中的全部values生成多少个Collection。

为什么二个生成Set,一个生成Collection?那是因为,key总是独一无二的,value允许重复。

  –TreeSet

 

Map                  
    接口                            键值对的集纳

–Hashtable      
     接口达成类  同步        线程安全     不得以储存null值

–HashMap      
                 接口已毕类  没有一起   线程不安全
 可以储存null值

  –LinkedHashMap

  –WeakHashMap

–TreeMap

–IdentifyHashMap

Map拔取哈希散列,查找成分时比ArrayList快

二 、详细介绍

1、List接口

  1.1 次序是List最根本的特色,可以用索引来访问成分,允许有同等元素;

  1.2
除了Collection接口必备的iterator()方法,List提供了三个listIterator()方法,允许添加删减,设定成分,向前向后遍历;

  LinkedList:对种种访问进行了优化,随机访问相对较慢

  1.3
LinkedList允许null值,提供了addFirst(),getFirst()等艺术在LinkedList的首部或尾部,使linkedList可被当做仓库,队列或双向队列;

  1.4 LinkedList没有联手方法,假若三多线程访问时,必须协调达成访问同步

    如  List list=Collection.synchronizedList(new LinkedList(…));

  ArrayList:向List中间插入与移除成分的进程很慢,随机走访相对较快

  1.5 ArrayList有数组完毕,允许全数因素,包罗null

  1.6  ListIterator 只应该用来由后迈入遍历 ArrayList,
而不是用来插入和移除成分。因为这比 LinkedList 开支要大过多;

  Vector:

  1.7
由Vector成立的iterator被成立而且正在被使用,另一线程改变了vector的情况,这时调用
Iterator 的情势时将抛出 ConcurrentModificationException
,因而必须捕获该特别

  Stack:

  1.8 达成一个后进先出的仓库,Stack 提供 5 个附加的措施使得 Vector
得以被看做储藏室使用。基本的 push 和 pop 方法,还有 peek
方法赢得栈顶的要素, empty 方法测试堆栈是还是不是为空, search
方法检测2个因素在仓库中的地点。 Stack 刚创造后是空栈;

2 Set接口

  2.1 set不有限资助维护成分的程序,最多有二个null值;

  2.2 Set的构造函数有几个羁绊规范
,传入的Collection参数不只怕包蕴重复的要素;

  HashSet:

  LinkedHashSet:

  TreeSet:

3.Map接口

  3.1
可以用containsKey()和containsValue()测试Map中是还是不是包括某些”键”或“值”,有内置的排序;

  3.2
HsahMap使用对象的hashCode()进行高效查询,“散列码”是“相对唯一”用以代表对象的
int 值,它是经过将该目的的一点音信进行转换而变更的,全部 Java
对象都能生出散列码,因为 hashCode() 是概念在基类 Object 中的方法;

  HashTable:

  3.3
完毕了3个key-value映射的哈希表,任何非空对象都可以作为key只怕value;

  3.4 添加多少put,去除数据get;

  3.5 Hashtable 通过开头化体量 (initial capacity) 和负载因子 (load
factor) 三个参数调整质量,平时缺省的 load factor 0.75
较好地达成了光阴和空间的户均。增大 load factor
可以节省空间但对应的查找时间将叠加,那会潜移默化像 get 和 put 那样的操作;

  3.6
作为key的靶子将经过统计散列函数来规定与之对应的value的职分,因而任何作为
key 的对象都不可以不兑现 hashCode 方法和 equals 方法。hashCode 方法和 equals
方法继承自根类 Object ,假使您用自定义的类当作 key
的话,要一定小心,根据散列函数的概念,如若五个对象相同,即
obj1.equals(obj2)=true ,则它们的 hashCode
必须一律,但一旦七个对象差距,则它们的 hashCode
不肯定不一样,假诺八个不一样对象的 hashCode
相同,那种景色称为争辨,争论会导致操作哈希表的年华支出增大,所以尽或然定义好的
hashCode() 方法,能加快哈希表的操作;

  HashMap:

  3.7 hashmap非同步,允许null值。将 HashMap 视为 Collection 时(
values() 方法可重回 Collection
),插入和询问“键值对”的付出是一定的,但其迭代子操作时间支付和 HashMap
的体积成比例。由此,如若迭代操作的属性十分首要的话,不要将 HashMap
的先导化体量 (initial capacity) 设得过高,可能负载因子 (load factor)
过低;

  LinkedHashMap

  3.8 类似于 HashMap
,不过迭代遍历它时,取得“键值对”的逐一是其插入次序,只怕是方今至少使用
(LRU) 的主次。只比 HashMap
慢一点。而在迭代访问时发而更快,因为它利用链表维护其中次序;

  WeakHashMap:

  3.9 弱键( weak key ) Map 是一种创新的 HashMap
,它是为缓解特殊题材计划的,对 key 举办 “ 弱引用 ” ,假诺壹个 key
不再被外表所引述(没有 map 之外的引用),那么该 key 可以被垃圾收集器
(GC) 回收;

  TreeMap:

  基于红黑树数据结构的落实。查看“键”或“键值对”时,它们会被排序 (
次序由 Comparabel 或 Comparator 决定 ) 。 TreeMap
的特性在于,你收获的结果是经过排序的。 TreeMap 是唯一的盈盈 subMap()
方法的 Map ,它可以再次来到1个子树;

  IdentifyHashMap:

  使用 == 代替 equals() 对“键”作比较的 hash map
。专为消除非凡难题而陈设。

三  比较

1.数组(Array) 数组类(Arrays)

  1.1
java存储及随意走访一而再串对象时,array最有功能,但缺点是容积固定且不可以动态改变,不能看清实际存在多少成分,length为体积;

  1.2 数组类专门操作数组,数组类拥有一组static函数:equals() ,fill()
,sort(),binarySearch() 在排好序的array中摸索元素 ,System.arraycopy()
array复制;

  1.3 若编写程序时不领会终究要求多少对象,须求在上空不足时自动扩增容积,则必要选择容器类库,
array 不适用;

2.容器(Collection)和map

  2.1
collection逐个地方唯有多少个要素;map持有key-value对,像个小型数据库
( Collections.max(Collection coll); 取 coll 中最大的要素);

四、总结

1 List,Set,Map将持有对象一律视为object型别;

2 Collection 、 List 、 Set 、 Map 都以接口,不大概实例化。继承自它们的
ArrayList, Vector, HashTable, HashMap 是具体 class ,这一个才可被实例化;

3 使用keySet()抽取key体系,将 map 中的全数 keys 生成3个Set(不可重复);

   使用 values() 抽取 value 连串,将 map 中的全部 values 生成三个Collection ;

4 在种种 Lists ,对于急需飞速插入,删除成分,应该运用 LinkedList (可用
LinkedList 构造堆栈 stack 、队列 queue
),假若急需火速随机走访成分,应该运用 ArrayList 。最好的做法是以
ArrayList 作为缺省采用。 Vector 总是比 ArrayList
慢,所以要尽量防止使用;

5 在种种 Sets 中, HashSet 常常优于 HashTree
(插入、查找)。唯有当须要发出三个通过排序的队列,才用 TreeSet 。
HashTree 存在的唯一理由:可以爱护其内成分的排序状态;在各类 Maps 中
HashMap 用于飞快搜索

6 当成分个数固定,用 Array ,因为 Array 效用是参天的

 

 

原文:http://blog.csdn.net/jackie03/article/details/7312481

 

相关文章