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)

1、功效高,但体量固定且无法动态改变。array还有一个弱点是,无法看清当中实际存有多少成分,length只是告诉咱们array的体积。
二、Java中有贰个Arrays类,专门用来操作array。
     arrays中持有一组static函数,
   
 equals():比较五个array是或不是等于。array拥有相同成分个数,且具有对应成分两两相等。
     fill():将值填入array中。
     sort():用来对array进行排序。
     binarySearch():在排好序的array中追寻元素。
     System.arraycopy():array的复制。

1、数组Array和集合的区分:

一)
 数组是大大小小固定的,并且同2个数组只能存放类型一样的多寡(基本类型/引用类型)
②)
JAVA集合能够存储和操作数目不固定的一组数据。

3)
 若程序时不懂获得底需求多少对象,要求在上空不足时自动扩大与扩展容积,则要求运用容器类库,array不适用。

–List          子接口
有序 可重复

  –LinkedList
               接口完成类  链表  插入删除  未有同台  线程不安全

二 set map list的区别  

都以聚众接口

  set --当中的值不允许再次,冬天的数据结构 
  list   --个中的值允许再一次,因为其为平稳的数据结构 
  map--成对的数据结构,健值必须拥有唯壹性(键不可能同,不然值替换) 

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

Set对各类对象只接受一次,并利用自个儿之中的排序方法(平常,你只关切有个别成分是或不是属于Set,而不关切它的逐一–不然应该利用List)。

Map同样对各种成分保存一份,但那是依照”键”的,Map也有内置的排序,因此不爱惜成分添加的逐一。假使添法郎素的逐1对你很要紧,应该利用
LinkedHashSet大概LinkedHashMap.

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

List 可以因此下标
(壹,二..)
来取得值,值能够再一次

而 Set 只可以因而游标来取值,并且值是无法重复的

ArrayList , Vector , LinkedList 是 List 的贯彻类
ArrayList 是线程不安全的, Vector
是线程安全的,那多个类底层都是由数组完毕的
LinkedList 是线程不安全的,底层是由链表达成的  

Map 是键值对聚集
HashTable 和 HashMap 是 Map 的兑现类
HashTable 是线程安全的,不能够积存 null 值
HashMap 不是线程安全的,能够储存 null 值

  –ArrayList
                 接口实现类  数组  随机访问  未有联手
 线程不安全

  –Vector    
                 接口完成类  数组               同步      
 线程安全

三、 Collections类和Collection接口

        
Collections是本着集合类的3个声援类,他提供一二种静态方法完结对各类集合的探寻、排序、线程安全化等操作。

 
   
 Collection是最中央的集纳接口,三个Collection代表1组Object,即Collection的要素(Elements)。1些
Collection允许同壹的成分而另1部分要命。壹些能排序而另1部分要命。Java SDK不提供直接接轨自Collection的
类,Java SDK提供的类皆现在续自Collection的“子接口”如List和Set。

  全体达成 Collection
接口的类都无法不提供四个专业的构造函数:无参数的构造函数用于创立七个空的
Collection ,有三个 Collection 参数的构造函数用于创立二个新的 Collection
,这几个新的 Collection 与传播的 Collection
有同样的因素。后1个构造函数允许用户复制二个 Collection 。

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

  怎么样遍历 Collection
中的每1个成分?不论 Collection 的莫过于类型怎么着,它都帮忙两个 iterator()
的法子,该办法重临2个迭代子,使用该迭代子即可逐一走访 Collection
中每多少个成分。典型的用法如下:

 

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

由 Collection 接口派生的多个接口是 List 和 Set 。 List
按目的进入的一1保存对象,不做排序或编辑操作。 Set
对种种对象只接受一遍,并选择自个儿内部的排序方法 (
平日,你只关怀有些成分是还是不是属于 Set, 而不关怀它的顺序–
不然应当运用 List) 。


    –Stack

4、 List接口,有序可重复的聚众

实则有二种List:
一种是基本的ArrayList,其独到之处在于随机走访成分,另一种是越来越强劲的LinkedList,它并不是为快捷随机走访安插的,而是有着1套更通用的法门。 

