Java语言高级教程

Java 高级教程
参考资料

Java 高级教程

数据结构

Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类：

枚举（Enumeration）
位集合（BitSet）
向量（Vector）
栈（Stack）
字典（Dictionary）
哈希表（Hashtable）
属性（Properties）

以上这些类是传统遗留的，在Java2中引入了一种新的框架-集合框架(Collection)，我们后面再讨论。

枚举（Enumeration）

枚举（Enumeration）接口虽然它本身不属于数据结构,但它在其他数据结构的范畴里应用很广。枚举（The Enumeration）接口定义了一种从数据结构中取回连续元素的方式。

例如，枚举定义了一个叫nextElement 的方法，该方法用来得到一个包含多元素的数据结构的下一个元素。

Enumeration接口中定义了一些方法，通过这些方法可以枚举（一次获得一个）对象集合中的元素。

这种传统接口已被迭代器取代，虽然Enumeration 还未被遗弃，但在现代代码中已经被很少使用了。尽管如此，它还是使用在诸如Vector和Properties这些传统类所定义的方法中，除此之外，还用在一些API类，并且在应用程序中也广泛被使用。下表总结了一些Enumeration声明的方法：

序号     方法描述
1     boolean hasMoreElements( )
测试此枚举是否包含更多的元素。
2     Object nextElement( )
如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

以下实例演示了Enumeration的使用：

import java.util.Vector;
import java.util.Enumeration;
 
public class EnumerationTester {
 
   public static void main(String args[]) {
      Enumeration<String> days;
      Vector<String> dayNames = new Vector<String>();
      dayNames.add("Sunday");
      dayNames.add("Monday");
      dayNames.add("Tuesday");
      dayNames.add("Wednesday");
      dayNames.add("Thursday");
      dayNames.add("Friday");
      dayNames.add("Saturday");
      days = dayNames.elements();
      while (days.hasMoreElements()){
         System.out.println(days.nextElement()); 
      }
   }
}

以上实例编译运行结果如下：

Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday

位集合（BitSet）

位集合类实现了一组可以单独设置和清除的位或标志。

该类在处理一组布尔值的时候非常有用，你只需要给每个值赋值一”位”，然后对位进行适当的设置或清除，就可以对布尔值进行操作了。

一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。这和位向量（vector of bits）比较类似。

这是一个传统的类，但它在Java 2中被完全重新设计。

BitSet定义了两个构造方法。

第一个构造方法创建一个默认的对象：

BitSet()

第二个方法允许用户指定初始大小。所有位初始化为0。

BitSet(int size)

BitSet中实现了Cloneable接口中定义的方法如下表所列：

序号     方法描述
1     void and(BitSet set)
对此目标位 set 和参数位 set 执行逻辑与操作。
2     void andNot(BitSet set)
清除此 BitSet 中所有的位，其相应的位在指定的 BitSet 中已设置。
3     int cardinality( )
返回此 BitSet 中设置为 true 的位数。
4     void clear( )
将此 BitSet 中的所有位设置为 false。
5     void clear(int index)
将索引指定处的位设置为 false。
6     void clear(int startIndex, int endIndex)
将指定的 startIndex（包括）到指定的 toIndex（不包括）范围内的位设置为 false。
7     Object clone( )
复制此 BitSet，生成一个与之相等的新 BitSet。
8     boolean equals(Object bitSet)
将此对象与指定的对象进行比较。
9     void flip(int index)
将指定索引处的位设置为其当前值的补码。
10     void flip(int startIndex, int endIndex)
将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的每个位设置为其当前值的补码。
11     boolean get(int index)
返回指定索引处的位值。
12     BitSet get(int startIndex, int endIndex)
返回一个新的 BitSet，它由此 BitSet 中从 fromIndex（包括）到 toIndex（不包括）范围内的位组成。
13     int hashCode( )
返回此位 set 的哈希码值。
14     boolean intersects(BitSet bitSet)
如果指定的 BitSet 中有设置为 true 的位，并且在此 BitSet 中也将其设置为 true，则返回 true。
15     boolean isEmpty( )
如果此 BitSet 中没有包含任何设置为 true 的位，则返回 true。
16     int length( )
返回此 BitSet 的"逻辑大小"：BitSet 中最高设置位的索引加 1。
17     int nextClearBit(int startIndex)
返回第一个设置为 false 的位的索引，这发生在指定的起始索引或之后的索引上。
18     int nextSetBit(int startIndex)
返回第一个设置为 true 的位的索引，这发生在指定的起始索引或之后的索引上。
19     void or(BitSet bitSet)
对此位 set 和位 set 参数执行逻辑或操作。
20     void set(int index)
将指定索引处的位设置为 true。
21     void set(int index, boolean v)
 将指定索引处的位设置为指定的值。
22     void set(int startIndex, int endIndex)
将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的位设置为 true。
23     void set(int startIndex, int endIndex, boolean v)
将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的位设置为指定的值。
24     int size( )
返回此 BitSet 表示位值时实际使用空间的位数。
25     String toString( )
返回此位 set 的字符串表示形式。
26     void xor(BitSet bitSet)
对此位 set 和位 set 参数执行逻辑异或操作。

下面的程序说明这个数据结构支持的几个方法：

import java.util.BitSet;
 
public class BitSetDemo {
 
