集合框架

来源：互联网发布：带牛熊先知软件编辑：程序博客网时间：2024/05/29 18:17

集合框架.1. Collection

集合实际用来存储对象(Object)，但需要注意的是，集合存放的实质上是对象的地址。接下来我们先来看一下集合框架图，如下(同一颜色方框，我将它们视为同一级)：

首先由上图确认一下它们的关系：

Collection

java提供了一种可以存数一组数据的数据结构，其提供了丰富的方法，在实际开发中往往比数组使用的广泛。这种数据结构成为集合:Collection。

Collection是一个接口，其定义了集合的相关功能方法。

List和Set

Collection派生出了两个子接口，一个是List另一个则是Set。

List:称为可重复集，顾名思义，该集合中是允许存放重复元素的，那么何为重复元素？重复元素指的并非是同一个元素，而是指equals方法比较为true的元素。

Set:称为不可重复集，所以，该集合中是不能将相同的元素存入集合两次，同List，这里相同指的也是两个元素的equals比较结果为true。

集合持有对象的引用

集合中存储的都是引用类型的元素，那么引用类型变量实际上存储的是对象的“地址”，所以实际上集合只存储了元素对象在堆中的地址。而并不是将对象本身存入了集合中。

add()方法

Collection定义了一个add方法用于向集合中添加新元素。

boolean add(E e)

该方法会将给定的元素添加进集合，若添加成功则返回true,否则返回false

例如:

Collection<String> c = new ArrayList<String>();
System.out.println(c); // []
c.add("a");
c.add("b");
c.add("c");
System.out.println(c); // [a, b, c]

这里Collection后面的<String>是泛型，我们后面会讲解，这里不写也没有关系。

contains方法

boolean contains(Object o)

该方法会用于判断给定的元素是否被包含在集合中。若包含则返回true,否则返回false。

这里需要注意的是，集合在判断元素是否被包含在集合中是使用元素的equals的比较结果。

(o==null ? e==null : o.equals(e)) 其中e是集合中的元素。

例如:

Collection<Cell> cells = new ArrayList<Cell>(); 
cells.add(new Cell(1, 2));
cells.add(new Cell(1, 3));
cells.add(new Cell(2, 2));
cells.add(new Cell(2, 3));     
Cell cell = new Cell(1, 3); 
// List集合contains方法和对象的equals方法相关
boolean flag = cells.contains(cell);
// 如果Cell不重写equals方法将为false
System.out.println(flag); // true

size,clear,isEmpty方法

size方法用于获取当前集合中的元素总数。该方法定义为:int size()

clear方法用于清空集合。该方法定义为:void clear()

isEmpty方法用于判断当前集合中是否不包含元素。该方法定义为:boolean isEmpty()

集合框架
集合操作——线性表

1. 集合框架

1.1. Collection

java提供了一种可以存数一组数据的数据结构，其提供了丰富的方法，在实际开发中往往比数组使用的广泛。这种数据结构成为集合:Collection。

Collection是一个接口，其定义了集合的相关功能方法。

1.1.1. addAll与containsAll方法

集合也提供了批处理操作:

addAll方法用于将给定集合中的所有元素添加到当前集合中，其方法定义为:

boolean addAll(Collection c)

例如:

Collection<String> c1 = new ArrayList<String>();
c1.add("java");
c1.add("cpp");        
c1.add("php");
c1.add("c#");        
c1.add("objective-c"); 
System.out.println(c1); // [java, cpp, php, c#, objective-c] 
Collection<String> c2 = new HashSet<String>(); 
c2.addAll(c1);
System.out.println(c2); // [cpp, php, c#, java, objective-c]

containsAll方法用于判断当前集合是否包含给定集合中的所有元素，若包含则返回true。其方法定义为:

boolean containsAll(Collection c)

例如:

Collection<String> c1 = new ArrayList<String>();
c1.add("java");        
c1.add("cpp");        
c1.add("php");
c1.add("c#");        
c1.add("objective-c"); 
System.out.println(c1); // [java, cpp, php, c#, objective-c] 
Collection<String> c2 = new ArrayList<String>();
c2.add("java");        
c2.add("cpp");
System.out.println(c1.containsAll(c2)); // true

1.2. Iterator 迭代器

Collection提供了一个遍历集合的通用方式，迭代器(Iterator)。

