宏观接触Java集合框架(转)

Java阳台提供了三个全新的会聚框架。“集合框架”首要由一组用来操作对象的接口组成。不一致接口描述一组分裂数据类型。

图片 1
Java 2集合框架图

  集合接口:四个接口(短虚线表示),表示分歧集合类型,是汇集框架的功底。

  抽象类:八个抽象类(长虚线表示),对聚集接口的有个别完成。可扩大为自定义集合类。

  完成类:七个落实类(实线表示),对接口的现实性完毕。

  在十分的大程度上,一旦您领略了接口,您就通晓了框架。纵然你总要创设接口特定的兑现,但访问实际集合的艺术应该限制在接口方法的行使上;因而,允许你更改基本的数据结构而毋庸改变其它代码。

  · Collection 接口是一组允许再度的靶子。

  · Set 接口继承
Collection,但不一致意再度,使用本身内部的二个排列机制。

  · List 接口继承
Collection,允许再一次,以成分插入的先后来放置成分,不会重新排列。

  · Map接口是一组成对的键-值对象,即所具有的是key-value
pairs。Map中无法有重复的key。拥有和谐的里边排列机制。

  ·
容器中的成分类型都为Object。从容器取得成分时,必须把它转换来原来的类型。

图片 2
  Java 2简化集合框架图

**集合接口

**  1.Collection 接口

  用于表示其他对象或成分组。想要尽大概以健康办法处理一组成分时,就采取这一接口。

图片 3

  (1) 单成分添加、删除操作:

   boolean add(Object o):将对象添加给集合

   boolean remove(Object o):
假如集合中有与o相匹配的靶子,则删除对象o

  (2) 查询操作:

   int size() :重返当前集结申月素的多寡

   boolean isEmpty() :判断集合中是或不是有其它因素

   boolean contains(Object o) :查找集合中是或不是包括对象o

   Iterator iterator() :返回一个迭代器,用来拜会集合中的各种要素

  (3) 组操作 :成效于成分组或任何集合

   boolean containsAll(Collection c): 查找集合中是不是带有集合c
中拥有因素

   boolean addAll(Collection c) : 将集合c 中享有因素添加给该集合

   void clear(): 删除集合中有所因素

   void removeAll(Collection c) : 从集合中去除集合c 中的全部因素

   void retainAll(Collection c) : 从集合中剔除集合c 中不含有的因素

  (4) Collection转换为Object数组 :

   Object[] toArray() :再次来到3个内含集合全体因素的array

   Object[] toArray(Object[] a)
:重返1个内含集合全部因素的array。运维期重返的array和参数a的型别相同,供给更换为正确型别。

  其余,您还足以把集合转换到其余任何别的的靶子数组。不过,您无法向来把集合转换到基本数据类型的数组,因为集合必须怀有对象。

  “斜体接口方法是可选的。因为1个接口完成必须完成全数接口方法,调用程序
须要一种途径来通晓1个可选的艺术是否不接受援救助。假使调用一种可选方法时,二个UnsupportedOperationException
被抛出,则操作败北,因为方法不受帮忙。此十二分类继承 RuntimeException
类,防止了将全部集合操作放入 try-catch 块。”

  Collection不提供get()方法。假使要遍历Collectin中的成分,就亟须用Iterator。

  1.1.AbstractCollection 抽象类

   AbstractCollection
类提供切实“集合框架”类的基本功用。纵然您能够自行实现 Collection
接口的全部办法,不过,除了iterator()和size()方法在适龄的子类中贯彻以外,其余具有办法都由
AbstractCollection
类来提供落成。假设子类不掩盖某个方法,可选的如add()之类的措施将抛出拾壹分。

  1.2.Iterator 接口

  Collection 接口的iterator()方法重回叁个Iterator。Iterator接口办法能以迭代艺术挨个访问集合中逐一要素,并安全的从Collection
中除了适当的成分。

图片 4

  (1) boolean hasNext(): 判断是还是不是存在另二个可访问的因素

    Object next():
重临要访问的下一个要素。假使到达集合结尾,则抛出NoSuchElementException非常。

  (2) void remove():
