【第21期】观点:人工智能到底用 GPU?还是用 FPGA?

Collection、Map、Iterable

转载 2015年11月20日 08:37:05

数组(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不适用。


  1. 几乎有有的集合都是基于数组来实现的.  因为集合是对数组做的封装,所以,数组永远比任何一个集合要快  
  1. 但任何一个集合,比数组提供的功能要多  
  1.   
  1. 一:数组声明了它容纳的元素的类型,而集合不声明。这是由于集合以object形式来存储它们的元素。  
  1. 二:一个数组实例具有固定的大小,不能伸缩。集合则可根据需要动态改变大小。  
  1. 三:数组是一种可读/可写数据结构---没有办法创建一个只读数组。然而可以使用集合提供的ReadOnly方法,以只读方式来使用集合。该方法将返回一个集合的只读版本。



Java集合类基本概念

在编程中,常常需要集中存放多个数据。从传统意义上讲,数组是我们的一个很好的选择,前提是我们事先已经明确知道我们将要保存的对象的数量。一旦在数组初始化时指定了这个数组长度,这个数组长度就是不可变的,如果我们需要保存一个可以动态增长的数据(在编译时无法确定具体的数量),java的集合类就是一个很好的设计方案了。

集合类主要负责保存、盛装其他数据,因此集合类也被称为容器类。所以的集合类都位于java.util包下,后来为了处理多线程环境下的并发安全问题,java5还在java.util.concurrent包下提供了一些多线程支持的集合类。

在学习Java中的集合类的API、编程原理的时候,我们一定要明白,"集合"是一个很古老的数学概念,它远远早于Java的出现。从数学概念的角度来理解集合能帮助我们更好的理解编程中什么时候该使用什么类型的集合类。

Java容器类类库的用途是"保存对象",并将其划分为两个不同的概念:

复制代码
1) Collection
一组"对立"的元素,通常这些元素都服从某种规则
   1.1) List必须保持元素特定的顺序
   1.2) Set不能有重复元素
   1.3) Queue保持一个队列(先进先出)的顺序
2) Map
一组成对的"键值对"对象
复制代码

Collection和Map的区别在于容器中每个位置保存的元素个数:

1) Collection 每个位置只能保存一个元素(对象)
2) Map保存的是"键值对",就像一个小型数据库。我们可以通过""找到该键对应的""


java集合框架的基本接口/类层次结构

java.util.Collection [I]
+--java.util.List [I]
   +--java.util.ArrayList [C]
   +--java.util.LinkedList [C]
   +--java.util.Vector [C]
      +--java.util.Stack [C]
+--java.util.Set [I]
   +--java.util.HashSet [C]
      +--java.util.LinkedHashSet [C]
   +--java.util.SortedSet [I]
      +--java.util.TreeSet [C]

java.util.Map [I]
+--java.util.SortedMap [I]
   +--java.util.TreeMap [C]
+--java.util.Hashtable [C]
+--java.util.HashMap [C]
+--java.util.LinkedHashMap [C]
+--java.util.WeakHashMap [C]
 
[I]:接口
[C]:类


那么,为什么要有集合类?

面向对象的语言对事物的体现都是以对象的形式,为了方便对多个对象操作,就要对对象进行存储,集合类就是对多个对象进行存储的一种方式。



Collection的常用操作

方法

意义

boolean add(E e)

添加指定的元素

boolean addAll(Collection<? extends E> c)

将指定collection 中的所有元素都添加到新的collection 中

void clear()

移除所有元素

boolean contains(Object o)

检测是否包含指定的元素,如果真返回true,反之返回false

boolean containsAll(Collection<?> c)

检测是否包含某Collection的所有元素,如果真返回true,反之返回false

boolean equals(Object o)

对比指定的对象

int hashCode()

返回哈希码值

boolean isEmpty()

是否为空

Iterator<E> iterator()

迭代器

boolean remove(Object o)