获取迭代器的方式是使用Collection定义的方法:

Iterator iterator()

迭代器Iterator是一个接口，集合在覆盖Collection的iterator()方法时提供了迭代器的实现。

Iterator提供了统一的遍历集合元素的方式。

1.2.1. hasNext与next方法

迭代器用于遍历集合的两个主要方法:

boolean hasNext():判断集合是否还有元素可以遍历。
E next():返回迭代的下一个元素

遍历集合应遵循“先问后取”的方式，也就是说，应当在确定hasNext()方法的返回值为true的情况下再通过next()方法取元素。

由此可以看出，使用迭代器遍历集合是通过boolean值驱动的，所以它更适合使用while循环来遍历。

例如:

Collection<String> c = new HashSet<String>();
c.add("java");        
c.add("cpp");        
c.add("php");
c.add("c#");        
c.add("objective-c");
Iterator<String> it = c.iterator();
while (it.hasNext()) {
    String str = it.next();
    System.out.println(str);
}

1.2.2. remove方法

迭代器还提供了一个方法:void remove()。该方法用于删除迭代器当次从集合中获取的元素。若我们在迭代过程中想删除集合元素时，我们就需要通过该方法来进行。这里需要注意，在使用迭代器遍历集合时是不能通过集合自身提供的remove方法删除元素的，否则迭代器在迭代时会抛出异常。

例如:

Collection<String> c = new HashSet<String>();
c.add("java");        
c.add("cpp");        
c.add("php");
c.add("c#");        
c.add("objective-c"); 
System.out.println(c); // [cpp, php, c#, java, objective-c] 
Iterator<String> it = c.iterator();
while (it.hasNext()) {
    String str = it.next();
    if (str.indexOf("c") != -1) {
        it.remove();
    } 
} 
System.out.println(c); // [php, java]

1.2.3. 增强for循环

Java5.0之后推出了一个新的特性，增强for循环,也称为新循环。该循环不通用于传统循环的工作，其只用于便利集合或数组。语法:

for(元素类型 e : 集合或数组){
    循环体 
}

新循环并非新的语法，而是在编译过程中，编译器会将新循环转换为迭代器模式。所以新循环本质上是迭代器。

例如:

Collection<String> c = new HashSet<String>();
c.add("java");
c.add("cpp");
c.add("php");
c.add("c#");
c.add("objective-c");
for (String str : c) {
    System.out.print(str.toUpperCase() + " ");
} 
// CPP PHP C# JAVA OBJECTIVE-C

1.3. 泛型机制

1.3.1. 泛型在集合中的应用

泛型是Java SE 5.0引入的特性，泛型的本质是参数化类型。在类、接口和方法的定义过程中，所操作的数据类型被传入的参数指定。

Java泛型机制广泛的应用在集合框架中。所有的集合类型都带有泛型参数，这样在创建集合时可以指定放入集合中的对象类型。Java编译器可以据此进行类型检查，这样可以减少代码在运行时出现错误的可能性。

我们来举个例子，比如ArrayList，其在定义时是这样的:

public class ArrayList<E> {
    … … …                
    public boolean add(E e) {…};
    public E get(int index) {…};
}

由此我们可以看出，再声明ArrayList时，类名的右侧有一个<E>。"<>"表示泛型，而其中可以使用数字字母下划线(数字不能的第一个字符)来表示泛型的名字。(通常我们使用一个大写字母来表示，当然这个不是规定。)这时，在类中声明的方法的参数，返回值类型可以被定义为泛型。这样在创建对象时可以将类型作为参数传递，此时，类定义所有的E将被替换成传入的参数。

例如:

ArrayList<String> list = new ArrayList<String>();//泛型E在这里被指定为String类型
list.add("One");//那么add方法的参数就被替换为String类型
list.add(100);//这里就会出现编译错误，因为这里的参数应为String类型。

2. 集合操作——线性表

2.1. List

List接口是Collection的子接口，用于定义线性表数据结构；可以将List理解为存放对象的数组，只不过其元素个数可以动态的增加或减少。并且List是可重复集，这个我们在以前的章节已经描述。

2.1.1. ArrayList和LinkedList

List接口的两个常见实现类为ArrayList和LinkedList，分别用动态数组和链表的方式实现了List接口。

可以认为ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上有一定的差别，ArrayList更适合于随机访问而LinkedList更适合于插入和删除；在性能要求不是特别苛刻的情形下可以忽略这个差别。

