在编辑器中完成了基本类型和包装类之间的转换，即装箱和拆箱的操作。

请参考注释将 8、11、19、22 代码补充完整

public class HelloWorld {
    public static void main(String[] args) {
        
        // 定义double类型变量
        double a = 91.5;
        
         // 手动装箱
        Double b = new Double(a);        
        
        // 自动装箱
        Double c = a;      

        System.out.println("装箱后的结果为：" + b + "和" + c);
        
        // 定义一个Double包装类对象，值为8
        Double d = new Double(87.0);
        
        // 手动拆箱
        double e = d.doubleValue();
        
        // 自动拆箱
        double f = d;
        
         System.out.println("拆箱后的结果为：" + e + "和" + f);
    }
}

带有泛型 的List类型属性

List<类型> 属性名

使用迭代器遍历

Iterator（）

while（it。next）{

}

数据存入集合时默认为Object类型，取出时需要强制转换。

集合框架概述

Math.random（） * x 产生x以内的随机数

round（ ）四舍五入

floor  返回小于参数的最大整数

ceil   返回大于参数的最小整数

java.util.Calendar；

创建Calendar对象

Calendar c = Calendar.getInstance（）；

调用年 c.get(Calendar.YEAR);

月                                 MONTH

日                                DAY_OF_MONTH

时                                 HOUR_OF_DAY

分                                   MINUTE

秒                                 SECOND

将Calendar对象转换为Date类

Date d = c.getTime（）；

SimpleDateFormat sdf = new SimpleDateFormat（文本格式）；

两个包

java.util.Date;

java.text.SimpleDateFormat；

日期转换为指定格式的文本

Date date = new Date();

SimpleDateFormat sdf = new SimpleDateFormat(文本格式yyyy年mm月dd日HH时mm分ss秒)；

String today = str.format(date);

文本转换为日期

String day = “文本格式”；

SimpleDateFormat sdf = new SimpleDateFormat(和上面文本格式相同  yyyy年mm月dd日 HH：mm：ss)

Date date = sdf.parse(day);

将基本类型转换为字符串

String str = Double。toString（a）；

                = String.valueOf(a);

                = a + " ";

将字符串转为基本类型

类型 a = 类型的包装类.valueOf（字符串名）；

                                   .parse类型（字符串名）；

基本类型和包装的转换

(正)装箱和拆箱(反)

类型 x = new 类型（）；

类型 x =  ；

类型 x = y.类型Value()；

基本类型转换

县创建一个变量，然后创建integer包装类对象，然后将之转换为其他类型。

int a =   ；

integer a = new integer(a);

转换的类型 c = b.转换的类型Value();

编程思路和逻辑方式，这节课很有用，收藏！

1. 字符串 str 中字符的索引从0开始，范围为 0 到 str.length()-1

2. 使用 indexOf 进行字符或字符串查找时，如果匹配返回位置索引；如果没有匹配结果，返回 -1

3. 使用 substring(beginIndex , endIndex) 进行字符串截取时，包括 beginIndex 位置的字符，不包括 endIndex 位置的字符

针对如此繁杂的方法，推荐大家一个学习技巧：好记性不如烂笔头！多看的同时一定要多敲哦~~

用new关键字创建String对象，总会是有不同的引用；而通过声明String对象再将String常量的引用赋值给该对象时，当多次出现相同的String常量时则只会创建一个对象，即对象的引用相同。

//扑克牌类

public class Poker{

    //创建扑克牌的成员变量

public String num;//扑克牌数字

public String shape;//扑克牌花色

public Poker(String shape,String num) {

this.shape=shape;

this.num=num;

}

public Poker() {

}

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + ((num == null) ? 0 : num.hashCode());

result = prime * result + ((shape == null) ? 0 : shape.hashCode());

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (!(obj instanceof Poker))

return false;

Poker other = (Poker) obj;

if (num == null) {

if (other.num != null)

return false;

} else if (!num.equals(other.num) & !shape.equals(other.shape))

      //由于是数字和花色组合后的比较，故比较重复时，比较条件中应同时满足是否相等

return false;

if (shape == null) {

if (other.shape != null)

return false;

} else if (!num.equals(other.num) & !shape.equals(other.shape))

return false;

return true;

}

@Override

public String toString() {

return shape+num;

}

}

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

//玩家类

public class Player {

public Integer id;//设置id类型，如输入的是字符，则报错并输出"请重新输入整数型id"

