菜鸡自学JAVA坎坷路day.23（collections工具类的应用，队列，匿名内部类的讲解，Enumeration，引用类型的分类（强软弱虚），容器的同步控制与只读控制，枚举）
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 cards = new ArrayList (); //这个是扑克牌
for(int i=0;i<54;i++) {
cards.add(i);
}
Collections.shuffle(cards);//洗牌
//shuffle(List list, Random rnd)
//使用指定的随机源随机排列指定的列表。
List p1 = new ArrayList ();
List p2 = new ArrayList ();
List p3 = new ArrayList ();
List last = new ArrayList ();
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 list =new ArrayList();
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
我们在例子中用到的方法：
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 que = new ArrayDeque ();//使用他的实现类来创建对象
for(int i=0;i<10;i++) {//假设有10个人在排队存钱
final int num = i + 1;//匿名内部类只能调用final修饰的变量
que.offer(new People() {//这里写了一个匿名内部类
@Override
public void deposit() {
System.out.println("第" + num + "个人办理存钱业务，存款金额为： " + Math.random()*100000);
}});
}//这个for循环中已经相队列里存放了10存钱的人
dealWith(que);
}
public static void dealWith(Queue 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
extends Queue 支持两端元素插入和移除的线性集合。 名称 deque是“双端队列”的缩写，通常发音为“deck”。 大多数Deque实现对它们可能包含的元素的数量没有固定的限制，但是该接口支持容量限制的deques以及没有固定大小限制的deques。该界面定义了访问deque两端元素的方法。 提供了插入，移除和检查元素的方法。 这些方法中的每一种存在两种形式：如果操作失败，则会抛出异常，另一种方法返回一个特殊值（
null或false，具体取决于操作）。 插入操作的后一种形式专门设计用于容量限制的Deque实现; 在大多数实现中，插入操作不能失败。
public class ArrayDeque
extends AbstractCollection implements Deque , 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 {
private Deque space = new ArrayDeque ();//方法要想加泛型 首先是类要加泛型
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 stack = new MyStack (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 vector =new Vector();
vector.add("javase");
vector.add("html");
vector.add("oracle");
//遍历该Vector
Enumeration 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了；