2.1.2. get与set方法

List除了继承Collection定义的方法外，还根据其线性表的数据结构定义了一系列方法，其中最常用的就是基于下标的get和set方法。

E get(int index):获取集合中指定下标对应的元素，下标从0开始。
E set(int index, E elment):将给定的元素存入给定位置，并将原位置的元素返回。

例如:

List<String> list = new ArrayList<String>();
list.add("java");        
list.add("cpp");        
list.add("php");
list.add("c#");        
list.add("objective-c");
// get方法遍历List
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
} 
String value = list.set(1, "c++");
System.out.println(value); // cpp
System.out.println(list); // [java, c++, php, c#, objective-c] 
// 交换位置1和3上的元素
list.set(1, list.set(3, list.get(1)));
System.out.println(list); 
// [java, c#, php, c++, objective-c]

2.1.3. 插入和删除

List根据下标的操作还支持插入与删除操作:

void add(int index,E element):

将给定的元素插入到指定位置，原位置及后续元素都顺序向后移动。

E remove(int index):

删除给定位置的元素，并将被删除的元素返回。

例如:

List<String> list = new ArrayList<String>();
list.add("java");
list.add("c#");
System.out.println(list); // [java, c#]
         
list.add(1, "cpp");
System.out.println(list); // [java, cpp, c#]
         
list.remove(2);
System.out.println(list); // [java, cpp]

2.1.4. subList方法

List的subList方法用于获取子List。

需要注意的是，subList获取的List与原List占有相同的存储空间，对子List的操作会影响的原List。

List<E> subList(int fromIndex, int toIndex);

fromIndex和toIndex是截取子List的首尾下标（前包括，后不包括) 。

例如:

List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
    list.add(i);
}
System.out.println(list); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
List<Integer> subList = list.subList(3, 8);
System.out.println(subList); // [3, 4, 5, 6, 7] 
// subList获得的List和源List占有相同的数据空间
for (int i = 0; i < subList.size(); i++) {
    subList.set(i, subList.get(i) * 10);
}
System.out.println(subList); // [30, 40, 50, 60, 70]
System.out.println(list); // [0, 1, 2, 30, 40, 50, 60, 70, 8, 9] 
// 可以用于删除连续元素list.subList(3, 8).clear();
System.out.println(list);

2.1.5. List转换为数组

List的toArray方法用于将集合转换为数组。但实际上该方法是在Collection中定义的，所以所有的集合都具备这个功能。

其有两个方法:

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

其中第二个方法是比较常用的，我们可以传入一个指定类型的数组，该数组的元素类型应与集合的元素类型一致。返回值则是转换后的数组，该数组会保存集合中所有的元素。

例如:

List<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
//通常我们传入的数组不需要给定长度
String[] strArr = list.toArray(new String[] {});        System.out.println(Arrays.toString(strArr)); // [a, b, c]

2.1.6. 数组转换为List

Arrays类中提供了一个静态方法asList，使用该方法我们可以将一个数组转换为对应的List集合。

其方法定义为:

static <T>List<T> asList<T… a>

返回的List的集合元素类型由传入的数组的元素类型决定。

需要注意的是，返回的集合我们不能对其增删元素，否则会抛出异常。并且对集合的元素进行的修改会影响数组对应的元素。

例如:

String[] strArr = { "a", "b", "c" }; 
List<String> list = Arrays.asList(strArr);
System.out.println(list); // [a, b, c]
// list.add("d"); // 会抛出UnsupportedOperationException 
//     java.util.Arrays$ArrayList 
System.out.println(list.getClass().getName());        
List<String> list1 = new ArrayList<String>();
list1.addAll(Arrays.asList(strArr));

2.2. List排序

2.2.1. Collections.sort方法实现排序

Collections是集合的工具类，它提供了很多便于我们操作集合的方法，其中就有用于集合排序的sort方法。该方法的定义为:

void sort(List<T> list)

其作用是对集合元素进行自然排序(按照元素的由小至大的顺序)

例如:

List<Integer> list = new ArrayList<Integer>();
Random r = new Random(1);
for (int i = 0; i < 10; i++) {
    list.add(r.nextInt(100));
} 
System.out.println(list); // [85, 88, 47, 13, 54, 4, 34, 6, 78, 48]
Collections.sort(list);
System.out.println(list); // [4, 6, 13, 34, 47, 48, 54, 78, 85, 88]