  public static void main(String args[]) {
     BitSet bits1 = new BitSet(16);
     BitSet bits2 = new BitSet(16);
      
     // set some bits
     for(int i=0; i<16; i++) {
        if((i%2) == 0) bits1.set(i);
        if((i%5) != 0) bits2.set(i);
     }
     System.out.println("Initial pattern in bits1: ");
     System.out.println(bits1);
     System.out.println("\nInitial pattern in bits2: ");
     System.out.println(bits2);
 
     // AND bits
     bits2.and(bits1);
     System.out.println("\nbits2 AND bits1: ");
     System.out.println(bits2);
 
     // OR bits
     bits2.or(bits1);
     System.out.println("\nbits2 OR bits1: ");
     System.out.println(bits2);
 
     // XOR bits
     bits2.xor(bits1);
     System.out.println("\nbits2 XOR bits1: ");
     System.out.println(bits2);
  }
}

以上实例编译运行结果如下：

Initial pattern in bits1:
{0, 2, 4, 6, 8, 10, 12, 14}

Initial pattern in bits2:
{1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}

bits2 AND bits1:
{2, 4, 6, 8, 12, 14}

bits2 OR bits1:
{0, 2, 4, 6, 8, 10, 12, 14}

bits2 XOR bits1:
{}

向量（Vector）

向量（Vector）类和传统数组非常相似，但是Vector的大小能根据需要动态的变化。

和数组一样，Vector对象的元素也能通过索引访问。

使用Vector类最主要的好处就是在创建对象的时候不必给对象指定大小，它的大小会根据需要动态的变化。

Vector 类实现了一个动态数组。和 ArrayList 很相似，但是两者是不同的：

Vector 是同步访问的。
Vector 包含了许多传统的方法，这些方法不属于集合框架。

Vector 主要用在事先不知道数组的大小，或者只是需要一个可以改变大小的数组的情况。

Vector 类支持 4 种构造方法。

第一种构造方法创建一个默认的向量，默认大小为 10：

Vector()

第二种构造方法创建指定大小的向量。

Vector(int size)

第三种构造方法创建指定大小的向量，并且增量用 incr 指定。增量表示向量每次增加的元素数目。

Vector(int size,int incr)

第四种构造方法创建一个包含集合 c 元素的向量：

Vector(Collection c)

除了从父类继承的方法外 Vector 还定义了以下方法：

序号     方法描述
1     void add(int index, Object element) 
 在此向量的指定位置插入指定的元素。
2     boolean add(Object o) 
 将指定元素添加到此向量的末尾。
3     boolean addAll(Collection c) 
将指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的顺序添加这些元素。
4     boolean addAll(int index, Collection c) 
在指定位置将指定 Collection 中的所有元素插入到此向量中。
5     void addElement(Object obj) 
 将指定的组件添加到此向量的末尾，将其大小增加 1。
6     int capacity() 
返回此向量的当前容量。
7     void clear() 
从此向量中移除所有元素。
8     Object clone() 
返回向量的一个副本。
9     boolean contains(Object elem) 
如果此向量包含指定的元素，则返回 true。
10     boolean containsAll(Collection c) 
如果此向量包含指定 Collection 中的所有元素，则返回 true。
11     void copyInto(Object[] anArray) 
 将此向量的组件复制到指定的数组中。
12     Object elementAt(int index) 
返回指定索引处的组件。
13     Enumeration elements() 
返回此向量的组件的枚举。
14     void ensureCapacity(int minCapacity) 
增加此向量的容量（如有必要），以确保其至少能够保存最小容量参数指定的组件数。
15     boolean equals(Object o) 
比较指定对象与此向量的相等性。
16     Object firstElement() 
返回此向量的第一个组件（位于索引 0) 处的项）。
17     Object get(int index) 
返回向量中指定位置的元素。
18     int hashCode() 
返回此向量的哈希码值。
19     int indexOf(Object elem) 
 返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回 -1。
20     int indexOf(Object elem, int index) 
 返回此向量中第一次出现的指定元素的索引，从 index 处正向搜索，如果未找到该元素，则返回 -1。
21     void insertElementAt(Object obj, int index) 
将指定对象作为此向量中的组件插入到指定的 index 处。
22     boolean isEmpty() 
测试此向量是否不包含组件。
23     Object lastElement() 
返回此向量的最后一个组件。
24     int lastIndexOf(Object elem) 
 返回此向量中最后一次出现的指定元素的索引；如果此向量不包含该元素，则返回 -1。
25     int lastIndexOf(Object elem, int index) 
返回此向量中最后一次出现的指定元素的索引，从 index 处逆向搜索，如果未找到该元素，则返回 -1。
26     Object remove(int index) 
 移除此向量中指定位置的元素。
27     boolean remove(Object o) 
移除此向量中指定元素的第一个匹配项，如果向量不包含该元素，则元素保持不变。
28     boolean removeAll(Collection c) 
从此向量中移除包含在指定 Collection 中的所有元素。
29     void removeAllElements() 
从此向量中移除全部组件，并将其大小设置为零。
30     boolean removeElement(Object obj) 
从此向量中移除变量的第一个（索引最小的）匹配项。
31     void removeElementAt(int index) 
删除指定索引处的组件。
32     protected void removeRange(int fromIndex, int toIndex)
从此 List 中移除其索引位于 fromIndex（包括）与 toIndex（不包括）之间的所有元素。
33     boolean retainAll(Collection c) 
在此向量中仅保留包含在指定 Collection 中的元素。
34     Object set(int index, Object element)
 用指定的元素替换此向量中指定位置处的元素。
