java练习：质数，匿名内部类创建接口，抽象类派生子类，画圆，字节截取字符串，数字变钱币,五子棋，梭哈

java学习-质数的孤独

正在看质数的孤独，，，于是写了一个练习代码，输出1-100之间的质数

代码比较烂。待完善吧。

这里用到了continue和break，continue指结束当前轮次循环，跳入下一个循环，break指结束当前循环，进入下一步。

在网上找了别人的代码做参考，优化如下：

上面的代码不正确，只能到3 5 7，需要改成下面的代码：

原因是，flag定义在循环体外面，所以一旦从true改成false之后，状态是不能回去的，就一直false了，后面那句话永远不能输出。

定义一个接口，使用匿名内部类方式创建接口的实例

public interface Oil{
String color="yellow";
public String use();
public String msg(String tool);
}
public class Pen {
public void test(Oil o,String tool){
System.out.println(o.use());
System.out.println(o.msg(tool));
}
public static void main(String[]args){
Pen p=new Pen();

String tool="The tool is Pen";
p.test(
new Oil(){
public String use(){
return "It is for write";
}
public String msg(String tool){

return tool+",the color is "+color;
}
},tool);
}

}

　　

java - 练习，定义一个抽象类，通过抽象的类来派生子类

public abstract class Car{
{
System.out.println("init car");
}
private String color;
//public abstract String Certificate();
public abstract String getType();
public Car(){}
public Car(String color){
System.out.println("exe car");
this.color=color;//without this ,the color couldn't send to the car Object
}

public void setColor(String color)
{
this.color = color;
}
public String getColor()
{
return this.color;
}
}
public class Tractor extends Car{
private int paWeight;//weight of passenger
private int toolWeight;//weight of tool
public void setWeight(int paWeight,int toolWeight){
if(paWeight<=0||toolWeight<=0){
System.out.println("the weight of passenger and tools can't be less than 0");
}
this.paWeight=paWeight;
this.toolWeight=toolWeight;
}
public Tractor(String color,int paWeight,int toolWeight){
super(color);
this.setWeight(paWeight,toolWeight);
}

public String getType(){
return "the paWeight is :"+paWeight+",the toolWeight is :"+toolWeight+"; the color is "+getColor();
};
public static void main(String[]args){
Car c1=new Tractor("yellow",2,300);
System.out.println(c1.getType());
}
}

　

java -练习 给定半径 圆大小随之变化

参考：https://www.cnblogs.com/TaoLeonis/p/6507052.html

画圆代码

	public static void paint(int r){
		for(int i = r;i>=r*(-1);i--){
			int a=r-(int)Math.sqrt((r*r)-(i*i)); //*左侧的间隔数
			int b=r-a;//两个*之间的间隔数
			String str=space(a)+"*"+space(b*2)+"*";
			System.out.println(str);
		}
	}
	public static String space(int x){
		String str = "";
		for(int i=0;i<x;i++){
			str = str+"--";
		}
		return str;
	}

	public static void main(String []args){
		//int r = getInput();
		//paint(r);
		paint(6);
	}　　

原理：

输入数字代码

public static int getInput(){
		int a =-1;
		while(true){
		Scanner scan = new Scanner(System.in);
		if(scan.hasNextInt()){
			 a=scan.nextInt();
			if (a>0){
			System.out.println("输入的数据为：" + a);
			break;}
			else{
				System.out.println("请重新输入");
			}
		}else{
			System.out.println("请重新输入");
		}
		}
		return a ;
	}

　　

　

按字节来截取字符串子串

public class SubStringTest {
	public static void main(String[]args){
		String str="中国国国abcb";
		System.out.println(str.substring(1, 8));
		System.out.println(test(str,1,8));
	}
	public static String test(String str ,int a,int b){
		for(int i=a;i<b;i++){
			if(str.charAt(i)<0||str.charAt(i)>127){
				b=b-1;
			}
		}
		return str.substring(a,b);
	}
}

　　输出结果

国国国abcb
gggggab
国国国a

　　

把数字转化为钱币

写到最后懒得写小数部分了，反正逻辑都是一样绕。

package chapter4;

public class FloatToRmb {
	public static void main(String[] args) {
		double f = 1006.789;
		String[] ds = num(f);
		String begin = ds[0];
		String after = ds[1];
		String str = "";
		if (begin.length() > 0)
			str = handleBefore(begin);
		if (after.length() > 0) {
			str = str + handleAfter(after);
		}
		System.out.println(str);
	}

	public static String handleBefore(String str) {// 1006
		String str1 = "";
		if (str.length() > 0) {// 2{
			if (!str.substring(str.length() - 1).equals("0"))// 6
				str1 = str.substring(str.length() - 1) + "元";
			str = str.substring(0, str.length() - 1);
			System.out.println(str.length());
		}
		if (str.length() > 0) {// 2
			if (!str.substring(str.length() - 1).equals("0"))// 6
			{
				str1 = str.substring(str.length() - 1) + "shi" + str1;
			} else {
				str1 = "零" + str1;
			}
			str = str.substring(0, str.length() - 1);
		}

		if (str.length() > 0) {// 2
			if (!str.substring(str.length() - 1).equals("0"))// 6
			{
				str1 = str.substring(str.length() - 1) + "bai" + str1;
			} else if (!str1.startsWith("零")) {
				str1 = "零" + str1;
			}
			str = str.substring(0, str.length() - 1);
		}

		if (str.length() > 0) {// 2
			if (!str.substring(str.length() - 1).equals("0"))// 6
				str1 = str.substring(str.length() - 1) + "qian" + str1;
		}

		return str1;
	}

	public static String toChineseNum(int a) {
		String str = "";
		switch (a) {
		case 1:
			str = "壹";
		case 2:
			str = "贰";
		case 3:
			str = "叁";
		case 4:
			str = "肆";
		case 5:
			str = "伍";
		case 6:
			str = "陆";
		case 7:
			str = "柒";
		case 8:
			str = "捌";
		case 9:
			str = "久";
		}
		return str;
	}

	public static String handleAfter(String str) {
		return "2";
	}

	public static String[] num(double d) {
		String[] ds = { "", "" };
		String str = String.valueOf(d);
		int num = str.indexOf(".");
		ds[0] = str.substring(0, num);
		ds[1] = str.substring(num + 1);
		return ds;
	}

}

　　改进版

思路想好了

对所有数值，都转换成  xxxxxxx的格式

即 1006 转为 1006000，10067转为1006700 ，6.7转为0006700；

对任意7位数，插入字符

String 1 ="1234567";

String 2 = "千百十元角分毫"

str="1千2百3十4元5分6角7毫";

package chapter4;