    public String name;//设置玩家姓名

    public List<Poker> poker;//玩家要拿牌，故需要有扑克牌属性

    public Player(Integer id,String name) {

    this.id=id;

    this.name=name;

    this.poker=new ArrayList<Poker>();//对Set接口的实例化，即实现类HashSet

    }

    public Player() {

    }

@Override

public String toString() {

return name;

}

}

package com.imooc3_7;

import java.util.Comparator;

//compara类

public class comparetorPoker implements Comparator<Poker> {

@Override

public int compare(Poker o1, Poker o2) {

// TODO Auto-generated method stub

String pokerNumber = "2,3,4,5,6,7,8,9,10,J,Q,K,A";

// String pokerShape = "黑桃，红桃，梅花，方块";

String pokerShape = "方块，梅花，红桃，黑桃";

int result;

result = pokerNumber.indexOf(o1.num)-pokerNumber.indexOf(o2.num);

         //利用String类处理字符串的方法，根据o1.num得到扑克牌数字，然后用indexOf()方法找出该数字的位置下标

        if(result <0) {

        return -1;

    }else if(result >0) {

    return 1;

    }else {

    int result2;

    result2 = pokerShape.indexOf(o1.shape)-pokerShape.indexOf(o2.shape);

    if(result <0) {

        return -1;

    }else if(result >0) {

    return 1;

    }

    }

return 0;

}

}

//开始游戏类

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.InputMismatchException;

import java.util.List;

import java.util.Random;

import java.util.Scanner;

//步骤一：创建扑克牌