35     void setElementAt(Object obj, int index) 
将此向量指定 index 处的组件设置为指定的对象。
36     void setSize(int newSize) 
 设置此向量的大小。
37     int size() 
 返回此向量中的组件数。
38     List subList(int fromIndex, int toIndex) 
返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）。
39     Object[] toArray()
 返回一个数组，包含此向量中以恰当顺序存放的所有元素。
40     Object[] toArray(Object[] a) 
返回一个数组，包含此向量中以恰当顺序存放的所有元素；返回数组的运行时类型为指定数组的类型。
41     String toString() 
返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式。
42     void trimToSize() 
  对此向量的容量进行微调，使其等于向量的当前大小。

下面的程序说明这个集合所支持的几种方法：

import java.util.*;

public class VectorDemo {

   public static void main(String args[]) {
      // initial size is 3, increment is 2
      Vector v = new Vector(3, 2);
      System.out.println("Initial size: " + v.size());
      System.out.println("Initial capacity: " + v.capacity());
      v.addElement(new Integer(1));
      v.addElement(new Integer(2));
      v.addElement(new Integer(3));
      v.addElement(new Integer(4));
      System.out.println("Capacity after four additions: " + v.capacity());

      v.addElement(new Double(5.45));
      System.out.println("Current capacity: " + v.capacity());
      v.addElement(new Double(6.08));
      v.addElement(new Integer(7));
      System.out.println("Current capacity: " + v.capacity());
      v.addElement(new Float(9.4));
      v.addElement(new Integer(10));
      System.out.println("Current capacity: " + v.capacity());
      v.addElement(new Integer(11));
      v.addElement(new Integer(12));
      System.out.println("First element: " + (Integer)v.firstElement());
      System.out.println("Last element: " + (Integer)v.lastElement());
      if(v.contains(new Integer(3)))
         System.out.println("Vector contains 3.");
      // enumerate the elements in the vector.
      Enumeration vEnum = v.elements();
      System.out.println("\nElements in vector:");
      while(vEnum.hasMoreElements())
         System.out.print(vEnum.nextElement() + " ");
      System.out.println();
   }
}

以上实例编译运行结果如下：

Initial size: 0
Initial capacity: 3
Capacity after four additions: 5
Current capacity: 5
Current capacity: 7
Current capacity: 9
First element: 1
Last element: 12
Vector contains 3.

Elements in vector:
1 2 3 4 5.45 6.08 7 9.4 10 11 12

栈（Stack）

栈（Stack）实现了一个后进先出（LIFO）的数据结构。

你可以把栈理解为对象的垂直分布的栈，当你添加一个新元素时，就将新元素放在其他元素的顶部。

当你从栈中取元素的时候，就从栈顶取一个元素。换句话说，最后进栈的元素最先被取出。

栈是Vector的一个子类，它实现了一个标准的后进先出的栈。

堆栈只定义了默认构造函数，用来创建一个空栈。堆栈除了包括由Vector定义的所有方法，也定义了自己的一些方法。

Stack()

除了由Vector定义的所有方法，自己也定义了一些方法：

序号     方法描述
1     boolean empty() 
测试堆栈是否为空。
2     Object peek( )
查看堆栈顶部的对象，但不从堆栈中移除它。
3     Object pop( )
移除堆栈顶部的对象，并作为此函数的值返回该对象。
4     Object push(Object element)
把项压入堆栈顶部。
5     int search(Object element)
返回对象在堆栈中的位置，以 1 为基数。

下面的程序说明这个集合所支持的几种方法：

mport java.util.*;
 
public class StackDemo {
 
    static void showpush(Stack<Integer> st, int a) {
        st.push(new Integer(a));
        System.out.println("push(" + a + ")");
        System.out.println("stack: " + st);
    }
 
    static void showpop(Stack<Integer> st) {
        System.out.print("pop -> ");
        Integer a = (Integer) st.pop();
        System.out.println(a);
        System.out.println("stack: " + st);
    }
 
    public static void main(String args[]) {
        Stack<Integer> st = new Stack<Integer>();
        System.out.println("stack: " + st);
        showpush(st, 42);
        showpush(st, 66);
        showpush(st, 99);
        showpop(st);
        showpop(st);
        showpop(st);
        try {
            showpop(st);
        } catch (EmptyStackException e) {
            System.out.println("empty stack");
        }
    }
}

以上实例编译运行结果如下：

stack: [ ]
push(42)
stack: [42]
push(66)
stack: [42, 66]
push(99)
stack: [42, 66, 99]
pop -> 99
stack: [42, 66]
pop -> 66
stack: [42]
pop -> 42
stack: [ ]
pop -> empty stack

字典（Dictionary）

字典（Dictionary）类是一个抽象类，它定义了键映射到值的数据结构。

当你想要通过特定的键而不是整数索引来访问数据的时候，这时候应该使用Dictionary。

由于Dictionary类是抽象类，所以它只提供了键映射到值的数据结构，而没有提供特定的实现。

Dictionary 类是一个抽象类，用来存储键/值对，作用和Map类相似。

给出键和值，你就可以将值存储在Dictionary对象中。一旦该值被存储，就可以通过它的键来获取它。所以和Map一样， Dictionary 也可以作为一个键/值对列表。

Dictionary定义的抽象方法如下表所示：