移除对象

boolean removeAll(Collection<?> c)

移除某Collection的所有元素

boolean retainAll(Collection<?> c)

只保留两个Collection 的交集

Object[] toArray()

返回包含此 collection 中所有元素的数组

<T> T[]toArray(T[] a)

返回包含此 collection 中所有元素的数组;返回数组的运行时类型与指定数组的运行时类型相同




List接口

  List接口是有序的Collection,使用该接口能精确控制每个元素的插入位置,可以使用索引来访问List中的元素,跟数组是很类似的。并且List中允许有重复元素,当然有些List的实现类不允许重复元素的存在。

  List中有iterator()方法,还有listIterator方法,返回一个ListIterator接口,这个接口比标准的Iterator接口相比,多了一些add之类的方法,允许添加、删除、设置元素值以及向前或者向后遍历等。

  如上图,List下有几个常用类:LinkedList、ArrayList和Vector以及Stack

  (1)ArrayList类:实现了可变大小的数组。它允许包含所有元素,包括null。每个ArrayList实例都有一个容量,即用于存储元素的数组的大小,这个容量可以随着不断添加新元素而自动增加,但增长算法没有定义,当插入大量元素时,插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。

  • 底层的数据结构使用的是数组数据结构,封装了一个动态的增长的、允许再分配的Object[]数组
    • 查询速度很快。
    • 增删慢。
    • 线程不同步。
    • 默认长度为10增长率为50%。

    (2)LinkedList类:允许null元素,提供额外的get,remove和insert方法,这使得LinkedList可以用作stack、queue或双向队列。它可以再List的中间插入和移除,在这方面比ArrayList有效,但是在随机访问方面就没有ArrayList有效了。如果多个线程同时访问一个List,则必须自己实现访问同步,一种解决方法是在创建List时构造一个同步的List:

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

implements List<E>, Deque<E>。实现List接口,能对它进行队列操作,即可以根据索引来随机访问集合中的元素。同时它还实现Deque接口,即能将LinkedList当作双端队列使用。自然也可以被当作"栈来使用"

  • 底层使用的链表数据结构。
    • 增删速度很快。
    • 查询稍慢。
    • 线程不同步。
    • ArrayList就是线性表的顺序表示,LinkedList就是线性表的链表表示。

(3)Vector类:Vector跟ArrayList非常类似,但是Vector是同步的,由Vector创建的Iterator,虽然和ArrayList创建的 Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了Vector的状态(例如,添加或删除了一些元素),这时调用Iterator的方法时将抛出ConcurrentModificationException,因此必须捕获该异常。

  • Vector:底层是数组数据结构。
    • 线程同步,多线程时使用
    • 被ArrayList替代了。
    • 长度增长率100%。

  (4)Stack类:继承自Vector,实现一个后进先出的栈。提供了几个基本方法,push、pop、peak、empty、search等。



Set接口

Set接口是继承自Collection的,它不能包含有重复元素且无序也不包含索引。Set中最多有一个null元素。Set具有与Collection完全一样的接口,因此没有任何额外的功能,不像前面有两个不同的List。实际上Set就是Collection,只是行为不同。(这是继承与多态思想的典型应用:表现不同的行为。)Set不保存重复的元素(至于如何判断元素相同则较为负责) 

Set : 存入Set的每个元素都必须是唯一的,因为Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。 

因为Set的这个制约,在使用Set集合的时候,应该注意:
    1,为Set集合里的元素的实现类实现一个有效的equals(Object)方法。
    2,对Set的构造函数,传入的Collection参数不能包含重复的元素。