public class FloatToRmb {
	public static void main(String[] args) {
		double d=10.078;
		int a=(int)(d*1000);//1066789
		String str=String.valueOf(a);
		if(str.length()<=1){
			str="零";
		}
		while(str.length()!=7){
			str="0"+str;
		}
		String str1="千百十元角分毫";//3
		String str2="";
		for(int i=str.length();i>0;i--){
			if(!str.substring(i-1,i).equals("0")){
			str2=str.substring(i-1,i)+str1.substring(i-1, i)+str2;
			}else if (str.substring(i-1,i).equals("0")
					&&(!str2.startsWith("零"))
					&&((i-1)<3)
					&&(!str.startsWith("0"))
					&&!str2.startsWith("元")//元
					){//indexof 似乎不能识别中文？
				System.out.println(str1.indexOf("元")+","+(i-1));
				str2="零"+str2;
			}else if(!str2.startsWith("元")
					&&((i-1)==3)){
				str2="元"+str2;
			}
			System.out.println(str.substring(i-1, i));
			str1=str1.substring(0, i-1);
			str=str.substring(0, i-1);
		}
		System.out.println(str2);
	}

}

　　逻辑判断的部分太垃圾了。。。。还需要改进

改进后的版本：

1.先把位数插入到字符串中

2.再分析语义，字符串中需要做处理的只有 元 和零这两个字。修改代码，在字符串基础上，分别插入元和零这两个字就可以了。

package chapter4;

public class FloatToRmb {
	public static void main(String[] args) {
		double d=010.078;
		int a=(int)(d*1000);//1066789
		String str=String.valueOf(a);
		String str2="";
		if(str.length()<=1&&str.toString().equals("0")){
			str2="零";
		}else if(str.length()<=1&&(!str.toString().equals("0"))){
			str2=str+"毫";
		}
		while(str.length()!=7){
			str="0"+str;
		}
		String str1="千百十元角分毫";//3
		if(str2.equals("")){
		for(int i=str.length();i>0;i--){
			if(!str.substring(i-1,i).equals("0")){//给不等于0的位数加上单位
			str2=str.substring(i-1,i)+str1.substring(i-1, i)+str2;
			}
			else if(str.substring(i-1,i).equals("0")//当前位数为0时
					&&((i-1)==3)//整数部分
					&&notAllZero(str)){//给个位数为0，但整数部分不全为零的部分 ，加上元单位
				str2="元"+str2;
				System.out.println("当前位数为："+(i-1)+",整数部分不全为0？："+notAllZero(str));
			}
			else if((!str2.startsWith("元"))
					&&(notAllZero(str))
					&&str.substring(i-1,i).equals("0")
					&&(i-1<=3)){//整数部位中，str2不以元开头，整数部分不全为零，当前单位str为0，加上“零”
				str2="零"+str2;
			}
			str=str.substring(0,i-1);//每个循环，缩短一下str的尾部
		}
		}
		System.out.println(str2);
	}
	public static boolean notAllZero(String str){
		boolean b = false;//默认全0
		while(str.length()>0){
			if(!(str.substring(str.length()-1, str.length()).equals("0"))){
				b=true;
				break;
			}
				str=str.substring(0,str.length()-1);
		}
		return b;
	}

}

　　

其实还是很辣鸡。。。。_(:з)∠)_

　　

看了下，网上的大多数解决办法是把浮点数和整数分开处理，然后用数组来循环。

唔。。。。好吧

改进了一下代码

可以处理4位的亿的数值

package chapter4;

public class FloatToRmb {
	static String []bigDigit={"元","万","亿"};
	static String []staticDigit={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
	static String zero="零";
	public static void main(String[] args) {
		double l=100000.1;
		System.out.println(toChinese(getString(l)));
	}
	public static String getString(double l){
		long a=(long) Math.floor(l);
		long b=Math.round((l-a)*100);
		String inte=String.valueOf(a);
		String floate=String.valueOf(b);
		String str="";
		String[]intee=cutNum(inte);
		if(!((inte.length()==1)&&inte.equals("0"))){
			for(int i=0;i<intee.length;i++){
//			System.out.print(intee[i]);
			str=handleNum(intee[i])+bigDigit[i]+str;
			}
		}
		return str=str+handleFloat(floate);
	}

	public static String toChinese(String num){
		String result="";
		for(int i =0;i<num.length();i++){
			//对每一位进行遍历，每一位从0~9，分别赋值staticDigit[0]~[9]
			if(num.substring(i,i+1).matches("\\d")){
				int j =Integer.valueOf(num.substring(i,i+1));
				result=result+staticDigit[j];
			}else{
				result=result+num.substring(i,i+1);
			}

		}
		return result;
	}

	public static String handleFloat(String num){//11
		String a ="";
		String [] f={"角","分"};
//		System.out.println(num.length());
		if(num.length()!=0){
			for(int i =0;i<num.length();i++){
				if(!num.substring(i, i+1).equals("0")){
					a=a+num.substring(i,i+1)+f[i];
				}
			}
		}
		return a;
	}
	public static String[] cutNum(String num){
		int digit=getDigit(num.length());
		String []a=new String[digit];
		while(num.length()<4*digit){
			num="0"+num;
		}
		for(int i=0;i<digit;i++){
			//将num进行四位切割
			a[i]=num.substring((digit-i-1)*4,(digit-i)*4);//从后往前填充
		}
		return a;
	}
	public static String handleNum(String num){
		String []smallDigit={"千","百","拾",""};
		String newNum="";
		for(int i=num.length();i>0;i--){//1010 i=1
            if(!num.substring(i-1,i).equals("0")){//给不等于0的位数加上单位
            	newNum=num.substring(i-1,i)+smallDigit[i-1]+newNum;
            }
            else if(
            		num.substring(i-1,i).equals("0")//当前位的数值为0，后面数值有，前面数值不全为0，补“零"
                    &&(newNum.length()!=0)
                    &&(notAllZero(num))
            		){
            	newNum=zero+newNum;
            }
            num=num.substring(0,i-1);//每个循环，缩短一下str的尾部
        }
		return newNum;
	}

	public static int getDigit(int length){
		int a =0;
		a=(int)Math.ceil((double)length/4);
		return a ;
	}

	public static boolean notAllZero(String str){
		boolean b = false;//默认全0
		while(str.length()>0){
			if(!(str.substring(str.length()-1, str.length()).equals("0"))){
				b=true;
				break;
			}
				str=str.substring(0,str.length()-1);
		}
		return b;
	}
}

　　

五子棋

增加gameOver()方法，判断落子之后，棋局是否结束

结束的标准：

1.棋盘已满

2.横，竖，左斜，右斜 5个子相连

第一版本：

对棋盘上的所有的位置进行校验，看看是否结束战斗：

_(:з)∠)_ 好鸡儿烦躁啊，不能用一个循环和一个数组搞定。。。。