2.2.2. Comparable

通过上一节我们知道了如何对集合元素进行自然排序，但是要想对元素进行自然排序那么就必须要有一个必要条件，就是元素的大小。集合中存入的都是引用类型，是以对象的形式存在于内存中，那么对象是如何进行的大小比较呢？实际上，若想对某个集合的元素进行自然排序，该集合的元素有一个要求，就是这些元素必须是Comparable的子类。

Comparable是一个接口，用于定义其子类是可以比较的。因为该接口有一个抽象方法:

    int compareTo(T t)

所有子类都需要重写该方法来定义对象间的比较规则。该方法要求返回一个整数，这个整数不关心具体的值，而是关注取值范围。

当返回值>0时，表示当前对象比参数给定的对象大。
当返回值<0时，表示当前对象比参数给定的对象小。
当返回值=0时，表示当前对象和参数给定的对象相等。

例如:

Class Cell implements Comparable<Cell>{
    int row;
    int col;
    public Cell(int row,int col){
        this.row = row;
        this.col = col;
    }
            
    public int compareTo(Cell c){
        //根据row比较大小
        return this.row - c.row;
    }
}

那么Collections的sort在进行排序时就会根据集合中元素的compareTo方法的返回值来判断大小从而进行自然排序。

// Cell实现了Comparable接口，CompareTo方法逻辑为按照row值的大小排序
List<Cell> cells = new ArrayList<Cell>();
cells.add(new Cell(2, 3));
cells.add(new Cell(5, 1));
cells.add(new Cell(3, 2)); 
Collections.sort(cells);
System.out.println(cells); // [(2,3), (3,2), (5,1)]

2.2.3. comparator

一旦Java类实现了Comparable，其比较逻辑就已经确定；如果希望在排序的操作中临时指定比较规则，可以采用Comparator接口回调的方式。

该接口要求实现类必须重写其定义的方法:

    int compare(T o1,T o2)

该方法的返回值要求，若o1>o2则返回值应>0,若o1<o2则返回值应<0，若o1==o2则返回值应为0

例如:

List<Cell> cells = new ArrayList<Cell>();
cells.add(new Cell(2, 3));    
cells.add(new Cell(5, 1));
cells.add(new Cell(3, 2)); 
// 按照col值的大小排序
Collections.sort(cells, new Comparator<Cell>() {
    @Override
    public int compare(Cell o1, Cell o2) {
        return o1.col - o2.col;}
    });
System.out.println(cells); // [(5,1), (3,2), (2,3)]

2.3. 队列和栈

2.3.1. Queue

队列（Queue）是常用的数据结构，可以将队列看成特殊的线性表，队列限制了对线性表的访问方式：只能从线性表的一端添加（offer）元素，从另一端取出（poll）元素。

队列遵循先进先出（FIFO First Input First Output ）的原则。

JDK中提供了Queue接口，同时使得LinkedList实现了该接口（选择LinkedList实现Queue的原因在于Queue经常要进行插入和删除的操作，而LinkedList在这方面效率较高）。

Queue提供了操作队列的相关方法,其主要方法如下:

boolean offer(E e):将元素追加到队列末尾,若添加成功则返回true。
E poll():从队首删除并返回该元素。
E peek():返回队首元素，但是不删除。

例如:

Queue<String> queue = new LinkedList<String>();
queue.offer("a");
queue.offer("b");
queue.offer("c");
System.out.println(queue); // [a, b, c] 
String str = queue.peek();
System.out.println(str); // a 
while (queue.size() > 0) {
    str = queue.poll();
    System.out.print(str + " "); // a b c
}

2.3.2. Deque

Deque是Queue的子接口，定义了所谓“双端队列”即从队列的两端分别可以入队（offer）和出队（poll），LinkedList实现了该接口。

如果将Deque限制为只能从一端入队和出队，则可实现“栈”（Stack）的数据结构，对于栈而言，入栈称之为push，出栈称之为pop。

栈遵循先进后出（FILO First Input Last Output ）的原则。

Deque提供了操作栈的相关方法,其主要方法如下:

void push(E e):将给定元素"压入"栈中。存入的元素会在栈首。即:栈的第一个元素
E pop():将栈首元素删除并返回。

