Java OOP——第六章 框架集合

一、集合框架包含的主要内容及彼此之间的关系：

图1：
集合框架：是为了表示和操做集合而统一规定的一种统一的标准体系结构。               包含三大块的内容：对外的接口、接口的是实现和对集合运算的算法； 　　　　Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中：   　　　　   ●接口：表示集合的抽象数据类型，在图1中用虚线框表示，下图绿色的：      　　　　　　　　　　          　　　　  ●实现：集合框架中接口的具体实现，图1中一实线表示，粗实线表示经常使用的：上图蓝色的：     　　　　 ●算法：在一个实现了某个集合框架中的接口的对象身上完成某种有用的计算的方法；如：查询、排序；             　　　　 Java提供了进行集合操做的工具类Collections（相似于Arrays类）：它提供了对集合进行排序、遍历等多种算法实现；

二、java集合中的的两大类接口：Collection和Map；

  　　　　●Collection：Collection 接口存储一组不惟一，无序的对象（List:不惟1、有序；Set：惟1、无序；因此Collection接口是不惟一无序的）；

  　　　　●List：List 接口继承Collection 接口，存储一组不惟一（容许重复），有序（以插入的次序来放置元素，不会重写排列）的对象；

              　　　　  

 　　　　 ●Set：Set 接口继承Collection 接口，存储一组惟一（不容许重复），无序的对象；

                　　　　

  　　　　●Map：Map接口存储一组键值对象，提供key到value的映射，Map中的Key不要求有序、不容许重复。value一样不要求有序，但容许重复；

                 　　 　　

  　　　　●Iterator(迭代器)：接口是负责定义访问和遍历元素的接口；、

3、List接口：经常使用的类：ArrayList和LinkedList；(附加: Vector类：Vector集合类的使用(线程安全具备同步性)，Stack类)

       ●ArrayList集合类对数组进行了封装，实现了长度可变的数组，存储数据的方式和数组相同，都是在内存中分配连续的空间；

　　　　　　优势：在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高；

 　　　　　　　　　　

                    缺点：ArrayList类的使用无同步性，线程不安全；

●使用ArrayList存储元素： ●使用ArrayList移除、判断元素：
Eg：ArrayList集合的增删查：
Pet类（父类）：	Dog类（子类）：
Test测试类：			遍历方式1：（for）   遍历方式2：（foreach）
添加元素：			按指定位置添加元素：
上面的代码的输出结果：
删除元素（按索引删除）：   结果：（与上面进行对比）			删除元素（按对象删除）：   结果（与上面进行对比）：
判断对象是否存在：			输出结果：

　　●List接口（ArrayList）经常使用方法：

方法名	说    明
boolean add(Object o)	在列表的末尾顺序添加元素，起始索引位置从0开始
void add(int index,Object o)	在指定的索引位置添加元素。原索引位置及其后面的元素依次后移； 注意：新添加元素的索引位置必须介于0和列表中元素个数之间；
int size()	返回列表中的元素个数
Object get(int index)	返回指定索引位置处的元素。 注意：取出的元素是Object类型，使用前须要进行强制类型转换
boolean contains(Object o)	判断列表中是否存在指定元素
boolean remove(Object o)	从列表中删除元素
Object remove(int index)	从列表中删除指定位置元素，起始索引位置从0开始

          ●附加： ArrayList和Vector的区别：

相同点：ArrayList与Vector都是java的集合类，均可以用来存放java对象

不一样点（以下）：

1、同步性：   Vector是线程同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。   ArrayList则是线程异步的，所以ArrayList中的对象并非线程安全的。由于同步的要求会影响执行的效率，因此若是你不须要线程安全的集合那么使用ArrayList是一个很好的选择，这样能够避免因为同步带来的没必要要的性能开销。

2、数据增加： 　　从内部实现机制来说ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类型中增长元素的时候，若是元素的数目超出了内部数组目前的长度它们都须要扩展内部数组的长度，Vector缺省状况下自动增加原来一倍的数组长度，ArrayList是原来的50%，因此最后你得到的这个集合所占的空间老是比你实际须要的要大。因此若是你要在集合中保存大量的数据那么使用Vector有一些优点，由于你能够经过设置集合的初始化大小来避免没必要要的资源开销。

 　　●LinkedList采用链表存储方式。它提供了额外的addFirst（），addLast（），removeFirst（）和removeLast（）等方法；这些方法使得该集合可被看成堆栈（stack）或列（queue）