删除上次访问归来的目的。本办法必须紧跟在3个要素的拜访后实施。假若上次造访后集合已被修改,方法将抛出IllegalStateException。

  “Iterator中剔除操作对底层Collection也有震慑。”

   迭代器是
故障火速修复(fail-fast)的。那表示,当另叁个线程修改底层集合的时候,假诺您正在用
Iterator 遍历集合,那么,Iterator就会抛出
ConcurrentModificationException (另一种
RuntimeException非凡)非凡并当即退步。
2.List接口

  List 接口继承了 Collection
接口以定义二个允许再一次项的有序聚集。该接口不但能够对列表的一有个别举办拍卖,还添加了面向地点的操作。

图片 5

  (1) 面向地点的操作包涵插入有个别成分或 Collection
的功能,还包蕴获取、除去或转移元素的职能。在 List
中搜索成分能够从列表的尾部或底部初叶,若是找到成分,还将告诉成分所在的岗位
:

  void add(int index, Object element):
在内定地方index上添英镑素element

  boolean addAll(int index, Collection c):
将集合c的有着因素添加到钦命地方index

  Object get(int index): 再次来到List中内定地方的因素

  int indexOf(Object o): 重回第2个冒出成分o的职务,不然重临-1

  int lastIndexOf(Object o)
:再次来到最终四个出现成分o的岗位,不然再次回到-1

  Object remove(int index) :删除内定地方上的成分

  Object set(int index, Object element)
:用成分element取代地方index上的成分,并且重回旧的因素

  (2) List
接口不但以职分体系迭代的遍历整个列表,还是能处理集合的子集:

   ListIterator listIterator() :
重回3个列表迭代器,用来拜会列表中的成分

   ListIterator listIterator(int index) :
再次回到二个列表迭代器,用来从钦命地方index先导访问列表中的成分

  List subList(int fromIndex, int toIndex)
:重返从钦赐地方fromIndex(包蕴)到toIndex(不包括)范围中相继要素的列表视图

  “对子列表的变更(如 add()、remove() 和 set() 调用)对底层 List
也有震慑。”

  2.1.ListIterator接口

  ListIterator 接口继承 Iterator
接口以支撑添加或改变底层集合中的成分,还帮忙双向访问。ListIterator没有当前职分,光标位于调用previous和next方法重回的值时期。三个长度为n的列表,有n+1个有效索引值:

图片 6
图片 7

  (1) void add(Object o): 将对象o添加到当前地方的先头

   void set(Object o):
用对象o替代next或previous方法访问的上三个成分。假若上次调用后列表结构被修改了,那么将抛出IllegalStateException至极。

  (2) boolean hasPrevious(): 判断向后迭代时是或不是有成分可访问

   Object previous():重临上多个目的

   int nextIndex(): 重回下次调用next方法时将赶回的成分的目录

   int
previousIndex(): 重临下次调用previous方法时将赶回的因素的目录

  “符合规律状态下,不用ListIterator改变某次遍历集合成分的趋势 —
向前只怕向后。固然在技术上能够兑现,但previous()
后马上调用next(),重回的是同三个成分。把调用
next()和previous()的逐条颠倒一下,结果一律。”

  “大家还索要有个别再解释一下 add()
操作。添加3个元素会造成新成分登时被添加到隐式光标的前面。由此,添法郎素后调用
previous() 会重返新成分,而调用 next()
则不起功能,重返添加操作从前的下三个因素。”

  2.2.AbstractList和AbstractSequentialList抽象类

   有四个抽象的 List 实现类:AbstractList 和
AbstractSequentialList。像 AbstractSet 类一样,它们覆盖了 equals() 和
hashCode()
方法以管教多个相当的集结重临相同的哈希码。若五个列表大小相等且富含顺序相同的一样成分,则那多少个列表相等。那里的
hashCode() 实现在 List 接口定义中钦定,而在此处实现。

  除了equals()和hashCode(),AbstractList和
