java学习笔记（day23）
0x00 泛型
1.概述
泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型。
泛型也可以看出是一个变量，用来接收数据类型
E e:Element 元素
T t:Type 类型
例如：ArrayList集合在定义的时候，不知道集合中都会存储什么类型的数据，所以类型使用泛型。
E：未知的数据类型
创建集合对象的时候，就会确定泛型的数据类型
2.使用泛型的好处
package day23;
import java.util.ArrayList;
import java.util.Iterator;
public class Demo01 {
public static void main(String[] args) {
}
/*
创建集合对象，不使用泛型
好处：集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据。
弊端：不安全，会引发异常。
*/
private static void show1(){
ArrayList list = new ArrayList();
list.add("adb");
list.add(1);
//使用迭代器遍历list集合
Iterator it = list.iterator();
while (it.hasNext()) {
Object obj = it.next();
System.out.println(obj);
//想要使用String类特有的方法，length获取字符串长度，需要向下转型。
//而在这时，会抛出类型转换一场，不能把Integer类型转换成String类型。
String s = (String)obj;
System.out.println(s.length());
}
}
/*
创建集合对象，使用泛型
好处：
1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型。
2.把运行期异常（代码运行之后会抛出的异常），提升到了编译器（写代码的时候会报错）。
弊端：
泛型是什么类型，只能存储什么类型的数据。
*/
private static void show2(){
ArrayList<String> list = new ArrayList<>();
list.add("abc");
//使用迭代器遍历list集合
Iterator<String> it = list.iterator();
while(it.hasNext()){
}
}
3.泛型的定义和使用
定义含有泛型的方法：泛型定义在方法和修饰符和返回值类型之间
格式：
修饰符 <泛型> 返回值类型 方法名（参数列表（使用泛型））｛
方法体；
｝
含有泛型的方法，在调用方法的时候确定泛型的数据类型。传递什么类型的参数，泛型就是什么类型。
4.含有泛型的接口的定义和使用
-
含有泛型的接口第一种使用方式：定义接口的实现类，视线接口，指定接口的泛型。
public interface Iterator{
E next();
}
Scanner类视线了Iterator接口，并指定接口的泛型为String，所以重写的next方法泛型默认就是String
public final class Scanner implements Iterator{
public String next() { }
} -
含有泛型的接口第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走。
public interface list{
boolean add(E e);
E get(int index);
}
public class ArrayListimplements List {
public boolean add(E e) {}
public E get(int index) {}
}
5.泛型通配符
泛型的通配符：
？：代表任意的数据类型
使用方式：
不能创建对象使用
只能作为方法的参数使用
使用环境
定义一个方法，能遍历所有类型的ArrayList集合。
这时候我们不知道ArrayList集合使用什么数据类型，可以泛型的通配符?来接受数据类型。
注意：泛型没有继承概念
0x01 斗地主案例
斗地主综合案例要求：
以斗地主的规则，完成洗牌和发牌的动作。
案例完成思路
-
准备牌：54张牌，存储到一个集合中。
特殊牌：大王，小王
其他52张牌：
定义一个数组/集合，存储四种花色：黑桃、红桃、梅花、方块。
定义一个数组/集合，存储13个序号A，2，3...K。 -
循环嵌套遍历两个数组/集合，组装52张牌。
-
洗牌
使用集合工具类Collection的方法
static void shuffle(List<?>list)使用指定的随即元对指定列表进行置换。
会随机的打乱集合中元素的顺序。 -
发牌
要求：1人17张牌，剩余3张作为底牌，一人一张轮流发牌：集合的索引（0-53）%3
定义4个集合，存储3个玩家的牌和底牌
索引%2，有两个值（0，1）0%2=0 1%2=1 2 2%2=0 3%2=1。
索引%3，有三个值（0，1，2）0%3=0 1%3=1 2%3=2 3%3=0。
索引>=51，该底牌发牌。 -
看牌
直接打印集合，遍历存储玩家和底牌的集合。
代码实现
package day23;
/*
斗地主综合案例：
1. 准备牌
2. 洗牌
3. 发牌
4. 看牌
*/
import javafx.print.Collation;
import javax.lang.model.element.NestingKind;
import java.util.ArrayList;
import java.util.Collections;
public class doudizhu01 {
public static void main(String[] args) {
// 1.准备牌
//定义一个存储54张牌的ArrayList集合，泛型使用String
ArrayList<String> poker = new ArrayList<>();
// 定义一个数组，一个数组存储牌的花色，一个数组存储牌的序号。
String[] colors = {"♠","♥","♣","♦"};
String[] numbers = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
//先把大王和小王存储到poker集合中
poker.add("大王");
poker.add("小王");
//循环嵌套遍历两个数组，组装52张牌
for (String number:numbers){
for (String color : colors){
// System.out.println(color+number);
poker.add(color+number);
}
}
// 2.洗牌
//使用集合的工具类Collections种的方法
//static void shuffle(list<?> list)使用默认随机源对指定列表进行置换。
Collections.shuffle(poker);
// 3.发牌
//定义四个集合，存储玩家的牌和底牌。
ArrayList<String> player1 = new ArrayList<>();
ArrayList<String> player2 = new ArrayList<>();
ArrayList<String> player3 = new ArrayList<>();
ArrayList<String> dipai = new ArrayList<>();
/*
遍历poker集合，获取每一张牌
使用poker集合的索引%3给3个玩家轮流发牌
剩余3张牌给底牌
注意：
首先判断底牌是不是大于51张，否则就没有底牌了、
*/
for (int i = 0; i < poker.size(); i++) {
//获取每一张牌
String p = poker.get(i);
//设置发牌循环
if (i>=51){
dipai.add(p);
} else if (i%3 == 1){
player1.add(p);
} else if (i%3 == 2){
player2.add(p);
} else {
player3.add(p);
}
}
// 4.看牌
System.out.println("玩家1的牌："+player1);
System.out.println("玩家2的牌："+player2);
System.out.println("玩家3的牌："+player3);
System.out.println("底牌："+dipai);
}
}