　　　　　　　　优势：插入、删除元素时效率比较高；

 　　　　　　　　　　

● 使用LinkedList存储元素：
Test测试类：（父类和子类见上面集合）：	添加元素方式1：   添加元素方法2：
遍历元素：   输出结果：	访问指定对象：   结果：
删除指定对象：   结果：	删除指定对象2：   结果：

　　●LinkedList的特殊方法：

方法名	说    明
void  addFirst(Object o)	在列表的首部添加元素
void  addLast(Object o)	在列表的末尾添加元素
Object  getFirst()	返回列表中的第一个元素
Object  getLast()	返回列表中的最后一个元素
Object  removeFirst()	删除并返回列表中的第一个元素
Object  removeLast()	删除并返回列表中的最后一个元素

4、Map接口：Map接口存储一组键值对象，提供key到value的映射，Map中的Key不要求有序、不容许重复。value一样不要求有序，但容许重复；

　　　　●HashMap集合类：

●使用HashMap存储元素：
Test测试类：（父类和子类见上面集合）：	添加元素方式1：   经过key得到值：
得到元素的个数：   结果：	判断key是否存在：   结果：
判断key是否存在：   结果：	判断值是否存在：   结果：
删除指定元素：   清空元素：   结果：	显示键值集合数据：   输出结果：
循环遍历key：   结果：	循环遍历值：   结果：

       ●Map接口经常使用方法：

方法名	说    明
Object put(Object key, Object val)	以“键-值对”的方式进行存储 注意：键必须是惟一的，值能够重复，若是试图添加剧复的键，加入的键值对会替换原来的
Object get (Object key)	根据键返回相关联的值，若是不存在指定的键，返回null
Object remove (Object key)	删除由指定的键映射的“键-值对”
int size()	返回元素个数（返回此映射中的键-值映射关系数。）
Set keySet ()	返回键的集合
Collection values ()	返回值的集合
boolean  containsKey (Object key)	若是存在由指定的键映射的“键-值对”，返回true
Boolean isEmpty()	若不存在键值对关系，则返回true
void clear()	今后映射中移除全部映射关系；

• ●Hashtable集合类：Hashtable集合类的使用(Hashtable具备同步性，线程安全)；
• ●HashMap和Hashtable集合类对比：

HashMap和Hashtable的异同：   ◆HashMap类出现以前，JDK中存在一个和它 一样采用哈希表存储方式。一样实现键值映射的集合类，HashMap，二者实现原理相同，功能相同，不少状况下能够互用；
HashMap和Hashtable的主要区别：   ◆Hashtable继承自Dictionary类，而HashMap是实现了Map接口，（是java 1.2引进的Map接口的一个实现。）   ◆Hashtable是线程安全的，HashMap重速度轻安全，是线程非安全，因此当运行到多线程环境中时，须要程序员本身管理线程的同步问题；   ◆HashMap可让你将空值做为一个表的条目的key或value可是Hashtable是不能放入空值的(null)； ◆同步性：Hashtable是线程同步的。这个类中的一些方法保证了Hashtable中的对象是线程安全的。 HashMap则是线程异步的，所以HashMap中的对象并非线程安全的。由于同步的要求会影响执行的效率，因此若是你不须要线程安全的集合那么使用HashMap是一个很好的选择，这样能够避免因为同步带来的没必要要的性能开销，从而提升效率。
注意： 开发过程当中，最好使用ArrayList和HashMap；

5、迭代器(Iterator)：

　　●java.util包中包含了一系列重要的集合类，集合类的根接口Collection。Collection接口是全部集合类的根类型。

　　●经过迭代器Iterator实现遍历:

　　　　●获取Iterator ：Collection 接口的iterator()方法

　　　　●Iterator的方法

   　　　　　　●boolean hasNext(): 判断是否存在另外一个可访问的元素