package chapter4;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Gobang
{
	// 定义棋盘的大小
	private static int BOARD_SIZE =7;
	// 定义一个二维数组来充当棋盘
	private static int EDGE=4;
	private  String[][] board;
	private int color=0;
	public void initBoard(){
		board=new String[BOARD_SIZE][BOARD_SIZE];
		for(int i =0;i<BOARD_SIZE;i++){//列
			//打印x个+
			for(int j =0;j<BOARD_SIZE;j++){//行
				board[i][j]="+ ";//数组的内容在赋值之前需要先初始化，不然会报nullPoint错误
			}
		}
	}
	public void showBoard(){
		for(int i =0;i<BOARD_SIZE;i++){//列
			//打印x个+
			for(int j =0;j<BOARD_SIZE;j++){//行
				System.out.print(board[i][j]);//j从0~14打印不换行
			}
			System.out.println();//i 从0~14打印换行
		}
		System.out.println("____________________________________");
	}

	public Boolean paint(int i,int j ){
		Boolean flag=false;
		if(i>BOARD_SIZE||i<1||j>BOARD_SIZE||j<1){
			return false;
		}
		//怎么判断是写○还是写*？
		// color=0 下O,为用户方，=1 下第二个，为PC方；
		if(board[i-1][j-1].equals("+ ")){
			if(color==0){
				board[i-1][j-1]="○ ";
				color=1;
			}else if(color==1){
				board[i-1][j-1]="Q ";
				color=0;
			}
			flag=true;
		}
		return flag;
	}
	public int random(){
		return (int)Math.round(Math.random()*(BOARD_SIZE-1)+1);
	}
	//flag为true时,游戏结束
	public Boolean gameOver(String i){
		//1.棋盘占满 横向对比
		Boolean flag=false;//游戏未结束
		String [][]board_change=new String[BOARD_SIZE][BOARD_SIZE];
		int [][]board_judge=new int [BOARD_SIZE][BOARD_SIZE];
		int[][] board_judge2=new int [BOARD_SIZE][BOARD_SIZE];
		for(int j=0;j<BOARD_SIZE;j++){
			String str1="";
			int count_x=0;
			for(int k=0;k<BOARD_SIZE;k++){
				board_change[k][j]=board[j][k];
				str1=board[j][k]+str1;
				if(board[j][k].equals(i)){
					count_x=count_x+1;
					if(count_x>=EDGE){
						flag=true;
						System.out.println(i+"胜利了，游戏结束。");//横向对比
						return flag;
					}
					if(j==0){
						board_judge[j][k]=1;
						System.out.println("j:"+j+",k:"+k+",board_judge[j][k]:"+board_judge[j][k]);
					}
					//左斜判断
					if((k>0)&&(board_judge[j-1][k-1]==j)){
						board_judge[j][k]=j+1;
					}
					//右斜判断
					if(k<BOARD_SIZE-1&&(board_judge2[j-1][k+1]==j)){
						board_judge2[j][k]=j+1;
					}
					if(board_judge[j][k]==5||board_judge2[j][k]==5){
						flag=true;
						System.out.println(i+"胜利了，游戏结束。");//对角线对比
					}
				}else if(!board[j][k].equals(i)){
					count_x=0;
				}
				if((!str1.contains("+ "))&&(j==BOARD_SIZE-1)&&(k==BOARD_SIZE-1)&&(!board[j][k].equals("+ "))){
					System.out.println("棋盘已满，和");
					flag=true;
					return flag;
				}
			}
		}
		//竖着
		for(int j=0;j<BOARD_SIZE;j++){
			String str1="";
			int count_x=0;
			for(int k=0;k<BOARD_SIZE;k++){
				str1=board_change[j][k]+str1;
				if(board_change[j][k].equals(i)){
					count_x=count_x+1;
					if(count_x>=EDGE){
						flag=true;
						System.out.println(i+"胜利了，游戏结束。");//横向对比
						return flag;
					}
				}else if(!board_change[j][k].equals(i)){
					count_x=0;
				}
				if((!str1.contains("+ "))&&(j==BOARD_SIZE-1)&&(k==BOARD_SIZE-1)&&(!board_change[j][k].equals("+ "))){
					System.out.println("棋盘已满，和");
					flag=true;
					return flag;
				}
			}
		}
		return flag;
	}

	public static void main(String []args) throws NumberFormatException, IOException{
		Gobang gb=new Gobang();
		System.out.println("—————————————————五子棋游戏—————————————————");
		System.out.println("请输入1~"+BOARD_SIZE+"的数字");
		gb.initBoard();
		//get输入，用，分离
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String inputStr = null;
		// br.readLine()：每当在键盘上输入一行内容按回车，用户刚输入的内容将被br读取到。
		while ((inputStr = br.readLine()) != null)
		{
			// 将用户输入的字符串以逗号（,）作为分隔符，分隔成2个字符串
			if(!inputStr.contains(",")){
				System.out.println("需要输入英文逗号哦，请重新输入~");
				continue;
			}
			String[] posStrArr = inputStr.split(",");
			// 将2个字符串转换成用户下棋的座标
			int xPos = Integer.parseInt(posStrArr[0]);
			int yPos = Integer.parseInt(posStrArr[1]);
			if(xPos<1||xPos>BOARD_SIZE||yPos<1||yPos>BOARD_SIZE){
				System.out.println("请输入1~"+BOARD_SIZE+"的数字");
				continue;
			}
			if(gb.paint(xPos,yPos)){
				gb.showBoard();
			}else{
				System.out.println("当前位置已有棋子，请重新落子");
				continue;
			}
//			System.out.println(gb.gameOver(0));
			if(gb.gameOver("○ ")){
				break;
			}

			while(true){
				if(gb.paint(gb.random(),gb.random())){
					gb.showBoard();
					break;
				}else{
					continue;
				}
			}
			if(gb.gameOver("Q ")){
				break;}
		}
}
	}

　　第二版本：

　　参考了其他人用GUI写的用例，修改规则：

　　1.只对落子的位置进行判断，不用对整个棋盘遍历

　　_(:з)∠)_ 日哦，又要重写一发，我怎么这么笨。

　　搞定了，只写了横向对比，其他方向的以此类推了，懒得动了。。。。