AbstractSequentialList完毕了别的 List
方法的一有的。因为数量的人身自由访问和顺序访问是独家达成的,使得实际列表完成的始建更为简单。须要定义的一套方法取决于你愿意支持的作为。您永远不要亲自
提供的是 iterator方法的达成。

  2.3. LinkedList类和ArrayList类

  在“集合框 架”中有三种健康的 List 完毕:ArrayList 和
LinkedList。使用二种 List
落成的哪个种类取决于你一定的急需。如若要协理随机访问,而无需在除底部的别样地方插入或除去成分,那么,ArrayList
提供了可选的联谊。但一旦,您要频仍的从列表的高级中学级地方添加和除去成分,而假若逐项的造访列表成分,那么,LinkedList
实现更好。

  “ArrayList 和 LinkedList 都达成 Cloneable
接口,都提供了三个构造函数,八个无参的,3个收受另1个Collection”

  2.3.1. LinkedList类

  LinkedList类添加了一些处理列表两端元素的不二法门。

图片 8

  (1) void addFirst(Object o): 将对象o添加到列表的开首

    void addLast(Object o):将对象o添加到列表的最终

  (2) Object getFirst(): 重临列表开头的要素

    Object getLast(): 再次回到列表结尾的要素

  (3) Object removeFirst(): 删除并且再次回到列表初步的要素

    Object removeLast():删除并且重返列表结尾的要素

  (4) LinkedList(): 创设1个空的链接列表

    LinkedList(Collection c):
创设几个链接列表,并且增进集合c的有所因素

  “使用那么些新办法,您就足以轻松的把 LinkedList
当作一个仓房、队列或任何面向端点的数据结构。”

  2.3.2. ArrayList类

  ArrayList类封装了叁个动态再分配的Object[]数组。每个ArrayList对象有三个capacity。那些capacity表示存款和储蓄列表相月素的数组的容积。当成分添加到ArrayList时,它的capacity在常量时间内电动扩展。

  在向1个ArrayList对象添加多量因素的程序中,可采取ensureCapacity方法扩充capacity。那足以减小扩大重分配的数额。

  (1) void ensureCapacity(int minCapacity):
将ArrayList对象体量扩充minCapacity

  (2) void trimToSize():
整理ArrayList对象体积为列表当前高低。程序可采纳这一个操作减弱ArrayList对象存款和储蓄空间。

  2.3.2.1. RandomAccess接口

  三个特色接口。该接口没有任何措施,然而你可以选取该接口来测试有些集合是不是协理有效的随机访问。ArrayList和Vector类用于落到实处该接口。
3.Set接口

  Set 接口继承 Collection
接口,而且它不容许集合中留存双重项,每一个具体的 Set
实现类注重添加的靶子的
equals()方法来检查独一性。Set接口没有引入新点子,所以Set便是二个Collection,只不过其行事差别。

图片 9

  3.1. Hash表

 
 Hash表是一种数据结构,用来探寻对象。Hash表为种种对象总括出2个平头,称为Hash
Code(哈希码)。Hash表是个链接式列表的阵列。各类列表称为贰个buckets(哈希表元)。对象地点的持筹握算 index
= HashCode % buckets (HashCode为目的哈希码,buckets为哈希表元总数)。

  当您添美成分时,有时你会赶三月经填充了成分的哈希表元,那种场所称为Hash
Collisions(哈希顶牛)。那时,你必须认清该因素是或不是早已存在于该哈希表中。

 
 假诺哈希码是在理地肆意分布的,并且哈希表元的数量丰裕大,那么哈希争持的数目就会缩减。同时,你也能够因此设定1个上马的哈希表元数量来更好地控制哈
希表的运维。开头哈希表元的多少为 buckets = size * 15/10 + 1
(size为预期成分的数码)。

  尽管哈希表中的成分放得太满,就非得开始展览rehashing(再哈希)。再哈希使哈希表元数增倍,并将原有的目的重新导入新的哈希表元中,而原来的哈希表元被剔除。load