Set下有几个set类,HashSet、SortedSet、TreeSet,用的较多的是HashSet,其他两种基本不常用。

  (1)HashSet,底层数据结构式哈希表,由哈希表支持,存取速度快,不保证集合的迭代顺序,特别是不保证该顺序恒久不变,此类允许使用null元素。
  • 底层数据结构式哈希表。
    • 线程不同步
    • 主要作用是快速查找
    • HashSet是如何保证元素的唯一性的呢?是通过元素的两个方法,hashCode和equals来完成。如果元素的HashCode值相同,才会判断equals是否为true。如果元素的hashCode值不同,不会调用equals。
    • 注意,对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashCode和equals方法。

equals()决定是否可以加入HashSet、而hashCode()决定存放的位置,它们两者必须同时满足才能允许一个新元素加入HashSet
但是要注意的是: 如果两个对象的hashCode相同,但是它们的equlas返回值不同,HashSet会在这个位置用链式结构来保存多个对象。而HashSet访问集合元素时也是根据元素的HashCode值来快速定位的,这种链式结构会导致性能下降。

所以如果需要把某个类的对象保存到HashSet集合中,我们在重写这个类的equlas()方法和hashCode()方法时,应该尽量保证两个对象通过equals()方法比较返回true时,它们的hashCode()方法返回值也相等

  
(2)TreeSet保存次序的Set。使用它可以从Set中提取有序的序列。
  • 底层数据结构式二叉树。注:添加元素必须实现Comparable接口或在实例TreeSet时指定比较器
    • 可以对Set集合中的元素进行排序。保证元素唯一性的依据:compareTo方法return 0;
    • TreeSet排序的第一种方式:让元素自身具备比较性。元素需要实现Cmparable接口,覆盖compareTo方法。这种方式也称为元素自然排序,或者叫做默认排序。
    • TreeSet的第二种排序方式:定义一个类,实现Comparator接口,覆盖compare方法。
    • 当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化,就有了这种比较方式。
    • 当两种排序都存在时,以比较器为主。

与HashSet集合采用hash算法来决定元素的存储位置不同,TreeSet采用红黑树的数据结构来存储集合元素。TreeSet支持两种排序方式: 自然排序、定制排序
1. 自然排序:

TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系,然后将集合元素按升序排序,即自然排序。如果试图把一个对象添加到TreeSet时,则该对象的类必须实现Comparable接口,否则程序会抛出异常。

当把一个对象加入TreeSet集合中时,TreeSet会调用该对象的compareTo(Object obj)方法与容器中的其他对象比较大小,然后根据红黑树结构找到它的存储位置。如果两个对象通过compareTo(Object obj)方法比较相等,新对象将无法添加到TreeSet集合中(牢记Set是不允许重复的概念)。

注意: 当需要把一个对象放入TreeSet中,重写该对象对应类的equals()方法时,应该保证该方法与compareTo(Object obj)方法有一致的结果,即如果两个对象通过equals()方法比较返回true时,这两个对象通过compareTo(Object obj)方法比较结果应该也为0(即相等)


LinkedHashSet:具有HashSet的查询速度,且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时,结果会按元素插入的次序显示。LinkedHashSet集合也是根据元素的hashCode值来决定元素的存储位置,但和HashSet不同的是,它同时使用链表维护元素的次序,这样使得元素看起来是以插入的顺序保存的。
当遍历LinkedHashSet集合里的元素时,LinkedHashSet将会按元素的添加顺序来访问集合里的元素。
LinkedHashSet需要维护元素的插入顺序,因此性能略低于HashSet的性能,但在迭代访问Set里的全部元素时(遍历)将有很好的性能(链表很适合进行遍历)

 

Map接口