例如:

Deque<String> stack = new LinkedList<String>();
stack.push("a");
stack.push("b");
stack.push("c");
System.out.println(stack); // [c, b, a] 
String str = stack.peek();
System.out.println(str); // c 
while (stack.size() > 0) {
    str = stack.pop();
    System.out.print(str + " "); // c b a
}

Map接口

java提供了一组可以以键值对(key-value)的形式存储数据的数据结构，这种数据结构称为Map。我们可以把Map看成一个多行两列的表格，其中第一列存放key,第二列存放value。

而每一行就相当于一组key-value对，表示一组数据。

Map对存入的元素有一个要求，就是key不能重复，所谓不能重复指的是在Map中不能包含两个equals为true的key。

Map对于key,value的类型没有严格要求，只要是引用类型均可。但是为了保证在使用时不会造成数据混乱，通常我们会使用泛型去约束key与value的类型。

put方法

既然我们知道了Map在保存数据时实际上是存入了两部分信息的，key与value。那么我们来看看如何向Map中存入数据。

Map提供了一个方法:

V put(K k,V v)

该方法的作用是将key-value对存入Map中，因为Map中不允许出现重复的key,所以若当次存入的key已经在Map中存在，则是替换value操作，而返回值则为被替换的元素。若此key不存在，那么返回值为null。

get方法

我们学会了如何向Map中存入数据，那么我们再来看看如何获取数据。Map中获取数据的方式是给定Key获取对应的Value。

Map提供了一个方法:

V get(Object key)

该方法的作用就是根据给定的key去查找Map中对应的value并返回，若当前Map中不包含给定的key,那么返回值为null。

containsKey方法

Map中的containsKey方法用于检测当前Map中是否包含给定的key。其方法定义如下:

boolean containsKey(Object key)

若当前Map中包含给定的key(这里检查是否包含是根据key的equals比较结果为依据的。)则返回true。

HashMap

hash表原理

HashMap是Map的一个常用的子类实现。其实使用散列算法实现的。

HashMap内部维护着一个散列数组(就是一个存放元素的数组)，我们称其为散列桶，而当我们向HashMap中存入一组键值对时，HashMap首先获取key这个对象的hashcode()方法的返回值，然后使用该值进行一个散列算法，得出一个数字，这个数字就是这组键值对要存入散列数组中的下标位置。

那么得知了下标位置后，HashMap还会查看散列数组当前位置是否包含该元素。（这里要注意的是，散列数组中每个元素并非是直接存储键值对的，而是存入了一个链表，这个链表中的每个节点才是真实保存这组键值对的。）检查是否包含该元素时根据当前要存入的key在当前散列数组对应位置中的链表里是否已经包含这个key,若不包含则将这组键值对存入链表，否则就替换value。

那么在获取元素时，HashMap同样先根据key的hashcode值进行散列算法，找到它在散列数组中的位置，然后遍历该位置的链表，找到该key所对应的value之后返回。

看到这里可能有个疑问，链表中应该只能存入一个元素，那么HashMap是如何将key-value存入链表的某个节点的呢？实际上，HashMap会将每组键值对封装为一个Entry的实例，然后将该实例存入链表。

hashcode方法

HashMap的存取是依赖于key的hashcode方法的返回值的，而hashcode方法实际上是在Object中定义的。其定义如下:

int hashCode()

重写一个类的hashcode()方法有以下注意事项:

1、若一个类重写了equals方法，那么就应当重写hashcode()方法。

2、若两个对象的equals方法比较为true,那么它们应当具有相同的hashcode值。

3、对于同一个对象而言，在内容没有发生改变的情况下，多次调用hashCode()方法应当总是返回相同的值。

4、对于两个对象equals比较为false的，并不要求其hashcode值一定不同，但是应尽量保证不同，这样可以提高散列表性能。

装载因子及HashMap优化

在散列表中有一下名词需要了解:

Capacity：容量, hash表里bucket(桶)的数量, 也就是散列数组大小.
Initial capacity：初始容量, 创建hash表的时初始bucket的数量, 默认构建容量是16. 也可以使用特定容量.
Size ：大小, 当前散列表中存储数据的数量.
Load factor：加载因子, 默认值0.75(就是75%), 向散列表增加数据时如果 size/capacity 的值大于Load factor则发生扩容并且重新散列(rehash).

