接下来让我们看看collections和collection的区别以及collections的一些简单方法的使用：
Collection和Collections的区别:
Collection:顶层次单列集合的根接口,它是一个集合,是一个接口
Collections:是针对集合操作的工具类,有一些功能:随机置换,集合里面的二分查找,将集合的元素进行反转
Collections的一些简单功能：
集合的二分查找
public static <T> int binarySearch(List<T> list, T key)
static T max(Collection coll):获取集合中的最大值
public static void reverse(List<?> list):将集合中的元素顺序反转
public static void shuffle(List<?> list):将集合中的元素打乱
public static void sort(List<T> list)
例如：
package com.westos.collections;
import java.util.ArrayList;
import java.util.Collections;
/*
* 集合的二分查找
* public static <T> int binarySearch(List<T> list, T key)
* static T max(Collection coll):获取集合中的最大值
* public static void reverse(List<?> list):将集合中的元素顺序反转
* public static void shuffle(List<?> list):将集合中的元素打乱
* public static void sort(List<T> list)
*
*
*/
public class collectionsDome {
public static void main(String[] args) {
//创建集合对象
ArrayList<Integer> list=new ArrayList<Integer>();
//向集合中添加元素
list.add(11);
list.add(22);
list.add(33);
list.add(44);
list.add(55);
System.out.println(list);
//调用collections集合中的二分查找方法，前提是集合中的元素必须是有序的
int index = Collections.binarySearch(list,44);
System.out.println("index:"+index);
//获取集合中的最大值
Integer max = Collections.max(list);
System.out.println("max:"+max);
//反转集合中的元素
Collections.reverse(list);
System.out.println("reverse:"+list);
//打乱集合中的元素
Collections.shuffle(list);
System.out.println("shuffle:"+list);
Collections.sort(list);
System.out.println("sort:"+list);
}
}
运行结果：
[11, 22, 33, 44, 55]
index:3
max:55
reverse:[55, 44, 33, 22, 11]
shuffle:[44, 55, 33, 11, 22]
sort:[11, 22, 33, 44, 55]Collections的sort方法还可以对自定义类进行自然排序和比较器排序的两种方法
例如：
先自定义一个学生类：
package com.westos.collections;
public class Student implements Comparable<Student> {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int compareTo(Student s) {
int num=s.getAge()-this.getAge();
int num2=num==0?this.getName().compareTo(s.getName()):num;
return num2;
}
}在定义一个测试类：
package com.westos.collections;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class collectionDome2 {
public static void main(String[] args) {
//创建ArrayList集合对象
ArrayList<Student> list=new ArrayList<Student>();
//创建学生类对象
Student s1=new Student("迪丽热巴",25);
Student s2=new Student("吴宣仪",23);
Student s3=new Student("孟美岐",23);
Student s4=new Student("程潇",22);
Student s5=new Student("萧薰儿",21);
Student s6=new Student("萧薰儿",21);
//将学生对象添加到集合中
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
list.add(s6);
//自然排序
Collections.sort(list);
//比较器排序(习惯用比较器排序)
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num=s1.getAge()-s2.getAge();
int num2=num==0?s1.getName().compareTo(s2.getName()):num;
return num2;
}
});
//循环遍历
for(Student st:list) {
System.out.println(st.getName()+st.getAge());
}
}
}
运行结果：
萧薰儿21
萧薰儿21
程潇22
吴宣仪23
孟美岐23
迪丽热巴25在上述代码中，使用排序的话我们一般习惯比较器排序，不过根据自己的习惯来定，另外在上述代码中我们可以看到两种排序方法都在运行，但是运行结果会依照哪一种方法来运行呢？
他会根据你的排序的书序，当你把自然排序放在比较器排序的前面，系统就会依照自然排序来运行，反之则会按照比较器排序来运行，所以我们一般只写一种排序方法
模拟斗地主游戏发牌洗牌：
思路分析：
1）先创建一个牌盒集合（ArrayList<Integer>）
2）创建颜色数组和牌号数组，将他们拼接在一起，添加到牌盒结合里
3）创建大小王，然后一起添加到牌盒集合中
4）运用collections的shuffle（）方法打乱牌盒集合中的元素
5）创建三个玩家的集合和底牌集合（ArrayList<Integer>），用来存放每个玩家该有的牌
6）给每个玩家发牌：遍历牌盒元素，当元素的索引>=集合长度-3时，添加到底牌中；当索引%3==0 %3==1 %3==2时，分别添加到玩家1，2，3中
7）创建一个看牌的方法，在主函数中去调用，输出三个玩家各有的牌
package com.westos.collections;
import java.util.ArrayList;
import java.util.Collections;
/**
*模拟斗地主的洗牌和发牌
*
*
*
*思路:
* 1)创建一个牌盒(容器:集合)
* ArrayList<String>
* 2)装牌
* 定义花色数组和点数数组(A,K)
* 红桃A
* 黑桃A
* 梅花A
* 方片A
* ....
* 3)洗牌
* Collections中的随机置换的功能
*
* 4)发牌
* 遍历集合(获取集合中的具体的牌)
* 需要判断:选择结构语句
* 1--->A 2--->B 3----C
* 4---A .................
*
* 斗地主三个玩
* 发个三个人----->三个人分别ArrayList<String>
* 如果当前牌 % 3 ==0/1/2
*
* 5)看牌
* 三个人看牌:将看牌封装成一个功能(独立的 代码块)
*
*/
public class pokerDome {
public static void main(String[] args) {
//创建一个集合对象,相当于牌盒
ArrayList<String> list=new ArrayList<String>();
//创建颜色和牌号
String[] color= {"♣","♥","♠","♦"};
//创建牌号数组
String[] number= {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
//遍历
for(String col:color) {
for(String num:number) {
String poker = col.concat(num);
list.add(poker);
}
}
String da="大王";
String xiao="小王";
list.add(da);
list.add(xiao);
//打乱集合中的顺序相当于洗牌
Collections.shuffle(list);
//发牌
//创建三个玩家集合
ArrayList<String> player1=new ArrayList<String>();
ArrayList<String> player2=new ArrayList<String>();
ArrayList<String> player3=new ArrayList<String>();
ArrayList<String> dipai=new ArrayList<String>();
//遍历牌盒中的元素
for(int x=0;x<list.size();x++) {
if(x>=list.size()-3) {
dipai.add(list.get(x));
}else if(x%3==0) {
player1.add(list.get(x));
}else if(x%3==1){
player2.add(list.get(x));
}else if(x%3==2){
player3.add(list.get(x));
}
}
System.out.println("开始发牌了...");
lookPoker("玩家1",player1);
lookPoker("玩家2",player2);
lookPoker("玩家3",player3);
lookPoker("底牌",dipai);
}
//创建方法去遍历玩家手中的牌
public static void lookPoker(String player, ArrayList<String> array) {
System.out.println(player+"的牌是：");
for(String poker:array) {
System.out.print(poker+" ");
}
System.out.println();
}
}
运行结果：
开始发牌了...
玩家1的牌是：
♦3 ♥Q ♥8 ♥3 ♦2 ♠7 ♦5 ♣J ♦K ♥6 ♣8 ♣Q ♦4 ♣3 ♠5 ♥5 ♥7
玩家2的牌是：
♦9 ♣5 ♣4 ♦10 ♠6 ♠3 ♠8 ♠Q ♠A ♦8 ♦Q ♠2 ♣9 ♥A ♦6 ♦A ♠4
玩家3的牌是：
♣7 ♠K ♠10 ♥4 ♥9 ♣6 ♣K ♣10 ♦7 ♥K ♠9 ♦J 大王 ♥2 ♣A ♥10 ♥J
底牌的牌是：
♣2 小王 ♠J 当我们想把每个玩家手中的牌让它按顺序排好，应该怎么做呢?这时我们应该要运用到TreeSet的自然排序
思路：
1）运用HashMap集合创建牌盒结合，将54张牌的数量当做键，每一张牌当做值，通过键去找对应的值。再创建一个ArrayList集合去装牌的数量
2）创建颜色数组和牌号数组将他们添加到牌盒集合中
3）洗牌
4）发牌（运用TreeSet集合使牌变得有序）
例如：
package com.westos.collections;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
/**
* @author 杰哥
*模拟斗地主发牌让牌变得有顺序
*/
public class Poker2 {
public static void main(String[] args) {
//创建一个集合去装牌
HashMap<Integer,String> map=new HashMap<Integer,String>();
//创建颜色数组
String[] color= {"♣","♥","♠","♦"};
//创建牌号数组
String[] number= {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
ArrayList<Integer> list=new ArrayList<Integer>();
int index=0;
for(String num:number) {
for(String col:color) {
String poker = num.concat(col);
map.put(index, poker);
list.add(index);
index++;
}
}
map.put(index,"小王");
list.add(index);
index++;
map.put(index, "大王");
//这里不能再index++了，防止角标越界
list.add(index);
Collections.shuffle(list);
//去创建玩家对象TreeSet
TreeSet<Integer> player1=new TreeSet<Integer>();
TreeSet<Integer> player2=new TreeSet<Integer>();
TreeSet<Integer> player3=new TreeSet<Integer>();
TreeSet<Integer> dipai=new TreeSet<Integer>();
//发牌
for(int x=0;x<list.size();x++) {
if(x>=list.size()-3) {
dipai.add(list.get(x));
}else if(x%3==0) {
player1.add(list.get(x));
}else if(x%3==1) {
player2.add(list.get(x));
}else if(x%3==2){
player3.add(list.get(x));
}
}
lookpoker("玩家1",player1,map);
lookpoker("玩家2",player2,map);
lookpoker("玩家3",player3,map);
lookpoker("底牌",dipai,map);
}
public static void lookpoker(String name,TreeSet<Integer> player,HashMap<Integer,String> hm) {
System.out.println(name+"的牌是：");
//获取HashMap集合中的键
for(Integer val:player) {
String value = hm.get(val);
System.out.print(value+" ");
}
System.out.println();
}
}
运行结果：
玩家1的牌是：
4♠ 4♦ 5♦ 7♠ 8♣ 8♥ J♣ Q♥ Q♦ K♣ K♠ K♦ A♥ A♦ 2♣ 2♠ 2♦
玩家2的牌是：
3♣ 3♦ 4♣ 6♥ 6♠ 7♦ 8♠ 9♦ 10♠ 10♦ Q♠ K♥ A♣ A♠ 2♥ 小王 大王
玩家3的牌是：
3♥ 3♠ 4♥ 5♣ 5♥ 6♦ 7♣ 7♥ 8♦ 9♣ 9♥ 9♠ 10♣ 10♥ J♥ J♠ Q♣
底牌的牌是：
5♠ 6♣ J♦