　　　　　　   ●Object next(): 返回要访问的下一个元素

          ★附加：每一种集合类返回的Iterator具体类型可能不一样，Array可能返回ArrayIterator，Set可能返回SetIterator，Tree 可能返回TreeIterator，可是它们都实现了Iterator接口，所以，客户端不关心究竟是哪一种Iterator，它只须要得到这个 Iterator接口便可，

6、遍历Map集合的方法：

●方法1：经过迭代器Iterator实现遍历	●方法2：加强for循环
Test测试类：	向HashMap中添加元素：   遍历方式2：（加强for）:   输出结果：
遍历方式1：（迭代器）	输出结果：

7、数组和集合的区别：

●数组能够存储基本数据类型和对象，而集合中只能存储对象（能够以包装类形式存储基本数据类型） ●数组长度固定。集合长度能够动态改变； ●定义数组时必须指定数组元素类型，集合默认其中全部元素都是Object ●没法直接获取数组实际存储的元素个数，length用来获取数组的长度，但能够经过size()方法直接获取集合实际存储的元素个数； ●集合有不少种实现方式和不用的使用场合，而不像数组仅分配连续空间方式； ●集合以接口和类的形式存在，具备封装、继承和多态等类的特性，经过简单的方法和属性调用便可实现各类复杂操做，大大提升了软件的开发效率; ●JDK中 有一个Arrays类，专门用来操做数组，它提供了一系列静态方法实现，对数组搜索、排序、比较和填充等操做。   JDK中有一个Collections类，专门用来操做集合，它提供一系列静态方法实现对各类集合的搜索、复制、排序和线程安全化等操做；

8、泛型（Generic）集合：

    　　  ●泛型是java se1.5的新特性，泛型的本质是参数化类型，也就是说所操做的数据类型被指定为一个参数。这种参数类型能够用在类、接口和方法的建立中，分别称为泛型类、泛型接口、泛型方法。

 　　     ●在java se1.5以前，没有泛型的状况下，经过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要作显式的强制类型转换，而这种转换是要求开发者对实际参数类型能够预知的状况下进行的，对于强制类型转换错误的状况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

　　      ●使用泛型有下面几个优势：

　　　　　　　　1、类型安全

　　　　　　　　2、向后兼容（泛型的好处是在编译的时候检查类型安全，而且全部的强制转换都是自动和隐式的，提升代码的重用率）

　　　　　　　　3、层次清晰

　　　　　　　　4、性能较高，用GJ(泛型JAVA)编写的代码能够为java编译器和虚拟机带来更多的类型信息，这些信息对java程序作进一步优化提供条件。

Eg：ArrayList：		Eg：Map和Set：
List泛型集合：
Test测试类：	添加元素：（向狗中添加企鹅会编译错误）：
移除指定元素：
Map:
Test测试类：	添加元素：（向狗中添加企鹅会编译错误）：
遍历：

9、如何选用集合类？

　　　　1、要求线程安全，使用Vector、Hashtable

　　　　2、不要求线程安全，使用ArrayList,LinkedList,HashMap

　　　　3、要求key和value键值，则使用HashMap,Hashtable

　　　　4、数据量很大，又要线程安全，则使用Vector

10、附加：

       ●Java中的Iterator(迭代器)的用法：

　　　　◆它的一个主要的接口方法是：

　　　　　　●boolean add(Object c)添加数据：add()方法将添加一个新元素。注意这个方法会返回一个boolean，可是返回值不是表示添加成功与否。

　　　　　　●Collection规定：若是一个集合拒绝添加这个元素，不管任何缘由，都必须抛出异常。

　　　　　　　　这个返回值表示的意义是add()方法执行后，集合的内容是否改变了(就是元素有无数量，位置等变化)，这是由具体类实现的。即：若是方法出错，总会抛出异常；返回值仅仅表示该方法执行后这个Collection的内容有无变化。

　　　　▲相似还有：

　　　　　　　　boolean addall(Collection c);添加全部数据

　　　　　　　　boolean remove(Object o);删除数据

　　　　　　　　boolean removeall(Collection c);删除全部数据

　　　　　　　　boolean remainall(Collection c);保持全部数据

                         ★Object[]toArray()方法很简单，把集合转换成数组返回。Object[]toArray(Object[] a)方法就有点复杂了，首先，返回的Object[]仍然是把集合的全部元素变成数组，可是类型和参数a的类型是相同的。