那么当加载因子较小时候散列查找性能会提高, 同时也浪费了散列桶空间容量. 0.75是性能和空间相对平衡结果. 在创建散列表时候指定合理容量, 从而可以减少rehash提高性能。

有序Map

LinkedHashMap实现有序的Map

Map 接口的哈希表和链表实现，具有可预知的迭代顺序。此实现与 HashMap 的不同之处在于，LinkedHashMap维护着一个双向循环链表。此链表定义了迭代顺序，该迭代顺序通常就是将存放元素的顺序。

需要注意的是，如果在Map中重新存入以有的key，那么key的位置会不会发生改变，只是将value值替换。

Collection (接口)：

——Set (Collection的子接口)----------------存储元素特点：元素无序，元素不可以重复，与List集合体系本质区别就是无索引。

实现类：

——HashSet

——TreeSet

——List (Collection子接口)-----------------存储元素特点：元素有序，元素可以重复，因为该集合体系含有索引。

实现类：

——ArrayList

——LinkedList

——Vector

Map(接口)：

实现类：

——HashMap

——TreeMap

——HashTable

补充说明： 1） Collection、Set、List、Map都为接口，不能被实例化，需要通过继承它们的子类(ArrayList、HashMap、HashSet...)才能被实例化。

接下来进行具体介绍。

1. Collection 方法摘要：

补充说明：1）.凡是继承了Collection接口的子类都有一个Iterator()方法，通过该方法可以取出集合中所有的值，该方法等后面介绍子类时再加以讲解。

2）.a1.removeAll(a2) //集合a1会删除集合a2中相同的元素。

3）a1.retainAll(a2) // 该方法相当于取交集，集合a1只会保留集合a2中相同的元素。

4）Collection其他的方法可以自行去学习，因为开发中比较常见，就不做更多讲解了。

—— 1. 1 List 需要注意的方法摘要：

补充说明：1）.列表迭代器(listIterator),是List集合体系中特有的迭代器，它是Iterator的子接口，它有自己的特有方法：hasPrevious()——逆向遍历列表，列表中有多少个元素，与迭代器(Iterator)中hasNext()方法恰好反、Previous()——获取列表中前一个元素，与next()方法恰好相反。

2）.列表迭代器(listIterator)另一个特点就是持有可以在集合遍历过程中进行增(add(E e))、删(remove())、改(set(E e))、查(previous())的方法。

3）subList(start,end) 方法可以返回指定部分中集合含有的元素。

———— 1. 1.1 Array List集合特点介绍：

1）底层是数组结构，所以查询速度快，相反增删速度慢。

2）因为该集合底层为数组结构，所以当存储的元素个数大于自定义数组的长度时，该集合会自动以原有数组长度50%延长，并将原数组中的元素复制到该数组中。

———— 1. 1.2LinkedList集合特点介绍：

1）底层是链表结构，所以查询速度比较慢，相反增删速度慢比较快。

2）LinkedList集合特有方法，可以将指定元素添加到列表开头和结尾处（addFirst(E e)与addLast(E e)）,可以获取列表的第一元素和列表的最后一个元素。getFirst()与getLast()，removeFirst()与removeLast(),二者区别在于后者获取元素的同时删除元素，前者只获取元素不删除。

———— 1. 1.3 Vector集合特点介绍：

1）底层是数组结构，jdk1.2版后被ArrayList集合取代。

2）与ArrayList集合不同之处在于，安全性方面线程同步，所以效率低，数组自动扩展以有数组长度100%延长。

3）Vector具有的特有方法：elements()方法，返回Enumeration(枚举)，其是一接口，包含hasMoreElements()——测试该枚举是否包含更多元素，返回为布尔型。如果有更多元素，继续调用nextElement()方法——取出枚举中的元素。相当于Iterator迭代器的用法。

—— 1. 2 Set 集合：

———— 1. 2.1 HashSet集合特点介绍：

1）底层数据结构是哈希表，所以导致该集合存储元素的时候是无序的，如果想按自身排序可以重写父类中hashCode()和equals(Object o)方法。

2）线程是非同步的，所以效率方便比较高效。

———— 1. 2.1 TreeSet集合特点介绍：

1）底层数据结构是二叉树结构，可以对Set中元素进行排序，也可以根据指定比较器进行排序，只要在该集合构造函数中传一个比较器的参数。