package chapter4;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Gobang
{
	// 定义棋盘的大小
	private static int BOARD_SIZE =7;
	// 定义一个二维数组来充当棋盘
	private static int EDGE=4;
	private  String[][] board;
	private int color=0;
	public void initBoard(){
		board=new String[BOARD_SIZE][BOARD_SIZE];
		for(int i =0;i<BOARD_SIZE;i++){//列
			//打印x个+
			for(int j =0;j<BOARD_SIZE;j++){//行
				board[i][j]="+ ";//数组的内容在赋值之前需要先初始化，不然会报nullPoint错误
			}
		}
	}
	public void showBoard(){
		for(int i =0;i<BOARD_SIZE;i++){//列
			//打印x个+
			for(int j =0;j<BOARD_SIZE;j++){//行
				System.out.print(board[i][j]);//j从0~14打印不换行
			}
			System.out.println();//i 从0~14打印换行
		}
		System.out.println("____________________________________");
	}

	public Boolean paint(int i,int j ){
		Boolean flag=false;
		if(i>BOARD_SIZE||i<1||j>BOARD_SIZE||j<1){
			return false;
		}
		//怎么判断是写○还是写*？
		// color=0 下O,为用户方，=1 下第二个，为PC方；
		if(board[i-1][j-1].equals("+ ")){
			if(color==0){
				board[i-1][j-1]="○ ";
				color=1;
			}else if(color==1){
				board[i-1][j-1]="Q ";
				color=0;
			}
			flag=true;
		}
		return flag;
	}
	public int random(){
		return (int)Math.round(Math.random()*(BOARD_SIZE-1)+1);
	}
	//flag为true时,游戏结束
	public Boolean gameOver(int xpos,int ypos){
		Boolean flag=false;
		xpos=xpos-1;
		ypos=ypos-1;
		//横向查看
		int countx=0;
		for(int i=ypos;i<BOARD_SIZE;i++){

			if(board[xpos][i].equals(board[xpos][ypos])){
				countx=countx+1;
			}else{
				break;
			}
		}
		for(int i=ypos ;i>0;i--){
			if(board[xpos][i].equals(board[xpos][ypos])){
				countx=countx+1;
			}else{
				break;
			}
		}
		if(countx>=5){
			flag=true;
			System.out.println("胜负已分");
			return flag;
		}
		/*//纵向查看
		int county=0;
		for(int i =xpos ;i<BOARD_SIZE;i++){
			if(board[i][ypos].equals(board[xpos][ypos])){
				county++;
			}else {
				break;
			}

		}
		for(int i=xpos;i>0;i--){
			if(board[i][ypos].equals(board[xpos][ypos])){
				county++;
			}else{
				break;
			}
		}
		if(county>=5){
			flag=true;
			return flag;
		}
		//左斜查看
		int counta=1;
		for(int i =1;i<5;i++){
			if(xpos+i<BOARD_SIZE&&ypos+i<BOARD_SIZE){
				if(board[xpos+i][ypos+i].equals(board[xpos][ypos])){
					counta++;
				}else{
					break;
				}
			}
		}
		for(int i=1;i<5;i++){
			if(xpos-i>0&&ypos-i>0){
				if(board[xpos-i][ypos-i].equals(board[xpos][ypos])){
					counta++;
				}else{
					break;
				}
			}
		}
		if(counta>=5){
			flag=true;
			return flag;
		}*/
		//右斜查看

		//棋盘查看
		return flag;
	}

	public static void main(String []args) throws NumberFormatException, IOException{
		Gobang gb=new Gobang();
		System.out.println("—————————————————五子棋游戏—————————————————");
		System.out.println("请输入1~"+BOARD_SIZE+"的数字");
		gb.initBoard();
		//get输入，用，分离
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String inputStr = null;
		// br.readLine()：每当在键盘上输入一行内容按回车，用户刚输入的内容将被br读取到。
		while ((inputStr = br.readLine()) != null)
		{
			// 将用户输入的字符串以逗号（,）作为分隔符，分隔成2个字符串
			if(!inputStr.contains(",")){
				System.out.println("需要输入英文逗号哦，请重新输入~");
				continue;
			}
			String[] posStrArr = inputStr.split(",");
			// 将2个字符串转换成用户下棋的座标
			int xPos = Integer.parseInt(posStrArr[0]);
			int yPos = Integer.parseInt(posStrArr[1]);
			if(xPos<1||xPos>BOARD_SIZE||yPos<1||yPos>BOARD_SIZE){
				System.out.println("请输入1~"+BOARD_SIZE+"的数字");
				continue;
			}
			if(gb.paint(xPos,yPos)){
				gb.showBoard();
				if(gb.gameOver(xPos,yPos)){
					break;
				}
			}else{
				System.out.println("当前位置已有棋子，请重新落子");
				continue;
			}
			while(true){
				int xpos;
				int ypos;
				if(gb.paint( xpos=gb.random(),ypos=gb.random())){
					gb.showBoard();
					gb.gameOver( xpos,ypos);
					break;
				}else{
					continue;
					}
			}
		}
	}
}

　　

梭哈游戏简易版

这个好久之前就看过，然后没写过，因为不懂梭哈怎么玩。。。。

还是没太懂，感觉是1张暗牌，然后依次发4张明牌，每发一轮来一轮跟/弃，发完后明牌分胜负。

唔。。。。五子棋的今天看了下官方给的正确答案，感觉自己的类设计很辣鸡。。。。梭哈感觉又要扑街。

第一步：流程图

这个逻辑太机儿复杂了，简化了一下：

这里实现大概有5个重点：

　　1.牌面设计

　　2.发牌随机

　　3.人工输入 Y/N

　　4.判定当前对局人数（有人弃牌，另一人就胜利了，这里没有考虑多人游戏）

　　5.比牌逻辑（同花顺>四条>葫芦>同花>顺子>三条>二对>单对>散牌 、黑桃>红桃>草花>方块 、A>K>Q>J>10>9>8 >7>6>5>4>3>2）

审题：

定义一个类，该类用户封装一桌梭哈游戏，这个类应该包含桌上剩下的牌的信息，并包含5个玩家的状态信息：各自的位置，游戏状态（正在游戏/已放弃），手上已有的牌等信息。如果有可能，这个类还应该实现发牌方法，这个方法需要控制从谁开始发牌，不要发牌给放弃的人，并修改桌上剩下的牌。

暂未实现比牌功能

package chapter6;

/**
 * @param WEEK 牌面数值
 * @param suit 花色
 * @param poker[] 扑克牌字符串数组
 */
class Stud{
	/**
     * 返回 {@code String}是初始化的牌面，
     * @return  由52张不同牌面组成的字符串
     */
	public final static int CARD_NO=52;
	public final static String WEEK="A23456789TJQK";
	public final static String SUIT="♠♥♦♣";
	public String pokercard;
	public String restcard;

