Java中间Map List Set和其他收藏品

时间：2024-01-10 15:58:08

Map List Set和其他收藏品：

一、概述

在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的容量。

2、Java中有一个Arrays类，专门用来操作array。

arrays中拥有一组static函数。

     equals()：比較两个array是否相等。

array拥有同样元素个数，且全部相应元素两两相等。

     fill()：将值填入array中。

sort()：用来对array进行排序。

     binarySearch()：在排好序的array中寻找元素。

     System.arraycopy()：array的复制。

一、数组Array和集合的差别：


1)  数组是大小固定的，而且同一个数组仅仅能存放类型一样的数据（基本类型/引用类型）

2) JAVA集合能够存储和操作数目不固定的一组数据。
3)  若程序时不知道到底须要多少对象，须要在空间不足时自己主动扩增容量，则须要使用容器类库，array不适用。

二 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 值

三、 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 中每个元素。

典型的使用方法例如以下：

　

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

由 Collection 接口派生的两个接口是 List 和 Set 。 List 按对象进入的顺序保存对象。不做排序或编辑操作。 Set 对每一个对象仅仅接受一次，并使用自己内部的排序方法 ( 通常，你仅仅关心某个元素是否属于 Set, 而不关心它的顺序--
否则应该使用 List) 。

四、 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时构造一个同步的List：

　　List list = Collections.synchronizedList(new LinkedList(...));

4. Stack 类

　　Stack继承自Vector，实现一个后进先出的堆栈。

Stack提供5个额外的方法使得Vector得以被当作堆栈使用。主要的push和pop方法，还有peek方法得到栈顶的元素。empty方法測试堆栈是否为空。search方法检測一个元素在堆栈中的位置。Stack刚创建后是空栈。

使用方法：

  1. package Test;
  2. import java.util.ArrayList;
  3. import java.util.Iterator;
  4. import java.util.List;
  5. public class TestList {
  6. public static void main(String dd[]) {
  7. // new了一个存储list
  8. List l = new ArrayList();
  9. // 由于Collection framework仅仅能存储对象所以new封装类
  10. l.add(new Integer(1));
  11. l.add(new Integer(2));
  12. l.add(new Integer(3));
  13. l.add(new Integer(4));
  14. Iterator it = l.iterator();
  15. //使用 迭代器（Iterator）:
  16. // hasNext是取值取的是当前值.他的运算过程是推断下个是否有值假设有继续.
  17. while (it.hasNext()) {
  18. System.out.println("iterator：Element in list is :   " + it.next());
  19. }
  20. //用for循环和get()方法：
  21. for (int i = 0; i < l.size(); i++) {
  22. System.out.println("for：Element in list is :   " + l.get(i));
  23. }
  24. }
  25. }

LinkedList

  1. package Test;
  2. import java.util.Iterator;
  3. import java.util.LinkedList;
  4. public class TestLinkedList {
  5. public static void main(String arg[]) {
  6. LinkedList ll = new LinkedList();// 声明LinkedList并实例化
  7. // 使用add（）方法加入元素
  8. ll.add("a");
  9. ll.add("b");
  10. ll.add("c");
  11. // 使用Iterator迭代器遍历出集合的元素并打印
  12. Iterator it = ll.iterator();
  13. while (it.hasNext()) {
  14. System.out.println(it.next());
  15. }
  16. System.out.println("------------------");
  17. // 向链表头和尾分别加入x和z
  18. ll.addFirst("z");
  19. ll.addLast("x");
  20. // 遍历查看加入后的结果
  21. for (Iterator i = ll.iterator(); i.hasNext();) {
  22. System.out.println(i.next());
  23. }
  24. }
  25. }

ArrayList和LinkedList的差别。

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

2.对于随机訪问get和set，ArrayList认为优于LinkedList，由于LinkedList要移动指针。

3.对于新增和删除操作add和remove。LinedList比較占优势，由于ArrayList要移动数据。

假设熟悉数据结构的同学，就会一下明确，ArrayList就是线性表的顺序表示，LinkedList就是线性表的链表表示。

五、 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时，结果会按元素插入的次序显示。

使用方法：

  1. Set set=new HashSet();
  2. String s1=new String("hello");
  3. String s2=s1;
  4. String s3=new String("world");
  5. set.add(s1);
  6. set.add(s2);
  7. set.add(s3);
  8. System.out.println(set.size());//打印集合中对象的数目 为 2。
  9. Set 的 add()方法是怎样推断对象是否已经存放在集合中？
  10. boolean isExists=false;
  11. Iterator iterator=set.iterator();
  12. while(it.hasNext())  {
  13. String oldStr=it.next();
  14. if(newStr.equals(oldStr)){
  15. isExists=true;
  16. }
  17. }

六、 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实行“弱引用”，假设一个key不再被外部所引用。那么该key能够被GC回收。

4. TreeMap 类

基于红黑树数据结构的实现。查看“键”或“键值对”时。它们会被排序 ( 次序由 Comparabel 或 Comparator 决定 ) 。

TreeMap 的特点在于，你得到的结果是经过排序的。 TreeMap 是唯一的带有 subMap() 方法的 Map 。它能够返回一个子树。

5. IdentifyHashMap 类

使用 == 取代 equals() 对“键”作比較的 hash map 。

专为解决特殊问题而设计。

使用方法：

1 加入。删除操作：

  1. Object put(Object key, Object value): 向集合中增加元素
  2. Object remove(Object key):   删除与KEY相关的元素
  3. void putAll(Map t):   将来自特定映像的全部元素加入给该映像
  4. void clear(): 从映像中删除全部映射

2 查询操作：

    Object get(Object key): 获得与keywordkey相关的值

    Map集合中的键对象不同意反复，也就说，随意两个键对象通过equals()方法比較的结果都是false.

    可是能够将随意多个键独享映射到同一个值对象上。

    Conllections : 集合有用类

    Conllections提供了供JAVA集合有用的静态方法

七、 怎样选择

1、容器类和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都是排序的。

注意：

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。

    *     hashing

          哈希码就是将对象的信息经过一些转变形成一个独一无二的int值，这个值存储在一个array中。

          我们都知道全部存储结构中，array查找速度是最快的。所以，能够加速查找。

发生碰撞时。让array指向多个values。即。数组每一个位置上又生成一个梿表。

6、Map中元素，能够将key序列、value序列单独抽取出来。

使用keySet()抽取key序列，将map中的全部keys生成一个Set。

使用values()抽取value序列。将map中的全部values生成一个Collection。

为什么一个生成Set，一代Collection？这是因为，key总是唯一，value反复同意。

版权声明：本文博客原创文章。博客，未经同意，不得转载。

相关文章