序号     方法描述
1     Enumeration elements( )
返回此 dictionary 中值的枚举。
2     Object get(Object key)
返回此 dictionary 中该键所映射到的值。
3     boolean isEmpty( )
测试此 dictionary 是否不存在从键到值的映射。
4     Enumeration keys( )
返回此 dictionary 中的键的枚举。
5     Object put(Object key, Object value)
将指定 key 映射到此 dictionary 中指定 value。
6     Object remove(Object key)
从此 dictionary 中移除 key （及其相应的 value）。
7     int size( )
返回此 dictionary 中条目（不同键）的数量。

Dictionary类已经过时了。在实际开发中，你可以实现 Map接口来获取键/值的存储功能。

哈希表（Hashtable）

Hashtable类提供了一种在用户定义键结构的基础上来组织数据的手段。

例如，在地址列表的哈希表中，你可以根据邮政编码作为键来存储和排序数据，而不是通过人名。

哈希表键的具体含义完全取决于哈希表的使用情景和它包含的数据。

Hashtable是原始的java.util的一部分，是一个Dictionary具体的实现。

然而，Java 2 重构的Hashtable实现了Map接口，因此，Hashtable现在集成到了集合框架中。它和HashMap类很相似，但是它支持同步。

像HashMap一样，Hashtable在哈希表中存储键/值对。当使用一个哈希表，要指定用作键的对象，以及要链接到该键的值。

然后，该键经过哈希处理，所得到的散列码被用作存储在该表中值的索引。

Hashtable定义了四个构造方法。第一个是默认构造方法：

Hashtable()

第二个构造函数创建指定大小的哈希表：

Hashtable(int size)

第三个构造方法创建了一个指定大小的哈希表，并且通过fillRatio指定填充比例。

填充比例必须介于0.0和1.0之间，它决定了哈希表在重新调整大小之前的充满程度：

Hashtable(int size,float fillRatio)

第四个构造方法创建了一个以M中元素为初始化元素的哈希表。

哈希表的容量被设置为M的两倍。

Hashtable(Map m)

Hashtable中除了从Map接口中定义的方法外，还定义了以下方法：

序号     方法描述
1     void clear( )
 将此哈希表清空，使其不包含任何键。
2     Object clone( )
创建此哈希表的浅表副本。
3     boolean contains(Object value)
 测试此映射表中是否存在与指定值关联的键。
4     boolean containsKey(Object key)
测试指定对象是否为此哈希表中的键。
5     boolean containsValue(Object value)
如果此 Hashtable 将一个或多个键映射到此值，则返回 true。
6     Enumeration elements( )
返回此哈希表中的值的枚举。
7     Object get(Object key)
 返回指定键所映射到的值，如果此映射不包含此键的映射，则返回 null. 更确切地讲，如果此映射包含满足 (key.equals(k)) 的从键 k 到值 v 的映射，则此方法返回 v；否则，返回 null。
8     boolean isEmpty( )
测试此哈希表是否没有键映射到值。
9     Enumeration keys( )
 返回此哈希表中的键的枚举。
10     Object put(Object key, Object value)
将指定 key 映射到此哈希表中的指定 value。
11     void rehash( )
增加此哈希表的容量并在内部对其进行重组，以便更有效地容纳和访问其元素。
12     Object remove(Object key)
从哈希表中移除该键及其相应的值。
13     int size( )
 返回此哈希表中的键的数量。
14     String toString( )
返回此 Hashtable 对象的字符串表示形式，其形式为 ASCII 字符 ", " （逗号加空格）分隔开的、括在括号中的一组条目。

下面的程序说明这个数据结构支持的几个方法：

import java.util.*;

public class HashTableDemo {

   public static void main(String args[]) {
      // Create a hash map
      Hashtable balance = new Hashtable();
      Enumeration names;
      String str;
      double bal;

      balance.put("Zara", new Double(3434.34));
      balance.put("Mahnaz", new Double(123.22));
      balance.put("Ayan", new Double(1378.00));
      balance.put("Daisy", new Double(99.22));
      balance.put("Qadir", new Double(-19.08));

      // Show all balances in hash table.
      names = balance.keys();
      while(names.hasMoreElements()) {
         str = (String) names.nextElement();
         System.out.println(str + ": " + balance.get(str));
      }
      System.out.println();
      // Deposit 1,000 into Zara's account
      bal = ((Double)balance.get("Zara")).doubleValue();
      balance.put("Zara", new Double(bal+1000));
      System.out.println("Zara's new balance: " + balance.get("Zara"));
   }
}

以上实例编译运行结果如下：

Qadir: -19.08
Zara: 3434.34
Mahnaz: 123.22
Daisy: 99.22
Ayan: 1378.0

Zara's new balance: 4434.34

属性（Properties）

Properties 继承于 Hashtable.Properties 类，表示了一个持久的属性集，属性列表中每个键及其对应值都是一个字符串。

Properties 类被许多Java类使用。例如，在获取环境变量时它就作为System.getProperties()方法的返回值。

Properties 继承于 Hashtable。表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符串。

Properties 类被许多 Java 类使用。例如，在获取环境变量时它就作为 System.getProperties() 方法的返回值。

Properties 定义如下实例变量，这个变量持有一个 Properties 对象相关的默认属性列表。

Properties defaults;

Properties类定义了两个构造方法，第一个构造方法没有默认值：

Properties()

第二个构造方法使用propDefault 作为默认值：

Properties(Properties propDefault)

两种情况下，属性列表都为空。