public class PokerList {

public List<Poker> pokerToSelect;//用来存装扑克牌

public List<Poker> playerAList;//用来存储玩家1手上的牌的集合

public List<Poker> playerBList;//用来存储玩家2手上的牌的集

//由于有自定义泛型，故需要在自定义类中进行重写

public List<String> playerName;//存储玩家的序列

public Scanner scanner;

String[] scores1 = {"方块","梅花","红桃","黑桃"};

String[] scores2 = {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};

String[] scores = new String[scores1.length*scores2.length];//设置空数组，数组需指明长度，保存顺序的扑克牌       

public PokerList() {

pokerToSelect = new ArrayList<Poker>();//初始化接口

playerAList = new ArrayList<Poker>();

playerBList = new ArrayList<Poker>();

scanner =new Scanner(System.in);

playerName = new ArrayList<String>();

}

public void pokeradd() {

System.out.println("---------------创建扑克牌---------------");

     System.out.println("---------------扑克牌创建成功！---------------");

int index = 0;

for(int i = 0;i<scores1.length;i++) {

for(int j = 0;j<scores2.length;j++) {

scores[index++]=scores1[i]+scores2[j];//创建新数组的元素

pokerToSelect.add(new Poker(scores1[i],scores2[j]));//将扑克牌存入List序列中

}

}

     System.out.println("为："+Arrays.toString(scores));//按顺序打印输出扑克牌

     //使用toString()方法可以将一个数组转换为字符串，且按顺序将多个数组元素连在一起，且用逗号和空格隔开

}

//步骤二：洗牌、创建玩家对象并发牌

public void playerToPoker() {

System.out.println("---------------开始洗牌---------------");

Collections.shuffle(pokerToSelect);//打乱顺序

System.out.println("---------------洗牌结束！---------------");

System.out.println("---------------创建玩家---------------");

        int i =0;

while(i<2) {

System.out.println("请输入第"+(i+1)+"位玩家的ID和姓名：");

System.out.println("请输入ID");

int ID = 0;

String name =null;

try {

ID = scanner.nextInt();//要求输入的ID是int的整数型

System.out.println("请输入姓名");

name =scanner.next();      

i++;

}

catch(InputMismatchException e) {//1.输入类型错误时捕捉

String token =scanner.next();//2.把Scanner里不要的内容推掉，这样Scaner才进一步读取后面的内容

System.out.println("请重新输入");

continue;//跳过重新循环，否则系统会加错误的id也保持在玩家对象中

}

            playerName.add(name);//将玩家姓名保存在playerName的List序列中            

}

    for (String playername : playerName) {//遍历玩家的序列    

System.out.println("----欢迎玩家："+playername);//此时需显示姓名    

}

System.out.println("---------------开始发牌---------------");

List<Poker> playerToPoker = new ArrayList<Poker>();//创建一个新的List有序序列,存储玩家手里能拿到的牌

    Random random = new Random();

    Integer number;//整数型的随机数

    for(int i1 = 0;i1<4;i1++) {//循环扑克牌的序列，用随机的下标位置得到玩家手里的4张牌

    do {

    number = random.nextInt(pokerToSelect.size());//生成随机数得到有序的List扑克牌序列的下标

    }while(playerToPoker.contains(pokerToSelect.get(number)));

    //用contains方法判断玩家手里的牌是否重复

    playerToPoker.add(pokerToSelect.get(number));//若不重复，加入到玩家牌序列中

    if(i1 == 0 || i1 == 2) {//4张牌的分配方法是玩家分别抽出playerToPoker中的牌

    playerAList.add(pokerToSelect.get(number));//将第一张和第三张都给玩家A的牌序列中

    }else {

    playerBList.add(pokerToSelect.get(number));//将第二张和第四张都给玩家B的牌序列中

    }

    }

for(int i2=0;i2<2;i2++) {//循环遍历玩家姓名序列，同时重复2次

for (String playername : playerName) {

    System.out.println("玩家："+playername+"-拿牌");

}        

}

System.out.println("---------------发牌结束！---------------");

System.out.println("---------------开始游戏...---------------");

// 此时玩家手上各有两张牌

//方法一：用comparator进行比较大小

        //通过comparatorPoker类的中comparator()方法,对玩家手中的牌进行排序（此时的排序方法是自定义的方法）

Collections.sort(playerAList,new comparetorPoker());//对玩家A手中的牌进行排序,升序

Collections.sort(playerBList,new comparetorPoker());//对玩家B手中的牌进行排序

System.out.println("玩家："+playerName.get(0)+"最大的手牌为："+playerAList.get(1));

System.out.println("玩家："+playerName.get(1)+"最大的手牌为："+playerBList.get(1));

        List<Poker> max_Poker = new ArrayList<Poker>();//保存玩家各自手上最大的牌的新序列max_Poker

        max_Poker.add(playerAList.get(1));

        max_Poker.add(playerBList.get(1));

Collections.sort(max_Poker,new comparetorPoker());//对玩家各自手中的最大的牌进行排序

if(max_Poker.get(1).equals(playerAList.get(1))) {//根据max_Poker中最大数是否和玩家A的牌最大数相同

System.out.println("------玩家："+playerName.get(0)+"获胜------------");

}else {

System.out.println("------玩家："+playerName.get(1)+"获胜------------");

}

System.out.println("玩家各自的手牌为：");

System.out.println(playerName.get(0)+"：["+playerAList.get(0)+"，"+playerAList.get(1)+"]");

System.out.println(playerName.get(1)+"：["+playerBList.get(0)+"，"+playerBList.get(1)+"]");

//方法二：根据自定义的排序方法getNum(Poker poker)，设置牌和花色的权值进行比较大小

// int playerA1 = this.getNum(playerAList.get(0));//初始化getNum()方法

// int playerA2 = this.getNum(playerAList.get(1));

// int playerB1 = this.getNum(playerBList.get(0));

// int playerB2 = this.getNum(playerBList.get(1));

// if((playerA1>playerA2?playerA1:playerA2)>(playerB1>playerB2?playerB1:playerB2)) {

// System.out.println("------玩家："+playerName.get(0)+"获胜------------");

// }else if((playerA1>playerA2?playerA1:playerA2)<(playerB1>playerB2?playerB1:playerB2)) {

// System.out.println("------玩家："+playerName.get(1)+"获胜------------");

// }

}

// /*

// * 获得牌权值

// */

// public int getNum(Poker poker) {

// int num;

// if(poker.num == "A") {

// num = 14;

// }else if(poker.num == "J") {

// num = 11;

// }else if(poker.num == "Q") {

// num = 12;

// }else if(poker.num == "K") {

// num = 13;

// }else {

// num = Integer.valueOf(poker.num);

// }

// /*

// * 获取花色权值

// */

// int shape=0;

// if(poker.shape == "黑桃") {

// shape = 4;

// }else if(poker.shape == "红桃") {

// shape = 3;

// }else if(poker.shape == "梅花") {

// shape = 2;

// }else if(poker.shape == "方块") {

// shape = 1;

// }

// int result = num*10 + shape;

// return result;

// }

//以上方法是为后期if中的条件比较大小使用的

public static void main(String[] args) {

// TODO Auto-generated method stub

PokerList p = new PokerList();

p.pokeradd();

        p.playerToPoker();

}

}