List :
次序是List最重大的表征:它有限支撑维护成分特定的逐一。List为Collection添加了不少措施,使得能够向List中间插入与移除成分(那只推荐LinkedList使用。)1个List能够生成ListIterator,使用它可以从七个样子遍历List,也足以从List中间插入和移除成分。 

1.
ArrayList类

1)
ArrayList达成了可变大小的数组。它同意持有因素,包罗null。ArrayList未有一起。
2)
size,isEmpty,get,set方法运转时刻为常数。但是add方法开发为分摊的常数,添加n个成分需求O(n)的时光。其余的秘籍运维时刻为线性。
三)
每种ArrayList实例都有二个容积(Capacity),即用于存款和储蓄成分的数组的轻重。那几个体积可乘机不断添加新因素而活动增添,然而拉长算法
并未概念。当必要插入大批量要素时,在插入前能够调用ensureCapacity方法来充实ArrayList的容积以进步插入效用。
4) 和LinkedList一样,ArrayList也是非同步的(unsynchronized)。

5) 由数组达成的List。允许对元素举行快捷随机走访,不过向List中间插入与移除成分的快慢一点也不快。ListIterator只应该用来由后迈入遍历ArrayList,而不是用来插入和移除元素。因为那比LinkedList花费要大过多。
2. Vector类
  Vector分外周围ArrayList,可是Vector是联合的。由Vector创造的Iterator,即使和ArrayList创造的Iterator是一模壹样接口,可是,因为Vector是1块的,当3个Iterator被创制而且正在被接纳,另1个线程改变了Vector的情状(例如,添加或删除了某些成分),那时调用Iterator的艺术时将抛出ConcurrentModificationException,由此必须捕获该特别。

3.
LinkedList类

  LinkedList落到实处了List接口,允许null成分。别的LinkedList提供额外的get,remove,insert方法在
LinkedList的首部或尾巴部分。如下列形式:addFirst(),
addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(),
那么些形式(未有在此外接口或基类中定义过)。那一个操作使LinkedList可被看做仓库(stack),队列(queue)或双向队列(deque)。
  注意LinkedList未有同台方法。如若多少个线程同时做客2个List,则必须自身达成访问同步。1种缓解办法是在创制List时组织八个手拉手的List:
  List list = Collections.synchronizedList(new LinkedList(…));

4.
Stack 类

  Stack继承自Vector,实现1个后进先出的仓库。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的区别。

壹.ArrayList是贯彻了基于动态数组的数据结构,LinkedList基于链表的数据结构。

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

叁.对于新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要活动多少。

若是熟知数据结构的同学,就会须臾间知晓,ArrayList正是线性表的依次表示,LinkedList就是线性表的链表表示。

–Set          
                   子接口  仅收到3遍,并做内部排序  不可重复

伍、 Set接口,代表冬辰,不可重复的成团

      
 Set具有与Collection完全等同的接口,因而尚未任何额外的法力,不像后边有多个分歧的List。实际上Set正是Collection,只是作为不一样。(那是持续与多态思想的一级应用:表现各异的一言一动。)Set不保留重复的因素(至于何以判断成分相同则较为负责) 
Set :
存入Set的种种成分都必须是绝无仅有的,因为Set不保留重复成分。插手Set的成分必须定义equals()方法以保证目的的唯1性。Set与Collection有一齐1致的接口。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
只好照射1个 value 。 Map 接口提供3 种集合的视图, Map
的内容能够被用作一组 key 集合,一组 value 集合,或许1组 key-value
映射。

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

Map 同样对各样成分保存1份,但那是依照 ” 键” 的, Map
也有停放的排序,因此不拥戴成分添加的逐条。要是添英镑素的逐条对您很重大,应该使用
LinkedHashSet 或然 LinkedHashMap.

推行作用是 Map 的3个大难点。看看 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 ,二 ,三 放到 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));
  要取出一个数,比如 二 ,用相应的 key :
     Integer n =
(Integer)numbers.get(“two”);
     System.out.println(“two= ”+ n);
   由于作为 key 的目的将透过总计其散列函数来规定与之对应的 value