	public String getRestcard() {
		return restcard;
	}
	public void setRestcard(String restcard) {
		this.restcard = shuffleCard(pokercard);
	}
	public String getPokercard() {
		return pokercard;
	}
	public void setPokercard() {
		String  poker="";
		for(int j=0;j<SUIT.length();j++){
			for(int k=0;k<WEEK.length();k++){
				poker=poker+SUIT.substring(j, j+1)+WEEK.substring(k, k+1);
				}
			}
		this.pokercard= poker;
	}
	 /**
     * 返回 {@code String}是洗牌后的牌面结果，
     * 给一个[0,52)的随机数,然后从给定的牌里面，按照随机数取出来，付给新牌面
     * 并将旧牌面的该随机数的牌replace
     * @param   pokercard  a {@code String} value.
     * @return  将pokercard洗牌后的结果
     */
	public static String  shuffleCard(String pokercard){
		String sc = "";
		String pc=pokercard;
		if(pokercard.length()!=CARD_NO*2){
			System.out.println("the pokercard is wrong,please check the num");
			return "";
		}

		while(pc.length()>0){
			int randomNum=(int)Math.floor(Math.random()*(pc.length()/2));
			String card=pc.substring(2*randomNum, 2*randomNum+2);
			sc=sc+card;
			pc=pc.replace(card, "");
		}
		return sc;
	}
	/**
     * 返回 发给玩家的手牌,并减少剩下的公牌,并更新玩家手牌
     * @param restcard 参数是用来发牌的公牌
     *
     */
	public String handCard(String restcard,Player player){
		String dc="";
		dc =restcard.substring(0,2);
		this.restcard=this.restcard.substring(2);
		player.setCard(player.getCard()+dc);
		return dc;
	}

	/**
	 * 比牌
	 */
//	public void
}
/**
 * @author zhizhiyin
 * @param name 玩家名字；
 * @param position 玩家位置；
 * @param fold 是否弃牌，默认false不弃牌；
 * @param card 玩家手牌
 */
class Player{
	private String name ;
	private int position;
	private String card="";
	private boolean fold=false;//弃牌
	public String getCard() {
		return card;
	}
	public void setCard(String card) {
		if(card.length()==2){
			//||card.matches("^[A|2|3|4|5|6|7|8|9|T|J|Q|K]{1}[♠|♥|♦|♣]{1}$")
			this.card = card;
			return ;
		}
		else{
			System.out.println("传入的card 长度不为2");
		}
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		if(name.length()>=1&&name.length()<=4){
			this.name = name;
			return;
		}else{
			System.out.println("name长度须在1~4之间");
		}
	}
	public int getPosition() {
		return position;
	}
	public void setPosition(int position) {
		if(position>=0&&position<5){
			this.position = position;
			return ;
		}else{
			System.out.println("position长度须在0~4之间");
		}
	}
	public boolean getFold() {
		return fold;
	}
	public void setFold(boolean fold) {
		this.fold = fold;
	}
	//创建玩家，如果只需要五个玩家呢？怎么给这些玩家初始化呢？
	/**
	 * @param name 玩家的名字
	 * @param positioni 玩家的位置
	 */
	public Player(String name ,int position){
		setName(name);
		setPosition(position);
	}
	/**
	 * @param player 需要切换成弃牌状态的玩家
	 * @method turnFold(player) 如果用户未弃牌，置状态为弃牌，返回true，如果用户已经弃牌，置状态为false，表示转换失败，该用户已是弃牌状态
	 */
	public boolean turnFold(){
		if(this.getFold()==false){
			this.setFold(true);
			return true;
		}else{
			return false;
		}
	}
}

public class TestStud {
	public static void main(String[]args){

	}
}

　　

加入测试代码，并修复了一些bug

比牌逻辑并未完善，明牌暗牌什么的也没有加上。

package chapter6;

import java.util.Scanner;

/**
 * @param WEEK 牌面数值
 * @param suit 花色
 * @param poker[] 扑克牌字符串数组
 */
class Stud{
	/**
     * 返回 {@code String}是初始化的牌面，
     * @return  由52张不同牌面组成的字符串
     */
	public final static int CARD_NO=52;
	public final static String WEEK="A23456789TJQK";
	public final static String SUIT="♠♥♦♣";
	public String getPokercard() {
		String  poker="";
		for(int j=0;j<SUIT.length();j++){
			for(int k=0;k<WEEK.length();k++){
				poker=poker+SUIT.substring(j, j+1)+WEEK.substring(k, k+1);
				}
			}
		return poker;
	}
	 /**
     * 返回 {@code String}是洗牌后的牌面结果，
     * 给一个[0,52)的随机数,然后从给定的牌里面，按照随机数取出来，付给新牌面
     * 并将旧牌面的该随机数的牌replace
     * @param   pokercard  a {@code String} value.
     * @return  将pokercard洗牌后的结果
     */
	public String  shuffleCard(String pokercard){
		String sc = "";
		String pc=pokercard;
		if(pokercard.length()!=CARD_NO*2){
			System.out.println("the pokercard is wrong,please check the num");
			return "";
		}

		while(pc.length()>0){
			int randomNum=(int)Math.floor(Math.random()*(pc.length()/2));
			String card=pc.substring(2*randomNum, 2*randomNum+2);
			sc=sc+card;
			pc=pc.replace(card, "");
		}
		return sc;
	}
	/**
     * 返回 发给玩家的手牌,并更新玩家手牌
     * @param restcard 参数是用来发牌的公牌
     *
     */
	public String handCard(String restcard,Player player){
		String dc="";
		dc =restcard.substring(0,2);
		System.out.println("handCard前,player的card是："+player.getCard());
		player.setCard(player.getCard()+dc);
		return dc;
	}
	public String restCard(String restCard){
		return restCard.substring(2);
	}

	/**
	 * 比牌
	 */
//	public void
}
/**
 * @author zhizhiyin
 * @param name 玩家名字；
 * @param position 玩家位置；
 * @param fold 是否弃牌，默认false不弃牌；
 * @param card 玩家手牌
 */
class Player{
	private String name ;
	private int position;
	private String card="";
	private boolean fold=false;//弃牌
	public String getCard() {
		return card;
	}
	public void setCard(String card) {
			this.card = card;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		if(name.length()>=1&&name.length()<=4){
			this.name = name;
			return;
		}else{
			System.out.println("name长度须在1~4之间");
		}
	}
	public int getPosition() {
		return position;
	}
	public void setPosition(int position) {
		if(position>=0&&position<5){
			this.position = position;
			return ;
		}else{
			System.out.println("position长度须在0~4之间");
		}
	}
	public boolean getFold() {
		return fold;
	}
	public void setFold(boolean fold) {
		this.fold = fold;
	}
	//创建玩家，如果只需要五个玩家呢？怎么给这些玩家初始化呢？
	/**
	 * @param name 玩家的名字
	 * @param positioni 玩家的位置
	 */
	public Player(String name ,int position){
		setName(name);
		setPosition(position);
	}
	/**
	 * @param player 需要切换成弃牌状态的玩家
	 * @method turnFold(player) 如果用户未弃牌，置状态为弃牌，返回true，如果用户已经弃牌，置状态为false，表示转换失败，该用户已是弃牌状态
	 */
	public boolean turnFold(){
		if(this.getFold()==false){
			this.setFold(true);
			return true;
		}else{
			return false;
		}
	}
}