　　　　　　　　　　　　如：String[] o=(String)c.toArray(new String[0]);   //获得的o实际类型是String[]数组。

                                ●其次，若是参数a的大小装不下集合的全部元素，返回的将是一个新的数组。若是参数a的大小能装下集合的全部元素，则返回的仍是a，但a的内容用集合的元素来填充。

 　　　　　　　　　　　　尤为要注意的是，若是a的大小比集合元素的个数还多，a后面的部分所有被置为null(空)。

　　●Set结构的集合类：HashSet类，TreeSet类

　　　　　　◆HashSet是基于HashMap实现的，HashSet底层采用HashMap来保存全部元素。hashCode和equal()是HashMap用的，由于无需排序因此只须要关注定位和惟一性便可；hashCode是用来计算hash值的，hash值是用来肯定hash表索引的，hash表中的一个索引存放的是一张链表，因此还要经过equal方法循环比较链上的每个对象才能够真正定位到键值对应的Entryput时，若是hash表中没定定位到，就在链表前加一个Entry，若是定位到了，则更换Entry中的value(值)并返回value(值)

　　　　　　◆覆写key的hashCode()和equal()时必定要注意，不要把它们和可变属性关联上，不然属性变了以后hashCode会变，equal也会为false，这样在Map中就找不到它了并且这样的对象由于找不到它因此得不到释放，这样就变成了一个无效引用(至关于内存泄漏)

　　　　　　◆TreeSet集合类是一个有序集合，它的元素按照升序排序，默认是天然顺序排列，也就是说TreeSet中的对象元素须要实现Comparable接口。TreeSet与HashSet类同样没有get()方法来获取列表中的元素，因此也只能经过迭代器方法来获取。因为TreeMap须要排序，因此须要一个Comparator为键值进行大小比较，固然也是用Comparator定位的Comparator能够在建立TreeMap时指定，这时排序时使用Comparator.compare若是建立时没有指定Comparator那么就会使用key.compareTo()方法，这就要求key必须实现Comparable接口

　　　　　　◆TreeMap是使用Tree数据结构实现的，因此使用compare接口就能够完成定位了。TreeSet是依靠TreeMap来实现的，TreeSet是一个有序集合，它的元素按照升序排列，默认是按照天然顺序排列，也就是说TreeSet中的对象元素须要实现Comparable接口。TreeSet类中跟HashSet类一要也没有get()方法来获取列表中的元素，因此也只能经过迭代器的方法来获取 。

◆HashSet与TreeSet集合类的区别：HashSet是基于hash算法实现的，性能优于TreeSet。一般使用HashSet，在咱们须要对其中元素排序的时候才使用TreeSet。

●Java中的List/Set和Map的区别:

                  ★List按对象进入的顺序保存对象，不作排序和编辑操做。

                  ★Set对每一个对象只接受一次，并使用本身内部的排序方法(一般，你只关心某个元素是否属于Set而不关心它的顺序--不然使用List)。

                  ★Map一样对每一个元素保存一份，但这是基于"键"(key)的，Map也有内置的排序，于是不关心元素添加的顺序。若是添加元素的顺序对程序设计很重要，应该使用LinkedHashSet或者LinkedHashMap。

●List的功能方法：

                   实际上有两种List：一种是基本的ArrayList其优势在于随机访问元素，另外一种是更强大的LinkedList它并非为快速随机访问设计的，而是具备一套更通用的方法。

                    ★List：次序是List最重要的特色：它保证维护元素特定的顺序。List为Collection添加了许多方法，使得可以向List中间插入与移除元素(这只推荐LinkedList使用)一个List能够生成Listlterator，使用它能够从两个方向遍历List，也能够从List中间插入和移除元素。

                    ★ArrayList：由数组实现的List。容许对元素进行快速随机访问，可是向List中间插入与移除元素的速率很慢。Listlterator只应该用来由后向前遍历ArrayList。而不是用来插入和移除元素。由于那比LinkedList开销要大不少。

                    ★LinkedList：对顺序访问进行了优化，向List中间插入与删除的开销并不大。随机访问则相对较慢。

(使用ArrayList代替)还具备下列方法：addFirst()，addLast()，getFirst()，getLast()，removeFirst()和removeLast()

