（一）泛型

（1.1）泛型的声明

可以使用“class 名称<泛型列表>”声明一个类，为了和普通的类有所区别，这样声明的类称为泛型类如：

class people<E> 

people是泛型类的名称，E是其中的泛型，并没有指定E是何种类型的数据，它可以是任何对象或接口，但不能是基本数据类型。泛型声明时，“泛型列表”给出的泛型可以作为类的成员变量类型、方法的类型以及局部变量的类型。

泛型类

class xing<E>{          double h;         E a; public xing (E b){        a=b;      } }  

（1.2）使用泛型声明对象

和普通的类相比，泛型类的声明和创建对象时，类名后多了一对“<>”,而且必须要用具体的类型替换“<>”的泛型。

xing<E> xin; xin=new xing<E>(new E()); 

声明了一个泛型类xing,一个xing对象计算体积时，只关心它的底是否能计算出面积，并不关心底的类型。

（1.3）通配符

通配符是泛型的一种延伸,扩展。这里用通配符就是为了表明要输入的类型要在一定范围之内，就是一个类型取值范围，而最大值是Object这是确定的。
1.<?>:无限通配符，可以在?中放入里放入任何引用数据类型，用来接收任意引用数据类型。
2. <? extends E>:通配符的上界，即小于等于E的所有类型，表明可以输入所有的E的子类和E（最大取Object类）。
3. <? super E>:通配符的下界，就是大于等于E,小于等于Object类。

（二）链表

如果需要处理一些类型相同的数据，人们习惯使用数组这种数据结构，但数组在使用之前必须定义其元素的个数，即数组的大小，而且不能轻易该变数组的大小。当需要动态地减少或增加数据项时，可以使用链表这种数据结构。
链表是由若干个称作结点的对象组成的一种数据结构，每个结点含有一个数据和下一个结点的引用，或含有一个数据并含有上一个结点的引用和下一个结点的引用。

（2.1）LinkedList泛型类

LinkedList泛型类创建的对象以链表结构存储数据，习惯上称LinkedList类创建的对象为链表对象。例如：

LinkedList<String> mylist=new LinkedList<String>(); 

使用LinkedList泛型类声明创建结点时，必须要指明E的具体类型，然后链表就可以使用==add（E obj）==的方法向链表依次增加结点。结点中的数据必须是String对象。

mylist.add("xing"); mylist.add("Are") 

这样mylist就有2个结点了，结点是自动连接在一起的。

（2.2）常用方法

以下是LinkedList泛型类实现List泛型接口中的一些常用方法。
1.public boolean add(E element)向链表末尾添加一个新的结点，该结点中的数据是参数element指定的数据。
2.public void add(int index,E element)向链表的指定位置添加一个新的结点，该结点中的数据是参数element指定的数据。
3.public void clear()删除链表的所有结点，使当前链表成为空链表。
4.public E remove(int index)删除指定位置上的结点。
5.public boolean remove(E element)删除首次出现含有数据element的结点。
6.public E get(int index)得到链表中指定位置处结点中的数据。
7.public int indexOf(E element)返回含有数据element的结点在链表中首次出现的位置，如果链表中无此节点返回-1。
8…public int lastIdexOf(E element)返回含有数据element的结点在链表中最后出现的位置，如果链表中无此节点返回-1。
9.public E set(int index, E element)将当前链表index位置结点中的数据替换成参数为element指定的数据，并返回被替换的数据。
10.public int size()返回链表的长度，即结点的个数。
11.public boolean contains(Object element)判断链表中是否有结点含有数据element。
以下是LinkedList泛型类本身新增加一些常用方法。
1.public void addFirst(E element)向链表的头添加新节点，该节点中的数据是element指定的数据。
2.public void addLast(E element)向链表的末尾添加新节点，该节点中的数据是element指定的数据。
3.public E getFirst()得到链表中第一个结点的数据。
4.public E getLast()得到链表中最后一个结点的数据。
5.pubic E removeFirst()删除第一个结点，并返回这个结点中的数据。
6.pubic E removeLast()删除最后一个结点，并返回这个结点中的数据。
7.public Object clone()得到当前链表的一个克隆链表，该克隆链表中结点数据的改变不会影响到当前链表中的数据，反之亦然。

（2.3）遍历链表

当用户需要遍历集合中的对象时，应当使用该集合提供的迭代器，而不是让集合本身来遍历其中的对象。由于迭代器遍历集合的方法在找到集合中的一个对象的同时，也得到待遍历的后继对象的引用，因此迭代器可以快速地遍历集合。
链表对象可以使用iterator()方法获取一个Iterator对象，该对象就是针对当前链表的迭代器。

（2.4）排序与查找

程序可能经常需要对链表按着某种大小关系排序，以便查找一个数据是否和链表中某个结点上的数据相等。Collections类提供的用于排序和查找的类方法如下：
public static sort(List list) 该方法可以将list中的元素按升序排序
int binarySearch(List list,T key,CompareTo c) 使用折半法查找list是否含有参数key相等的元素，如果相等返回索引位置，否则返回-1。

（2.5）洗牌与旋转

Collections类还提供了将链表中的数据重新随机排列的类方法以及旋转链表中数据的类方法。
i.public static void shuffle(List list) 将list中的数据按洗牌算法重新随机排列。
ii.static void rotate(List list, int distance) 旋转链表中的数据。
iii.public static void reverse(List list) 翻转list中的数据。

（三）堆栈