Map集成Collection接口,Map和Collection是两种不同的集合,Collection是值(value)的集合,Map是键值对(key,value)的集合,key不允许重复。包含几种主要类和接口:HashMap、LinkedMap、WeakHashMap、SortedMap、TreeMap、HashTable等几种。
Map的key不允许重复,即同一个Map对象的任何两个key通过equals方法比较结果总是返回false。
关于Map,我们要从代码复用的角度去理解,java是先实现了Map,然后通过包装了一个所有value都为null的Map就实现了Set集合
Map的这些实现类和子接口中key集的存储形式和Set集合完全相同(即key不能重复)
Map的这些实现类和子接口中value集的存储形式和List非常类似(即value可以重复、根据索引来查找)

  (1)Hashtable继承Map接口,实现一个key-value映射的哈希表。任何非空(non-null)的对象都可作为key或者value。添加数据使用put(key, value),取出数据使用get(key),这两个基本操作的时间开销为常数。
  (2)WeakHashMap类,WeakHashMap是一种改进的HashMap,HashMap的key保留了对实际对象的"强引用",这意味着只要该HashMap对象不被销毁,该HashMap所引用的对象就不会被垃圾回收。但WeakHashMap的key只保留了对实际对象的弱引用,这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所引用,则这些key所引用的对象可能被垃圾回收,当垃圾回收了该key所对应的实际对象之后,WeakHashMap也可能自动删除这些key所对应的key-value对

HashMapMap基于散列表的实现。插入和查询“键值对”的开销是固定的。可以通过构造器设置容量capacity和负载因子load factor,以调整容器的性能。 最多只允许一条为null的键

LinkedHashMap也使用双向链表来维护key-value对的次序,该链表负责维护Map的迭代顺序,与key-value对的插入顺序一致(注意和TreeMap对所有的key-value进行排序进行区。只比HashMap慢一点。而在迭代访问时反而更快,因为它使用链表维护内部次序。

TreeMap基于红黑树数据结构的实现,

每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对(节点)时,需要根据key对节点进行排序。TreeMap可以保证所有的key-value对处于有序状态。同样,TreeMap也有两种排序方式: 自然排序、定制排序查看“键”或“键值对”时,它们会被排序(次序由Comparabel或Comparator决定)。TreeMap的特点在 于,你得到的结果是经过排序的。TreeMap是唯一的带有subMap()方法的Map,它可以返回一个子树。

执行效率是Map的一个大问题。看看get()要做哪些事,就会明白为什么在ArrayList中搜索“键”是相当慢的。而这正是HashMap提高速 度的地方。HashMap使用了特殊的值,称为“散列码”(hash code),来取代对键的缓慢搜索。“散列码”是“相对唯一”用以代表对象的int值,它是通过将该对象的某些信息进行转换而生成的。所有Java对象都 能产生散列码,因为hashCode()是定义在基类Object中的方法。 

HashMap就是使用对象的hashCode()进行快速查询的。此方法能够显着提高性能。 

 
总结:
如果涉及到堆栈,队列等操作,应该考虑用List,对于需要快速插入,删除元素,应该使用LinkedList,如果需要快速随机访问元素,应该使用ArrayList。
    如果程序在单线程环境中,或者访问仅仅在一个线程中进行,考虑非同步的类,其效率较高,如果多个线程可能同时操作一个类,应该使用同步的类。
    在除需要排序时使用TreeSet,TreeMap外,都应使用HashSet,HashMap,因为他们 的效率更高。
    要特别注意对哈希表的操作,作为key的对象要正确复写equals和hashCode方法。
 
    容器类仅能持有对象引用(指向对象的指针),而不是将对象信息copy一份至数列某位置。一旦将对象置入容器内,便损失了该对象的型别信息。
    尽量返回接口而非实际的类型,如返回List而非ArrayList,这样如果以后需要将ArrayList换成LinkedList时,客户端代码不用改变。这就是针对抽象编程。
在各种Lists中,最好的做法是以ArrayList作为缺省选择。当插入、删除频繁时,使用LinkedList();Vector总是比ArrayList慢,所以要尽量避免使用。
在各种Sets中,HashSet通常优于HashTree(插入、查找)。只有当需要产生一个经过排序的序列,才用TreeSet。HashTree存在的唯一理由:能够维护其内元素的排序状态。
在各种Maps中,HashMap用于快速查找。
当元素个数固定,用Array,因为Array效率是最高的。
 
注意:
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允许重复。

HashMap和HashTable的比较

HashMap和Hashtable都实现了Map接口,但决定用哪一个之前先要弄清楚它们之间的分别。主要的区别有:线程安全性,同步(synchronization),以及速度

  1. HashMap几乎可以等价于Hashtable,除了HashMap是非synchronized的,并可以接受null(HashMap可以接受为null的键值(key)和值(value),而Hashtable则不行)。
  2. HashMap是非synchronized,而Hashtable是synchronized,这意味着Hashtable是线程安全的,多个线程可以共享一个Hashtable;而如果没有正确的同步的话,多个线程是不能共享HashMap的。Java 5提供了ConcurrentHashMap,它是HashTable的替代,比HashTable的扩展性更好。
  3. 另一个区别是HashMap的迭代器(Iterator)是fail-fast迭代器,而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构(增加或者移除元素),将会抛出ConcurrentModificationException,但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。但这并不是一个一定发生的行为,要看JVM。这条同样也是Enumeration和Iterator的区别。
  4. 由于Hashtable是线程安全的也是synchronized,所以在单线程环境下它比HashMap要慢。如果你不需要同步,只需要单一线程,那么使用HashMap性能要好过Hashtable。
  5. HashMap不能保证随着时间的推移Map中的元素次序是不变的。

要注意的一些重要术语:

1) sychronized意味着在一次仅有一个线程能够更改Hashtable。就是说任何线程要更新Hashtable时要首先获得同步锁,其它线程要等到同步锁被释放之后才能再次获得同步锁更新Hashtable。

