一、Java 集合框架

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

• 接口：是代表集合的抽象数据类型。接口允许集合独立操纵其代表的细节。在面向对象的语言，接口通常形成一个层次。
• 实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构。
• 算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

集合接口

集合实现类（集合类）

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

标准集合类汇总于下表：

Listlist=Collections.synchronizedList(newLinkedList(...));

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

import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;
 
public class myArrayList {
    public static void main(String[] args){
        List<String> list = new ArrayList<String>();
        list.add("nick");
        list.add("jenny");
        list.add("Maria");
 
        //第一种遍历方法使用foreach遍历List
        for (String str : list){
            System.out.println(str);
        }
 
        //第二种遍历，把链表变为数组相关的内容进行遍历
        String[] strArray = new String[list.size()];
        list.toArray(strArray);
        for (int i=0;i<strArray.length;i++){
            System.out.println(strArray[i]);
        }
 
        //第三种遍历 使用迭代器进行相关遍历
        Iterator<String> ite=list.iterator();
        while (ite.hasNext()){
            System.out.println(ite.next());
        }
    }
}

myArrayList.java

package three;
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
 
public class mymap {
    public static void main(String[] args){
        Map<String, String> map = new HashMap<String, String>();
        map.put("name", "nick");
        map.put("age", "18");
        map.put("single", "singleDog");
 
        //第一种：普遍使用，二次取值
        for (String key : map.keySet()){
            System.out.println(key + " " + map.get(key));
        }
 
        //通过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(entry.getKey() + " " + entry.getValue());
        }
 
        //第三种：推荐，尤其是容量大时
        for (Map.Entry<String, String> entry : map.entrySet()){
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
 
        //通过Map.values()遍历所有的value，但不能遍历key
        for (String v : map.values()){
            System.out.println(v);
        }
    }
}

mymap.java

二、Java数据结构

在Java中的数据结构主要包括以下几种接口和类：

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

枚举（Enumeration）

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

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

package three;
 
import java.util.Vector;
import java.util.Enumeration;
 
public class myEnumeration {
    public static void main(String[] args){
        Enumeration days;
        Vector dayNames = new Vector();
        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());
        }
    }
}

practice

位集合（BitSet）

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

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

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

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

BitSet定义了两个构造方法。

BitSet()    //第一个构造方法创建一个默认的对象
BitSet(int size)    //第二个方法允许用户指定初始大小。所有位初始化为0。

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

package three;
 
import java.util.BitSet;
 
public class myBitset {
    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);    // {0, 2, 4, 6, 8, 10, 12, 14}
        System.out.println("\nInitial pattern in bits2: ");
        System.out.println(bits2);    // {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}
 
        // AND bits
        bits2.and(bits1);
        System.out.println("\nbits2 AND bits1: ");
        System.out.println(bits1);    // {0, 2, 4, 6, 8, 10, 12, 14}
        System.out.println(bits2);    // {2, 4, 6, 8, 12, 14}
 
        // OR bits
        bits2.or(bits1);
        System.out.println("\nbits2 OR bits1: ");
        System.out.println(bits1);    // {0, 2, 4, 6, 8, 10, 12, 14}
        System.out.println(bits2);    // {0, 2, 4, 6, 8, 10, 12, 14}
 
        // XOR bits
        bits2.xor(bits1);
        System.out.println("\nbits2 XOR bits1: ");
        System.out.println(bits1);    // {0, 2, 4, 6, 8, 10, 12, 14}
        System.out.println(bits2);    // {}
    }
}

practice

向量（Vector）

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

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

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

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

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

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

Vector类支持4种构造方法。

Vector()    //第一种构造方法创建一个默认的向量，默认大小为10
Vector(int size)    //第二种构造方法创建指定大小的向量
Vector(int size,int incr)    //第三种构造方法创建指定大小的向量，并且增量用incr指定. 增量表示向量每次增加的元素数目
Vector(Collection c)    //第四中构造方法创建一个包含集合c元素的向量

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

package three;
 
import java.util.*;
 
public class myVector {
    public static void main(String[] args){
          Vector v = new Vector(3, 2);
          System.out.println(v.size());    //
          System.out.println(v.capacity());    //
          v.addElement(new Integer(1));
          System.out.println(v.capacity());    //
          v.addElement(new Integer(2));
          System.out.println(v.capacity());    //
          v.addElement(new Integer(3));
          System.out.println(v.capacity());    //
 
          v.addElement(new Integer(4));
          System.out.println(v.capacity());    //
          v.addElement(new Double(5.45));
          System.out.println(v.capacity());    //
 
          v.addElement(new Double(6.08));
          v.addElement(new Integer(7));
          System.out.println(v.capacity());    //
          v.addElement(new Float(9.4));
          v.addElement(new Integer(10));
          System.out.println(v.capacity());    //
          v.addElement(new Integer(11));
          v.addElement(new Integer(12));
          System.out.println(v.capacity());    //
          System.out.println((Integer)v.firstElement()); //
          System.out.println((Integer)v.lastElement());    //
 
          if(v.contains(new Integer(3)))
             System.out.println("Vector contains 3.");    //true
 
          // enumerate the elements in the vector.
          Enumeration vEnum = v.elements();
          System.out.println("\nElements in vector:");
          while(vEnum.hasMoreElements())
             System.out.print(vEnum.nextElement() + " ");
               // 1 2 3 4 5.45 6.08 7 9.4 10 11 12
          System.out.println();
    }
}

practice

栈（Stack）

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

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

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

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

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

Stack()

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

package three;
 
import java.util.*;
 
public class myStack {
       static void showpush(Stack st, int a) {
          st.push(new Integer(a));
          System.out.println("push(" + a + ")");
          System.out.println("stack: " + st);
       }
 
