Java基础集合总结

1：集合体系(掌握)

集合

|--Collection(单列,底层结构是针和元素有关) |--List(有序,可重复)

|--ArrayList

底层数据结构是数组，查询快，增删慢。 线程不安全，效率高。

|--Vector

底层数据结构是数组，查询快，增删慢。 线程安全，效率低。

|--LinkedList

底层数据结构是链表，查询慢，增删快。 线程不安全，效率高。

|--Set(无序,唯一)

|--HashSet

底层数据结构是哈希表。 线程不安全，效率高。 怎么保证唯一性的呢? 它依赖两个方法：hashCode()和equals() 顺序： 首先判断hashCode()值是否相同。 同：继续走equals()，看返回值 如果true：就不添加到集合。 如果false：就添加到集合。 不同：就添加到集合。 |--TreeSet 底层数据结构是二叉树。 线程不安全，效率高。 怎么保证唯一性的呢?是根据返回是否是0。 怎么保证排序的呢?两种方式 自然排序(元素具备比较性) 实现Comparable接口 比较器排序(集合具备比较性) 实现Comparator接口 |--Map(双列底层结构是针对键有效，跟值无关) |--HashMap 底层数据结构是哈希表。 线程不安全，效率高。可以存null值和null键

怎么保证唯一性的呢? 它依赖两个方法：hashCode()和equals() 顺序： 首先判断hashCode()值是否相同。 同：继续走equals()，看返回值 如果true：就不添加到集合。 如果false：就添加到集合。 不同：就添加到集合。 |--Hashtable 底层数据结构是哈希表。 线程安全，效率低。 怎么保证唯一性的呢? 它依赖两个方法：hashCode()和equals() 顺序： 首先判断hashCode()值是否相同。 同：继续走equals()，看返回值 如果true：就不添加到集合。 如果false：就添加到集合。 不同：就添加到集合。 |--TreeMap 底层数据结构是二叉树。 线程不安全，效率高。

怎么保证唯一性的呢?是根据返回是否是0。 怎么保证排序的呢?两种方式

自然排序(元素具备比较性)

实现Comparable接口

比较器排序(集合具备比较性)

实现Comparator接口

2：应用。(添加功能，判断功能，删除功能，获取功能，长度功能) Collection

add(Object obj)

remove(Object obj)

contains(Object obj)

iterator()

size()

|--List

get(int index)

add(intindex,Objectobj)

remove(int index)

set(intindex,Objectobj)

|--Set Map put(Object key,Object value) remove(Object key) containsKey(Object key) containsValue(Object value) size() get(Object key) keySet() values()

3：遍历方式

List:

迭代器(在源码中可以看到的，开发中也经常看到) 增强for(开发中看到,JDK5以后用) 普通for 如果仅仅为了遍历，用任意一种即可。一般选择前两种的任意一种。 如果要做修改，或者删除指定位置的元素，或者在指定位置添加元素。用普通for。 Set: 迭代器 增强for

任选一种。

Map:

键找值。

4：代码补齐：请对array,hs,hm进行遍历。

A:

ArrayList<String> array = new ArrayList<String>();

方式1： Iterator<String> it = array.iterator(); while(it.hasNext()){ String s = it.next(); System.out.println(s); } 方式2： for(String s : array){ System.out.println(s); }

方式3： for(int x=0; x<array.size(); x++){ String s = array.get(x); System.out.println(s); } B: HashSet<String>hs = new HashSet<String>(); 方式1： Iterator<String> it = hs.iterator(); while(it.hasNext()){ String s = it.next(); System.out.println(s); } 方式2： for(String s : hs) { System.out.println(s); } C: HashMap<String,Strting>hm = new HashMap<String,String>(); Set<String> set = hm.keySet(); for(String key : set) { String value = hm.get(key); System.out.println(key+"***"+value); }

5：什么时候用谁?

是否键值对?

是：Map

是否对键排序?

是：TreeMap

否：HashMap

不懂的情况下，使用HashMap。

否：Collection

是否唯一

是：Set

是否对元素进行排序?

是：TreeSet 否：HashSet 不懂的情况下，使用HashSet 否：List 是否要安全： 是：Vector(真正开发中也不用) List list = Collections.synchronizedList(new ArrayList()); 否：ArrayList，LinkedList 查询多：ArrayList 增删多：LinkedList 不懂的情况下，使用ArrayList

第二篇：JAVA中集合类的总结

JAVA中集合类的总结

为什么要使用集合类

当你事先不知道要存放数据的个数，或者你需要一种比数组下标存取机制更灵活的方法时，你就需要用到集合类。

理解集合类

集合类存放于java.util包中。

集合类存放的都是对象的引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用（reference)。

