目录
一、Collection系列下集合的使用场景
1、如果希望元素可以重复,又有索引,索引查询要快?
用ArrayList集合,基于数组的。(用的最多)
2、如果希望元素可以重复,又有索引,增删首尾操作快?
用LinkedList集合,基于链表的。
3. 如果希望增删改查都快,但是元素不重复、无序、无索引。
用HashSet集合,基于哈希表的。
4、如果希望增删改查都快,但是元素不重复、有序、无索引。
用LinkedHashSet集合,基于哈希表和双链表。
5、如果要对对象进行排序。
用TreeSet集合,基于红黑树。后续也可以用List集合实现排序。
二、可变参数
1、可变参数
可变参数用在形参中可以接收多个数据。
可变参数的格式:数据类型...参数名称。
2、可变参数的作用
接收参数非常灵活,方便。可以不接收参数,可以接收1个或者多个参数,也可以接收一个数组。
可变参数在方法内部本质上就是一个数组。
3、可变参数的注意事项
3.1、一个形参列表中可变参数只能有一个。
3.2、可变参数必须放在形参列表的最后面。
4、案例
4.1、需求
假如需要定义一个方法求和,该方法可以灵活的完成如下需求:
计算1个数据的和。
计算2个数据的和。
计算3个数据的和。
计算n个数据的和,甚至可以支持不接收参数进行调用。
4.2、代码
public static void main(String[] args) {
sum(); //1、不传参数
sum(10); //2、传一个参数
sum(10, 20, 30, 40); //3、传多个参数
sum(new int[]{10, 20, 30, 40}); //4、传一个数组
}
/**
注意:一个形参列表中只能有一个可变参数,可变参数必须放在参数列表的最后面
* @param sums
*/
public static void sum(int...sums){
//注意: 可变参数在方法内部其实就是一个数组。nums
System.out.println("元素长度"+sums.length);
System.out.println("元素内容"+Arrays.toString(sums));
}
4.3、结果
三、集合工具类Collections
1、Collections集合工具类
java.utils.Collections:是集合工具类
作用:Collections并不属于集合,是用来操作集合的工具类。
2、Collections常用的API
方法名称 | 说明 |
public static <T> boolean addAll(Collection<? super T> c, T... elements) | 给集合对象批量添加元素 |
public static void shuffle(List<?> list) | 打乱List集合元素的顺序 |
3、Collections排序相关API
使用范围:只能对于List集合的排序。
排序方式1:
方法名称 | 说明 |
public static <T> void sort(List<T> list) | 将集合中元素按照默认规则排序 |
注意:本方式不可以直接对自定义类型的List集合排序,除非自定义类型实现了比较规则Comparable接口。
排序方式2:
方法名称 | 说明 |
public static <T> void sort(List<T> list,Comparator<? super T> c) | 将集合中元素按照指定规则排序 |
四、Collection体系的综合案例
1、需求
斗地主游戏:在启动游戏房间的时候,应该提前准备好54张牌,完成洗牌、发牌、牌排序、逻辑。
2、分析
2.1:当系统启动的同时需要准备好数据的时候,就可以用静态代码块了。
2.2:洗牌就是打乱牌的顺序。
2.3:定义三个玩家、依次发出51张牌
2.4:给玩家的牌进行排序
2.5:输出每个玩家的牌数据。
3、代码
3.1、定义实体类Card
public class Card {
private String size;
private String colors;
private int index;
public Card(){
}
public Card(String size, String colors, int index) {
this.size = size;
this.colors = colors;
this.index = index;
}
public String getSize() {
return size;
}
public void setSize(String size) {
this.size = size;
}
public String getColors() {
return colors;
}
public void setColors(String colors) {
this.colors = colors;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
@Override
public String toString() {
return size + colors;
}
}
3.2、main函数
public class GameDemo {
//1、定义一个静态集合来存54张牌对象
public static List<Card> allCards = new ArrayList<>();
//2、做牌:定义一个静态代码块初始化牌数据
static {
//3、定义点数:个数确定,类型确定,使用数组
String[] sizes = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "1", "2"};
//4、定义花色:个数确定,类型确定,使用数组
String[] colors = {"♥", "♦", "♣", "♠"};
//5、组合点数和花色
int index = 0;
for (String size : sizes) {
index++;
for (String color : colors) {
//6、封装成一个牌对象
Card c = new Card(size , color, index);
//7、存入到集合容器中
allCards.add(c);
}
}
//8、大小王存入到集合中去
Card c1 = new Card("","小王",++index);
Card c2 = new Card("","大王",++index);
Collections.addAll(allCards,c1,c2);
System.out.println("新牌:"+allCards);
}
public static void main(String[] args) {
//9、洗牌
Collections.shuffle(allCards);
System.out.println("洗牌后:"+allCards);
//10、发牌(定义三个玩家,每个玩家的牌也是一个集合容器)
List<Card> linhuchong = new ArrayList<>();
List<Card> jiumozhi = new ArrayList<>();
List<Card> renyingying = new ArrayList<>();
//11、开始发牌(从集合中发出51张牌给三个玩家,剩余3张作为底牌)
//allCards = :[K♠, 7♦, 3♣, 5♠, 3♠, 10♥........
// i 0 1 2 3 4 5
for (int i = 0; i < allCards.size() - 3; i++) {
//先拿到牌对象
Card c = allCards.get(i);
if (i % 3 == 0){
//啊冲接牌
linhuchong.add(c);
}else if (i % 3 == 1){
//啊鸠接牌
jiumozhi.add(c);
}else if (i % 3 == 2){
//莹莹接牌
renyingying.add(c);
}
}
//12、拿到最后的三底牌(把最后的三张牌截取成一个子集合)
List<Card> lastThreeCards = allCards.subList(allCards.size() - 3, allCards.size());
//13、给玩家的牌排序(从大到小 )
sortCard(linhuchong);
sortCard(jiumozhi);
sortCard(renyingying);
//14、打印出他们的牌
System.out.println(linhuchong);
System.out.println(jiumozhi);
System.out.println(renyingying);
System.out.println(lastThreeCards);
}
public static void sortCard(List<Card> c){
// Collections.sort(c, new Comparator<Card>() {
// @Override
// public int compare(Card o1, Card o2) {
// return o2.getIndex() - o1.getIndex();
// }
// });
Collections.sort(c, ( o1, o2) ->o2.getIndex() - o1.getIndex() );
}
}