java扑克识别算法

Ⅰ java扑克牌编程

1.定义扑克的对象 有两个参数a。花色，b数字Poke{ int number, String color, Poker(String color,int number) { this.color=color; this.number=number; }} 2.每一张牌都实例化一个扑克对象。 poke1= new Poke("红桃","10");poke2=new Poke("黑桃","9"); 3.定义游戏规则类，类里定义一个方法，用来比较大小。public comparePoke(Poke poke1,Poke poke2){ if(花色比较){ return 结果； } if(数字比较){ return 结果； }}。调用方法就能比较

Ⅱ java 52张 扑克牌 问题

识别类：
一张牌：public class Card{};
一副牌：public class Poker{};
带main方法的类用于实现洗牌和切牌：public class Shuffle{};

识别属性：
class Card:
一张牌应该具有花色和点数这两个属性：
private color; //花色
private value; //点数
class Poker:
一副牌有54张牌，四种花色，每种花色都有2~A的点数：
static Card[] cards=new Card[54]；// 每副扑克都有54张牌；
static String[] colors={"红桃","黑桃","方块","梅花"}； //每副牌都有四种花色；
static String values[]={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};//每个花
色的点数
定义类：
public class Card{
String color;
String value;
//定义一个构造函数用于初始化点数2~A的牌
public Card(String color,String value){
this.color = color;
this.value = value;
}
//定义一个构造函数用于初始化大王和小王
public Card(String value){
this.color=""; //如果不给color赋值的话，洗牌和切牌后的大小王前面会显示“null”
this.value = value;
}
// 取一张牌的花色
public String getcolor() {
return color;
}
// 取一张牌的值
public String getvalue() {
return value;
}
}
public class Poker{
static Card[] cards=new Card[54];
static String[] colors={"红桃","黑桃","方块","梅花"};
static String values[]={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
//构造方法Poker（）用于初始化这副扑克
public Poker() {
for (int i = 0; i < colors.length; i++) {
for (int j = 0; j < values.length; j++) {
cards[i * 13 + j] = new Card(colors[i], values[j]);
}
}
cards[52] = new Card("小王");
cards[53] = new Card("大王");
}
//方法getCard()用于获取一张牌的花色和点数
public Card[] getCard() {
return Poker.cards;
}
//方法Show()用于显示一副新的扑克
public void Show() {
……………………
}

public class Shuffle {
static Poker poker = new Poker();
static Card[] cards = new Card[54];
//方法random用于返回一个不重复的数组
public static int[] random(int length) {
int[] a = new int[length];
for (int i = 0; i < length; i++) {
a[i] = (int) (Math.random() * length);//产生一个0到length的随机数
for (int j = 0; j < i; j++) {
if (a[j] == a[i]) {//比较是否相等，如果相等则重新产生
i--;
break;
}
}
}
return a;
}
//方法xipai（）用于将所得的随机数组的值赋值给牌的下标
public static void xipai() {
int[] b = new int[54];
b = random(54);//调用random方法产生一个长度为54的不重复的随机数组
cards = poker.getCard();
Card temp = null;
for(int i = 0; i < b.length; i++){ //开始遍历数组实现重新排列
int k = b[i];
temp = cards[k];
cards[i] = cards[k];
cards[k] = temp;}
//输出洗牌后的扑克
……………………
……………………
}

//方法qiepai（）实现扑克的切牌操作
public static void qiepai(int length) {
int number = (int) (Math.random() * length);//产生一个随机数
System.out.println("随机数为:" + number);//显示随机数是多少
Card[] temp = new Card[length];
int start = number;//设置切牌后的起点位置
for (int i = 0; i < length - number; i++) {
temp[i] = cards[start++];//将切点后面的牌暂时放入temp数组中
}
for (int j = 0; j < number; j++) {
temp[length - number + j] = cards[j];//将切点前面的牌加入temp数组中
}
for (int k = 0; k < length; k++) {
cards[k] = temp[k];}
//输出切牌后的扑克
……………………
……………………
}
//main方法
public static void main(String[] args) {
Poker newpoker = new Poker();
newpoker.Show();//调用Show()方法显示一副新扑克
xipai();//调用xipai()方法显示洗牌过后的扑克
qiepai(54);//调用qiepai()方法显示切牌以后的扑克
}
}
参考资料：http://greenchen84.spaces.live.com/blog/cns!7aa735406579b132!111.entry

Ⅲ 用Java for 编写关于扑克牌的程序！急！

存储时可以用数字，最后显示时可以装换为字母
import java.util.Random;

public class Poker {
public static void main(String[] args) {
Random random = new Random();
int[] computer = new int[5];
int[] player = new int[5];
for (int i = 0; i < 5; i++) {// 发牌
computer[i] = random.nextInt(13) + 2;// 2到14的随机数，14表示A
player[i] = random.nextInt(13) + 2;// 2到14的随机数，14表示A
}
int result = Judge(player, computer);
Show(player, computer, result);
}

// 比较
private static int Judge(int[] player, int[] computer) {
int p = 0, c = 0;
for (int i = 0; i < 5; i++) {
if (14 == player[i])
p++;
if (14 == computer[i])
c++;
}
if (p > 0 && 0 == c)
return 1;
if (p == 0 && c > 0)
return 2;
return 0;

}

private static void Show(int[] player, int[] computer, int result) {
System.out.print("Your cards are:");
for (int i = 0; i < 5; i++) {
PrintCard(player[i]);
}
System.out.print("\nThe computer's cards are:");
for (int i = 0; i < 5; i++) {
PrintCard(computer[i]);
}
switch (result) {
case 0:
System.out.print("\nYou and the computer are tied for the highest single card.");
break;
case 1:
System.out.print("\nYou has the highest single card.");
break;
case 2:
System.out.print("\nThe computer has the highest single card.");
break;

}

}

private static void PrintCard(int card) {
switch (card) {
case 11:
System.out.print("J ");
break;
case 12:
System.out.print("Q ");
break;
case 13:
System.out.print("K ");
break;
case 14:
System.out.print("A ");
break;
default:
System.out.print(card + " ");
}
}

void m() {
int[] personCard = new int[5];
int[] computerCard = new int[5];
int personCount = 0;
int computerCount = 0;

System.out.print("Your cards are: ");
for (int i = 0; i < 5; i++) {
personCard[i] = (int) (Math.random() * 13) + 2;
if (personCard[i] == 11) {
System.out.print("J" + "\t");
} else if (personCard[i] == 12) {
System.out.print("Q" + "\t");
} else if (personCard[i] == 13) {
System.out.print("K" + "\t");
} else if (personCard[i] == 14) {
personCount++;
System.out.print("A" + "\t");
} else {
System.out.print(personCard[i] + "\t");
}
}
System.out.println("\n");
System.out.print("The computer's cards are:");
for (int i = 0; i < 5; i++) {
computerCard[i] = (int) (Math.random() * 13) + 1;
if (computerCard[i] == 11) {
System.out.print("J" + "\t");
} else if (computerCard[i] == 12) {
System.out.print("Q" + "\t");
} else if (computerCard[i] == 13) {
System.out.print("K" + "\t");
} else if (computerCard[i] == 14) {
computerCount++;
System.out.print("A" + "\t");
} else {
System.out.print(computerCard[i] + "\t");
}
}
System.out.println("\n");
if (personCount > 0 && computerCount == 0) {
System.out.println("You has the highest single card");
} else if (personCount == 0 && computerCount > 0) {
System.out.println("The computer has the highest single card");
} else if (personCount == 0 && computerCount == 0) {
System.out.println("You and the computer are tied for the highest single card");
} else if (personCount > 0 && computerCount > 0) {
System.out.println("Both you and the computer have the highest single card");
}

}
}

Ⅳ 用java如何判断扑克牌同花顺

扑克牌有两个属性,花色和牌面大小,可以分别比较花色和牌面大小是否递增或递减来确定是不是同花顺.但是由于扑克牌会有JQKA,所以牌面大小最好以数组或者字符串的方式实现,通过比较下标来比较大小,以下是大概的代码

publicclassPuKe{
	privateStringcolor;
	privateStringnum;
	publicStringgetColor(){
		returncolor;
	}
	publicvoidsetColor(Stringcolor){
		this.color=color;
	}
	publicStringgetNum(){
		returnnum;
	}
	publicvoidsetNum(Stringnum){
		this.num=num;
	}
	
	publicPuKe(Stringcolor,Stringnum){
		super();
		this.color=color;
		this.num=num;
	}
	publicstaticvoidmain(String[]args){
		List<PuKe>card=newArrayList<PuKe>();
		card.add(newPuKe("black","2"));
		card.add(newPuKe("black","3"));
		card.add(newPuKe("black","4"));
		card.add(newPuKe("black","5"));
		card.add(newPuKe("black","6"));
		//这里因为10是两位数且牌面里面用不到1,所以直接用1代替10
		Stringcheck="234567891JQKA";
		booleanflage=true;
		//自定义比较器,用num在check里的下标大小作为比较依据排序
		Collections.sort(card,newComparator<Object>(){
			@Override
			publicintcompare(Objecto1,Objecto2){
				PuKeer1=(PuKe)o1;
				PuKeer2=(PuKe)o2;
				Integerorg1=(int)(er1.getNum()==null?0.0:check.indexOf(er1.getNum()));
				Integerorg2=(int)(er1.getNum()==null?0.0:check.indexOf(er2.getNum()));
				returnorg1.compareTo(org2);
			}
		});
		for(inti=0;i<card.size()-1;i++){
			//遍历所有的牌,如果颜色不一样直接跳出循环,不是同花顺
			if(!card.get(i).getColor().equals(card.get(i+1).getColor())){
				flage=false;
				break;
			}
			//如果上一张减去下一张的差值不是1,说明牌面不是顺子,也不是同花顺,跳出循环
			if((int)check.indexOf(card.get(i+1).getNum())-(int)check.indexOf(card.get(i).getNum())!=1){
				flage=false;
				break;
			}
		}
		if(flage){
			System.out.println("牌面是同花顺");
		}else{
			System.out.println("牌面不是同花顺");
		}
	}
}

不过这种方法唯一不好的地方是check中不能直接用10,将来展示的时候需要判定,展示的是1时直接改成10.

其实实现方法很多,我这么写是因为最近在复习,这么写用到的知识点相对会多一点.

Ⅳ java 二位数组中 判断扑克的最大的牌型

写代码不难..给你一个思路 你就按照这个思路写.
首先按照7张牌的大小 存到一个hashmap<integer,integer> 存的每种数字 及其 出现的次数..
当 hashMap 的count <5 意味着 他们不可能存在 同花顺 同花之类的..那么你可以轻松的判断里面到底是 4条 3条之类的 这个很简单...
当 count >= 5的时候 你就需要判断是否为同花 或者同花顺了..
这个也简单 你在按照花色 进行一次 hashmap 然后看看是否有同一个花色超过5的的..如果没有 则不可能为同花...同样 顺子的判断也根据所有的数字 去重复之后排序..看有没有5个连续的数字..如果没有 就不是顺子..
这样就可以搞定了

Ⅵ Java扑克牌问题

使用JAVA编写以下程序：
1、请定义一个名为Card的扑克牌类，该类有两个private访问权限的字符串变量face和suit；分别描述一张牌的牌面值（如：A、K、Q、J、10、9、……3、2等）和花色（如：“黑桃”、“红桃”、“梅花”、“方块”）；定义Card类中的public访问权限的构造方法，为类中的变量赋值；定义protected访问权限的方法getFace()，得到扑克牌的牌面值；定义protected访问权限的方法getSuit()，得到扑克牌的花色；定义方法toString()，返回表示扑克牌的花色和牌面值字符串（如“红桃A”、“梅花10”等）。

2、若应用程序的main方法中，定义字符串数组f和s；分别表示扑克牌的牌面值和花色；定义52个元素的Card类型数组deck，用来存放4个花色的52张牌。如下所示。
String f[] = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
String s[] = {"黑桃","红桃","梅花","方块"};
Card deck = new Card[52]；
（1）使用Card类的构造方法给deck数组的52张牌赋值，要求数组中先存放黑桃花色的A、2、3、……、K；然后是红桃花色的A、2、3、……、K；梅花花色的A、2、3、……、K；方块花色的A、2、3、……、K。请写出实现上述功能的程序段。
（2）请编写模拟洗牌的完整程序，即把数组deck中的扑克牌随机打乱存放顺序。

原题如下：

引用内容
private String face; // A, K, Q, J, 10, ... 2
private String suit; // Spade, Heart, Club, Diamond
public Card(String suit, String face) {
this.face = face;
this.suit = suit;
}

protected String getFace() {
return face;
}

protected String getSuit() {
return suit;
}

public String toString() {
return suit + " " + face;
}

解题，完成程序解：

程序代码
package poker;

public class Card {

private String face; // A, K, Q, J, 10, ... 2
private String suit; // Spade, Heart, Club, Diamond
public Card(String suit, String face) {
this.face = face;
this.suit = suit;
}

protected String getFace() {
return face;
}

protected String getSuit() {
return suit;
}

public String toString() {
return suit + " " + face;
}

public static void shuffle(Card[] deck, int startIndex, int size,
int splitIndex) { //shuffle洗牌
System.out.println("startIndex:" + startIndex);
if (splitIndex * 2 > size) { //if rand is 30
Card.swap(deck, startIndex, splitIndex, size - splitIndex); //[52]、0、30、22
shuffle(deck, size - splitIndex, splitIndex, size - splitIndex); //[52]、22、30、22
} else if (splitIndex * 2 < size) { //if rnd is 10
Card.swap(deck, startIndex, size - splitIndex, splitIndex); //[52]、0、42、10
shuffle(deck, startIndex, size - splitIndex, splitIndex); //[52]、0、42、10
} else {
Card.swap(deck, startIndex, splitIndex, splitIndex);
}

}

public static void swap(Card[] deck, int srcIndex, int dstIndex, int size) { //交换
//SRC是在本位置显示：source的缩写，源的意思 HREF是点击后连接的目标：HyperlinkReference，超链接引用
String face = "";
String suit = "";
for (int i = 0; i < size; i++) {
face = deck[srcIndex + i].face;
suit = deck[srcIndex + i].suit;
deck[srcIndex + i].face = deck[dstIndex + i].face;
deck[srcIndex + i].suit = deck[dstIndex + i].suit;
deck[dstIndex + i].face = face;
deck[dstIndex + i].suit = suit;
}
}

/**
* @param args
*/
public static void main(String[] args) {
//第一问解答
Card[] deck = new Card[52];
String f[] = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J",
"Q", "K"};
String s[] = {"Spade", "Heart", "Club", "Diamond"};
for (int i = 0; i < s.length; i++) {
for (int j = 0; j < f.length; j++) {
deck[i * 13 + j] = new Card(s[i], f[j]); //依次存入数组之中，每13张一回合
}
}
//第二问解答
int rnd = 0;
int numOfShuffle = 10;
for (int i = 0; i < numOfShuffle; i++) {
rnd = (int) Math.abs(Math.random() * 52); //Math.random()返回大于或等于 0.0 但小于 1.0 的伪随机 double 值。

Card.shuffle(deck, 0, deck.length, rnd);
}
// Test
/*
for (int i=0; i<deck.length; i++)
{
System.out.println(deck[i]);
} */
}

}

Ⅶ java的问题（扑克牌）

代码仅供参考，如有疑问，欢迎追问：

importjava.util.ArrayList;
importjava.util.List;
importjava.util.Scanner;

/**
*随机扑克牌
*@authorSTONE
*@version2015-10-28
*/
publicclassPoker{
	//用于记录丢失的手牌数
	privatestaticIntegerlostTotal=0;
	//用于存放已下发的扑克
	privatestaticInteger[]its1=newInteger[54];
	//用于存放当前的扑克
	privatestaticInteger[]its2=newInteger[54];
	privatestaticList<Integer>lostList=newArrayList<Integer>();
	
	publicstaticvoidmain(String[]args){
		Scannerscn=newScanner(System.in);
		for(inti=0;i<54;i++){
			its1[i]=0;
			its2[i]=0;
		}
		System.out.println("系统开始发牌...");
		givePoker(5);
		System.out.println("发牌完毕，当前手牌为：");
		printPoker(its2);
		IntegergameTotal=0;
		while(gameTotal<10){//循环跑10次，请注意此处发牌没做限制，如果循环次数过大，会导致死循环
			System.out.println("请输入需要丢弃的手牌(多张牌格式如下：黑桃1,黑桃2,黑桃3)：");
			Stringlost=scn.nextLine();
			checkLost(lost);
			System.out.println("丢失手牌完毕，当前手牌：");
			printPoker(its2);
			System.out.println("系统开始重发手牌...");
			givePoker(lostTotal);
			System.out.println("重发发牌完毕，当前手牌为：");
			printPoker(its2);
			gameTotal++;
		}
		scn.close();
	}
	
	publicstaticvoidgivePoker(Integernum){//随机分发手牌
		inttotal=0;
		while(total<num){
			intpoke=(int)(Math.random()*54);
			if(its1[poke]==0){
				its1[poke]=1;
				its2[poke]=1;
				total++;
			}
		}
		lostTotal=0;
	}
	
	publicstaticBooleancheckLost(Stringlost){//检查需要丢失的手牌
		if(lost==null||lost.equals("")){
			System.out.println("输入手牌错误，系统无法处理...");
			returnfalse;
		}
		if(lost.indexOf("黑桃")<0&&lost.indexOf("红心")<0&&lost.indexOf("梅花")<0&&lost.indexOf("方块")<0){
			System.out.println("输入手牌错误，系统无法处理...");
			returnfalse;
		}
		String[]strs=lost.split(",");
		Booleanbol=false;
		for(Stringstr:strs){
			str=str.trim();
			if(str==null||str.equals(""))continue;//去掉，防止空格
			bol=getPokerNum(str);
		}
		if(bol){
			losePoker();
		}
		returnfalse;
	}
	
	publicstaticvoidlosePoker(){//丢掉手牌
		lostTotal=lostList.size();
		for(Integeritr:lostList){//丢掉手牌
			its2[itr-1]=0;
		}
		lostList=newArrayList<Integer>();
	}
	
	(Stringstr){//获取手牌点数并去掉
		try{
			Integeritr=0;
			if(str.indexOf("黑桃")==0){
				str=str.replace("黑桃","");
				itr=Integer.parseInt(str);
				if(itr>13){
					System.out.println("输入手牌不存在：黑桃"+str);
					returnfalse;
				}
				if(its2[itr-1]==1){
					lostList.add(itr);
				}
			}elseif(str.indexOf("红心")==0){
				str=str.replace("红心","");
				itr=Integer.parseInt(str);
				if(itr>13){
					System.out.println("输入手牌不存在：红心"+str);
					returnfalse;
				}
				if(its2[itr+12]==1){
					lostList.add(itr+13);
				}
			}elseif(str.indexOf("梅花")==0){
				str=str.replace("梅花","");
				itr=Integer.parseInt(str);
				if(itr>13){
					System.out.println("输入手牌不存在：梅花"+str);
					returnfalse;
				}
				if(its2[itr+25]==1){
					lostList.add(itr+26);
				}
			}elseif(str.indexOf("方块")==0){
				str=str.replace("方块","");
				itr=Integer.parseInt(str);
				if(itr>13){
					System.out.println("输入手牌不存在：方块"+str);
					returnfalse;
				}
				if(its2[itr+38]==1){
					lostList.add(itr+39);
				}
			}elseif(str.indexOf("小王")==0){
				if(its2[52]==1){
					lostList.add(53);
				}
			}elseif(str.indexOf("大王")==0){
				if(its2[53]==1){
					lostList.add(54);
				}
			}
			returntrue;
		}catch(Exceptione){
			System.out.println("输入手牌有误...");
			returnfalse;
		}
	}
	
	publicstaticvoidprintPoker(Integer[]its){//打印当前手牌
		Stringresult="";
		for(inti=0;i<its.length;i++){
			if(its[i]==1){//等于1表示当前手牌存在
				result+=pukerCheck(i+1)+",";
			}
		}
		System.out.println(result);
	}
	
	publicstaticStringpukerCheck(Integeritr){//判断扑克类型
		/**
		*1~13黑桃花色、14~26红心花色、27~39梅花花色
		*40~52方块花色、53小王、54大王
		*/
		if(1<=itr&&itr<=13){
			return"黑桃"+itr;
		}elseif(14<=itr&&itr<=26){
			return"红心"+(itr-13);
		}elseif(27<=itr&&itr<=39){
			return"梅花"+(itr-26);
		}elseif(40<=itr&&itr<=52){
			return"方块"+(itr-39);
		}elseif(itr==53){
			return"小王";
		}elseif(itr==54){
			return"大王";
		}
		return"";
	}

}

测试运行结果：

Ⅷ JAVA编程判断扑克牌大小

importjava.util.*;

publicclassMain{
	publicstaticvoidmain(String[]args){
		Scannerscanner=newScanner(System.in);
		List<String>list=newArrayList<String>();
		while(scanner.hasNextLine()){
			Stringstring=scanner.nextLine();
			list.add(string);
			if(list.size()==5){
				intr=getCard(list);
				System.out.println(r);
				list.clear();
			}
		}
	}

	privatestaticintgetCard(List<String>list){
		inttemp=7;
		intsize=list.size();
		List<String>numList=newArrayList<String>();
		Set<String>numSet=newTreeSet<String>();
		List<String>colourList=newArrayList<String>();
		Set<String>colourSet=newTreeSet<String>();
		for(inti=0;i<list.size();i++){
			Stringnum=list.get(i).split("")[0];
			Stringcolour=list.get(i).split("")[1];
			if(num.equals("J")){
				numList.add("11");
				numSet.add("11");
			}elseif(num.equals("Q")){
				numList.add("12");
				numSet.add("12");
			}elseif(num.equals("K")){
				numList.add("13");
				numSet.add("13");
			}elseif(num.equals("A")){
				numList.add("14");
				numSet.add("14");
			}else{
				numList.add(num);
				numSet.add(num);
			}
			colourList.add(colour);
			colourSet.add(colour);
		}
		//同花顺,或者同花
		if(colourSet.size()==1){
			Collections.sort(numList);
			for(inti=0;i<numList.size()-1;i++){
				if(Integer.parseInt(numList.get(i+1))-Integer.parseInt(numList.get(i))==1){
					if(i==numList.size()-2){
						temp=1;
					}
					continue;
				}else{
					if(temp>4){
						temp=4;
					}
				}
			}
		}
		//四条或者葫芦
		if(numSet.size()==2){
			Collections.sort(numList);
			//四条
			if(!numList.get(0).equals(numList.get(1))||!numList.get(size-1).equals(numList.get(size-2))){
				if(temp>2){
					temp=2;
				}
			}else{
				if(temp>3){
					temp=3;
				}
			}
		}
		//三条
		if(numSet.size()==3){
			if(temp>6){
				temp=6;
			}
		}
		//顺子
		if(colourSet.size()>1){
			Collections.sort(numList);
			for(inti=0;i<numList.size()-1;i++){
				if(Integer.parseInt(numList.get(i+1))-Integer.parseInt(numList.get(i))==1){
					if(i==numList.size()-2){
						if(temp>5){
							temp=5;
						}
					}
				}else{
					break;
				}
			}
		}
		returntemp;
	}
}

Ⅸ 用java写扑克牌游戏，怎么判断两张牌相同呢我用equals怎么不能成功

应该是没重写扑克类的equals()方法，和hashCode()方法
java中equals方法不重写的话，默认比较的是两个对象的内存地址，你new两个扑克类，打死它们俩的内存地址也不可能是相同的。。。。
重写equals()方法即可，判断条件是花色和点数相同即为相等的牌。
同时别忘了重写hashCode()方法，如果只单独重写equals方法可能造成扑克对象在Map中的散列值冲突，后果就是你向Map中放入两张不一样的牌有可能因为两张牌的散列值一样，后添加的覆盖了前一张牌。

Ⅹ 用Java写一个扑克牌类，扑克牌有花色和大小，并且有一个tostring方法，返回扑克牌的信息

Card[] cards = new Card[54]; // 这是一个数组，是一个普通对象。
Player[] players = new Player[3]; // 这是一个数组，是一个普通对象。
第一行，调用了数组 cards 上索引为 0 的元素的 toString 方法，对应于 Card 类的 toString 方法。
第二行，调用了数组 cards 的 toString 方法，对应于 Card[] 类的 toString 方法，继承自 Object 类。
第三行，调用了 Arrays 类的 toString 方法，传入参数是数组 cards ，具体可查找该方法的源码。
第四行，调用了数组 players 上索引为 0 的元素的 toString 方法，对应于 Player 类的 toString 方法。
第五行，调用了数组 players 的 toString 方法，对应于 Player[] 类的 toString 方法，继承自 Object 类。
第六行，调用了 Arrays 类的 toString 方法，传入参数是数组 players ，具体可查找该方法的源码。
简单说一下 Arrays.toString() ，它返回是由数组内所有元素的字符串化（toString）合并而成的字符串对象。
因此：
1. 不是同一个 toString 方法，任何对象都可调用自身的 toString 方法。
2. 因为 Player 类的 toString 方法内曾调用了“ Arrays.toString(cards) ”。
4. 任何对象都可调用自身的 toString 方法，数组是对象。
5. 数组是对象，一样有对应的类型，其类型一样继承自 Object 类，继承了 toString 方法。
最后，有任何疑问请追问。