2) Fail-safe和iterator迭代器相关。如果某个集合对象创建了Iterator或者ListIterator,然后其它的线程试图“结构上”更改集合对象,将会抛出ConcurrentModificationException异常。但其它线程可以通过set()方法更改集合对象是允许的,因为这并没有从“结构上”更改集合。但是假如已经从结构上进行了更改,再调用set()方法,将会抛出IllegalArgumentException异常。

3) 结构上的更改指的是删除或者插入一个元素,这样会影响到map的结构。

我们能否让HashMap同步?

HashMap可以通过下面的语句进行同步:Map m = Collections.synchronizeMap(hashMap);

结论

Hashtable和HashMap有几个主要的不同:线程安全以及速度。仅在你需要完全的线程安全的时候使用Hashtable,而如果你使用Java 5或以上的话,请使用ConcurrentHashMap吧。

ConcurrentHashMap 是 Doug Lea 的 util.concurrent 包的一部分,现已被集成到JDK5.0中,它提供比 Hashtable 或者 synchronizedMap 更高程度的并发性。而且,对于大多数成功的 get() 操作它会设法避免完全锁定,其结果就是使得并发应用程序有着非常好的吞吐量。

ConcurrentHashMap为了提高本身的并发能力,在内部采用了一个叫做Segment的结构,一个Segment其实就是一个类Hash Table的结构,Segment内部维护了一个链表数组

从上面的结构我们可以了解到,ConcurrentHashMap定位一个元素的过程需要进行两次Hash操作,第一次Hash定位到Segment,第二次Hash定位到元素所在的链表的头部,因此,这一种结构的带来的副作用是Hash的过程要比普通的HashMap要长,但是带来的好处是写操作的时候可以只对元素所在的Segment进行加锁即可,不会影响到其他的Segment,这样,在最理想的情况下,ConcurrentHashMap可以最高同时支持Segment数量大小的写操作(刚好这些写操作都非常平均地分布在所有的Segment上),所以,通过这一种结构,ConcurrentHashMap的并发能力可以大大的提高。

HashMap的底层源码实现