       static void showpop(Stack 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 st = new Stack();
          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
        * */
}

ractice

字典（Dictionary）

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

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

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

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

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

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

哈希表（Hashtable）

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

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

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

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

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

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

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

Hashtable定义了四个构造方法。

Hashtable()
Hashtable(int size)    //创建指定大小的哈希表
Hashtable(int size,float fillRatio)    //创建一个指定大小的哈希表，并且通过fillRatio指定填充比例。填充比例必须介于0.0和1.0之间，它决定了哈希表在重新调整大小之前的充满程度
Hashtable(Map m)    //创建一个以M中元素为初始化元素的哈希表。哈希表的容量被设置为M的两倍。

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

package three;
 
import java.util.*;
 
public class myHashTable {
    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
     * */
}

practice

属性（Properties）

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

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

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

Properties defaults;

Properties类定义了两个构造方法。

Properties()    //第一个构造方法没有默认值。
Properties(Properties propDefault)    //使用propDefault 作为默认值。
两种情况下，属性列表都为空

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

package three;
 
import java.util.*;
 
public class myProperties {
       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.
        * */
}

ractice

三、泛型

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

泛型的好处

Java 语言中引入泛型是一个较大的功能增强。不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了。这带来了很多好处：

类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。

Java 程序中的一种流行技术是定义这样的集合，即它的元素或键是公共类型的，比如“String 列表”或者“String 到 String 的映射”。通过在变量声明中捕获这一附加的类型信息，泛型允许编译器实施这些附加的类型约束。类型错误现在就可以在编译时被捕获了，而不是在运行时当作 ClassCastException 展示出来。将类型检查从运行时挪到编译时有助于您更容易找到错误，并可提高程序的可靠性。

消除强制类型转换。 泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。

尽管减少强制类型转换可以降低使用泛型类的代码的罗嗦程度，但是声明泛型变量会带来相应的啰嗦。

泛型方法

你可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。

下面是定义泛型方法的规则：

• 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的<E>）。
• 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
• 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
• 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。

实例

下面的例子演示了如何使用泛型方法打印不同字符串的元素：

public class GenericMethodTest
{
   // 泛型方法 printArray
   public static < E > void printArray( E[] inputArray )
   {
      // 输出数组元素
         for ( E element : inputArray ){
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }
 
    public static void main( String args[] )
    {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.println( "整型数组元素为:" );
        printArray( intArray  ); // 传递一个整型数组
 
        System.out.println( "\n双精度型数组元素为:" );
        printArray( doubleArray ); // 传递一个双精度型数组
 
        System.out.println( "\n字符型数组元素为:" );
        printArray( charArray ); // 传递一个字符型数组
    }
}
 
/*输出结果
整型数组元素为:
1 2 3 4 5 
 
双精度型数组元素为:
1.1 2.2 3.3 4.4 
 
字符型数组元素为:
H E L L O
* */

有界的类型参数:

可能有时候，你会想限制那些被允许传递到一个类型参数的类型种类范围。例如，一个操作数字的方法可能只希望接受Number或者Number子类的实例。这就是有界类型参数的目的。

要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends关键字，最后紧跟它的上界。

下面的例子演示了"extends"如何使用在一般意义上的意思"extends"（类）或者"implements"（接口）。该例子中的泛型方法返回三个可比较对象的最大值。

public class MaximumTest
{
   // 比较三个值并返回最大值
   public static <T extends Comparable<T>> T maximum(T x, T y, T z)
   {
      T max = x; // 假设x是初始最大值
      if ( y.compareTo( max ) > 0 ){
         max = y; //y 更大
      }
      if ( z.compareTo( max ) > 0 ){
         max = z; // 现在 z 更大
      }
      return max; // 返回最大对象
   }
   public static void main( String args[] )
   {
      System.out.printf( "%d, %d 和 %d 中最大的数为 %d\n\n",
                   3, 4, 5, maximum( 3, 4, 5 ) );
 
      System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n",
                   6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );
 
      System.out.printf( "%s, %s 和 %s 中最大的数为 %s\n","pear",
         "apple", "orange", maximum( "pear", "apple", "orange" ) );
   }
}
 
/*输出结果
3, 4 和 5 中最大的数为 5
 
6.6, 8.8 和 7.7 中最大的数为 8.8
 
pear, apple 和 orange 中最大的数为 pear
*/

泛型类

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。

和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。

如下实例演示了我们如何定义一个泛型类:

public class Box<T> {
 
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("嗨.."));
 
    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}
/*
整型值为 :10
 
字符串为 :嗨..
*/

泛型类型通配符

类型通配符一般是使用?代替具体的类型参数

例如 List<?> 在逻辑上是List<String>,List<Integer> 等所有List<具体类型实参>的父类。

package three;
 
import java.util.ArrayList;
import java.util.List;
 
public class GenericTest {
     public static void main(String[] args) {
            List<String> name = new ArrayList<String>();
            List<Integer> age = new ArrayList<Integer>();
            List<Number> number = new ArrayList<Number>();
 
            name.add("nick");
            age.add(18);
            number.add(530);
 
            getData(name);
            getData(age);
            getData(number);
 
//            getUperNumber(name);    //报错
            getUperNumber(age);
            getUperNumber(number);
       }
 
       public static void getData(List<?> data) {
          System.out.println("getData :" + data.get(0));
       }
 
       public static void getUperNumber(List<? extends Number> data) {
              System.out.println("getUperNumber :" + data.get(0));
       }
}
 
/*输出结果
 * getData :nick
getData :18
getData :530
getUperNumber :18
getUperNumber :530
 * */