集合类型主要有3种：set(集）、list(列表）和map(映射)。

(1)集

集（set）是最简单的一种集合，它的对象不按特定方式排序，只是简单的把对象加入集合中，就像往口袋里放东西。

对集中成员的访问和操作是通过集中对象的引用进行的，所以集中不能有重复对象。 集也有多种变体，可以实现排序等功能，如TreeSet，它把对象添加到集中的操作将变为按照某种比较规则将其插入到有序的对象序列中。它实现的是 SortedSet接口，也就是加入了对象比较的方法。通过对集中的对象迭代，我们可以得到一个升序的对象集合。

(2)列表

列表的主要特征是其对象以线性方式存储，没有特定顺序，只有一个开头和一个结尾，当然，它与根本没有顺序的集是不同的。

列表在数据结构中分别表现为：数组和向量、链表、堆栈、队列。

关于实现列表的集合类，是我们日常工作中经常用到的，将在后边的笔记详细介绍。

(3)映射

映射与集或列表有明显区别，映射中每个项都是成对的。映射中存储的每个对象都有一个相关的关键字（Key）对象，关键字决定了对象在映射中的存储位置，检索对象时必须提供相应的关键字，就像在字典中查单词一样。关键字应该是唯一的。

关键字本身并不能决定对象的存储位置，它需要对过一种散列(hashing)技术来处理，产生一个被称作散列码(hash code)的整数值，散列码通常用作一个偏置量，该偏置量是相对于分配给映射的内存区域起始位置的，由此确定关键字/对象对的存储位置。理想情况下，散列 处理应该产生给定范围内均匀分布的值，而且每个关键字应得到不同的散列码。

? 集合类简介

java.util中共有13个类可用于管理集合对象，它们支持集、列表或映射等集合，以下是这些类的简单介绍

集：

HashSet： 使用HashMap的一个集的实现。虽然集定义成无序，但必须存在某种方法能相当高效地找到一个对象。使用一个HashMap对象实现集的存储和检索操作是在固

定时间内实现的.

TreeSet： 在集中以升序对对象排序的集的实现。这意味着从一个TreeSet对象获得第一个迭代器将按升序提供对象。TreeSet类使用了一个TreeMap.

列表：

Vector： 实现一个类似数组一样的表，自动增加容量来容纳你所需的元素。使用下标存储和检索对象就象在一个标准的数组中一样。你也可以用一个迭代器从一个Vector中检索对象。Vector是唯一的同步容器类??当两个或多个线程同时访问时也是性能良好的。

Stsck: 这个类从Vector派生而来，并且增加了方法实现栈??一种后进先出的存储结构。

LinkedList: 实现一个链表。由这个类定义的链表也可以像栈或队列一样被使用。 ArrayList: 实现一个数组，它的规模可变并且能像链表一样被访问。它提供的功能类似Vector类但不同步。

映射：

HashTable： 实现一个映象，所有的键必须非空。为了能高效的工作，定义键的类必须实现hashcode()方法和equal()方法。这个类是前面java实现的一个继承，并且通常能在实现映象的其他类中更好的使用。

HashMap： 实现一个映象，允许存储空对象，而且允许键是空（由于键必须是唯一的，当然只能有一个）。

WeakHashMap： 实现这样一个映象：通常如果一个键对一个对象而言不再被引用，键/对象对将被舍弃。这与HashMap形成对照，映象中的键维持键/对象对的生命周期，尽管使用映象的程序不再有对键的引用，并且因此不能检索对象。

TreeMap： 实现这样一个映象，对象是按键升序排列的。

Set 和List都是由公共接口Collection扩展而来，所以它们都可以使用一个类型为Collection的变量来引用。这就意味着任何列表或集构成的 集合都可以用这种方式引用，只有映射类除外（但也不是完全排除在外，因为可以从映射获得一个列表。）所以说，把一个列表或集传递给方法的标准途径是使用 Collection类型的参数。

? Vector 还是ArrayList，哪一个更好，为什么？

要回答这个问题不能一概而论，有时候使用Vector比较好；有时是ArrayList，有时候这两个都不是最好的选择。你别指望能够获得一个简单肯定答案，因为这要看你用它们干什么。下面有4个要考虑的因素：

(1)API

(2)同步处理

(3)数据增长性

(4)使用模式

下面针对这4个方面进行一一探讨

API

在由Ken Arnold等编著的《Java Programming Language》(Addison-Wesley, June 2000)一书中有这样的描述，Vector类似于ArrayList.。所有从API的角度来看这两个类非常相似。但他们之间也还是有一些主要的区别 的。

同步性

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

数据增长

从内部实 现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类型中增加元素的时候，如果元素的数目超出了内 部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%,所以最后你获得 的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一些优势，因为你可以通过设置集合的初始化大小 来避免不必要的资源开销。

使用模式

在 ArrayList和Vector中，从一个指定的位置（通过索引）查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的，这个时间我们用 O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除 元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢？

这 意味着，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作，你最好选择其他的 集合操作类。比如，LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的—O(1)，但它在索引一个元素的使用缺比较慢 －O(i),其中i是索引的位置.使用ArrayList也很容易，因为你可以简单的使用索引来代替创建iterator对象的操作。LinkList也 会为每个插入的元素创建对象，所有你要明白它也会带来额外的开销。 最后，在《Practical Java》一书中Peter Haggar建议使用一个简单的数组（Array）来代替Vector或ArrayList。尤其是对于执行效率要求高的程序更应如此。因为使用数组 (Array)避免了同步、额外的方法调用和不必要的重新分配空间的操作。 关于作者：Tony Sintes是BroadVision的首席顾问。它是SUN的认证程序员，并且从19xx年就开始使用Java开发程序。

在使用Java的时候，我们都会遇到使用集合（Collection）的时候，但是Java API提供了多种集合的实现，我在使用和面试的时候频

频遇到这样的“抉择” 。 :）（主要还是面试的时候）

久而久之，也就有了一点点的心得体会，写出来以供大家讨论 。

总的说来，Java API中所用的集合类，都是实现了Collection接口，他的一个类继承结构如下：

Collection<--List<--Vector

Collection<--List<--ArrayList

Collection<--List<--LinkedList

Collection<--Set<--HashSet

Collection<--Set<--HashSet<--LinkedHashSet

Collection<--Set<--SortedSet<--TreeSet

Vector : 基于Array的List，其实就是封装了Array所不具备的一些功能方便我们使用，它不可能走入Array的限制。性能也就不可能

超越Array。所以，在可能的情况下，我们要多运用Array。另外很重要的一点就是Vector“sychronized”的，这个也是Vector和

ArrayList的唯一的区别。

ArrayList：同Vector一样是一个基于Array上的链表，但是不同的是ArrayList不是同步的。所以在性能上要比Vector优越一些，但

是当运行到多线程环境中时，可需要自己在管理线程的同步问题。

LinkedList：LinkedList不同于前面两种List，它不是基于Array的，所以不受Array性能的限制。它每一个节点（Node）都包含两方

面的内容：1.节点本身的数据（data）；2.下一个节点的信息（nextNode）。所以当对LinkedList做添加，删除动作的时候就不用像

基于Array的List一样，必须进行大量的数据移动。只要更改nextNode的相关信息就可以实现了。这就是LinkedList的优势。

List总结：

1. 所有的List中只能容纳单个不同类型的对象组成的表，而不是Key－Value键值对。例如：[ tom,1,c ]；

2. 所有的List中可以有相同的元素，例如Vector中可以有 [ tom,koo,too,koo ]；

3. 所有的List中可以有null元素，例如[ tom,null,1 ]；

4. 基于Array的List（Vector，ArrayList）适合查询，而LinkedList（链表）适合添加，删除操作。

HashSet：虽然Set同List都实现了Collection接口，但是他们的实现方式却大不一样。List基本上都是以Array为基础。但是Set则是

在HashMap的基础上来实现的，这个就是Set和List的根本区别。HashSet的存储方式是把HashMap中的Key作为Set的对应存储项。看看

HashSet的add（Object obj）方法的实现就可以一目了然了。

public boolean add(Object obj)

{

return map.put(obj, PRESENT) == null;

}

这个也是为什么在Set中不能像在List中一样有重复的项的根本原因，因为HashMap的key是不能有重复的。

LinkedHashSet：HashSet的一个子类，一个链表。

TreeSet：SortedSet的子类，它不同于HashSet的根本就是TreeSet是有序的。它是通过SortedMap来实现的。

Set总结：

1. Set实现的基础是Map（HashMap）；

2. Set中的元素是不能重复的，如果使用add(Object obj)方法添加已经存在的对象，则会覆盖前面的对象

为什么要使用集合类

当你事先不知道要存放数据的个数，或者你需要一种比数组下标存取机制更灵活的方法时，你就需要用到集合类。

理解集合类

集合类存放于java.util包中。

集合类存放的都是对象的引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用（reference)。

集合类型主要有3种：set(集）、list(列表）和map(映射)。

(1)集

集（set）是最简单的一种集合，它的对象不按特定方式排序，只是简单的把对象加入集合中，就像往口袋里放东西。

对集中成员的访问和操作是通过集中对象的引用进行的，所以集中不能有重复对象。 集也有多种变体，可以实现排序等功能，如TreeSet，它把对象添加到集中的操作将变为按照某种比较规则将其插入到有序的对象序

列中。它实现的是SortedSet接口，也就是加入了对象比较的方法。通过对集中的对象迭代，我们可以得到一个升序的对象集合。

(2)列表

列表的主要特征是其对象以线性方式存储，没有特定顺序，只有一个开头和一个结尾，当然，它与根本没有顺序的集是不同的。

列表在数据结构中分别表现为：数组和向量、链表、堆栈、队列。

关于实现列表的集合类，是我们日常工作中经常用到的，将在后边的笔记详细介绍。

(3)映射

映射与集或列表有明显区别，映射中每个项都是成对的。映射中存储的每个对象都有一个相关的关键字（Key）对象，关键字决定了

对象在映射中的存储位置，检索对象时必须提供相应的关键字，就像在字典中查单词一样。关键字应该是唯一的。

关键字本身并不能决定对象的存储位置，它需要对过一种散列(hashing)技术来处理，产生一个被称作散列码(hash code)的整数值，

散列码通常用作一个偏置量，该偏置量是相对于分配给映射的内存区域起始位置的，由此确定关键字/对象对的存储位置。理想情况

下，散列处理应该产生给定范围内均匀分布的值，而且每个关键字应得到不同的散列码。

集合类简介

java.util中共有13个类可用于管理集合对象，它们支持集、列表或映射等集合，以下是这些类的简单介绍

集：

HashSet： 使用HashMap的一个集的实现。虽然集定义成无序，但必须存在某种方法能相当高效地找到一个对象。使用一个HashMap对

象实现集的存储和检索操作是在固定时间内实现的.

TreeSet： 在集中以升序对对象排序的集的实现。这意味着从一个TreeSet对象获得第一个迭代器将按升序提供对象。TreeSet类使用

了一个TreeMap.

列表：

Vector： 实现一个类似数组一样的表，自动增加容量来容纳你所需的元素。使用下标存储和检索对象就象在一个标准的数组中一样

。你也可以用一个迭代器从一个Vector中检索对象。Vector是唯一的同步容器类??当两个或多个线程同时访问时也是性能良好的。

Stsck: 这个类从Vector派生而来，并且增加了方法实现栈??一种后进先出的存储结构。

LinkedList: 实现一个链表。由这个类定义的链表也可以像栈或队列一样被使用。 ArrayList: 实现一个数组，它的规模可变并且能像链表一样被访问。它提供的功能类似Vector类但不同步。

映射：

HashTable： 实现一个映象，所有的键必须非空。为了能高效的工作，定义键的类必须实现hashcode()方法和equal()方法。这个类

是前面java实现的一个继承，并且通常能在实现映象的其他类中更好的使用。

HashMap： 实现一个映象，允许存储空对象，而且允许键是空（由于键必须是唯一的，当然只能有一个）。

WeakHashMap： 实现这样一个映象：通常如果一个键对一个对象而言不再被引用，键/对象对将被舍弃。这与HashMap形成对照，映象

中的键维持键/对象对的生命周期，尽管使用映象的程序不再有对键的引用，并且因此不能检索对象。

TreeMap： 实现这样一个映象，对象是按键升序排列的。

Set和List都是由公共接口Collection扩展而来，所以它们都可以使用一个类型为Collection的变量来引用。这就意味着任何列表或

集构成的集合都可以用这种方式引用，只有映射类除外（但也不是完全排除在外，因为可以从映射获得一个列表。）所以说，把一个

列表或集传递给方法的标准途径是使用Collection类型的参数。

Vector 还是ArrayList，哪一个更好，为什么？

要回答这个问题不能一概而论，有时候使用Vector比较好；有时是ArrayList，有时候这两个都不是最好的选择。你别指望能够获得

一个简单肯定答案，因为这要看你用它们干什么。下面有4个要考虑的因素：

(1)API

(2)同步处理

(3)数据增长性

(4)使用模式

下面针对这4个方面进行一一探讨

API

在由Ken Arnold等编著的《Java Programming Language》(Addison-Wesley, June 2000)一书中有这样的描述，Vector类似于

ArrayList.。所有从API的角度来看这两个类非常相似。但他们之间也还是有一些主要的区别的。

同步性

Vector是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而ArrayList则是异步的，因此ArrayList中的对象并不

是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样

可以避免由于同步带来的不必要的性能开销。

数据增长

从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类型中增加元素的时候，如果元素

的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是

原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector

有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。 使用模式

在ArrayList和Vector中，从一个指定的位置（通过索引）查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的，

这个时间我们用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中

元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所

有元素都要执行位移的操作。这一切意味着什么呢？

这意味着，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作，

你最好选择其他的集合操作类。比如，LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的—O(1)，但它在

索引一个元素的使用缺比较慢－O(i),其中i是索引的位置.使用ArrayList也很容易，因为你可以简单的使用索引来代替创建iterator

对象的操作。LinkList也会为每个插入的元素创建对象，所有你要明白它也会带来额外的开销。

最后，在《Practical Java》一书中Peter Haggar建议使用一个简单的数组（Array）来代替Vector或ArrayList。尤其是对于执行效

率要求高的程序更应如此。因为使用数组(Array)避免了同步、额外的方法调用和不必要的重新分配空间的操作

Collections Framework

集合框架是一个统一的架构,用来表示和操作集合.

集合框架主要是由接口,抽象类和实现类构成.

接口

Collection

|_____Set

| |_____SortedSet

|

|_____List

Map

|____SortedMap

Collection:集合层次中的根接口,JDK没有提供这个接口的实现类.

Set:不能包含重复的元素.SortedSet是一个按照升序排列的元素的Set.

List:是一个有序的集合,可以包含重复的元素.提供了按索引访问的

方式.

有次序，位置不改变.

Map:包含了key-value对.Map不能包含重复的key.SortedMap是一个

按升序排列key的Map.

存储关键字和值.

集合框架中的接口,和实现类都是在

java.util包当中的

在Collection当中提供add()方法

可以将元素加入集合当中.

在List当中增加了一个get()方法

是按照索引获取集合当中的元素.

在系统区windows目录下有win.ini

有键和对应的值

asf=MPEGVideo

注册表存储的也是这种类型.

就是用Map接口所提供的方法来存储.

Map不能包含重复的键,但值是可以重复的.

SortedMap是一个按照升序排列key的Map.

集合框架中的实现类.

ArrayList:我们可以将其看作是能够自动增长容量的数组. 实际是采用对象数组实现的.

自动增长容量就是当数组不够的时候,再定义更大的数组, 然后将数组元素拷贝到新的数组.

//ArryListTest.java

import java.util.*;

class ArrayListTest

{

public static void main(String[] args)

{

ArrayList al=new ArrayList();

a1.add("winsun");

a1.add("weixin");

a1.add("mybole");

for(int i=0;i<a1.size();i++)

{

System.out.println(a1.get(i));

}

//ArrayList实现了List接口

//System.out.println(a1);

}

}

add()方法就是给数组增加对象元素.

ArrayList实际上就是利用对象数组来实现对象存储的.

ArrayList:可以将其看作是能够自动增长容量的数组.

增长容量就是定义一个新的数组并将原来元素复制到新的数组当中. 集合类也是从Object类继承来所以有toString()方法.

import java.util.*;

class Point

{

int x,y;

Point(int x,int y)

{

this.x=x;

this.y=y;

}

public String toString()

{

return "x="+x+",y="+y;

}

}

class ArrayListTest

{

public static void main(String[] args)

{

ArrayList al=new ArrayList();

a1.add(new Point(3,3));

a1.add(new Point(4,4));

a1.add(new Point(5,5));

for(int i=0;i<a1.size();i++)

{

System.out.println(a1.get(i));

}

Object[] objs=a1.toArray();

//利用ArrayList的toArray()返回一个对象的数组.

for(int i=0;i<objs.length;i++)

{

System.out.println(objs[i]);

}

//Arrays.asList()返回一个列表.

List l=Arrays.asList(objs);

System.out.println(l);

}

}

利用ArrayList的toArray()返回一个对象的数组.

*************

Arrays.asList()返回一个列表.

可以将一个对象数组转换一个列表返回.

返回固定尺寸的列表,当返回以后就不能修改列表的大小了.

可以修改列表中元素的值,但不能增加容量.

可以用set()方法对值进行修改

Object set(int index,Object element)

用element替换指定的index的对象

Arrays.asList()和Collection.toArray()是作为数组和集合类的一个桥 如果想从集合类中获得一个数组可以使用toArray()方法

如果想从数组中获得一个列表可以使用asList()方法

**************

集合框架中的迭代

迭代器(Iterator)提供了一种通用的方式来访问集合中的元素. Iterator是java.util包中提供的方法.

其中有3个方法

hasNext()

next()

remove()

hasNext()判断是否有更多的元素.如果有返回true

next()

remove()方法删除上一个被访问的元素.可以实现也可以不实现. 迭代器是指向两个元素之间的.

Collection提供了一个iterator()方法,可以返回一个迭代器. 凡是继承自Collection的接口或间接的实现类都有这个方法. Iterator it=a1.iterator();

it.next();

it.remove();

while(it.hasNext())

{

System.out.println(it.next());

}

remove()方法需要删除上一个返回的元素.

需要先调用next()方法后在用remove()的

*

Iterator it=l.iterator();//返回列表调用迭代器. *

返回的列表有时不一定真正实现remove()方法...

集合框架中常用的实现类都支持所有的操作.

通用方式访问集合中的元素

另外定义打印函数

public static void printElements(Collection c) {

Iterator it=c.iterator();

while(it.hasNext())

{

System.out.println(it.next());

}

}

//在main()方法中调用

printElements(al);

al是ArrayList对象

Collection接口派生List接口,ArrayList类实现了List接口 Collection->List->ArrayList->al

6-4

有用的类

排序:Collections.sort()不同于Collection类

Collections.sort()主要是对列表排序.

1.自然排寻natural ordering

2.实现比较器Comparator接口

取最大元素Collections.max().

取最小元素Collections.min().

在已经排序的List中搜索指定的元素.

Collections.binarySearch().

static void sort(List list)方法是按升序对指定列表排序. 自然排序法.

列表中元素必须都实现了comparable接口.与Arrays.sort()是一样的. comparable接口在java.lang包当中.

实现comparable接口就要实现compareTo()方法.

compareTo()大于返回正数,等于返回0,小于返回负数.

class Student implements Comparable

{

int num;

String name;

Student(int num,String name)

{

this.num=num;

this.name=name;

}

public int compareTo(Object o)

{

Student s=(Student)o;

return num>s.num?1:(num==s.num?0:-1);

}

public String toString()

{

return num+":"+name;

}

}

public static void printElements(Collection c)

{

Iterator it=c.iterator();

while(it.hasNext())

{

System.out.println(it.next());

}

}

public static void main(String []args)

{

Student s1=new Student(2,"zhangsan");

Student s2=new Student(1,"lisi");

Student s3=new Student(3,"wangwu");

ArrayList a1=new ArryList();

a1.add(s1);

a2.add(s2);

a3.add(s3);

Collections.sort(a1);

printElements(a1);

}

排序的时候可以传递一个比较器.

Comparator接口.

java.util包当中.

有两个方法int compare(Object o1,Object o2) 两个对象进行比较当对象1大于对象2的时候返回1, 当对象1等于对象2的时候返回一个0,

当对象1小于对象2的时候返回一个负数.

和boolean equals(Object obj)方法.

实现一个比较器.

比较器总是和一个特定的类相关.

为某一个类指定一个比较器.

利用内部类实现比较器接口.

**内部类

声明为静态方法就不需要产生外部类对象.

class Student implements Comparable

{

int num;

String name;

Student(int num,String name)

{

this.num=num;

this.name=name;

}

public int compareTo(Object o)

{

Student s=(Student)o;

return num>s.num?1:(num==s.num?0:-1);

}

public String toString()

{

return num+":"+name;

}

static class StudentComparator implements Comparator {

public int compare(Object o1,Object o2) {

Student s1=(Student)o1;

Student s2=(Student)o2;

int result=s1.num>s2.num ? 1 : (s1.num==s2.num ? 0 : -1); if(result==0)

{ //String类实现了compareTo()方法.

result=pareTo(s2.name);

}

return result;

}

}

}

public static void printElements(Collection c)

{

Iterator it=c.iterator();

while(it.hasNext())

{

System.out.println(it.next());

}

}

public static void main(String []args)

{

Student s1=new Student(2,"zhangsan");

Student s2=new Student(1,"lisi");

Student s3=new Student(3,"wangwu");

ArrayList a1=new ArryList();

a1.add(s1);

a2.add(s2);

a3.add(s3);

Collections.sort(a1,Student.StudentComparator());

printElements(a1);

}

Collections类中提供了一种反序排列方式.

本身返回就是一个比较器对象

static Comparator reverseOrder()

Arrays.sort()也可以指定一个比较器对象

static void sort(Object[] a,Comparator c)

取最大和最小的元素:

Collections.max().

Collections.min().

在已排序的List中搜索指定的元素:

Collections.binarySearch().

********Collections类主要对列表操作.

Arrays类主要对数组操作.

***LinkedList类

LinkedList是采用双向循环链表实现的.

利用LinkedList实现栈(stack).队列(queue).

双向队列(double-ended queue).*****************

LinkedList常用方法

void addFirst(Object o)

void addLast(Object o)

Object getFirst()

Object getLast()

Object remove(int index)

boolean remove(Object o)

Object removeFirst()

Object removeLast()

判断是否为空

LinkedList继承了一个方法isEmpty()

Methods inherited from class java.util.AbstractCollection 如果没有包含任何元素返回true,没有包含任何元素返回false 队列

front rear

ArrayList底层采用数组完成,而LinkedList则是以一般的

双向链表完成,其内每个对象除了数据本身外,还有两个引用,

分别指向前一个元素和后一个元素.

如果我们经常在List的开始处增加元素,或者在List中进行插入 和删除操作,我们应该使用LinkedList,否则的话,使用ArrayList 将更加快速.

因为插入和删除都要移动数组中的元素.

只是访问就用ArrayList,提供了按索引访问的机制.

*********

HashSet

HashSet实现了Set接口的hash table(哈希表),依靠HashMap来实现. 应该为要存放到散列表的各个对象定义hashCode()和equals(). 因为实现了set接口所以不能有重复的元素.

散列表:

散列表又称为哈希表.

散列表算法的基本思想:

以结点的关键字为自变量,通过一定的函数关系(散列函数)

计算出对应的函数值,以这个值作为该结点存储在散列表中的地址.

当散列表中的元素存放太满,就必须进行再散列,将产生一个新的散列表, 所有元素存放到新的散列表中,原先的散列表将被删除.

在java语言中,通过负载因子(load factor)来决定何时对散列表进行再 散列.例如:如果负载因子是0.75,当散列表中已经有75%的位置已经放满, 那么将进行散列.

负载因子越高(越接近1.0),内存的使用率越高,元素的寻找时间越长.

负载因子越低(越接近0.0),元素的寻找时间越短,内存浪费越多. HashSet类的缺省负载因子是0.75.

HashSet在java.util包当中.

需要导入.

常用方法

boolean add(Object o)

void clear()

没有get()方法

需要使用迭代器

Iterator iterator();输出

HashSet类实现了Set接口,所以不能有重复的元素.

**

要根据散列码计算存储位置.

而散列码是利用Object类当中的HashCode()函数获得的.

而HashCode()函数是通过一个对象的内存地址来得到散列码的. 所以要重写public int HashCode()方法.

String类实继承了HashCode()方法.

import java.util.*;

public class HashSetTest {

public static void main(String []args)

{

HashSet hs=new HashSet();

/* hs.add("one");

hs.add("two");

hs.add("three");

hs.add("one");

*/

hs.add(new Student(1,"zhangsan"));

hs.add(new Student(2,"lisi"));

hs.add(new Student(1,"zhangsan"));

hs.add(new Student(3,"wangwu"));

Iterator it=hs.iterator();

while(it.hasNext())

{

System.out.println(it.next());

}

}

}

class Student

{

int num;

String name;

Student(int num,String name)

{

this.name=name;

this.num=num;

}

public int HashCode()

{

return num*name.hashCode();

}

public boolean equals(Object o)

{

Student s=(Student)o;

return num==s.num && name.equals(s.name);

}

public String toString()

{

return "name : ="+name;

}

}

需要覆盖HashCode()和equals()方法

HashSet->HashCode->对象内存地址

**

TreeSet

TreeSet是依靠TreeMap来实现的.

TreeSet是一个有序集合,TreeSet中元素将按照升序排列, 缺省是按照自然排序进行排列,意味着TreeSet中元素要 实现Comparable接口.

我们可以在构造TreeSet对象时,传递实现了Comparator接口 的比较器对象.

java.util包当中TreeSet类

import java.util.*;

public class TreeSetTest {

//如果自定义类对象要加入TreeSet要实现Comparable接口 public static void main(String []args)

{

TreeSet ts=new TreeSet(new Student.StudentComparator()); /* ts.add("winsun");

ts.add("weixin");

ts.add("mybole");

*/

ts.add(new Student(2,"lisi"));

ts.add(new Student(1,"wangwu"));

ts.add(new Student(3,"zhangsan"));

ts.add(new Student(3,"mybole"));

Iterator it=ts.iterator();

while(it.hasNext())

{

System.out.println(it.next());

}

}

}

class Student implements Comparable

{

int num;

String name;

static class StudentComparator implements Comparator {

public int compare(Object o1,Object o2)

{

Student s1=(Student)o1;

Student s2=(Student)o2;

int result=s1.num>s2.num ? 1 : (s1.num==s2.num ? 0 : -1); if(result==0)

{ //String类实现了compareTo()方法.

result=pareTo(s2.name);

}

return result;

}

}

public static void printElements(Collection c)

{

Iterator it=c.iterator();

while(it.hasNext())

{

System.out.println(it.next());

}

}

Student(int num,String name)

{

this.name=name;

this.num=num;

}

public int HashCode()

{

return num*name.hashCode();

}

public boolean equals(Object o)

{

Student s=(Student)o;

return num==s.num && name.equals(s.name); }

public int compareTo(Object o)

{

Student s=(Student)o;

return num>s.num?1:(num==s.num?0:-1);

}

public String toString()

{

return num+":"+name;

}

}

**

HashSet是基于Hash算法实现的,其性能通常优于TreeSet. 通常都应该使用HashSet,在需要排序的功能时,才使用 TreeSet.

**

HashMap对key进行散列.

keySet()..values()..entrySet()..

HashMap是实现了Map接口的Hash表.

实现了所有hashmap操作,允许空值和空键.

HashSet底层就是hashmap的实现.

map接口没有add()方法.

要放置元素通过put()方法.

Object put(Object key,Object value)

获取元素的时候

Object get(Object key)

通过键获取值

Hash表,通过键计算出相对应的存储位置的值,并输出. **********************************

常用的方法

Set keySet()

返回一个键的视图类型是Set.

Collection values()

返回一个值的视图类型是Collection.

Set entrySet()

返回一个键值对视图类型是Set.

返回的Set集合当中每一个对象都是一个Map.Entry对象. Map.Entry是一个静态的接口.

接口中提供了常用方法

Object getKey()

Object getValue()

*****************************

import java.util.*;

public class HashMapTest

{

public static void printElements(Collection c)

{

Iterator it=c.iterator();

while(it.hasNext())

{

System.out.println(it.next());

}

}

public static void main(String []args)

{

HashMap hm=new HashMap();

hm.put("1", "zhang3");

hm.put("2", "li4");

hm.put("3", "wang5");

System.out.println(hm.get("1"));

System.out.println(hm.get("2"));

System.out.println(hm.get("3"));

Set keys=hm.keySet();

System.out.println("-----------keys---------"); printElements(keys);

Collection values=hm.values();

System.out.println("-----------values---------"); printElements(values);

Set entrySets =hm.entrySet();

System.out.println("------------entrySets-----------"); printElements(entrySets);

Iterator it=entrySets.iterator();

while(it.hasNext())

{

Map.Entry me=(Map.Entry)it.next();

System.out.println(me.getKey()+" = "+me.getValue()); }

}

}

**

TreeMap是实现了sorted Map接口的类

TreeMap按照key进行排序.

类似HashMap用法

**********************

HashMap和TreeMap比较

和Set类似,HashMap的速度通常都比TreeMap快,

只有在需要排序的功能的时候,才使用TreeMap.

**********************

java1.0/1.1

集合类

Vector:用ArrayList代替Vector.

Vector内所有方法都是同步的,存取元素效率低.

在多线程中可以使用

在Collection类中提供了

static list synchronizedList(List list)

可以返回一个同步列表

可以将列表实参传递进去会返回一个安全的线程同步列表 还有

static Collection synchronizedCollection(Collection c) static Set synchronizedSet(Set s)

Hashtable:用HashMap代替Hashtable

需要同步Map的时候

可以用Collection类的方法

static Map synchronizedMap(Map m)

但是还是Hashtable获取的同步Map快一些.

Stack:用LinkedList代替Stack.

Stack是从java.util.Vector继承而来.

还从Vector继承了alementAt()方法.

同时Stack还继承了不需要的特性.

所以要使用栈的时候要用LinkedList来自己实现.

Properties属性类.是从Hashtable继承而来也是存储键值对的. 表示一个持久的属性集合.

可以存储win.ini的键值对.

在

java.lang.System类当中

有

static Properties getProperties()

检测当前系统的属性

可以使用

void list(PrintStream out)打印系统属性

还可以读取一个配置文件:

先建立一个配置文件

winsun.ini

写入

company=winsun

author=sunxin

corpyright=2003-2004

先实例化一个Property对象

在用

void load(InputStream inStream)方法

可以从一个输入流中加载一个属性列表.

输入流可以用java.io包中的一个类构造.

可用

Enumeration propertyNames()

返回Enumeration对象.返回所有键的枚举.

Enumeration是一个接口

提供了两个方法

boolean hasMoreElements()

Object nextElement()

需要返回值的时候

String getProperty(String key)

返回键对应的值

import java.util.*;

import java.io.FileInputStream;

import java.io.*;

public class ProTest {

public static void main(String []args)

{

/* Properties pps=System.getProperties();

pps.list(System.out);

*/

Properties pps=new Properties();

try

{

pps.load(new FileInputStream("d:/workspace/ProTest/bin/winsun.ini")); Enumeration ENUM=pps.propertyNames();

while(ENUM.hasMoreElements())

{

String str=(String)ENUM.nextElement();

String strValue=pps.getProperty(str);

System.out.println(str+" = "+strValue); }

}

catch(FileNotFoundException e)

{

e.printStackTrace();

}

catch(IOException ex)

{

ex.printStackTrace();

}

}

}

static String getProperty(String key)

static String getProperty(String key,String def)

**********************************

迭代器以通用的方式打印集合类的不同对象.