HashMap的底层主要是基于数组和链表来实现的,它之所以有相当快的查询速度主要是因为它是通过计算散列码来决定存储的位置,能够很快的计算出对象所存储的位置。HashMap中主要是通过key的hashCode来计算hash值的,只要hashCode相同,计算出来的hash值就一样。如果存储的对象对多了,就有可能不同的对象所算出来的hash值是相同的,这就出现了所谓的hash冲突。学过数据结构的同学都知道,解决hash冲突的方法有很多,HashMap底层是通过链表来解决hash冲突的。

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        final int hash;

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n; //hash值冲突后存放在链表的下一个
            key = k;
            hash = h;
        }

        .........
    }
HashMap其实就是一个Entry数组,Entry对象中包含了键和值,其中next也是一个Entry对象,它就是用来处理hash冲突的,形成一个链表。

//计算hash值的方法 通过键的hashCode来计算
    static int hash(int h) {
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }
得到hash码之后就会通过hash码去计算出应该存储在数组中的索引,计算索引的函数如下:

static int indexFor(int h, int length) { //根据hash值和数组长度算出索引值
         return h & (length-1);  //这里不能随便算取,用hash&(length-1)是有原因的,这样可以确保算出来的索引是在数组大小范围内,不会超出
     }

这个方法非常巧妙,它通过 h & (table.length -1) 来得到该对象的保存位,而HashMap底层数组的长度总是 2 次方,这是HashMap在速度上的优化。

length总是 2 n次方时,h& (length-1)运算等价于对length取模,也就是h%length,但是&%具有更高的效率。

  这看上去很简单,其实比较有玄机的,我们举个例子来说明:

  假设数组长度分别为1516,优化后的hash码分别为89,那么&运算后的结果如下:

       h & (table.length-1)                     hash                             table.length-1

       8 & (15-1)                                 0100                                1110                                  0100

       9 & (15-1)                                 0101                   &              1110                   =                0100

       -----------------------------------------------------------------------------------------------------------------------

       8 & (16-1)                                 0100                                1111                   =                0100

       9 & (16-1)                                 0101                                1111                   =                0101

  

  从上面的例子中可以看出:当它们和15-11110的时候,产生了相同的结果,也就是说它们会定位到数组中的同一个位置上去,这就产生了碰撞,89会被放到数组中的同一个位置上形成链表,那么查询的时候就需要遍历这个链 表,得到8或者9,这样就降低了查询的效率。同时,我们也可以发现,当数组长度为15的时候,hash值会与15-11110)进行,那么 最后一位永远是0,而0001001101011001101101111101这几个位置永远都不能存放元素了,空间浪费相当大,更糟的是这种情况中,数组可以使用的位置比数组长度小了很多,这意味着进一步增加了碰撞的几率,减慢了查询的效率!而当数组长度为16时,即为2n次方时,2n-1得到的二进制数的每个位上的值都为1,这使得在低位上&时,得到的和原hash的低位相同,加之hash(int h)方法对keyhashCode的进一步优化,加入了高位计算,就使得只有相同的hash值的两个值才会被放到数组中的同一个位置上形成链表。

   所以说,当数组长度为2n次幂的时候,不同的key算得得index相同的几率较小,那么数据在数组上分布就比较均匀,也就是说碰撞的几率小,相对的,查询的时候就不用遍历某个位置上的链表,这样查询效率也就较高了。

  

  上面说明了前面所说的HashMap容量总是取2的指数次幂的原因。下面我们继续回到put方法里面,前面已经计算出索引的值了,看到第6到14行,如果数组中该索引的位置的链表已经存在key相同的对象,则将其覆盖掉并返回原先的值。如果没有与key相同的键,则调用addEntry方法创建一个Entry对象