的职责,因而任何作为 key 的对象都必须实现 hashCode 方法和 equals 方法。
hashCode 方法和 equals 方法继承自根类 Object ,即便你用自定义的类当作
key 的话,要一定小心,遵照散列函数的概念,假如四个目的相同,即
obj1.equals(obj二)=true ,则它们的 hashCode
必须1致,但假诺两个指标不一样,则它们的 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进行“弱引用”,要是1个key不再被外表所引用,那么该key能够被GC回收。

4. TreeMap 类
听大人讲红黑树数据结构的实现。查看“键”或“键值对”时,它们会被排序 ( 次序由
Comparabel 或 Comparator 决定 ) 。 TreeMap
的天性在于,你拿走的结果是因而排序的。 TreeMap 是唯一的隐含 subMap()
方法的 Map ,它能够回来三个子树。

5. IdentifyHashMap

应用 == 代替 equals()
对“键”作比较的 hash map 。专为化解特殊题材而规划。

 用法:

一添加,删除操作:

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

 
  二 查询操作:
    Object get(Object key): 获得与重点字key相关的值
   
Map集合中的键对象不一样意再一次,也就说,任意八个键对象通过equals()方法比较的结果都以false.
    然而足以将轻易七个键独享映射到同1个值对象上。
    Conllections : 集合实用类
    Conllections提供了供JAVA集合实用的静态方法

    –LinkedHashSet

7、 如何抉择

一、容器类和Array的分别、择取
     
壹)容器类仅能具有对象引用(指向对象的指针),而不是将对象音信copy1份至数列某位置。
      二)一旦将对象置入容器内,便损失了该目的的型别新闻。

2、
     壹)
 在各样Lists中,最棒的做法是以ArrayList作为缺省选用。当插入、删除频仍时,使用LinkedList();
           Vector总是比ArrayList慢,所以要尽量幸免使用。
      2)
在各样Sets中,HashSet日常优于HashTree(插入、查找)。只有当需求发出几个通过排序的类别,才用TreeSet。
           HashTree存在的唯一理由:能够敬重其内成分的排序状态。
      3) 在各类Maps中,HashMap用于火速搜索。
      四)  当元素个数固定,用Array,因为Array成效是最高的。

结论:最常用的是ArrayList,HashSet,HashMap,Array。而且,大家也会发觉一个规律,用TreeXXX都以排序的。

注意:

壹、Collection未有get()方法来收获有个别成分。只好通过iterator()遍历成分。
二、Set和Collection拥有一模1样的接口。
3、List,能够由此get()方法来3回取出七个因素。使用数字来挑选一群对象中的2个,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。即,数组每种地方上又转移2个梿表。

六、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快

2、详细介绍

1、List接口

  一.壹 次序是List最重视的特色,可以用索引来访问成分,允许有相同成分;

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

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

  一.三LinkedList允许null值,提供了addFirst(),getFirst()等艺术在LinkedList的首部或后面部分,使linkedList可被用作仓库,队列或双向队列;

  一.四 LinkedList未有一起方法,假设二十多线程访问时,必须团结完结访问同步

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

  ArrayList:向List中间插入与移除成分的快慢一点也不快,随机走访绝对较快

  壹.五 ArrayList有数组达成,允许持有因素,包含null

  一.6  ListIterator 只应该用来由后迈入遍历 ArrayList,
而不是用来插入和移除成分。因为那比 LinkedList 费用要大过多;

  Vector:

  一.7由Vector创造的iterator被创建而且正在被使用,另一线程改变了vector的景观,那时调用
Iterator 的办法时将抛出 ConcurrentModificationException
,由此必须捕获该尤其

  Stack:

  1.捌 完结一个后进先出的库房,Stack 提供 5 个附加的不贰秘诀使得 Vector
得以被看作储藏室使用。基本的 push 和 pop 方法,还有 peek
方法得到栈顶的要素, empty 方法测试堆栈是不是为空, search
方法质量评定多个成分在库房中的地方。 Stack 刚创设后是空栈;

2 Set接口

  二.一 set不保障维护成分的先后,最多有3个null值;

  二.二 Set的构造函数有一个封锁原则
,传入的Collection参数无法包含重复的成分;

  HashSet:

  LinkedHashSet:

  TreeSet:

3.Map接口

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

  三.二HsahMap使用对象的hashCode()举行高效查询,“散列码”是“相对唯一”用以代表对象的
int 值,它是通过将该指标的一点音信实行更换而变更的,全部 Java
对象都能发出散列码,因为 hashCode() 是概念在基类 Object 中的方法;

  HashTable:

  三.3完成了贰个key-value映射的哈希表,任何非空对象都得以看作key可能value;

  三.四 添加多少put,去除数据get;

  3.五 Hashtable 通过起首化体量 (initial capacity) 和负载因子 (load
factor) 三个参数调整品质,常常缺省的 load factor 0.7五较好地贯彻了时光和空中的人均。增大 load factor
能够节省空间但对应的查找时间将附加,那会影响像 get 和 put 那样的操作;

  3.6作为key的指标将经过测算散列函数来规定与之相应的value的岗位,因而任何作为
key 的对象都不能够不完毕 hashCode 方法和 equals 方法。hashCode 方法和 equals
方法继承自根类 Object ,假诺您用自定义的类当作 key
的话,要一定小心,遵照散列函数的定义,假使五个目的相同,即
obj1.equals(obj二)=true ,则它们的 hashCode
必须一律,但要是三个对象差异,则它们的 hashCode
不必然区别,借使五个不等对象的 hashCode
相同,那种光景叫做冲突,争辨会造成操作哈希表的年华支出增大,所以尽量定义好的
hashCode() 方法,能加速哈希表的操作;

  HashMap:

  三.七 hashmap非同步,允许null值。将 HashMap 视为 Collection 时(
values() 方法可重回 Collection
),插入和查询“键值对”的花费是定位的,但其迭代子操作时间支付和 HashMap
的容积成比例。因而,如若迭代操作的习性非凡重大的话,不要将 HashMap
的开端化容积 (initial capacity) 设得过高,只怕负载因子 (load factor)
过低;

  LinkedHashMap

  三.捌 类似于 HashMap
,但是迭代遍历它时,取得“键值对”的顺序是其插入次序,也许是新近起码使用
(LRU) 的次序。只比 HashMap
慢一点。而在迭代访问时发而越来越快,因为它选取链表维护其中次序;

  WeakHashMap:

  三.九 弱键( weak key ) Map 是一种创新的 HashMap
,它是为缓解特殊题材安顿的,对 key 实行 “ 弱引用 ” ,假使三个 key
不再被外表所引用(未有 map 之外的引用),那么该 key 能够被垃圾收集器
(GC) 回收;

  TreeMap:

  基于红黑树数据结构的兑现。查看“键”或“键值对”时,它们会被排序 (
次序由 Comparabel 或 Comparator 决定 ) 。 TreeMap
的特点在于,你获取的结果是通过排序的。 TreeMap 是绝无仅有的蕴藏 subMap()
方法的 Map ,它可以回去2个子树;

  IdentifyHashMap:

  使用 == 代替 equals() 对“键”作比较的 hash map
。专为化解优秀难点而布署。

三  比较

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

  一.壹java存款和储蓄及随意走访接二连3串目的时,array最有效能,但缺点是容积固定且不恐怕动态改变,不可能断定实际存在多少成分,length为体量;

  一.二 数组类专门操作数组,数组类拥有一组static函数:equals() ,fill()
,sort(),binarySearch() 在排好序的array中寻觅成分 ,System.arraycopy()
array复制;

  1.3 若编写程序时不亮堂毕竟需求有个别对象,需求在上空欠缺时自动扩大与扩充体积,则须求动用容器类库,
array 不适用;

2.容器(Collection)和map

  二.1collection各种地点唯有一个成分;map持有key-value对,像个袖珍数据库
( Collections.max(Collection coll); 取 coll 中最大的要素);

四、总结

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

二 Collection 、 List 、 Set 、 Map 都以接口,不可能实例化。继承自它们的
ArrayList, Vector, HashTable, HashMap 是实际 class ,这么些才可被实例化;

三 使用keySet()抽取key连串,将 map 中的全体 keys 生成多少个Set(不可重复);

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

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

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

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

 

 

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