除了从 Hashtable 中所定义的方法，Properties 还定义了以下方法：

序号     方法描述
1     String getProperty(String key)
 用指定的键在此属性列表中搜索属性。
2     String getProperty(String key, String defaultProperty)
用指定的键在属性列表中搜索属性。
3     void list(PrintStream streamOut)
 将属性列表输出到指定的输出流。
4     void list(PrintWriter streamOut)
将属性列表输出到指定的输出流。
5     void load(InputStream streamIn) throws IOException
 从输入流中读取属性列表（键和元素对）。
6     Enumeration propertyNames( )
按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
7     Object setProperty(String key, String value)
 调用 Hashtable 的方法 put。
8     void store(OutputStream streamOut, String description)
 以适合使用  load(InputStream)方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。

下面的程序说明这个数据结构支持的几个方法：

import java.util.*;
 
public class PropDemo {
 
   public static void main(String args[]) {
      Properties capitals = new Properties();
      Set states;
      String str;
      
      capitals.put("Illinois", "Springfield");
      capitals.put("Missouri", "Jefferson City");
      capitals.put("Washington", "Olympia");
      capitals.put("California", "Sacramento");
      capitals.put("Indiana", "Indianapolis");
 
      // Show all states and capitals in hashtable.
      states = capitals.keySet(); // get set-view of keys
      Iterator itr = states.iterator();
      while(itr.hasNext()) {
         str = (String) itr.next();
         System.out.println("The capital of " +  str + " is " + capitals.getProperty(str) + ".");
      }
      System.out.println();
 
      // look for state not in list -- specify default
      str = capitals.getProperty("Florida", "Not Found");
      System.out.println("The capital of Florida is " + str + ".");
   }
}

以上实例编译运行结果如下：

The capital of Missouri is Jefferson City.
The capital of Illinois is Springfield.
The capital of Indiana is Indianapolis.
The capital of California is Sacramento.
The capital of Washington is Olympia.

The capital of Florida is Not Found.

集合框架

早在 Java 2 中之前，Java 就提供了特设类。比如：Dictionary, Vector, Stack, 和 Properties 这些类用来存储和操作对象组。

虽然这些类都非常有用，但是它们缺少一个核心的，统一的主题。由于这个原因，使用 Vector 类的方式和使用 Properties 类的方式有着很大不同。

集合框架被设计成要满足以下几个目标。

该框架必须是高性能的。基本集合（动态数组，链表，树，哈希表）的实现也必须是高效的。
该框架允许不同类型的集合，以类似的方式工作，具有高度的互操作性。
对一个集合的扩展和适应必须是简单的。

为此，整个集合框架就围绕一组标准接口而设计。你可以直接使用这些接口的标准实现，诸如： LinkedList, HashSet, 和 TreeSet 等,除此之外你也可以通过这些接口实现自己的集合。

从上面的集合框架图可以看到，Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。

Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。

集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：

接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

除了集合，该框架也定义了几个 Map 接口和类。Map 里存储的是键/值对。尽管 Map 不是集合，但是它们完全整合在集合中。

集合框架体系如图所示

Java 集合框架提供了一套性能优良，使用方便的接口和类，java集合框架位于java.util包中，所以当使用集合框架的时候需要进行导包。

集合接口

集合框架定义了一些接口。本节提供了每个接口的概述：

序号     接口描述
1     Collection 接口

Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。
Collection 接口存储一组不唯一，无序的对象。

2     List 接口

List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。
List 接口存储一组不唯一，有序（插入顺序）的对象。

3     Set

Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。
Set 接口存储一组唯一，无序的对象。

4     SortedSet
继承于Set保存有序的集合。

5     Map
Map 接口存储一组键值对象，提供key（键）到value（值）的映射。

6     Map.Entry
描述在一个Map中的一个元素（键/值对）。是一个 Map 的内部接口。

7     SortedMap
继承于 Map，使 Key 保持在升序排列。

8     Enumeration
这是一个传统的接口和定义的方法，通过它可以枚举（一次获得一个）对象集合中的元素。这个传统接口已被迭代器取代。

Set和List的区别

Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
Set 检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
List 和数组类似，可以动态增长，根据实际存储的数据的长度自动增长 List 的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

集合实现类（集合类）

Java提供了一套实现了Collection接口的标准集合类。其中一些是具体类，这些类可以直接拿来使用，而另外一些是抽象类，提供了接口的部分实现。

标准集合类汇总于下表

序号     类描述
1     AbstractCollection 
实现了大部分的集合接口。

2     AbstractList 
继承于AbstractCollection 并且实现了大部分List接口。

3     AbstractSequentialList 
继承于 AbstractList ，提供了对数据元素的链式访问而不是随机访问。

4     LinkedList

该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如：

List list=Collections.synchronizedList(newLinkedList(...));

LinkedList 查找效率低。

5     ArrayList
该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。

6     AbstractSet 
继承于AbstractCollection 并且实现了大部分Set接口。

7     HashSet
该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。

8     LinkedHashSet
具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。

9     TreeSet
该类实现了Set接口，可以实现排序等功能。

10     AbstractMap 
实现了大部分的Map接口。

11     HashMap
HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。

12     TreeMap
继承了AbstractMap，并且使用一颗树。

13     WeakHashMap
继承AbstractMap类，使用弱密钥的哈希表。

14     LinkedHashMap
继承于HashMap，使用元素的自然顺序对元素进行排序.