factor(加载因子)决定曾几何时要对哈希表举行再哈希。在Java编制程序语言中,加载因子私下认可值为0.75,默许哈希表元为101。

  3.2. Comparable接口和Comparator接口

 
 在“集合框架”中有三种相比较接口:Comparable接口和Comparator接口。像String和Integer等Java内建类实现Comparable接口以提供一定排序格局,但诸如此类只可以促成该接口1遍。对于那个没有落到实处Comparable接口的类、或许自定义的类,您能够透过
Comparator接口来定义您自个儿的可比艺术。

  3.2.1. Comparable接口

  在java.lang包中,Comparable接口适用于1个类有自然顺序的时候。假定对象集合是同等品种,该接口允许你把集合排序成自然顺序。

图片 10

  (1) int compareTo(Object o):
相比当前实例对象与对象o,如若放在对象o从前,再次回到负值,若是五个目的在排序中地点相同,则再次回到0,假若放在对象o后边,则赶回正值

  在 Java 2
SDK版本1.4中有贰拾五个类达成Comparable接口。下表浮现了8种为主项目标当然排序。纵然部分类共享同一种自然排序,但唯有相互相比较的类才能排序。

排序
BigDecimal,BigInteger,Byte, Double, Float,Integer,Long,Short 按数字大小排序
Character 按 Unicode 值的数字大小排序
String 按字符串中字符 Unicode 值排序

  
  利用Comparable接口成立您本身的类的排序依次,只是完成compareTo()方法的题材。平常就是借助多少个数据成员的本来排序。同时类也相应覆盖equals()和hashCode()以担保五个格外的对象回来同一个哈希码。

  3.2.2. Comparator接口

  若三个类不能够用于落到实处java.lang.Comparable,恐怕您不希罕缺省的Comparable行为并想提供温馨的排序依次(大概多样排序方式),你能够兑现Comparator接口,从而定义二个相比较器。

图片 11

  (1)int compare(Object o1, Object o2):
对八个对象o1和o2进行相比,假诺o1坐落o2的前边,则赶回负值,假如在排序依次中以为o1和o2是平等的,重回0,倘若o1身处o2的末尾,则赶回正值

  “与Comparable相似,0再次回到值不代表元素相等。一个0重返值只是表示五个对象排在同1人置。由Comparator用户决定哪些处理。借使四个不等于的成分比较的结果为零,您首先应当确信那正是您要的结果,然后记录作为。”

  (2)boolean equals(Object obj): 提示对象obj是不是和相比较器相等。

  “该方法覆写Object的equals()方法,检查的是Comparator实现的等同性,不是居于相比状态下的指标。”
3.3. SortedSet接口

 
 “集合框架”提供了个新鲜的Set接口:SortedSet,它保持成分的静止次第。SortedSet接口为集的视图(子集)和它的双方(即头和尾)
提供了访问方法。当您处理列表的子集时,更改视图会反映到源集。此外,更改源集也会反映在子集上。产生那种情景的案由在于视图由两端的成分而不是下标元素钦赐,所以若是您想要二个非正规的高端要素(toElement)在子集中,您必须找到下二个因素。

  添加到SortedSet完成类的因素必须兑现Comparable接口,否则你必须给它的构造函数提供三个Comparator接口的落实。TreeSet类是它的唯一一份实现。

 
 “因为集必须包涵唯一的项,假设添新币素时比较五个成分导致了0重回值(通过Comparable的compareTo()方法或Comparator
的compare()方法),那么新因素就从未有过增进进去。借使两个成分相等,那辛亏。但如果它们不对等的话,您接下去就应该修改相比较艺术,让比较艺术和
equals() 的功力同样。”

图片 12

  (1) Comparator comparator():
重返对成分举行排序时选拔的比较器,如若运用Comparable接口的compareTo()方法对成分实行比较,则赶回null

  (2) Object first(): 重临有序聚集中率先个(最低)成分

  (3) Object last(): 再次回到有序聚集中最后三个(最高)元素

  (4) SortedSet subSet(Object fromElement, Object toElement):
重返从fromElement(包含)至toElement(不包涵)范围内成分的SortedSet视图(子集)

  (5) SortedSet headSet(Object toElement):