table 的实质就是一个数组,一个长度为 capacity 的数组。 
对于 HashMap 及其子类而言,它们采用 Hash 算法来决定集合中元素的存储位置。当系统开始初始化 HashMap 时,系统会创建一个长度为 capacity 的 Entry 数组,这个数组里可以存储元素的位置被称为“桶(bucket)”,每个 bucket 都有其指定索引,系统可以根据其索引快速访问该 bucket 里存储的元素。 
无论何时,HashMap 的每个“桶”只存储一个元素(也就是一个 Entry),由于 Entry 对象可以包含一个引用变量(就是 Entry 构造器的的最后一个参数)用于指向下一个 Entry,因此可能出现的情况是:HashMap 的 bucket 中只有一个 Entry,但这个 Entry 指向另一个 Entry ——这就形成了一个 Entry 链。如图 1 所示: 
 
图 1. HashMap 的存储示意 
HashMap 的读取实现 
当 HashMap 的每个 bucket 里存储的 Entry 只是单个 Entry ——也就是没有通过指针产生 Entry 链时,此时的 HashMap 具有最好的性能:当程序通过 key 取出对应 value 时,系统只要先计算出该 key 的 hashCode() 返回值,在根据该 hashCode 返回值找出该 key 在 table 数组中的索引,然后取出该索引处的 Entry,最后返回该 key 对应的 value 即可。




Collection接口

Collection接口是最基本的集合接口,代表一组Object集合,这些Object被称作Collection的元素,所有实现Collection接口的类型必须提供两个标准的构造函数:无参数的构造函数用于创建一个空的Collection,有一个Collection参数的构造函数用于创建一个新的Collection,这个新的Collection与传入的Collection有相同的元素后一个构造函数允许用户复制一个Collection。这些都比较容易理解。

1 Collection<Integer> ci = new ArrayList<Integer>();
2 Collection<Integer> ci2 = new ArrayList<Integer>(Arrays.asList(1,2,3,4,5));

并且注意Collection中没有get()方法,要想查看或者操作Collection中的元素只能遍历,使用的是iterator()方法,使用该方法可以逐一访问Collection的每一个元素。


Collection接口继承了Iterable接口:(注意Collection是一个接口,而Collections是一个操作集合的工具类)
public interface Collection<E> extends Iterable<E> {}
Collection的几个子接口,如List、Set、Queue也都间接继承了Iterable接口。
public interface Map<K,V> {}
Map接口没有继承Iteratale接口,也没有继承其他接口,但是Map的遍历访问可以通过获取Map的KeySet(keySet是一个set集合)来遍历Map。

可以看出所有的集合类都是直接或间接继承了Iterable接口的,而Iterable接口中可以获得Iterator迭代器,这样保证了每个集合类的每个副本每次获得的Iterator都是从第一个元素开始遍历的,各个Iterator互不干扰。
另外,foreach的实现原理是编译器帮我们将遍历直接转换成了对集合iterator.next()的调用(可以使用foreach进行遍历集合都实现了Iterable接口),所以如果自定义类实现了Iterable接口并且实现了该接口中iterator()方法的具体定义,则可以通过foreach语法来遍历自定义的类


Iterable接口

迭代器接口,这是Collection类的父接口。实现这个Iterable接口的对象允许使用foreach进行遍历,也就是说,所有的Collection集合对象都具有"foreach可遍历性"。这个Iterable接口只有一个方法: iterator()

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


Iterator接口定义在java.util包中:
  1. public interface Iterator<E> {  
  2.     boolean hasNext();  
  3.     E next();  
  4.     void remove();  
  5. }  
实现Iterator接口的接口和类如下所示:
  1. 所有已知子接口:  
  2. ListIterator<E>, XMLEventReader  
  3. 所有已知实现类:  
  4. BeanContextSupport.BCSIterator, EventReaderDelegate, Scanner  
其中ListIterator接口在Iterable接口的基础上增加了前向遍历的方式,定义如下:
  1. public interface ListIterator<E> extends Iterator<E> {  
  2.     boolean hasNext();  
  3.     E next();  
  4.     boolean hasPrevious();  
  5.     E previous();  
  6.     int nextIndex();  
  7.     int previousIndex();  
  8.     void remove();  
  9.     void set(E e);  
  10.     void add(E e);  
  11. }  