15     IdentityHashMap
继承AbstractMap类，比较文档时使用引用相等。

在前面的教程中已经讨论通过java.util包中定义的类，如下所示：

序号     类描述
1     Vector
该类和ArrayList非常相似，但是该类是同步的，可以用在多线程的情况，该类允许设置默认的增长长度，默认扩容方式为原来的2倍。

2     Stack
栈是Vector的一个子类，它实现了一个标准的后进先出的栈。

3     Dictionary
Dictionary 类是一个抽象类，用来存储键/值对，作用和Map类相似。

4     Hashtable
Hashtable 是 Dictionary(字典) 类的子类，位于 java.util 包中。

5     Properties
Properties 继承于 Hashtable，表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符串。

6     BitSet
一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。

集合算法

集合框架定义了几种算法，可用于集合和映射。这些算法被定义为集合类的静态方法。

在尝试比较不兼容的类型时，一些方法能够抛出 ClassCastException异常。当试图修改一个不可修改的集合时，抛出UnsupportedOperationException异常。

集合定义三个静态的变量：EMPTY_SET，EMPTY_LIST，EMPTY_MAP的。这些变量都不可改变。

序号     算法描述
1     Collection Algorithms
这里是一个列表中的所有算法实现。

如何使用迭代器

通常情况下，你会希望遍历一个集合中的元素。例如，显示集合中的每个元素。

一般遍历数组都是采用for循环或者增强for，这两个方法也可以用在集合框架，但是还有一种方法是采用迭代器遍历集合框架，它是一个对象，实现了Iterator 接口或 ListIterator接口。

迭代器，使你能够通过循环来得到或删除集合的元素。ListIterator 继承了 Iterator，以允许双向遍历列表和修改元素。

序号     迭代器方法描述
1     使用 Java Iterator
这里通过实例列出 Iterator 和 ListIterator 接口提供的所有方法。

遍历 ArrayList

import java.util.*;
 
public class Test{
     public static void main(String[] args) {
         List<String> list=new ArrayList<String>();
         list.add("Hello");
         list.add("World");
         list.add("HAHAHAHA");
         
         // 第一种遍历方法使用 For-Each 遍历 List
         for (String str : list) {            // 也可以改写 for(int i=0;i<list.size();i++) 这种形式
            System.out.println(str);
         }
     
         // 第二种遍历，把链表变为数组相关的内容进行遍历
         String[] strArray=new String[list.size()];
         list.toArray(strArray);
         for(int i=0;i<strArray.length;i++)       // 这里也可以改写为  for(String str:strArray) 这种形式
         {
            System.out.println(strArray[i]);
         }
         
        // 第三种遍历 使用迭代器进行相关遍历
         Iterator<String> ite=list.iterator();
         while(ite.hasNext())      // 判断下一个元素之后有值
         {
             System.out.println(ite.next());
         }
     }
}

解析：

三种方法都是用来遍历ArrayList集合，第三种方法是采用迭代器的方法，该方法可以不用担心在遍历的过程中会超出集合的长度。

遍历 Map

import java.util.*;
 
public class Test{
     public static void main(String[] args) {
      Map<String, String> map = new HashMap<String, String>();
      map.put("1", "value1");
      map.put("2", "value2");
      map.put("3", "value3");
      
      // 第一种：普遍使用，二次取值
      System.out.println("通过Map.keySet遍历key和value：");
      for (String key : map.keySet()) {
       System.out.println("key= "+ key + " and value= " + map.get(key));
      }
      
      // 第二种
      System.out.println("通过Map.entrySet使用iterator遍历key和value：");
      Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
      while (it.hasNext()) {
       Map.Entry<String, String> entry = it.next();
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
      
      // 第三种：推荐，尤其是容量大时
      System.out.println("通过Map.entrySet遍历key和value");
      for (Map.Entry<String, String> entry : map.entrySet()) {
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
    
      // 第四种
      System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
      for (String v : map.values()) {
       System.out.println("value= " + v);
      }
     }
}

如何使用比较器

TreeSet和TreeMap的按照排序顺序来存储元素. 然而，这是通过比较器来精确定义按照什么样的排序顺序。

这个接口可以让我们以不同的方式来排序一个集合。

序号     比较器方法描述
1     使用 Java Comparator
这里通过实例列出Comparator接口提供的所有方法

总结

Java集合框架为程序员提供了预先包装的数据结构和算法来操纵他们。

集合是一个对象，可容纳其他对象的引用。集合接口声明对每一种类型的集合可以执行的操作。

集合框架的类和接口均在java.util包中。

任何对象加入集合类后，自动转变为Object类型，所以在取出的时候，需要进行强制类型转换。

ArrayList

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。

ArrayList 继承了 AbstractList ，并实现了 List 接口。

ArrayList 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.ArrayList; // 引入 ArrayList 类

ArrayList<E> objectName =new ArrayList<>();　 // 初始化

E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。
objectName: 对象名。

ArrayList 是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。

修改元素

如果要修改 ArrayList 中的元素可以使用 set() 方法：

import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        sites.set(2, "Wiki"); // 第一个参数为索引位置，第二个为要修改的值
        System.out.println(sites);
    }
}

以上实例，执行输出结果为：

[Google, Runoob, Wiki, Weibo]

ArrayList 排序

Collections 类也是一个非常有用的类，位于 java.util 包中，提供的 sort() 方法可以对字符或数字列表进行排序。

