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个数组只好存放类型一样的数据(基本项目/引用类型)
2)
JAVA集合能够存储和操作数目不定点的一组数据。

3)
 若程序时不清楚到底供给某个对象,需求在空中不足时自动扩大与扩展体量,则必要利用容器类库,array不适用。

–List          子接口
有序 可重复

  –LinkedList
               接口落成类  链表  插入删除  没有共同  线程不安全

二 set map list的区别  

都以集结接口

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

List 按指标进入的各样保存对象,不做排序或编辑操作。

Set对各样对象只接受3回,并利用自身之中的排序方法(常常,你只关怀有些成分是或不是属于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 的实际类型如何,它都帮忙2个 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实例都有二个体量(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没有同步方法。假设八个线程同时做客二个List,则必须协调完毕访问同步。一种缓解办法是在创立List时组织3个联手的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实行“弱引用”,若是2个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.
    然则足以将随机多少个键独享映射到同1个值对象上。
    Conllections : 集合实用类
    Conllections提供了供JAVA集合实用的静态方法

    –LinkedHashSet

柒 、 怎样挑选

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

2、
     1)
 在种种Lists中,最棒的做法是以ArrayList作为缺省选用。当插入、删除频仍时,使用LinkedList();
           Vector总是比ArrayList慢,所以要尽量幸免使用。
      2)
在各个Sets中,HashSet平时优于HashTree(插入、查找)。惟有当必要发出2个通过排序的行列,才用TreeSet。
           HashTree存在的绝无仅有理由:能够有限辅助其内成分的排序状态。
      3) 在各个Maps中,HashMap用于高效搜索。
      4)  当成分个数固定,用Array,因为Array效用是最高的。

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

注意:

① 、Collection没有get()方法来取得某些成分。只好通过iterator()遍历元素。
② 、Set和Collection拥有一模一样的接口。
③ 、List,能够透过get()方法来壹遍取出2个因素。使用数字来挑选一堆对象中的三个,get(0)…。(add/get)
四 、一般选用ArrayList。用LinkedList构造堆栈stack、队列queue。

五 、Map用 put(k,v) /
get(k),还是能使用containsKey()/containsValue()来检查当中是不是带有某些key/value。
      HashMap会利用目的的hashCode来飞快找到key。
    *     hashing          
哈希码正是将目的的新闻经过一些变迁形成2个无比的int值,这几个值存储在三个array中。
         
大家都清楚全数存款和储蓄结构中,array查找速度是最快的。所以,能够加速查找。
      
         
产生冲击时,让array指向四个values。即,数组每种位置上又变卦1个梿表。

陆 、Map巧月素,能够将key体系、value体系单独抽取出来。 使用keySet()抽取key连串,将map中的全体keys生成一个Set。
选拔values()抽取value类别,将map中的全体values生成1个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提供了3个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
方法检查和测试贰个要素在仓房中的地方。 Stack 刚成立后是空栈;

2 Set接口

  2.1 set不保障维护元素的主次,最多有2个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
达成了三个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 ,它可以回来三个子树;

  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 生成2个Set(不可重复);

   使用 values() 抽取 value 系列,将 map 中的全数 values 生成3个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

 

相关文章