public class TestStud {
	public static void main(String[]args){
		//怎么在初始化的时候创建玩家呢？怎么同时给五个玩家发牌呢？
		//用数组来解决
		int playerNo=5;//人数
		int flopNo=1;//轮次

		Player []player=new Player[playerNo];
		for(int i =0;i<playerNo;i++){
			String name="玩家"+i;
			player[i]=new Player(name,i);
		}
		//洗牌
		Stud s=new Stud();
		String restCard =s.shuffleCard(s.getPokercard());
		Boolean flag=false;
		while (!flag){
			for(int i =0;i<player.length;i++){
				//判断是否弃牌
				if(player[i].getFold()==false){
					s.handCard(restCard, player[i]);
					restCard=s.restCard(restCard);
					System.out.println("当前余牌："+restCard);
					//跟弃
					System.out.println(player[i].getName()+"的手牌："+player[i].getCard());
					System.out.println("当前玩家是否弃牌？Y/N");
					Scanner input = new Scanner(System.in);
					String str =input.next();
					if (str.equals("Y")){
						//弃牌
						player[i].turnFold();
						playerNo=playerNo-1;
						System.out.println("playerNo:"+playerNo);
					}
					if(playerNo==1){
						//结束
						System.out.println("game over");
						flag=true;
						break;
					}
				}
				}
			flopNo=flopNo+1;
			if(flopNo==5){
				System.out.println("进入比牌");
				flag=true;
				break;
			}
		}
	}
}

　　

梭哈游戏 阉割版

需要把毛坯版改成精装版。。。。

老规矩，流程图：

之前的版本，用数组和字符串写的。chapter7讲的是集合。

总体优化方向应该是用集合来写。

优化方向：

1.手牌需要区分 明牌/暗牌。

2.洗牌似乎可以用set来写？

3.比牌逻辑不会哦。。。这个怎么比较呢？

准备把集合看完了再来大改一下。

package chapter6;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;

/**
 * @param WEEK 牌面数值
 * @param suit 花色
 * @param poker[] 扑克牌字符串数组
 */
class Stud{
	public final static int CARD_NO=52;
	public final static String WEEK="A23456789TJQK";
	public final static String SUIT="♠♥♦♣";
	/**
	 * 返回 {@code ArrayList}是初始化的牌面，
	 * @return ArrayList 为初始化赋值的牌面
	 */
	public ArrayList initPokerCard() {
		ArrayList poker=new ArrayList();
		for(int j=0;j<SUIT.length();j++){
			for(int k=0;k<WEEK.length();k++){
				poker.add(SUIT.substring(j, j+1)+WEEK.substring(k, k+1));
				}
			}
		return poker;
	}
	 /**
     * 返回 {@code ArrayList}是洗牌后的牌面结果，
     * 给一个[0,52)的随机数,然后从给定的牌里面，按照随机数取出来，add给新牌面
     * 并将旧牌面的该随机数的牌remove
     * @param   pokercard  a {@code ArrayList} value.
     * @return  将poker洗牌后的结果
     */
	public ArrayList shuffleCard(ArrayList poker){
		ArrayList al=new ArrayList();
		while(poker.size()>0){
			int randomNum=(int)Math.floor(Math.random()*(poker.size()));
			al.add(poker.get(randomNum));
			poker.remove(randomNum);
		}
		return al;
	}
	/**
     * 返回 {@code String}发给玩家的手牌,并更新玩家手牌
     * @param poker 参数是用来发牌的公牌
     *
     */
	public String handCard(ArrayList poker,Player player){
		String handCard="";
		handCard=(String) poker.get(0);
		System.out.println("handCard前,player的card是："+player.getCard());
		player.setCard(player.getCard()+handCard);
		return handCard;
	}
	/**
	 * {@code ArrayList}将第一张牌移除，返回剩余的牌面
	 * @param poker 当前剩余公牌
	 * 模拟发牌
	 */
	public ArrayList restCard(ArrayList poker){
		poker.remove(0);
		return poker;
	}

	/**
	 * 比牌
	 */
	public Player judge(HashMap player){
		Player winner =(Player)player.get(0);
		//遍历，如果第一个大，就将第一个和第N个的位置调换

		return winner;
	}
}
/**
 * @author zhizhiyin
 * @param name 玩家名字；
 * @param position 玩家位置；
 * @param fold 是否弃牌，默认false不弃牌；
 * @param card 玩家手牌
 */
class Player{
	private String name ;
	private String card="";
	private boolean fold=false;//弃牌
	public String getCard() {
		return card;
	}
	public void setCard(String card) {
			this.card = card;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		if(name.length()>=1&&name.length()<=4){
			this.name = name;
			return;
		}else{
			System.out.println("name长度须在1~4之间");
		}
	}
	public boolean getFold() {
		return fold;
	}
	public void setFold(boolean fold) {
		this.fold = fold;
	}
	//创建玩家，如果只需要五个玩家呢？怎么给这些玩家初始化呢？
	/**
	 * @param name 玩家的名字
	 * @param positioni 玩家的位置
	 */
	public Player(String name){
		setName(name);
	}
	/**
	 * @param player 需要切换成弃牌状态的玩家
	 * @method turnFold(player) 如果用户未弃牌，置状态为弃牌，返回true，如果用户已经弃牌，置状态为false，表示转换失败，该用户已是弃牌状态
	 */
 	public boolean turnFold(){
		if(this.getFold()==false){
			this.setFold(true);
			System.out.println("该玩家弃牌");
			return true;
		}else{
			return false;
		}
	}
}

public class TestStud {
	public static void main(String[]args){
		//给玩家赋值
		int playerNo=5;
		HashMap player=new HashMap();
		for(int i =0;i<playerNo;i++){
			String name ="玩家"+i;
			player.put(i, new Player(name));
		}
		Stud s = new Stud();
		ArrayList poker =s.initPokerCard();//初始化牌面
		poker = s.shuffleCard(poker);//洗牌
		int flopNo=1;//轮次
		Boolean flag=false;
		while (!flag){
			for(int i =0;i<player.size();i++){
					Player currentPlayer =(Player)player.get(i);
					if(player.size()==1){
						//结束
						System.out.println("当前仅有一个玩家:"+currentPlayer.getName()+"，game over");
						flag=true;
						break;
					}
					s.handCard(poker,currentPlayer);
					poker=s.restCard(poker);
					System.out.println("当前余牌："+poker);
					//跟弃
					System.out.println(currentPlayer.getName()+"的手牌："+currentPlayer.getCard());
					System.out.println("当前玩家是否弃牌？Y/N");
					Scanner input = new Scanner(System.in);
					String str =input.next();
					if (str.equals("Y")){
						//弃牌
						currentPlayer.turnFold();
						player.remove(i);
					}
				}
			flopNo=flopNo+1;
			if(flopNo==5){
				System.out.println("进入比牌");
				s.judge(player);
				flag=true;
				break;
			}
		}
	}
}

　　比牌逻辑未修改，感觉这个好难哦。

有一点思路：