以下实例对字母进行排序：

import java.util.ArrayList;
import java.util.Collections;  // 引入 Collections 类

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Taobao");
        sites.add("Wiki");
        sites.add("Runoob");
        sites.add("Weibo");
        sites.add("Google");
        Collections.sort(sites);  // 字母排序
        for (String i : sites) {
            System.out.println(i);
        }
    }
}

以上实例，执行输出结果为：

Google
Runoob
Taobao
Weibo
Wiki

Java ArrayList 方法

Java ArrayList 常用方法列表如下：

方法     描述
add()     将元素插入到指定位置的 arraylist 中
addAll()     添加集合中的所有元素到 arraylist 中
clear()     删除 arraylist 中的所有元素
clone()     复制一份 arraylist
contains()     判断元素是否在 arraylist
get()     通过索引值获取 arraylist 中的元素
indexOf()     返回 arraylist 中元素的索引值
removeAll()     删除存在于指定集合中的 arraylist 里的所有元素
remove()     删除 arraylist 里的单个元素
size()     返回 arraylist 里元素数量
isEmpty()     判断 arraylist 是否为空
subList()     截取部分 arraylist 的元素
set()     替换 arraylist 中指定索引的元素
sort()     对 arraylist 元素进行排序
toArray()     将 arraylist 转换为数组
toString()     将 arraylist 转换为字符串
ensureCapacity()     设置指定容量大小的 arraylist
lastIndexOf()     返回指定元素在 arraylist 中最后一次出现的位置
retainAll()     保留 arraylist 中在指定集合中也存在的那些元素
containsAll()     查看 arraylist 是否包含指定集合中的所有元素
trimToSize()     将 arraylist 中的容量调整为数组中的元素个数
removeRange()     删除 arraylist 中指定索引之间存在的元素
replaceAll()     将给定的操作内容替换掉数组中每一个元素
removeIf()     删除所有满足特定条件的 arraylist 元素
forEach()     遍历 arraylist 中每一个元素并执行特定操作

更多 API 方法可以查看：https://www.runoob.com/manual/jdk11api/java.base/java/util/ArrayList.html

LinkedList

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。

链表可分为单向链表和双向链表。

一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。

一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。

Java LinkedList（链表）类似于 ArrayList，是一种常用的数据容器。

与 ArrayList 相比，LinkedList 的增加和删除的操作效率更高，而查找和修改的操作效率较低。

以下情况使用 ArrayList :

频繁访问列表中的某一个元素。
只需要在列表末尾进行添加和删除元素操作。

以下情况使用 LinkedList :

你需要通过循环迭代来访问列表中的某些元素。
需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

LinkedList 继承了 AbstractSequentialList 类。

LinkedList 实现了 Queue 接口，可作为队列使用。

LinkedList 实现了 List 接口，可进行列表的相关操作。

LinkedList 实现了 Deque 接口，可作为队列使用。

LinkedList 实现了 Cloneable 接口，可实现克隆。

LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。

LinkedList 类位于 java.util 包中，使用前需要引入它，语法格式如下：

// 引入 LinkedList 类
import java.util.LinkedList; 

LinkedList<E> list = new LinkedList<E>();   // 普通创建方法
或者
LinkedList<E> list = new LinkedList(Collection<? extends E> c); // 使用集合创建链表

简单的链表实例：

import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.removeFirst();  // 使用 removeFirst() 移除头部元素
        sites.removeLast();  // 使用 removeLast() 移除尾部元素  
        sites.addFirst("Wiki");  // 使用 addFirst() 在头部添加元素
        sites.addLast("Weibo");  // 使用 addLast() 在尾部添加元素
        System.out.println(sites);
    }
}

以上实例，执行输出结果为：

[Wiki, Runoob, Weibo]

HashSet

HashSet 基于 Collection 来实现的，是一个不允许有重复元素的集合。

HashSet 允许有 null 值。

HashSet 是无序的，即不会记录插入的顺序。

HashSet 不是线程安全的，如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。您必须在多线程访问时显式同步对 HashSet 的并发访问。

HashSet 实现了 Set 接口。

HashSet 中的元素实际上是对象，一些常见的基本类型可以使用它的包装类。

基本类型对应的包装类表如下：

基本类型    引用类型
boolean    Boolean
byte    Byte
short    Short
int    Integer
long    Long
float    Float
double    Double
char    Character

HashSet 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.HashSet; // 引入 HashSet 类

以下实例我们创建一个 HashSet 对象 sites，用于保存字符串元素：

HashSet<String> sites = new HashSet<String>();

Map 接口

Map 接口中键和值一一映射. 可以通过键来获取值。

给定一个键和一个值，你可以将该值存储在一个 Map 对象。之后，你可以通过键来访问对应的值。
当访问的值不存在的时候，方法就会抛出一个 NoSuchElementException 异常。
当对象的类型和 Map 里元素类型不兼容的时候，就会抛出一个 ClassCastException 异常。
当在不允许使用 Null 对象的 Map 中使用 Null 对象，会抛出一个 NullPointerException 异常。
当尝试修改一个只读的 Map 时，会抛出一个 UnsupportedOperationException 异常。

方法：

序号     方法描述
1     void clear( )
 从此映射中移除所有映射关系（可选操作）。