堆栈是一种“后进先出”的数据结构，只能在一端进行输入或输出数据的操作。把第一个放入该堆栈的数据放在最底下，把后续的放入的数据放在已有数据的顶上。
使用 Stack 泛型类创建一个堆栈对象，栈堆对象可以使用1.
1.public E push(E item); 实现圧栈操作
2.public E pop(); 实现弹栈操作
3.public boolean empty(); 判断堆栈是否还有数据，有数据返回false，否则返回true
4.public E peek()； 获取堆栈顶端的数据，但不删除该数据
5.public int search(Object data); 获取数据在堆栈中的位置，最顶端的位置是1，向下一次增加，如果堆栈不含此数据则返回-1.

（四）散列映射

（4.1）HashMap泛型类

HashMap<K,V>对象采用散列表这种数据结构存储数据，习惯上称HashMap<K,V>对象为散列映射。散列映射用于存储键/值对，允许把任何数量的键/值对存储在一起。键不可以发生逻辑冲突，即不要两个数据项使用相同的键，如果出现两个数据项对应相同的项，那么，先前散列映射中的键/值对将被替换。散列映射在它需要更多的存储空间是会自动增大容量。

HashMap<String,student> hashtable=HashSet<String,student>; 

hashtable就可以存储键/值对数据，其中的键必须是一个String对象，键对应的值必须是Student对象。hashtable可以调用public V put(K key,V value)将键/值对数据存放到散列映射中，该方法同时返回键所对应的值。

（4.2）常用方法

1.public void clear()清空散列映射。
2.public Object clone()返回当前散列映射的一个克隆。
3.public boolean containsKey(Object key)如果散列映射有键/值对使用了参数指定的键，方法返回 true,否则返回false。
4.public boolean containsValue(Object value)如果散列映射有键/值对的值是参数指定的值，方法返回 true,否则返回false。
5.public V get(Object key)返回散列映射中使用key做键/值对中的值。
6.public boolean isEmpty()如果散列映射不含任何键/值对，方法返回 true,否则返回false。
7.public V remove(Object key)删除散列映射中键为参数指定的键/值对，并返回键对应的值。
8.public int size()返回散列映射的大小，即散列映射中键/值对的数目。

（4.3）遍历散列映射

public Collectionvalues()方法返回一个实现Collection接口类创建的对象，可以使用接口回调技术，即将该对象的引用赋给Collection接口变量，该接口变量可以回调iterator()方法获取一个Iterator()对象，这个Iterator对象存放散列映射中所有键/值对中的值。

（4.4）基于散列映射的查询

对于经常需要进行查找的数据可以采用散列映射来存储这样的数据，即为数据指定一个查找它的关键字，然后按着键/值对，将关键字和数据一并存入散列映射中。

（五）树集

（5.1）TreeSet泛型类

TreeSet< E>类是实现Set< E>接口的类，它的大部分方法都是接口方法的实现。TreeSet< E>类创建的对象称为树集，采用树结构存储数据，树节点中的数据会按存放的数据的“大小”顺序一层一层地依次排列，在同一层中的结点从左到右按照字典序从小到大递增排序，下一层的都比上一层的小例如：

TreeSet< String> mytree=new TreeSet< String >();

然后使用add方法

mytree.add(“xing”);为树集添加结点。

（5.2）结点的大小关系

树集结点的排序和链表不同，不按照添加的先后顺序排列，树集用add方法添加结点，结点会按其存放的数据的大小顺序一层一层的依次排序，在同一层的结点从左到右按大小顺序递增排列，下一层的都比上一层的小。
String类实现了Comparable接口中的compareTo（Object str）方法，字符串对象调用compareTo(String s)方法按照字典序与参数s指定的字符串比较大小。因此，当树集中结点存放的是String对象时，树集的结点数据按照大小顺序一层一层地依次排序，在同一层中的结点从左到右按照大小顺序递增排列，下一层的都比上一层的大。
实现Comparable接口类创建的对象可以调用compareTo（Object str）方法和参数指定的对象比较大小关系，假如a和b是实现Comparable接口的类创建的两个对象，当a.compareTo(b)<0时，称a<b,当>0时，a>b;当==0时，a=b；
当一个树集中的数据是实现Comparable接口类创建的对象时，结点就按照对象的大小关系顺序排列。

（5.3）TreeSet类的常用方法

1.public boolean add(E o) 向树集添加结点，结点中的数据由参数指定，添加成功返回true，否则返回false；
2.public void clear() 删除树集中的所有结点。
3.public void contains(Object o)如果树集中有包含参数指定的对象，返回true。
4.public E first（）返回树集中的第一个结点中的数据。(最小的结点)
5.public E last（）返回最后一个结点中的数据。（最大的结点）
6.public boolean isEmpty（）；判断是否是空树集，如果树集不含任何结点，该方法返回true。
7.public boolean remove（Object o）删除树集中存储参数指定的对象的最小结点，成功就返回true，否则返回false。
8.public int size（）；返回树集中结点的数目

（六）树映射

前面的树集TreeSet< E>适合适合用于数据的排序，结点时按着存储的对象的大小升序排序。TreeMap<K,V>类实现了Map<K,V>接口，称TreeMap（K,V）对象为树映射。树映射使用public V put（K key,V value）方法添加结点，该结点不仅存储数据value，也存储和其关联的关键字key，也就是说，树映射的结点存储关键字值对。和树集不同的是，树映射保证结点是按照结点中的关键字升序排列。