再次回到SortedSet的3个视图,其内各要素皆小于toElement

  (6) SortedSet tailSet(Object fromElement):
重回SortedSet的三个视图,其内各因素皆胜出或等于fromElement

  3.4. AbstractSet抽象类

 
 AbstractSet类掩盖了Object类的equals()和hashCode()方法,以担保三个出色的集重临相同的哈希码。若多个集大小相当于且包括相同元素,则那多个集相等。按定义,集的哈希码是集瓜月素哈希码的总额。因而,不论集的中间顺序怎样,三个格外的议会有平等的哈希码。

  3.4.1. Object类

  (1) boolean equals(Object obj):
对多个对象开始展览相比较,以便鲜明它们是还是不是一致

  (2) int hashCode():
重回该目的的哈希码。相同的目的必须再次来到相同的哈希码

  3.5. HashSet类类和TreeSet类

 
 “集合框架”协理Set接口两种普通的落到实处:HashSet和TreeSet(TreeSet落成SortedSet接口)。在更加多处境下,您会采用HashSet 存款和储蓄重复自由的聚众。考虑到效能,添加到 HashSet
的靶子急需运用稳妥分配哈希码的形式来促成hashCode()方法。纵然多数系统类覆盖了
Object中缺省的hashCode()和equals()完成,但成立您本身的要添加到HashSet的类时,别忘了覆盖
hashCode()和equals()。

  当您要从集合中以平稳的格局插入和抽取成分时,TreeSet落成会有用处。为了能顺利举行,添加到TreeSet的因素必须是可排序的。

  3.5.1.HashSet类

  (1) HashSet(): 营造2个空的哈希集

  (2) HashSet(Collection c): 创设2个哈希集,并且增进集合c中负有因素

  (3) HashSet(int initialCapacity): 营造2个持有一定容积的空哈希集

  (4) HashSet(int initialCapacity, float loadFactor):
创设八个有着一定体积和加载因子的空哈希集。LoadFactor是0.0至1.0里头的二个数

  3.5.2. TreeSet类

  (1) TreeSet():营造3个空的树集

  (2) TreeSet(Collection c): 创设三个树集,并且增加集合c中持有因素

  (3) TreeSet(Comparator c):
构建1个树集,并且应用一定的比较器对其成分进行排序

  “comparator比较器没有其余数据,它只是比较艺术的存放器。那种对象有时称为函数对象。函数对象平时在“运维进程中”被定义为匿名内部类的一个实例。”

  TreeSet(SortedSet s):
营造一个树集,添加有序集合s中有着因素,并且利用与平稳集合s相同的相比较器排序

  3.6. LinkedHashSet类

 
 LinkedHashSet扩充HashSet。即便想跟踪添加给HashSet的成分的顺序,LinkedHashSet达成会有帮扶。
LinkedHashSet的迭代器根据成分的插入顺序来访问各类要素。它提供了多个能够神速访问种种要素的平稳聚集。同时,它也增多了完结的代价,因为
哈希表元中的种种要素是因此重复链接式列表链接在一起的。

  (1) LinkedHashSet(): 营造二个空的链接式哈希集

  (2) LinkedHashSet(Collection c):
构建贰个链接式哈希集,并且拉长集合c中全数因素

  (3) LinkedHashSet(int initialCapacity):
营造一个有着一定体积的空链接式哈希集

  (4) LinkedHashSet(int initialCapacity, float loadFactor):
营造三个拥有一定体量和加载因子的空链接式哈希集。LoadFactor是0.0至1.0中间的三个数

  “为优化HashSet空间的运用,您能够调优伊始体积和负载因子。TreeSet不含有调优选项,因为树总是平衡的。”

  1. Map接口

  Map接口不是Collection接口的持续。Map接口用于维护键/值对(key/value
pairs)。该接口描述了从未重复的键到值的投射。

图片 13

  (1) 添加、删除操作:

  Object put(Object key, Object value):