Iterable接口定义在java.lang包中:
  1. public interface Iterable<T> {  
  2.     Iterator<T> iterator();  //Iterable接口中只声明了一个Iterator迭代器
  3. }  
迭代器模式本质是将聚合对象的内容与遍历分开,所以使用者可以不用考虑聚合对象的底层实现(是用list存储还是用数组存储)而以一种统一的方式(Iterator)来遍历对象;而且可以利用筛选迭代器对对象进行过滤,只遍历符合条件的对象;迭代器的迭代策略(单向、双向等)可以灵活的修改。
为了利用迭代器模式,java中定义了一个Iterator迭代器接口和一个Iterable接口;Iterator迭代器中定义了遍历需要用到的方法,如next()、hasNext()、remove()方法;Iterable接口中声明了一个Iterator迭代器;

Iterable和Iterator的关系

Iterable告知这个集合可以直接进行遍历;Iterator则是执行具体的遍历操作。而且一个实现Iterable接口的集合可以进行多次的遍历,当每次执行遍历操作的时候把自己本身传给实现Iterator的对象,这样每次遍历的操作都不会影响这个集合的内部元素。

为什么很多类都实现Iterable而不是实现Iterator ??                                                                                             

既然Iterable内部只有一个方法来返回一个Iterator迭代器,到最后还是要用Iterator(迭代器),那么为什么不让Collection(或者其他需要迭代器的接口或类)去直接实现Iterator,反而要让其实现Iterable接口呢??????
在解决这个问题前,我们先来看一下Iterator的源代码
package java.util;  
public interface Iterator<E> {  
    boolean hasNext();  
    E next();  
    void remove();  
}  
Iterator内部的  next()方法和  hasNext()方法都依赖于当前迭代的位置,一次迭代后,“指向”或者说记录当前迭代位置的“指针”,会指向该集合的末尾,如果Collection实现的是Iterable的话,那么下一次再迭代的时候就需要另外写一个方法 将指针“移动到”集合的首部。即使是这样,该Collection内部也是只有一个迭代器,那么A的迭代仍然会影响B的迭代(多线程或者其他情况)。但是如果实现的是Iterable,然后在通过方法来调用迭代器的话,那么每次调用的时候产生的都是一个新的迭代器,迭代器之间互不干扰。











举报

相关文章推荐

Iterator && Iterable Collection && Map

ava的集合是一种特别有用的工具类,大体上分为:Set、List和Map三种体系。其中Set代表无序、不可重复的集合;List代表有序、重复的集合;而Map则代表具有映射关系的集合(键值对)。JDK ...

java.lang.Iterable接口 - 循环打印MAP容器时候所想到的

以前只做过LIST的循环打印,昨天被问到MAP循环怎么弄,一下给人问蒙了,最后查API,发现Map类中有一个方法values() ,可以返回一个Collection集合容器,然后可以循环打印。而且发现实现了Iterable的类都可以用foreach来循环打印,JDK5后的新特性。 虽然说,不用实现Iterable也可以循环抓出容器里的值,但是用用新特性也没坏处。准备从Iterable开始分析。 类名:java.lang Interface Iterable 方法:Iterator iterator() 说明:Implementing this interface all
  • qhuwn
  • qhuwn
  • 2009-09-12 13:35
  • 3019

java基础巩固系列(九):持有对象之间的使用与关系(Iterable、Collection、List、Queue、Set、Map、Stack)

java中的持有对象之间的继承关系

iterator与iterable关系

<div class="blogzz_ainfo" style="margin-bo

java 集合架构--[Collection] [List] [Set] [Map] [集合工具类]

数组与集合的共同点和区别集合框架--Set元素存取无序不可重复无索引Iterator 接口Stack 是 Vector的子类泛型Map 接口Collections 类关于数组 集合的总结   一 ...
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)