这些方法(没有在任何接口或基类中定义过)使得LinkedList能够看成堆栈、队列和双向队列使用。

●Set的功能方法：

                   ★ Set具备与Collection彻底同样的接口，所以没有任何额外的功能，不象前面有两个不一样的List。

实际上Set就是Collection，只是行为不一样。(这是继承与多态思想的典型应用：表现不一样的行为。)Set不保存重复的元素(至于如何判断元素相同则较为负责)

                   ★ Set：存入Set的每一个元素都必须是惟一的，由于Set不保存重复元素。加入Set的元素必需定义equals()方法以确保对象的惟一性。

Set与Collection有彻底同样的接口。Set接口不保证维护元素的次序。

                   ★ HashSet：为快速查找设计的Set。存入HashSet的对象必须定义hashCode()。

                   ★ TreeSet：保存次序的Set，底层为树结构。使用它能够从Set中提取有序的序列。

                   ★ LinkedHashSet：具备HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。因而在使用迭代器遍历Set时，结果会按元素插入的次序显示。

●Map的功能方法：

                 ★方法put(Object key,Object value)添加一个"值"(想要得东西)和与"值"相关的"键"(key)(使用它来查找)。

　　　　   ★方法get(Object key)返回与给定"键"相关联的"值"。能够用containsKey()和containsValue()测试Map中是否包含某个"键"或"值"。标准的java类库中包含了几种不一样的Map：HashMap，TreeMap，LinkedHashMap，WeakHashMap，ldentityHashMap。们都有一样的基本接口Map，可是行为、效率、排序策略、保存对象的生命周期和断定"键"等价的策略等各不相同。

                 ★ 执行效率是Map的一个大问题。看看get()要作哪些事，就会明白为何在ArrayList中搜索"键"是至关慢的。这正是HashMap提升速度的地方。HashMap使用了特殊的值，称为"散列码"(hash code)，来取代对键的缓慢搜索。"散列码"是"相对惟一"用以表明对象的int值，它是经过将该对象的某些信息进行转换而生成的。全部java对象都能产生散列码，由于hashCode()是定义在基类Object中的方法。

                 ★ HashMap就是使用对象的hashCode()进行快速查询的。此方法可以显著提升性能。

                         ▲Map：维护"键值对"的关联性，使你可经过"键"查找"值"

                         ▲ HashMap：Map基于散列表的实现。插入和查询"键值对"的开销是固定的。能够经过构造器设置容量capacity和负载因子load factor，以调整容器的性能。

                         ▲ LinkedHashMap：相似于HashMap，可是迭代遍历它时，取得"键值对"的顺序是其插入次序，或者是最近最少使(LRU)的次序。

只能HashMap慢一点。而在迭代访问时发而更快，由于它使用键表维护内部次序。

                         ▲TreeMap：基于红黑树数据结果的实现。查看"键"或"键值对"时，它们会被排序(次序由Comparabel或Comparator决定)。TreeMap的特色在于，

你获得的结果是通过排序的。TreeMap是惟一的带有subMap()方法的Map，它能够返回一个子树。

                         ▲  WeakHashMap:旨键(weak key)Map，Map中使用的对象也被容许释放：这是为解决特殊问题设计的。若是没有map以外的引用指向某个"键"，则此"键"能够被垃圾收集器回收。

                         ▲ ldentifyHashMap：使用==代替equals()对"键"做比较的hash map。专为解决特殊问题而设计。

11、附加2：