将相互关联的2个首要字与二个值放入该印象。假设该重庆大学字已经存在,那么与此关键字相关的新值将取而代之旧值。方法再次回到关键字的旧值,如若首要字原来并不存在,则赶回null

  Object remove(Object key): 从印象中除去与key相关的炫耀

  void putAll(Map t): 以往自特定影像的有所因素添加给该影像

  void clear(): 从影像中删去全部映射

  “键和值都能够为null。可是,您不能够把Map作为贰个键或值添加给自己。”

  (2) 查询操作:

  Object get(Object key):
得到与主要字key相关的值,并且重临与重庆大学字key相关的靶子,若是没有在该影象中找到该重庆大学字,则赶回null

  boolean containsKey(Object key): 判断影象中是不是存在首要字key

  boolean containsValue(Object value): 判断印象中是不是留存值value

  int size(): 重临当前印象中映射的多寡

  boolean isEmpty() :判断印象中是还是不是有其余映射

  (3) 视图操作 :处理影象中键/值对组

  Set keySet(): 重回影象中具备重庆大学字的视图集

  “因为映射中键的会合必须是唯一的,您用Set帮忙。你还足以从视图中除去成分,同时,关键字和它相关的值将从源影像中被剔除,不过你不能够添加其他因素。”

  Collection values():再次来到影象中全体值的视图集

  “因为映射中值的汇聚不是唯一的,您用Collection协理。你还足以从视图中删除成分,同时,值和它的重点字将从源影象中被剔除,然而你不可能添加别的因素。”

  Set entrySet(): 重返Map.Entry对象的视图集,即印象中的关键字/值对

  “因为映射是唯一的,您用Set扶助。你还足以从视图中去除成分,同时,那些因素将从源印象中被删除,不过你无法添加别的因素。”

  4.1. Map.Entry接口

  Map的entrySet()方法重临一个贯彻Map.Entry接口的对象集合。集合中各类对象都以底层Map中1个一定的键/值对。

图片 14

 
 通过那些集合的迭代器,您能够得到每1个条条框框(唯一获得方式)的键或值并对值进行变更。当条目通过迭代器重临后,除非是迭代器本身的remove()方
法可能迭代器再次回到的条指标setValue()方法,其他对源Map外部的改动都会造成此条款集变得不行,同时发出条目行为未定义。

  (1) Object getKey(): 再次回到条目标主要性字

  (2) Object getValue(): 重回条指标值

  (3) Object setValue(Object value):
将相关印象中的值改为value,并且重临旧值

  4.2. SortedMap接口

  “集合框架”提供了个独特的Map接口:SortedMap,它用来保持键的不变次第。

图片 15

  SortedMap接口为印象的视图(子集),蕴涵多少个端点提供了访问方法。除了排序是效率于映射的键以外,处理SortedMap和处理SortedSet一样。

  添加到SortedMap完成类的因素必须兑现Comparable接口,不然你必须给它的构造函数提供2个Comparator接口的贯彻。TreeMap类是它的唯一一份完成。

 
 “因为对于映射来说,每一个键只可以对应1个值,要是在增加一个键/值对时比较八个键发生了0再次来到值(通过Comparable的compareTo()方
法或透过Comparator的compare()方法),那么,原始键对应值被新的值替代。假设四个因素相等,那幸好。但一旦不等于,那么您就应该修改
相比较艺术,让相比较艺术和 equals() 的效率同样。”

  (1) Comparator comparator():
重返对关键字展开排序时行使的相比较器,借使运用Comparable接口的compareTo()方法对主要字展开比较,则赶回null

  (2) Object firstKey(): 再次回到影像中首先个(最低)关键字

  (3) Object lastKey(): 重临影象中最后二个(最高)关键字

  (4) SortedMap subMap(Object fromKey, Object toKey):
重回从fromKey(包罗)至toKey(不包蕴)范围内成分的SortedMap视图(子集)

  (5) SortedMap headMap(Object toKey):
重回SortedMap的一个视图,其内各要素的key皆小于toKey

  (6) SortedSet tailMap(Object fromKey):
重返SortedMap的1个视图,其内各因素的key皆大于或等于fromKey

  4.3. AbstractMap抽象类

   和任何抽象集合完成相似,AbstractMap