1.如果是牌桌的话，可以用冒泡排序依次排列，然后算钱，这里会简化一下，只找出最大的牌面，并返回player，这里我的player用的hashMap。取值的话只能依靠index。

取出最小值：

int min =numList[0];
		int exchange=0;
		//筛选出最小的，并显示
		for(int i=1;i<numList.length;i++){
			if(numList[i]<min){
				exchange=min;
				min=numList[i];
				numList[i]=exchange;
			}
		}

冒泡排序

int ex = 0;
		for (int i = numList.length; i>1; i--) {
			for (int j = 1; j < i; j++) {
				if (numList[j] < numList[j - 1]) {
					ex = numList[j - 1];
					numList[j - 1] = numList[j];
					numList[j] = ex;
				}
			}
		}

　　

2.需要写详细的1v1的手牌比较。需要分别比较花色，牌面。。。我讨厌写这个

判断牌型，同花顺，同花，顺子

public int levelOfCard(String handCard) {
		int level = 0;
		String week = "";
		if (handCard.length() > 10 || handCard.length() <= 0) {
			System.out.println("字符串长度异常");
			return -1;
		}
		int color = 1;
		// 判断同花的
		for (int i = 2; i < handCard.length(); i = i + 2) {
			char x = handCard.charAt(i);
			char last = handCard.charAt(i - 2);
			if (SUIT.indexOf(x) == SUIT.indexOf(last)) {
				color++;
			} else if (x != last) {
				break;
			}
		}
		// 判断顺子的
		for (int i = 1; i < handCard.length(); i = i + 2) {
			week = week + handCard.substring(i, i + 1);
		}
		// 判断同花顺，同花，顺子
		if (color == 5 && WEEK.contains(week)) {
			return 1;
		} else if (color == 5 && (!WEEK.contains(week))) {
			return 4;
		} else if (color != 5 && WEEK.contains(week)) {
			return 5;
		}
		// 判断同week出现的次数
		int maxTimes=1;
		for (int i = 1; i < week.length(); i++) {
			//how?????
		}
		return level;
	}
}

　　判断其他牌型，金刚，葫芦，三条，两对，一对，单牌

这里写了一个判断字符串中重复次数最多的字符和重复次数。。。。

感觉代码质量特别差，这里用的是hashMap，准备看看别人怎么处理的。

    String str="a112222233344444556";
		int count=1;
		char maxStr='*';
		HashMap hm = new HashMap();
		for(int i =1;i<str.length();i++){
			if(str.charAt(i)==str.charAt(i-1)){
				count++;
			}else if(i<str.length()-1){
				hm.put(str.charAt(i-1), count);
				count=1;
			}else if(i==str.length()-1){
				hm.put(str.charAt(i), count);
				count=0;
			}
		}
		for(Object key:hm.keySet()){
			int value=(Integer) hm.get(key);
			if(value>count){
				count=value;
				maxStr=(Character) key;
			}
		}
		System.out.println("出现最多的字符是："+maxStr+"count:"+count);

　　没有看别人的代码，修改了一下赋值逻辑

		String str="a112222233344444556";
		int countMax=1;
		int count=1;
		char maxchar=str.charAt(0);
		for(int i =1;i<str.length();i++){
			//计算count,将第一个count和char赋值给max
			if(str.charAt(i)==str.charAt(i-1)){
				count++;
			}else if(count>countMax){
				countMax=count;
				maxchar=str.charAt(i-1);
				count=1;
			}else{
				count=1;
			}
		}
		System.out.println("出现最多的字符是："+maxchar+",countMax:"+countMax);

　　同level的比牌没有完成：

package chapter6;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

import org.omg.Messaging.SyncScopeHelper;

/**
 * @param WEEK
 *            牌面数值
 * @param suit
 *            花色
 * @param poker[]
 *            扑克牌字符串数组
 */
class Stud {
	public final static int CARD_NO = 52;
	public final static String WEEK = "A23456789TJQK";
	public final static String SUIT = "♠♥♦♣";

	/**
	 * 返回 {@code ArrayList}是初始化的牌面，
	 *
	 * @return ArrayList 为初始化赋值的牌面
	 */
	public ArrayList initPokerCard() {
		ArrayList poker = new ArrayList();
		for (int j = 0; j < SUIT.length(); j++) {
			for (int k = 0; k < WEEK.length(); k++) {
				poker.add(SUIT.substring(j, j + 1) + WEEK.substring(k, k + 1));
			}
		}
		return poker;
	}

	/**
	 * 返回 {@code ArrayList}是洗牌后的牌面结果， 给一个[0,52)的随机数,然后从给定的牌里面，按照随机数取出来，add给新牌面
	 * 并将旧牌面的该随机数的牌remove
	 *
	 * @param pokercard
	 *            a {@code ArrayList} value.
	 * @return 将poker洗牌后的结果
	 */
	public ArrayList shuffleCard(ArrayList poker) {
		ArrayList al = new ArrayList();
		while (poker.size() > 0) {
			int randomNum = (int) Math.floor(Math.random() * (poker.size()));
			al.add(poker.get(randomNum));
			poker.remove(randomNum);
		}
		return al;
	}

	/**
	 * 返回 {@code String}发给玩家的手牌,并更新玩家手牌
	 *
	 * @param poker
	 *            参数是用来发牌的公牌
	 *
	 */
	public String handCard(ArrayList poker, Player player) {
		String newCard = (String) poker.get(0);// 发过来的牌
		String handCard = player.getCard();// 本来的牌
		System.out.println("NEW：" + newCard + ",handCard:" + handCard);
		int newIndex = WEEK.indexOf(newCard.charAt(1));
		if (handCard.equals("")) {
			handCard = newCard;
			player.setCard(handCard);

			System.out.println("handCard:" + handCard);
			return handCard;
		} else {
			for (int i = 1; i < handCard.length(); i = i + 2) {
				if (newIndex <= WEEK.indexOf(handCard.charAt(i))) {
					handCard = handCard.substring(0, i - 1) + newCard + handCard.substring(i - 1, handCard.length());
					player.setCard(handCard);
					return handCard;
				} else if (newIndex > WEEK.indexOf(handCard.charAt(i)) && i == handCard.length() - 1) {
					handCard = handCard + newCard;
					player.setCard(handCard);
					return handCard;
				}
			}
		}
		return handCard;
	}

	/**
	 * {@code ArrayList}将第一张牌移除，返回剩余的牌面
	 *
	 * @param poker
	 *            当前剩余公牌 模拟发牌
	 */
	public ArrayList restCard(ArrayList poker) {
		poker.remove(0);
		return poker;
	}

	/**
	 * 比牌
	 */
	public Player judge(HashMap player) {
		Player winner = (Player) player.get(0);
		// 遍历，如果第一个大，就将第一个和第N个的位置调换
		for (int i = 1; i < player.size(); i++) {
			Player next = (Player) player.get(i);
			// 比较两者，如果手牌next>winner ,返回true,反之，返回false
			if (compare(next.getCard(), winner.getCard())) {
				winner = next;
			}
		}
		return winner;
	}

