Collections工具类-Queue接口-自定义堆栈（Deque接口)-Enumerration接口-Vector类
- Collections工具类的使用：
package com.bjsxt.sort.util;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
*1、 binarySearch(List> list, T key) 容器有序
*2、sort(List list)
sort(List list, Comparator c)
*3、reverse(List list)
4、shuffle(List list) 洗牌
5、swap(List list, int i, int j)
* @author Administrator
*
*/
public class CollectionsDemo01 {
/**
* @param args
*/
public static void main(String[] args) {
List cards =new ArrayList();
//shuffle 洗牌 模拟斗地主
for(int i=0;i<54;i++){
cards.add(i);
}
//洗牌
Collections.shuffle(cards) ;
//依次发牌
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);
}
//反转
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);
}
}
2. Queue接口_单向队列_模拟银行业务
package com.bjsxt.others.que;
import java.util.ArrayDeque;
import java.util.Queue;
/**
* 使用队列模拟银行存款业务
* @author Administrator
*
*/
public class Demo01 {
/**
* @param args
*/
public static void main(String[] args) {
Queue que =new ArrayDeque();
//模拟排队情况
for(int i=0;i<10;i++){
final int num =i;
que.offer(new Request(){ //内置类
@Override
public void deposit() {
System.out.println("第"+num+"个人，办理存款业务，存款额度为:"+(Math.random()*10000));
}
});
}
dealWith(que);
}
//处理业务
public static void dealWith(Queue que){
Request req =null;
while(null!=(req=que.poll())){
req.deposit();
}
}
}
interface Request{
//存款
void deposit();
}
参考API
3. 自定义堆栈
boolean add(E e)
将指定元素插入此双端队列所表示的队列（换句话说，此双端队列的尾部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用空间，则抛出 IllegalStateException。
void addFirst(E e)
将指定元素插入此双端队列的开头（如果可以直接这样做而不违反容量限制）。
void addLast(E e)
将指定元素插入此双端队列的末尾（如果可以直接这样做而不违反容量限制）。
boolean contains(Object o)
如果此双端队列包含指定元素，则返回 true。
Iterator descendingIterator()
返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
E element()
获取，但不移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）。
E getFirst()
获取，但不移除此双端队列的第一个元素。
E getLast()
获取，但不移除此双端队列的最后一个元素。
Iterator iterator()
返回以恰当顺序在此双端队列的元素上进行迭代的迭代器。
boolean offer(E e)
将指定元素插入此双端队列所表示的队列（换句话说，此双端队列的尾部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用的空间，则返回 false。
boolean offerFirst(E e)
在不违反容量限制的情况下，将指定的元素插入此双端队列的开头。
boolean offerLast(E e)
在不违反容量限制的情况下，将指定的元素插入此双端队列的末尾。
E peek()
获取，但不移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回 null。
E peekFirst()
获取，但不移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。
E peekLast()
获取，但不移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。
E poll()
获取并移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回 null。
E pollFirst()
获取并移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。
E pollLast()
获取并移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。
E pop()
从此双端队列所表示的堆栈中弹出一个元素。
void push(E e)
将一个元素推入此双端队列所表示的堆栈（换句话说，此双端队列的头部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用空间，则抛出 IllegalStateException。
E remove()
获取并移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）。
boolean remove(Object o)
从此双端队列中移除第一次出现的指定元素。
E removeFirst()
获取并移除此双端队列第一个元素。
boolean removeFirstOccurrence(Object o)
从此双端队列移除第一次出现的指定元素。
E removeLast()
获取并移除此双端队列的最后一个元素。
boolean removeLastOccurrence(Object o)
从此双端队列移除最后一次出现的指定元素。
int size()
返回此双端队列的元素数。
package com.bjsxt.others.que;
import java.util.ArrayDeque;
import java.util.Deque;
/**
* 使用队列实现自定义堆栈
* 1、弹
* 2、压
* 3、获取头
* @author Administrator
*
* @param
*/
public class MyStack {
//容器
private Deque container =new ArrayDeque(); //双向队列
//容量
private int cap;
public MyStack(int cap) {
super();
this.cap = cap;
}
//压栈
public boolean push(E e){
if(container.size()+1>cap){
return false;
}
return container.offerLast(e); //在不违反容量限制的情况下，将指定的元素插入此双端队列的末尾,成功则返回true。超过容量，就不让压进去
}
//弹栈
public E pop(){
return container.pollLast(); //获取并移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。
}
//获取
public E peek(){
return container.peekLast(); // 获取，但不移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。
}
public int size(){
return this.container.size();
}
}
package com.bjsxt.others.que;
//测试自定义堆栈
public class Demo02 {
/**
* @param args
*/
public static void main(String[] args) {
MyStack backHistory =new MyStack(3);
backHistory.push("www.baidu.com");
backHistory.push("www.google.com");
backHistory.push("www.sina.com");
backHistory.push("www.bjsxt.cn");
System.out.println("大小："+backHistory.size());
//遍历
String item=null;
while(null!=(item=backHistory.pop())){
System.out.println(item);
}
}
}
结果：（后进先出）
package com.bjsxt.others.en;
import java.util.Enumeration;
import java.util.Vector;
/**
* Enumeration 的使用
* 1、判断 hasMoreElements()
* 2、获取 nextElement()
*
* Vector 的 elements()方法
*
*
* @author Administrator
*
*/
public class Demo01 {
/**
* @param args
*/
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());
}
}
}
结果：
类似于String.split 方法
package com.bjsxt.others.en;
import java.util.StringTokenizer;
/**
* Enumeration 子类
* StringTokenizer:String split() 字符串分割
* 不支持正则表达式
*
* StringTokenizer(String str, String delim)
* @author Administrator
*
*/
public class Demo02 {
/**
* @param args
*/
public static void main(String[] args) {
String emailStr="[email protected];[email protected];[email protected]";
StringTokenizer token =new StringTokenizer(emailStr,";");
//遍历获取
while(token.hasMoreElements()){
System.out.println(token.nextElement());
}
}
}
结果：