类覆盖了equals()和hashCode()方法以保障五个格外映射重返相同的哈希码。即便五个映射大小也便是、包括同样的键且各样键在那七个映射中对
应的值都无差别,则那五个映射相等。映射的哈希码是炫耀成分哈希码的总额,个中各类成分是Map.Entry接口的1个兑现。由此,不论映射内部顺序如何,
五个格外映射会报告同样的哈希码。

  4.4. HashMap类和TreeMap类

  “集合框架”提供三种常规 的Map落成:HashMap和TreeMap
(TreeMap完成SortedMap接口)。在Map 中插入、删除和永恒成分,HashMap
是最好的抉择。但假若你要按自然顺序或自定义顺序遍历键,那么TreeMap会更好。使用HashMap供给加上的键类明显定义了hashCode()和
equals()的兑现。

  这么些TreeMap没有调优选项,因为该树总处于平衡情状。

  4.4.1. HashMap类

  为了优化HashMap空间的行使,您能够调优开首体积和负载因子。

  (1) HashMap(): 创设三个空的哈希影像

  (2) HashMap(Map m): 构建一个哈希影象,并且增加影象m的全部映射

  (3) HashMap(int initialCapacity):
创设1个具有一定体量的空的哈希印象

  (4) HashMap(int initialCapacity, float loadFactor):
塑造2个持有一定体积和加载因子的空的哈希影像

  4.4.2. TreeMap类

  TreeMap没有调优选项,因为该树总处于平衡动静。

  (1) TreeMap():构建2个空的影象树

  (2) TreeMap(Map m): 创设三个映像树,并且添加印象m中全部因素

  (3) TreeMap(Comparator c):
塑造2个影像树,并且利用一定的比较器对根本字展开排序

  (4) TreeMap(SortedMap s):
创设1个影像树,添加印象树s中负有映射,并且利用与平稳影象s相同的相比较器排序

  4.5. LinkedHashMap类

  LinkedHashMap增加HashMap,以插入顺序将重点字/值对添加进链接哈希影像中。象LinkedHashSet一样,LinkedHashMap内部也利用双重链接式列表。

  (1) LinkedHashMap(): 创设3个空链接哈希影像

  (2) LinkedHashMap(Map m):
创设3个链接哈希影象,并且添加影像m中全部映射

  (3) LinkedHashMap(int initialCapacity):
营造三个存有一定体量的空的链接哈希印象

  (4) LinkedHashMap(int initialCapacity, float loadFactor):
创设2个享有一定体积和加载因子的空的链接哈希影像

  (5) LinkedHashMap(int initialCapacity, float loadFactor,

  boolean accessOrder):
营造贰个持有一定体积、加载因子和访问顺序排序的空的链接哈希影像

  “要是将accessOrder设置为true,那么链接哈希影像将运用访问顺序而不是插入顺序来迭

  代逐条影像。每趟调用get可能put方法时,相关的照射便从它的最近地方上剔除,然后嵌入链接式映像列表的结尾处(唯有链接式影象列表中的地点才会遭受震慑,哈希表元则不受影响。哈希表映射总是待在相应于重点字的哈希码的哈希表元中)。”

 
 “该性情对于完成高速缓存的“删除近年来最少使用”的标准化很有用。例如,你能够期待将最常访问的映射保存在内部存款和储蓄器中,并且从数据库中读取十分访问的指标。
当你在表中找不到有些映射,并且该表中的映射已经放得13分满时,你能够让迭代器进入该表,将它枚举的起来多少个映射删除掉。那几个是近年来起码使用的映射。”

   (6) protected boolean removeEldestEntry(Map.Entry eldest):
若是您想删除最老的照射,则覆盖该格局,以便回到true。当某些映射已经添加给影象之后,便调用该措施。它的私下认可达成格局重返false,表示默许条件
下老的照射没有被剔除。不过你能够重复定义本办法,以便有选用地在最老的照耀符合有个别条件,大概印象当先了某些大刻钟,重返true。

  4.6. WeakHashMap类

 
 WeakHashMap是Map的二个特种完毕,它选拔WeakReference(弱引用)来存放哈希表关键字。使用那种措施时,当映射的键在
