1.我们来用Collections这个工具类来写一个模仿斗地主的发牌的过程：
package Collections;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;/*** * 我们在这里模拟斗地主方法的过程* * @author Wang**/public class shuffle {public static void main(String[] args) {List <Integer> cards = new ArrayList <Integer> (); //这个是扑克牌for(int i=0;i<54;i++) {cards.add(i);}Collections.shuffle(cards);//洗牌//shuffle(List<?> list, Random rnd) //使用指定的随机源随机排列指定的列表。List <Integer> p1 = new ArrayList <Integer> (); List <Integer> p2 = new ArrayList <Integer> ();List <Integer> p3 = new ArrayList <Integer> (); List <Integer> last = new ArrayList <Integer> ();for(int i=0;i<51;i+=3){p1.add(cards.get(i));p2.add(cards.get(i+1));p3.add(cards.get(i+2));}//最后三张为底牌last.add(cards.get(51));last.add(cards.get(52));last.add(cards.get(53));System.out.println("第一个人:"+p1);System.out.println("第二个人:"+p2);System.out.println("第三个人:"+p3);System.out.println("底牌为:"+last);test1();}//反转public static void test1(){List<Integer> list =new ArrayList<Integer>();list.add(1);list.add(2);list.add(3);list.add(4);System.out.println(list);Collections.reverse(list);//这个就是一个反转的方法；System.out.println("反转之后"+list);}}
Queue:（是一个接口）单向队列；
-
队列通常但不一定是以FIFO（First in first out）（先进先出）方式排序元素。 除了优先级队列之外，优先级队列是根据提供的比较器对元素进行排序，还是元素的自然排序，以及对元素FIFO（先进先出）进行排序的LIFO（Last in first out）队列（或堆栈）。 无论使用什么顺序，队列的头都是通过调用
remove()或poll()删除的元素。 在一个FIFO队列，所有新元素插入到队列的尾部 。 其他类型的队列可以使用不同的布局规则。 每个Queue实现必须指定其排序属性。
first：Queue的所有方法：
boolean |
add(E e)
将指定的元素插入到此队列中，如果可以立即执行此操作，而不会违反容量限制，
true在成功后返回
IllegalStateException如果当前没有可用空间，则抛出IllegalStateException。
|
E |
element()
检索，但不删除，这个队列的头。
|
boolean |
offer(E e)
如果在不违反容量限制的情况下立即执行，则将指定的元素插入到此队列中。
|
E |
peek()
检索但不删除此队列的头，如果此队列为空，则返回
null 。
|
E |
poll()
检索并删除此队列的头，如果此队列为空，则返回
null 。
|
E |
remove()
检索并删除此队列的头。
|
second：我们来他的一个实现类：
Class ArrayDeque<E>
我们在例子中用到的方法：
boolean |
offer(E e)
在此deque的末尾插入指定的元素。
|
E |
poll()
检索并删除由此deque（换句话说，该deque的第一个元素）表示的队列的
null如果此deque为空，则返回
null 。
|
package Queue;import java.util.ArrayDeque;
import java.util.Queue;/*** * 使用单向队列模拟一下银行的存款业务* * @author Wang**/public class testQueue {public static void main(String[] args) {Queue <People> que = new ArrayDeque <People> ();//使用他的实现类来创建对象for(int i=0;i<10;i++) {//假设有10个人在排队存钱final int num = i + 1;//匿名内部类只能调用final修饰的变量que.offer(new People() {//这里写了一个匿名内部类@Overridepublic void deposit() {System.out.println("第" + num + "个人办理存钱业务，存款金额为： " + Math.random()*100000);}});}//这个for循环中已经相队列里存放了10存钱的人dealWith(que);}public static void dealWith(Queue <People> que) {People people = null;while(null != (people = que.poll())) {//循环把队列中排队的人给拿出来 只要拿完 poll（）会返回null 程序停止循环people.deposit();//调用每个人存钱的过程 打印出来；}}
}interface People{//排队的人void deposit();//存款
}3.匿名内部类的讲解：
我们在day.11中有对内部类的讲解但是没有对匿名内部类的讲解，在这里我们来说一下匿名内部类：
他的创建方式如下：（我们对照上面代码进行理解）
new 父类构造器（参数列表）|实现接口（） { //匿名内部类的类体部分 }使用匿名内部类必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。
匿名内部类对象只能访问final修饰的对象。
4.我用Deque双向队列来写一个自己的栈；
public interface Deque<E> extends Queue<E>支持两端元素插入和移除的线性集合。 名称 deque是“双端队列”的缩写，通常发音为“deck”。 大多数Deque实现对它们可能包含的元素的数量没有固定的限制，但是该接口支持容量限制的deques以及没有固定大小限制的deques。该界面定义了访问deque两端元素的方法。 提供了插入，移除和检查元素的方法。 这些方法中的每一种存在两种形式：如果操作失败，则会抛出异常，另一种方法返回一个特殊值（
null或false，具体取决于操作）。 插入操作的后一种形式专门设计用于容量限制的Deque实现; 在大多数实现中，插入操作不能失败。
public class ArrayDeque<E> extends AbstractCollection<E> implements Deque<E>, Cloneable, Serializable
-
可调整大小的数组的实现的
Deque接口。 数组deques没有容量限制; 他们根据需要增长以支持使用。 它们不是线程安全的; 在没有外部同步的情况下，它们不支持多线程的并发访问。 零元素被禁止。 当用作堆栈时，此类可能会比Stack快，并且当用作队列时速度高于LinkedList。
我们再写栈的时候会用的方法：
boolean |
offerLast(E e)
在此deque的末尾插入指定的元素。
|
E |
pollLast()
检索并删除此deque的最后一个元素，如果此deque为空，则返回
null 。
|
E |
peekLast()
检索但不删除此deque的最后一个元素，或返回
null如果此deque为空）。
|
package Queue;import java.util.ArrayDeque;
import java.util.Deque;/*** * 用双向队列来写一个自己的堆栈* 堆栈其实很简单 就是 压栈 弹栈 获取 返回栈元素的个数 （重要的就是前三个）* * @author Wang**/public class MyStack <E>{private Deque <E> space = new ArrayDeque <E> ();//方法要想加泛型 首先是类要加泛型private int size;public MyStack(int size) {this.size = size;}//压栈public boolean push(E e) {if(space.size() +1 > size) {//如果队列的空间 +1 > 你规定的栈的大小的说明现在 队列的大小已经和size相同了 就是栈满了 我们就不能在添加东西了return false;}return space.offerLast(e); //插入成功的话 就返回true}//弹栈 ； 我们指的弹栈都是弹出这个数 那么就相当于返回并删除public E pop() {return space.pollLast();}//获取 ; 返回但不删除public E peek() {return space.peekLast();}public int size() {return this.size;}}
package Queue;
/*** * 测试我们自己写栈* * @author Wang**/public class testMyStack {public static void main(String[] args) {MyStack <String> stack = new MyStack <String> (3);stack.push("1王亚杰");stack.push("2李大双");stack.push("3栋宝宝");stack.push("4愚蠢");//这里是压不进去的 因为容量超了System.out.println(stack.peek());for(int i=0;i<3;i++) {System.out.println(stack.pop()); //先进后出}}
}
举例：
package Enumeration;import java.util.Enumeration;
import java.util.Vector;/*** Enumeration 的使用* 1、判断 hasMoreElements()* 2、获取 nextElement()* * Vector 的 elements()方法 他相当于LinkedList（）* * * @author Wang**/public class test01 {public static void main(String[] args) {Vector<String> vector =new Vector<String>();vector.add("javase");vector.add("html");vector.add("oracle");//遍历该VectorEnumeration<String> en =vector.elements();while(en.hasMoreElements()){System.out.println(en.nextElement());}}
}package Enumeration;import java.util.StringTokenizer;/*** Enumeration 的实现类* StringTokenizer 类似于 String split() 字符串分割* 不支持正则表达式 split（）支持* * StringTokenizer(String str, String delim) * * * @author Wang**/
public class testo2 {public static void main(String[] args) {String str="I like you very much";StringTokenizer token =new StringTokenizer(str," ");//遍历获取while(token.hasMoreElements()){System.out.println(token.nextElement());}}
}6.HashTable与Properties 绝对路径与相对路径的读取与存储：（java300集的163源码5的175到179）
这里只是列举出来比较重要的方法 详细怎么用 可以去看API文档；
7.引用类型的分类（强软弱虚）；（164）
8.容器的同步控制与只读控制（165）
9.枚举（请查看自己的收藏Java中枚举的定义以及使用）
注意：
队列是一般没有容量限制但是 Deque该接口支持容量限制的deques以及没有固定大小限制的deques。
对于双向队列实现堆栈很简单 我们压栈，弹栈，获取都从后面来 就会实现堆栈的 last in first out(这里可以停顿3秒钟思考一下);
Enumeration 这个接口比较老了 可能在项目的维护上才会遇到 我们现在都是用它的加强版 iterator了；