●Java中Collections类彻底由在 collection 上进行操做或返回 collection 的静态方法组成。 它包含在 collection 上操做的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其余内容。 binarySearch()方法提供了多种重载形式，用于知足各类类型数组的查找须要， binarySearch()有两种参数类型此法为二分搜索法（使用二分搜索法搜索指定列表）， 故查询前须要用sort()方法将数组排序，若是数组没有排序，则结果是不肯定的，另外若是数组中含有多个指定值的元素，则没法保证找到的是哪个。
●Collection和Map其中Collection接口又有众多子接口，其中经常使用的有：List和Set，还有一些不经常使用的好比：Queue，Deque，NavigableSet，BeanContext，BeanContextServices，BlockingDeque，SortedSet
●List和Set都是单列元素的集合，它们有一个共同的父接口Collection。 　List内的元素讲究有序性，内部元素可重复；可是Set偏偏相反，它讲究的是无序性，元素不可重复。 　Map与List和Set不一样，它是双列存储的（键和值一一对应）
●HashSet的存储方式：散列存储；
●在Java集合框架中，有些类是线程同步安全的类，它们是Vector、Hashtable、Stack、enumeration。 除了这些以外，其余的都是非线程安全的类和接口。 线程安全类的方法是同步的，每次只能一个访问，它们是重量级对象，效率较低。 对于非线程安全的类和接口，在多线程中须要程序员本身处理线程安全问题
●Java中的集合包括三大类，它们是Set、List和Map， 它们都处于java.util包中，Set、List和Map都是接口，它们有各自的实现类。 Set接口,无重无序; List接口允重有序,正好相反!Map接口包含键值对,值重键不重。
●Collections类的经常使用方法： java.util.Collections类包含不少有用的方法，可使程序员的工做变得更加容易。经常使用方法有： 1）    使用sort()方法能够根据元素的天然顺序 对指定列表按升序进行排序。 列表中的全部元素都必须实现 Comparable 接口。此列表内的全部元素都必须是使用指定比较器可相互比较的。 2）    使用shuffle()混排算法所作的正好与 sort 相反。它打乱在一个 List 中可能有的任何排列的踪影。 也就是说，基于随机源的输入重排该 List, 这样的排列具备相同的可能性（假设随机源是公正的）。 3）使用reverse()方法能够根据元素的天然顺序，对指定列表按降序进行排序。 4）使用swap()方法能够在指定列表的指定位置处交换元素。
●HashSet是Set接口的实现类，HashMap类是Map接口的实现类。ArrayList实现了长度可变的数组，在内存中分配连续的空间。LinkedList采用链表存储方式。TreeSet是Set接口的实现类，TreeMap类是Map接口的实现类。
●Collection类的经常使用方法： size()方法为返回Collection中的元素数。 containsAll(Collection c)方法为判断是否包含指定 collection 中的全部元素。 Remove（Object obj）方法为移除集合中某个元素。 注意：compareTO(Object obj)方法是在Comparable接口中定义的。
●Java中Collections类彻底由在 collection 上进行操做或返回 collection 的静态方法组成。 它包含在 collection 上操做的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其余内容。 由于Collections类提供的方法都是static的，因此能够直接调用执行，不需实例化对象。
●ArrayList类的经常使用方法。boolean add(E e)  该方法是将指定的元素添加到此列表的尾部。里面元素能够重复. hashMap里面键同样的才会被覆盖；
●Java中，ArrayList提供了三种方式的构造器： 能够构造一个默认初始容量为10的空列表、构造一个指定初始容量的空列表，以及构造一个包含指定collection的元素的列表， 这些元素按照该collection的迭代器返回它们的顺序排列的。 Eg：List al=new ArrayList(100);将会建立一个预计有100个元素的ArrayList对象a1；
●Java的ArrayList类是传说中的动态数组，它实现了ICollection和IList接口，能够动态的增长和减小元素、灵活的设置数组的大小。 ArrayList类的add()方法用于添加一个元素到当前列表的末尾。
Eg：			分析： Java 的ArrayList类有不少方法。 选项B的代码中ArrayList使用toArray()方法将list对象转为Object[]数组对象，但执行System.out.println(list.toArray())方法不能输出展现list对象中的所有数据； 选项D的代码利用get(int index)方法得到指定索引位置的数据，并调用的System.out.println()方法输出该数据。 注意：本题要求打印出list中储存的全部数据，不是指定的某个索引位置的数据。 所以，选项D的打印输出结果不符合本题要求。本题应选择AC。
Eg：			分析： ArrayList集合中： 进行元素替换可以使用set(int arg,Object o)的方法，set方法中俩个参数，第一个i是修改下标，第二个参数是修改的值。 也能够经过移除remove（int index）或者remov(Object o),而后添加add（Obeject o）的方式。remove()方法重载参数能够填值或者下标来移除元素，D项add()方法重载中一时添加的下标，2是添加的value值。 故BD能够实现修改修改元素
Eg：			分析： peek（）方法是返回但不删除第一个元素， remove（）方法是 返回而且删除第一个元素， 因此调用这两个方法后 ，列表中的值是“橙黄绿”答案C
●ArrayList，是能够改变大小的，咱们称之为容量capacity在ArrayList存储成员达到增大的阀值时，会自动增长大小，其不指定时，默认大小为10。ArrayList不只能够存储null值，同时也能够存储重复的值。
●Java的ArrayList类是传说中的动态数组，它实现了ICollection和IList接口，能够动态的增长和减小元素、灵活的设置数组的大小。 ArrayList类的add()方法用于添加一个元素到当前列表的末尾，get()方法则是按照int类型的索引（从0开始计数）返回此列表中指定位置上的元素。
●LinkedList是实现List、Collection接口，是链表方式进行构建的，根据开发要求不一样，可使用LinkedList实现栈（先进先出）和堆（先进后出）这样的数据结构。
●Java集合框架中，LinkedList类实现全部可选的列表操做，而且容许全部元素（包括 null）。 LinkedList经常使用方法：offer()是将指定元素添加到此列表的末尾（最后一个元素）； pop()方法今后列表所表示的堆栈处弹出一个元素，即移除并返回此列表的第一个元素； offerFirst()方法是在此列表的开头插入指定的元素； get()方法是返回此列表中指定位置处的元素。本题应选择C。 注意：与offerFirst()方法对应的offerList()方法则是在此列表末尾插入指定的元素。
Eg：			分析： 该题使用HashMap存储诗人信息，主要考察的是HashMap的经常使用方法 1.Object map.get(Object key) 得到与key（李白）相关的value（唐代大诗人） 2.boolean containsKey(Object key) 判断map集合中是否存在key(李白)：true 3.boolean containsValue(Object value) 判断map集合中是否存在value(台湾著名做家)：true 4.int size() 返回集合中元素的数量：2 5.boolean isEmpty 判断集合中是否存在元素（为空返回true,存在元素返回false）：
Eg：			分析： 本题要从hMap中查找获得value是“Oracle”的字符串，要经过与之对应的key值"3"才能获得。 注意：put方法添加对象时key的值是字符串"1"、"2"、"3"、"4"，选项C的代码hMap.get(3)中参数是整数类型，而不是字符串"3"， Java的HashMap是Java Collection Framework 的重要成员，是 Map 接口的经常使用实现类。 对HashMap 而言，系统将 key-value 当成一个总体进行处理，根据 Hash 算法来计算 key-value 的存储位置，这样能够保证能快速存、取 Map 的 key-value 对。 HashMap 采用一种所谓的“Hash 算法”来决定每一个元素的存储位置。 当须要向HaspMap中添加对象时，程序执行该类的put()方法，系统将调用key值的 hashCode() 方法获得其 hashCode 值。获得这个对象的 hashCode 值以后，系统会根据该 hashCode 值来决定该元素的存储位置。 而要获取HaspMap中某个对象时，程序调用get()方法经过 key 取出对应 value 时，系统只要先计算出该 key 的 hashCode() 返回值，在根据该 hashCode 返回值找出该 key 在 table 数组中的索引，而后取出该索引处的 Entry，最后返回该 key 对应的 value 便可。
●HashMap类是基于哈希表的 Map 接口的实现。它提供全部可选的映射操做，并容许使用 null 值和 null 键。但此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
●HashMap 类是一个散列表，它存储的内容是键值对(key-value)映射。 HashMap 继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。 由于它属于Map接口的类，因此实现了将惟一键映射到特定的值上。 同时，它的key、value均可觉得null。因此，HashMap对象中最多只有1个key值能够为null。
●Map将键映射到值的对象。一个映射不能包含重复的键；每一个键最多只能映射到一个值，在Java中Key的值重复，会默认覆盖前一个。在C#会报错。
●HashMap类和Hashtable类都是基于哈希表的 Map 接口的实现。 Java集合框架中，有些类是线程同步安全的类，它们是Vector、Hashtable、Stack、enumeration。除了这些以外，其余的都是非线程安全的类和接口。 线程安全类的方法是同步的，每次只能一个访问，它们是重量级对象，效率较低。 对于非线程安全的类和接口，在多线程中须要程序员本身处理线程安全问题。 Hashtable类的性能会低于HashMap类；
●HashSet类是由哈希表支持。它不保证 set 的迭代顺序； 特别是它不保证该顺序恒久不变。此类容许使用 null 元素。 HashSet类为基本操做提供了稳定性能，这些基本操做包括 add、remove、contains 和 size，假定哈希函数将这些元素正确地分布在桶中。 Java的HashMap和Hashtable都实现了Map接口。它们及其子类都采用Hash算法决定Map中key的存储。 HashMap和Hashtable的主要区别有：线程安全性，同步(synchronization)，以及速度。
●关于迭代器，其中hasNext()方法是判断是否有下一个元素，返回值为boolean， 而next()方法是获取下一个元素，通常这两个方法配合while循环一块儿使用！ 遍历ArrayList时，能够经过Iterator迭代器，itor.hasNext()表示还有没有下一个集合元素，itor.next()取集合的下一个元素。
●Iterator接口描述的序列只能向后移动，这个从其提供的成员方法能够看出，next(),hasNext()。 其成员方法中，remove()是移出最后一个返回的序列成员。 next()是返回后一个序列成员（若是是第一次调用，则返回第一个成员）， hasNext()表示是否还有序列成员。
●ListIterator接口的理解。Java中，除了具备Collection接口必备的iterator()方法外， List还提供listIterator()方法，返回一个 ListIterator接口。 做为ListIterator，ListIterator接口继承了Iterator接口，是List的专门迭代器。 和标准的Iterator接口相比，ListIterator增长了hasPrevious()、prevoius()、add()三个方法，能够向前或向后遍历数据，容许向List集合中添加数据。ListIterator接口的put()方法不能实现添加元素的功能个，
LinkedList():	List<>:		List(注释4会报错)		TreeMap：
Eg：				foreach访问数组：
●泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操做的数据类型被指定为一个参数。 这种参数类型能够用在类、接口和方法的建立中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。 在Java SE 1.5以前，没有泛型的状况的下，经过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要作显式的强制类型转换，而这种转换是要求开发者对实际参数类型能够预知的状况下进行的。对于强制类型转换错误的状况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患 泛型的好处是在编译的时候检查类型安全，而且全部的强制转换都是自动和隐式的，提升代码的重用率。 若是一个类或接口上有一个或多个类型变量，那它就是泛型。类型变量由尖括号（“<>”）界定，放在类或接口名的后面。
●ava.util.Collections类包含不少有用的方法，可使程序员的工做变得更加容易。 使用swap()方法能够在指定列表的指定位置处交换元素。 使用sort()方法能够根据元素的天然顺序 对指定列表按升序进行排序。
●泛型同样遵循多态，父引用指向子对象。 集合类都是泛型的，包括Iterator这个迭代器。 泛型是为了进行类型声明是不肯定，编译时肯定，从而简化程序的一种方式，因此会进行类型的检查。 泛型是能用尽量使用-使程序更加健壮，避免运行时出现类型转换错误给用户带来麻烦。
Eg：		分析： 本题考查泛型语句的语法。 Java的SortedSet是一个接口，其中的元素使用其天然顺序进行排序，或者根据一般在建立有序 set 时提供的 Comparator 进行排序。 该 set 的迭代器将按元素升序进行遍历。它提供了一些附加的操做来利用这种排序。 first()方法返回此 set 中当前第一个（最低）元素；tailSet()方法返回此 set 中大于等于指定的数值（方法的参数值）的全部元素。 对返回的set添加泛型时，应该在赋值运算符的左侧限定泛型类型。所以，本题应选择A。
Eg：		分析： 这种参数类型能够用在类、接口和方法的建立中，分别称为泛型类、泛型接口、泛型方法。 若是一个类或接口上有一个或多个类型变量，那它就是泛型。 类型变量由尖括号<>界定，放在类或接口名的后面。 本题要求建立一个只能存放String的泛型ArrayList的语句， 选项A则是建立了一个存放int型数据的ArrayList对象； 选项C的赋值运算符左侧ArrayList类后面缺乏<string>，存在语法错误； 选项D的赋值运算符左侧是ArrayList类，但其右侧是List接口，代码也有错误。本题应选择B。</string>