WeakHashMap
的外表不再被引用时,垃圾收集器会将它回收,但它将把到达该对象的弱引用纳入一个系列。WeakHashMap的运作将定期检查该队列,以便找出新到达的
弱应用。当三个弱引用到达该队列时,就象征关键字不再被任哪个人使用,并且它早已被采访起来。然后WeakHashMap便删除相关的投射。

  (1) WeakHashMap(): 营造二个空弱哈希影象

  (2) WeakHashMap(Map t): 构建多个弱哈希影像,并且增进影像t中负有映射

  (3) WeakHashMap(int initialCapacity):
构建多个兼有一定体量的空的弱哈希印象

  (4) WeakHashMap(int initialCapacity, float loadFactor):
创设一个富有一定体积和加载因子的空的弱哈希影像

  4.6. IdentityHashMap类

 
 IdentityHashMap也是Map的一个异样达成。在那些类中,关键字的哈希码不应有由hashCode()方法来总结,而应该由
System.identityHashCode方法进行计算(即便已经再也定义了hashCode方法)。这是Object.hashCode依据目标的内部存款和储蓄器地址来总括哈希码时使用的不二法门。其余,为了对各种对象开始展览比较,IdentityHashMap将使用==,而不利用equals方法。

 
 换句话说,不相同的首要字对象,固然它们的内容一律,也被视为区别的目的。IdentityHashMap类可以用来落实目的拓扑结构转换
(topology-preserving object graph
transformations)(比如达成指标的串行化或深度拷贝),在举行更换时,需求3个“节点表”跟踪这些曾经处理过的靶子的引用。尽管碰巧有对
象相等,“节点表”也不应视其至极。另七个选择是维护代理对象。比如,调节和测试工具希望在程序调节和测试时期有限协理每种对象的三个代理对象。

  “IdentityHashMap类不是相似意义的Map实现!它的落成有意的违反了Map接口供给通过equals方法比较对象的约定。这一个类仅使用在很少爆发的急需强调等同性语义的情状。”

  (1) IdentityHashMap ():
营造三个空的全同哈希印象,默许预期最大尺寸为21

  “预期最大尺寸是影象期望把持的键/值映射的最大数目”

  (2) IdentityHashMap (Map m):
创设一个全同哈希映像,并且添加印象m中全数映射

  (3) IdentityHashMap (int expectedMaxSize):
构建一个具有预期最大尺寸的空的全同哈希影像。放置超越预期最大尺寸的键/值映射时,将引起内部数据结构的升高,有时或许很吃力

 

 转

http://bigpower.blog.51cto.com/209892/120362

 

 

Collection 头文件

 

图片 16图片 17View Code

//interface
import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.Map;

//child interface
import java.util.SortedSet;
import java.util.SortedMap;

//abstract method
import java.util.AbstractCollection;
import java.util.AbstractList;
import java.util.AbstractSet;
import java.util.AbstractMap;

//List implment class
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Vector;
import java.util.Stack;

//set implent class
/*Hashset不保留先后、大小和次序
您输入12345,遍历出来大概是31524
LinkedHashSet保留先后顺序
您输入12345,遍历保险12345
TreeSet保留大小顺序
你输入31524,遍历结果是12345
*/
import java.util.HashSet;
import java.util.TreeSet;
import java.util.LinkedHashSet;

//Map implement

/*
TreeMap基于红黑树,
HashMap是基于哈希表完结的,
TreeMap的键得完毕Comparable,(没有落到实处的话就得给TreeMap钦定2个Comparator)
HashMap的键得重写hashCode()和equals()
LinkedHashMap 双向链表,方便的获得前3个节点数据和后一个节点数据
*/
import java.util.Hashtable;
import java.util.HashMap;
import java.util.TreeMap;
import java.util.LinkedHashMap;
import java.util.WeakHashMap;

//一些碰面常用静态方法,提供部分线程安全的set和map,List的变通方法
import java.util.Collections;
import java.util.Iterator;

 

 

 

相关文章