2     boolean containsKey(Object k)
如果此映射包含指定键的映射关系，则返回 true。
3     boolean containsValue(Object v)
如果此映射将一个或多个键映射到指定值，则返回 true。
4     Set entrySet( )
返回此映射中包含的映射关系的 Set 视图。
5     boolean equals(Object obj)
比较指定的对象与此映射是否相等。
6     Object get(Object k)
返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
7     int hashCode( )
返回此映射的哈希码值。
8     boolean isEmpty( )
如果此映射未包含键-值映射关系，则返回 true。
9     Set keySet( )
返回此映射中包含的键的 Set 视图。
10     Object put(Object k, Object v)
将指定的值与此映射中的指定键关联（可选操作）。
11     void putAll(Map m)
从指定映射中将所有映射关系复制到此映射中（可选操作）。
12     Object remove(Object k)
如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
13     int size( )
返回此映射中的键-值映射关系数。
14     Collection values( )
返回此映射中包含的值的 Collection 视图。

下面的例子来解释Map的功能

import java.util.*;

public class CollectionsDemo {

   public static void main(String[] args) {
      Map m1 = new HashMap(); 
      m1.put("Zara", "8");
      m1.put("Mahnaz", "31");
      m1.put("Ayan", "12");
      m1.put("Daisy", "14");
      System.out.println();
      System.out.println(" Map Elements");
      System.out.print("\t" + m1);
   }
}

以上实例编译运行结果如下：

Map Elements
        {Mahnaz=31, Ayan=12, Daisy=14, Zara=8}

HashMap

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

HashMap 是无序的，即不会记录插入的顺序。

HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

HashMap 的 key 与 value 类型可以相同也可以不同，可以是字符串（String）类型的 key 和 value，也可以是整型（Integer）的 key 和字符串（String）类型的 value。

HashMap 中的元素实际上是对象，一些常见的基本类型可以使用它的包装类。

基本类型对应的包装类表如下：

基本类型    引用类型
boolean    Boolean
byte    Byte
short    Short
int    Integer
long    Long
float    Float
double    Double
char    Character

HashMap 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.HashMap; // 引入 HashMap 类

以下实例我们创建一个 HashMap 对象 Sites，整型（Integer）的 key 和字符串（String）类型的 value：

HashMap<Integer, String> Sites = new HashMap<Integer, String>();

Iterator

Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合。

Iterator 是 Java 迭代器最简单的实现，ListIterator 是 Collection API 中的接口，它扩展了 Iterator 接口。

迭代器 it 的两个基本操作是 next 、hasNext 和 remove。

调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。

调用 it.hasNext() 用于检测集合中是否还有元素。

调用 it.remove() 将迭代器返回的元素删除。

Iterator 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.Iterator; // 引入 Iterator 类

获取一个迭代器

集合想获取一个迭代器可以使用 iterator() 方法:

// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    public static void main(String[] args) {

        // 创建集合
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");

        // 获取迭代器
        Iterator<String> it = sites.iterator();

        // 输出集合中的第一个元素
        System.out.println(it.next());
    }
}

执行以上代码，输出结果如下：

Google

循环集合元素

让迭代器 it 逐个返回集合中所有元素最简单的方法是使用 while 循环：

while(it.hasNext()) {
    System.out.println(it.next());
}

以下输出集合 sites 中的所有元素：

// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    public static void main(String[] args) {

        // 创建集合
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");

        // 获取迭代器
        Iterator<String> it = sites.iterator();

        // 输出集合中的所有元素
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

执行以上代码，输出结果如下：

Google
Runoob
Taobao
Zhihu

删除元素

要删除集合中的元素可以使用 remove() 方法。

以下实例我们删除集合中小于 10 的元素：

// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<Integer>();
        numbers.add(12);
        numbers.add(8);
        numbers.add(2);
        numbers.add(23);
        Iterator<Integer> it = numbers.iterator();
        while(it.hasNext()) {
            Integer i = it.next();
            if(i < 10) {  
                it.remove();  // 删除小于 10 的元素
            }
        }
        System.out.println(numbers);
    }
}

执行以上代码，输出结果如下：

[12, 23]

Object

Java Object 类是所有类的父类，也就是说 Java 的所有类都继承了 Object，子类可以使用 Object 的所有方法。

Object 类位于 java.lang 包中，编译时会自动导入，我们创建一个类时，如果没有明确继承一个父类，那么它就会自动继承 Object，成为 Object 的子类。

类的构造函数

序号     构造方法 & 描述
1         Object() 构造一个新对象。

类的方法

序号     方法 & 描述
1     protected Object clone()
    创建并返回一个对象的拷贝
2     boolean equals(Object obj)
    比较两个对象是否相等
3     protected void finalize()
    当 GC (垃圾回收器)确定不存在对该对象的有更多引用时，由对象的垃圾回收器调用此方法。
4     Class<?> getClass()
    获取对象的运行时对象的类
5     int hashCode()
    获取对象的 hash 值
6     void notify()
    唤醒在该对象上等待的某个线程
7     void notifyAll()
    唤醒在该对象上等待的所有线程
8     String toString()
    返回对象的字符串表示形式
9     void wait()
    让当前线程进入等待状态。直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。
10     void wait(long timeout)
    让当前线程处于等待(阻塞)状态，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过参数设置的timeout超时时间。
11     void wait(long timeout, int nanos)
    与 wait(long timeout) 方法类似，多了一个 nanos 参数，这个参数表示额外时间（以纳秒为单位，范围是 0-999999）。 所以超时的时间还需要加上 nanos 纳秒。。