Collections
1.Collections概述和使用
Collections类的概述 —>是针对集合Collection操作的进化工具类
Collection是集合的顶层接口
—> 有单列的
list —>实现类ArrayList(数组列表 ,查询快增删慢),LinkedList(链表列表, 查询慢增删快)
set —>实现类HashSet(无序不重复),TreeSet(自然排序)
—> 有双列的
map(key->键 , value-> 值)
实现类HashMap(键的底层是set , 无序排序),TreeMap(键的底层是自然排序)
Tips: list和set添加是add(),map添加是put()
2.Collections类的常用方法
public static
public static void reverse(List<?> list): 反转指定列表中元素的顺序
public static void shuffle(List<?> list): 使用默认的随机员随机排列指定的列表
public class CollectionsDemo {
_public static void main(String[] args) {
// 创建集合对象
List<_Integer_> list = new ArrayList<>();
list.add(50);
list.add(40);
list.add(20);
list.add(10);
list.add(30);
System._out.println(_list); // [50, 40, 20, 10, 30]
// 将指定的列表按升序排序 — 本身列表没有sort排序,通过进化版的Collections可以对list排序
// public static
Collections._sort(_list
System._out.println(_list); // [10, 20, 30, 40, 50]
// 反转指定列表中元素的顺序
// public static void reverse(List<?> list):
Collections._reverse(_list);
System._out.println(_list); // [50, 40, 30, 20, 10]
// 使用默认的随机员随机排列指定的列表—> 每次执行该方法列表顺序都是随机排序
// public static void shuffle(List<?> list)
Collections._shuffle(_list);
System._out.println(_list); // [50, 30, 20, 10, 40] } }_
案例: ArrayList存储学生对象并排序
需求: ArrayList存储学生对象,使用Collections对ArrayList进行排序
要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序
思路:
1. 定义学生类1. 创建ArrayList集合对象1. 创建学生对象1. 把学生添加到集合1. 使用Collections对ArrayList集合排序
public class Student{
_private String name;
private int age;
public Student() { }
public Student(String name, int age) {
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; } }
——————————————————————-
public class Demo {
public static void main(String[] args) {
// 创建ArrayList集合对象
ArrayList<_Student_> al = new ArrayList<>();
// 创建学生对象
Student student = new Student(“李畅”, 20);
Student student1 = new Student(“赵明”, 23);
Student student2 = new Student(“唐明”, 25);
Student student3 = new Student(“奥利”, 21);
// 把学生添加到集合中
al.add(student);
al.add(student1);
al.add(student2);
al.add(student3);
// 使用Collections对ArrayList集合排序->使用sort()方法
// Collections.sort(al);
// sort()方法底层是自然排序接口,al的泛型类型是学生类,
// 但是学生类没有实现该接口的自然排序功能所以报错,需要学生类实现接口
// 或者使用另一种方法指定比较器 sort(List
// 使用比较器Comparator匿名内部类方法实现排序
Collections._sort(_al, new Comparator
@Override
public int compare(Student student, Student student1) {
// 按照年龄从小到大排序,
int num = student.getAge() - student1.getAge();
// 年龄相同时,按照姓名的字母顺序排序
int num2 = num == 0 ? student.getName().compareTo(student1.getName()) : num;
return num2; } });
for (Student s : al) { System._out.println(_s.getName() + ‘,’ + s.getAge()); } } }_
案例: 模拟斗地主
需求：通过程序实现斗地主过程中的洗牌，发牌和看牌
思路:
1. 创建一个牌盒子, 就是定义一个集合对象, 用ArrayList集合实现1. 往牌盒里面装牌1. 扑克牌是由花色和数字组成1. 大小王3. 洗牌,也就是把牌的顺序打乱,可以使用Collections类中的shuffle()方法实现3. 发牌, 也就是遍历集合,给三个玩家发牌3. 看牌, 也就是三个玩家自己遍历自己的牌
public class PokerDemo {
_public static void main(String[] args) {
//创建一个牌盒子, 就是定义一个集合对象, 用ArrayList集合实现
ArrayList<_String_> array = new ArrayList<>();
// 往牌盒里面装牌
// 1. 扑克牌是由花色和数字组成
// 花色:(♦,♣,♠,♥)
// 数字:(2,3,4…K,A)
// 2. 大小王
// 定义花色数组集合(String)类型
String[] colors = {“♦”, “♣”, “♠”, “♥”};
// 定义数字数组(Sting)类型
String[] numbers = {“2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “10”, “J”, “Q”, “K”, “A”};
// 使用增强for循环进行花色和点数的拼接
// 外层循环花色
for (String color : colors) {
// 内层循环点数
for (String number : numbers) {
// 花色和点数的拼接
array.add(color + number); } }
// 添加大王小王
array.add(“小王”);
array.add(“大王”);
// 洗牌,也就是把牌的顺序打乱,可以使用Collections类中的shuffle()方法实现
Collections._shuffle(_array);
// 发牌, 也就是遍历集合,给三个玩家为三个集合进行发牌
ArrayList<_String_> lcArray = new ArrayList<>();
ArrayList<_String_> zmArray = new ArrayList<>();
ArrayList<_String_> tmArray = new ArrayList<>();
// 因为斗地主留有底牌所以有底牌的Array集合
ArrayList<_String_> dpArray = new ArrayList<>();
// 遍历集合 使用普通for
for (int i = 0; i < array.size(); i++) {
// 获取遍历的i的每一个数组,就是每一张扑克牌
String poker = array.get(i);
// 进行判断,留有三张底牌
if (i >= array.size() - 3) {
dpArray.add(poker);
// 目前有三名玩家,所以索引对3取余分别得出0,1,2 对应三名玩家,几名玩家就是对几取余
} else if (i % 3 == 0) {
lcArray.add(poker);
} else if (i % 3 == 1) {
zmArray.add(poker);
} else if (i % 3 == 2) {
tmArray.add(poker); } }
// 看牌, 也就是三个玩家自己遍历自己的牌
// 调用本类包下的方法可以直接使用方法名
_show(“李畅”,lcArray);
show(“赵明”,zmArray);
show(“唐明”,tmArray);
show(“底牌”,dpArray); }
// 添加看牌方法,可以让三个集合直接调用该方法
// 方法名为show(); 类型为void 参数为该玩家的姓名String,以及集合ArrayList
public static void show(_String name, ArrayList<_String_> arrayList) {
System._out.print(_name + “的牌是: “);
// 遍历该集合的牌
for (String poker: arrayList){ System._out.print(_poker + “ “); }
// 添加打印换行
System._out.println(); } }
案例: 模拟斗地主升级版
需求：通过程序实现斗地主过程中的洗牌，发牌和看牌
新需求: 需要发牌后对牌进行排序
使用Map进行对集合的存储—> key 就是每个牌的索引 value 是牌
使用ArrayList洗牌，将HashMap中的key存入到ArrayList集合中，对索引洗牌
对索引随机排序后，在给三个集合发牌，发的牌也是索引可以使用TreeSet自然排序对索引排序
调用看牌方法,将从TreeSet获取对应的索引对应HashMap的key,通过keySet()方法获取对应的value
思路:
1. 创建HashMap , key 是对应牌的索引,value是牌本身1. 使用ArrayList对HashMap中的key存储1. 创建花色数组和点数数组,拼接后得到扑克牌1. 从0开始王HashMap里面存储所以,并存储对应的牌 同时往ArrayList里面存储编号1. 洗牌(对索引进行乱序)使用Collections的shuffle()方法实现1. 发牌(发的也是索引, 为了保证编号是顺序排列,创建TreeSet集合接收ArrayList的索引)1. 定义方法看牌(遍历TreeSet集合,获取索引, 通过索引到HashMap中获取对应的牌)1. 调用看牌方法
public class PokerDemo01 {
_public static void main(String[] args) {
// 创建HashMap , key 是对应牌的索引,value是牌本身
HashMap<_Integer, String_> hm = new HashMap<>();
// 使用ArrayList对HashMap中的key存储
ArrayList<_Integer_> array = new ArrayList<>();
// 定义花色数组集合(String)类型
String[] colors = {“♦”, “♣”, “♠”, “♥”};
// 定义数字数组(Sting)类型
String[] numbers = {“2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “10”, “J”, “Q”, “K”, “A”};
// 从0开始王HashMap里面存储所以,并存储对应的牌 同时往ArrayList里面存储编号
// 从索引0开始,定义一个index的整数
int index = 0;
// 外层循环数字,在循环颜色,同时往ArrayList里面存储编号
for (String number : numbers) {
for (String color : colors) {
// 将每个牌的索引index存储为key,拼接的花色存储为value
hm.put(index, color + number);
array.add(index);
index++; } }
hm.put(index, “小王”);
array.add(index);
index++;
hm.put(index, “大王”);
array.add(index);
// 洗牌(对索引进行乱序)使用Collections的shuffle()方法实现
Collections._shuffle(_array);
// 发牌(发的也是索引, 为了保证编号是顺序排列,创建TreeSet集合接收ArrayList的索引)
TreeSet<_Integer_> lcSet = new TreeSet<>();
TreeSet<_Integer_> zmSet = new TreeSet<>();
TreeSet<_Integer_> tmSet = new TreeSet<>();
// 因为斗地主留有底牌所以有底牌的TreeSet集合
TreeSet<_Integer_> dpSet = new TreeSet<>();
// 遍历集合 使用普通for给三名TreeSet玩家发牌,三个玩家就是对3取余
for (int i = 0; i < array.size(); i++) {
// 定义一个变量arrayindex获取集合得到的索引
int arrayindex = array.get(i);
// 最后三张牌交给底牌集合存储
if (i >= array.size() - 3) {
dpSet.add(arrayindex);
} else if (i % 3 == 0) {
lcSet.add(arrayindex);
} else if (i % 3 == 1) {
zmSet.add(arrayindex);
} else {
tmSet.add(arrayindex); } }
// 调用看牌方法,传递参数name:玩家名(自定义),TreeSet是获取的索引,HashMap是最初定义的牌
_show(“姚明”,lcSet,hm);
show(“詹姆斯”,zmSet,hm);
show(“科比”,tmSet,hm);
show(“底牌”,dpSet,hm); }
// 定义方法看牌(遍历TreeSet集合,获取索引, 通过索引到HashMap中获取对应的牌)
/ 方法参数:
String (name:取用户名)
TreeSet
HashMap
public static void show(_String name,TreeSet<_Integer_> ts,HashMap<_Integer,String_> hm){
System._out.print(_name+”的牌是: “);
// 遍历TreeSet集合,这里遍历的是TreeSet获取的索引
for (Integer key:ts){
String poker = hm.get(key);
System._out.print(_poker+” “); }
System._out.println(); } }
若有收获，就点个赞吧
0 人点赞