	/**
	 * 默认值是false，如果a的牌更大，就将player置为b
	 *
	 * @param 用来比较的牌
	 * @param 当前的winner的牌
	 * @return 前者比后者大，返回true，否则返回false
	 */
	public Boolean compare(String handCardA, String handCardB) {
		Boolean flag = false;
		// 先判断牌面level，再判断牌面大小
		int levelA = levelOfCard(handCardA);
		int levelB = levelOfCard(handCardB);
		if (levelA > levelB) {
			return true;
		} else if (levelA < levelB) {
			return false;
		} else if(levelA==levelB) {
			//同牌型比牌：
			switch (levelA) {
			// 同花顺
			case 1:
			// 金刚
			case 2:
			// 葫芦
			case 3:
			// 同花
			case 4:
			// 顺子
			case 5:
				//other
			}
		}
		return flag;
	}

	public int levelOfCard(String handCard) {
		int level = 0;
		String week = "";
		if (handCard.length() > 10 || handCard.length() <= 0) {
			System.out.println("字符串长度异常");
			return -1;
		}
		int color = 1;
		// 判断同花的
		for (int i = 2; i < handCard.length(); i = i + 2) {
			char x = handCard.charAt(i);
			char last = handCard.charAt(i - 2);
			if (SUIT.indexOf(x) == SUIT.indexOf(last)) {
				color++;
			} else if (x != last) {
				break;
			}
		}
		// 判断顺子的
		for (int i = 1; i < handCard.length(); i = i + 2) {
			week = week + handCard.substring(i, i + 1);
		}
		// 判断同花顺，同花，顺子
		if (color == 5 && WEEK.contains(week)) {
			System.out.println("同花顺");
			return 1;
		} else if (color == 5 && (!WEEK.contains(week))) {
			System.out.println("同花");
			return 4;
		} else if (color != 5 && WEEK.contains(week)) {
			System.out.println("顺子");
			return 5;
		}
		// 判断同week出现的次数
		int countMax=1;
		int count=1;
		char maxchar=week.charAt(0);
		for(int i =1;i<week.length();i++){
			//计算count,将第一个count和char赋值给max
			if(week.charAt(i)==week.charAt(i-1)){
				count++;
			}else{
				count=1;
			}
			if(count>countMax){
				countMax=count;
				maxchar=week.charAt(i-1);
			}
		}
			if(countMax ==4){
				System.out.println("金刚");
				return 2;
			}else if(countMax ==3){
				String str = maxchar+"";
				String [] str2=week.split(str);
				str="";
				for(String s:str2){
					str=str+s;
				}
				if(getMaxCount(str)==2){
					System.out.println("葫芦");
					return 3;
				}else{
					System.out.println("三条");
					return 6;
				}
			}else if(countMax==2){
				String str = maxchar+"";
				String [] str2=week.split(str);
				str="";
				for(String s:str2){
					str=str+s;
				}
				if(getMaxCount(str)==2){
					System.out.println("两对");
					System.out.println("str:"+str);
					return 7;
				}else {
					System.out.println("一对");
					System.out.println("str:"+str);
					return 8;
				}
			}else if(countMax==1){
				System.out.println("散牌");
				return 9;
			}
		return level;
	}

	private int getMaxCount(String week) {
		int countMax=1;
		int count=1;
//		char maxchar=handCard.charAt(0);
		for(int i =1;i<week.length();i++){
			//计算count,将第一个count和char赋值给max
			if(week.charAt(i)==week.charAt(i-1)){
				count++;
			}else if(count>countMax){
				countMax=count;
//				maxchar=handCard.charAt(i-1);
				count=1;
			}else{
				count=1;
			}
		}
		return countMax;
	}
}

/**
 * @author zhizhiyin
 * @param name
 *            玩家名字；
 * @param position
 *            玩家位置；
 * @param fold
 *            是否弃牌，默认false不弃牌；
 * @param card
 *            玩家手牌
 */
class Player {
	private String name;
	private String card = "";
	private boolean fold = false;// 弃牌

	public String getCard() {
		return card;
	}

	public void setCard(String card) {
		this.card = card;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		if (name.length() >= 1 && name.length() <= 4) {
			this.name = name;
			return;
		} else {
			System.out.println("name长度须在1~4之间");
		}
	}

	public boolean getFold() {
		return fold;
	}

	public void setFold(boolean fold) {
		this.fold = fold;
	}

	// 创建玩家，如果只需要五个玩家呢？怎么给这些玩家初始化呢？
	/**
	 * @param name
	 *            玩家的名字
	 * @param positioni
	 *            玩家的位置
	 */
	public Player(String name) {
		setName(name);
	}

	/**
	 * @param player
	 *            需要切换成弃牌状态的玩家
	 * @method turnFold(player)
	 *         如果用户未弃牌，置状态为弃牌，返回true，如果用户已经弃牌，置状态为false，表示转换失败，该用户已是弃牌状态
	 */
	public boolean turnFold() {
		if (this.getFold() == false) {
			this.setFold(true);
			System.out.println("该玩家弃牌");
			return true;
		} else {
			return false;
		}
	}
}

public class TestStud {
	public static void main(String[] args) {

		int playerNo = 5;

		Stud s = new Stud();
		ArrayList poker = s.initPokerCard();
		poker = s.shuffleCard(poker);

		HashMap player = new HashMap();
		for (int i = 0; i < playerNo; i++) {
			String name = "玩家" + i;
			player.put(i, new Player(name));
		}

		int flopNo = 1;// 轮次
		Boolean flag = false;

		while (!flag) {
			for (int i = 0; i < player.size(); i++) {
				Player currentPlayer = (Player) player.get(i);
				if (player.size() == 1) {
					System.out.println("当前仅有一个玩家:" + currentPlayer.getName() + "，game over");
					flag = true;
					break;
				}
				s.handCard(poker, currentPlayer);
				poker = s.restCard(poker);
				System.out.println("当前余牌：" + poker); // 跟弃
				System.out.println(currentPlayer.getName() + "的手牌：" + currentPlayer.getCard());
				System.out.println("当前玩家是否弃牌？Y/N");
				Scanner input = new Scanner(System.in);
				String str = input.next();
				if (str.equals("Y")) { // 弃牌
					currentPlayer.turnFold();
					player.remove(i);
				}
			}

			if (flopNo == 5) {
				System.out.println("进入比牌");
				for(Object key :player.keySet()){
					Player p =(Player)player.get(key);
					System.out.println(p.getCard());
					System.out.println(s.levelOfCard(p.getCard()));
				}
//				s.judge(player);
				flag = true;
				break;
			}
			flopNo = flopNo + 1;
		}

	}
}