定義一個類，該類用於封裝一桌梭哈遊戲，這個類應該包含桌上剩下的牌的資訊，幷包含5個玩家的狀態資訊：他們各自的位置，遊戲狀態（正在遊戲或已放棄）、手上已有的牌等資訊。如果有可能，這個類還應該實現發牌方法，這個方法需要控制從誰開始發牌，不要發牌給放棄的人，並修改桌上剩下的牌。
一些思路：
1.發牌前先洗牌，可以呼叫Collections.shuffle(List)。預設撲克的一種有序的排列，然後進行編號，將這52個編號打亂，在找到對應的撲克。
2.發牌按照座位號的順序，玩家隨意入座。考慮到放棄遊戲的玩家將不會發到牌，庫頂的牌需要做“歸位”處理。
3.五張牌的組合判斷：同花和順子的判斷較為簡單，對於兩對，三對這類的組合只需要統計重複撲克的次數即可，方法同“判斷陣列中各元素出現的次數”，可參考

https://blog.csdn.net/haiyoung/article/details/49006361

程式碼如下：

import java.util.*;

public class Stud {
	private static final int ROYAL_FLUSH = 10;
	private static final int SRTAIGHT_FLUSH = 9;
	private static final int FOUR = 8;
	private static final int FULLHOUSE = 7;
	private static final int
 
 FLUSH = 6;
	private static final int STRAIGHT = 5;
	private static final int THREE = 4;
	private static final int TWO_PAIRS = 3;
	private static final int ONE_PAIRS = 2;
	private static final int ZILCH = 1;
	private static final int GIVE_UP = 0;
	private static final int PLAYER_ALL = 5;
	//0:♠ 1:♣ 2:♥ 3:♦
 

	public static String[] sPoker = new String[52];  //after shuffle
	private static int topcard = 0;
	private static int top = 0;
	private static int dealTimes = 0;
	private static int seatStart = 0;  // 0~4
	private static int rounds = 1;
	private static int space = 0;
	private static int[] winner = new int[5];
	
	private class Player {
		String pName;
		boolean state = true;
		String[] handPoker = new String[5];
		int[] handPokerNum = new int[5];
		char[] handPokerColor = new char[5];
	}
	static Player seat[] = new Player[PLAYER_ALL];

	//Initialization
	public void studInit() {
		String[][] Poker = new String[4][13];
		String[] color = {"♠", "♣", "♥", "♦"};
		String[] num = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
		String[] name = {"player1", "player2", "player3", "player4", "player5"};
		
		for(int i =0 ; i < PLAYER_ALL; i++) {
			seat[i] = new Player();
		}
		
		for (int i = 0; i <4; i++) {
			for (int j = 0; j <13; j++) {
				Poker[i][j] = color[i]+num[j];
			}
		}
		//Shuffle
		List<Integer> cardList = new ArrayList<Integer>();
		for (int i = 0; i < 52; i++) {
			cardList.add(i+1);
		}
		Collections.shuffle(cardList);
		//exchange list to poker
		for (int n = 0; n < 52; n++) {
			sPoker[n] = Poker[(cardList.get(n)-1)/13][(cardList.get(n)-1)%13];
			System.out.print(sPoker[n]+" ");
			}
		System.out.print("\n");
		//take a seat
		List<Integer> pList = new ArrayList<Integer>();
		for (int i = 0; i < PLAYER_ALL; i++) {
			pList.add(i);
		}
		Collections.shuffle(pList);
		for (int n = 0; n < PLAYER_ALL; n++) {
			seat[n].pName = name[pList.get(n)];
		}
		}
	
	public void match(Player p, int k) {
		switch(p.handPoker[k].charAt(1)) {
		case 'A' :
			p.handPokerNum[k] = 1;
			break;
		case 'J' :
			p.handPokerNum[k] = 11;
			break;
		case 'Q' :
			p.handPokerNum[k] = 12;
			break;
		case 'K' :
			p.handPokerNum[k] = 13;
			break;
			default :
				p.handPokerNum[k] =(int)(p.handPoker[k].charAt(1)) - 48;
		}
	}
	//deal cards 存在放棄的玩家，需要space對topcard進行“歸位”
	public void deal(int sStrat) {
		sStrat = seatStart;
		for(int i = 0; i < PLAYER_ALL; i++) {
			top = topcard - space;
			switch(topcard%5) {
			case 0:
				if(seat[sStrat%5].state) {
					seat[sStrat%5].handPoker[dealTimes] = sPoker[top];
					seat[sStrat%5].handPokerColor[dealTimes] = seat[sStrat%5].handPoker[dealTimes].charAt(0);
					match(seat[sStrat%5], dealTimes);
				}
				else space ++;
				break;
			case 1:
				if(seat[(sStrat+1)%5].state) {
					seat[(sStrat+1)%5].handPoker[dealTimes] = sPoker[top];
					seat[(sStrat+1)%5].handPokerColor[dealTimes] = seat[(sStrat+1)%5].handPoker[dealTimes].charAt(0);
					match(seat[(seatStart+1)%5], dealTimes);
				}
				else space ++;
				break;
			case 2:
				if(seat[(sStrat+2)%5].state) {
					seat[(sStrat+2)%5].handPoker[dealTimes] = sPoker[top];
					seat[(sStrat+2)%5].handPokerColor[dealTimes] = seat[(sStrat+2)%5].handPoker[dealTimes].charAt(0);
					match(seat[(sStrat+2)%5], dealTimes);
				}
				else space ++;
				break;
			case 3:
				if(seat[(sStrat+3)%5].state) {
					seat[(sStrat+3)%5].handPoker[dealTimes] = sPoker[top];
					seat[(sStrat+3)%5].handPokerColor[dealTimes] = seat[(sStrat+3)%5].handPoker[dealTimes].charAt(0);
					match(seat[(sStrat+3)%5], dealTimes);
				}
				else space ++;
				break;
			case 4:
				if(seat[(sStrat+4)%5].state) {
					seat[(sStrat+4)%5].handPoker[dealTimes] = sPoker[top];
					seat[(sStrat+4)%5].handPokerColor[dealTimes] = seat[(sStrat+4)%5].handPoker[dealTimes].charAt(0);
					match(seat[(sStrat+4)%5], dealTimes);
				}
				else space ++;
				break;
			}
			topcard ++;
		}
		dealTimes++;
	}
	//STRAIGHT
	public boolean jStraight(Player p) {
		//Sort
		boolean flag = false;
		Arrays.sort(p.handPokerNum);
		for (int i = 0; i < p.handPokerNum.length-1; i++) {
			if(p.handPokerNum[i]+1 == p.handPokerNum[i+1])
				flag = true;
			else {
				flag = false;
				break;
			}
		}
		return flag;
	}
	//FLUSH
	public boolean jFlush(Player p) {
		boolean flag = false;
		for (int i = 0; i < p.handPokerColor.length-1; i++) {
			if(p.handPokerColor[i] == p.handPokerColor[i+1])
				flag = true;
			else {
				flag = false;
				break;
			}
		}
		return flag;
	}
	// FOUR, FULLHOUSE, THREE, TWO_PAIRS, ONE_PAIRS
	public int repetition(Player p) {
		int reFour = 0;
		int reThree = 0;
		int reTwo= 0;
		HashMap<Integer, Integer> pokers = new HashMap<Integer, Integer>();
		for(int num : p.handPokerNum) {
			Integer key = pokers.get(num);
			pokers.put(num, key == null ? 1 : key+1);
		}
		Iterator<Integer> itr = pokers.keySet().iterator();
		while(itr.hasNext()) {
			Object key = itr.next();
			if(pokers.get(key) == 4) {
				reFour ++;
				break;
			}
			else if(pokers.get(key) == 3)
				reThree ++;
			else if(pokers.get(key) ==2)
				reTwo ++;
		}
		if(reFour == 1) return FOUR;
		if(reThree == 1 && reTwo == 1) return FULLHOUSE;
		if(reThree == 1 && reTwo == 0) return THREE;
		if(reTwo == 2) return TWO_PAIRS;
		if(reThree == 0 && reTwo ==1) return ONE_PAIRS;
		else return ZILCH;
	}
	
	public int type(Player p) {
		int TYPE = 0;
		if(p.state) {
			if(jStraight(p)) {
				if(jFlush(p)) {
					if(p.handPokerNum[0] == 1)
						TYPE = ROYAL_FLUSH;
					else
						TYPE = SRTAIGHT_FLUSH;
				}
				else TYPE = STRAIGHT;
			}
			else if(jFlush(p)) TYPE = FLUSH;
			else TYPE = repetition(p);
			return TYPE;
		}
		else return GIVE_UP;
	}
	
	//其他輔助函式
	public char[] change(String str) {
		String s;
		s = str.replace(" ", "");   //刪除字串中的空格
		char[] stringArr = s.toCharArray();  //字串轉換為陣列
		return stringArr;
	}
	public int max(int data[]) {
		int m = 0;
		for (int i = 0; i < data.length; i++)
		{
			if(m < data[i]) m= data[i];
		}
		return m;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Stud s = new Stud();
		s.studInit();
		Scanner in = new Scanner(System.in);
		System.out.println("=======5人梭哈遊戲=======");
		System.out.print("隨機分配座位... 回車開始遊戲");
		while(in.nextLine() == null);
		for (int i = 0; i < PLAYER_ALL; i++) {
			System.out.print(" || "+(i+1)+"號座位: "+seat[i].pName+" || ");
		}
		System.out.println();
		//以下不考慮輸入錯誤
		System.out.print("確認從幾號座位開始發牌（輸入1~5）：");
		int sSt = 0;
		sSt = in.nextInt();
		seatStart = sSt  
 

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
瘋狂Java講義第六章下“梭哈遊戲練習”
     
  
  
  
 定義一個類，該類用於封裝一桌梭哈遊戲，這個類應該包含桌上剩下的牌的資訊，幷包含5個玩家的狀態資訊：他們各自的位置，遊戲狀態（正在遊戲或已放棄）、手上已有的牌等資訊。如果有可能，這個類還應該實現發牌方法，這個方法需要控制從誰開始發牌，不要發牌給放棄的人，並修改桌上剩下的牌。 一些思路： 1.發 

  
 

    

    
    
瘋狂java 講義第三章練習題---畫圓
     
 
                
public class PaintRound{
    /**
     * @author Dream_e.
     * @version  v1.0
     */
    private int r;//圓的半徑
    PaintRound(int r){
   

  
 

    

    
    
瘋狂JAVA講義第三章練習
     
 
                

3.1使用迴圈輸出九九乘法表
public class Exam3_1 {
     public static voidmain(String args[])
     {
          for(int i=1;i<10; i++)
         {
  

  
 

    

    
    
讀書筆記（二）瘋狂JAVA講義  第四章 控制迴圈與陣列
     
 
                
流程控制比較簡單，沒有什麼可寫的，但有些地方需要注意。
※ 使用if...else語句時，一般先處理包含範圍更小的情況。
4.2.2  Java 7的switch語句
switch語句由一個控制表示式和多個case標籤組成，和if語句不同的是，switch語句後面的控制表示 

  
 

    

    
    
java基礎學習（6）瘋狂java講義第5章課後習題解答原始碼
     
 
								
								            
							
							
							1



class Students{
    // define member variable
    private int age;
    private String name,gende 

  
 

    

    
    
Java瘋狂講義第六章習題之"定義一個介面，並使用匿名內部類方式建立介面的例項""
     
 
                //定義一個介面，並使用匿名內部類方式建立介面的例項// Graph.javapublic interface Graph{void draw();}// Triangle.javaclass Triangle implements Graph{public void dra 

  
 

    

    
    
Java基礎-第六章(面向物件5)
     
 
							
							
							一、介面



(一) 介面的定義和使用

多個抽象類的抽象就是介面。 
在Java中最小的程式單元就是類，介面其實是一個特殊的類。 
Java中的介面表示規範，用於定義一組抽象方法，表示某一類事物必須具備的功能，要求實現類必須來實現介面並提供方法實現。

定義 

  
 

    

    
    
瘋狂Java講義(第3版)pdf
     
 
                

下載地址：網盤下載





前 言
編輯

Java語言贏得了前所未有的成功：從2001年到2007年，Java語言一直是世界上應用最廣泛的程式語言，因此越來越多的工作者、學習者正努力進入Java領域或將要努力進入Java領域。

為了幫助廣大 

  
 

    

    
    
Effective java筆記-第六章 列舉和註解
     
 
							
							
							列舉和註解



第30條 用enum代替int常量

int列舉模式的缺點：
1.無名稱空間，所以要加字首防止名稱衝突
2.int列舉是編譯時常量，一旦常量關聯的int值變化，就要重新編譯
3.沒有很好的列印字串的方法（有一種String列舉常量，但是效能不好 

  
 

    

    
    
《瘋狂Java講義（第4版）》-----第6章【面向物件（下）】（命令模式、Lambda、列舉類、垃圾回收、jar）
     
 
							
							
							命令模式
命令模式，參考下面程式碼，就能領悟到，想做出怎樣的處理，就怎麼去覆蓋介面中的抽象方法！下面程式碼中介面Command中定義一個對陣列處理的方法，但沒說怎麼處理（畢竟是抽象方法嘛），然後讓其他類來實現這個介面，順便實現這個介面的方法，他們按照何種方式實現 

  
 

    

    
    
《瘋狂Java講義（第4版）》-----第6章【面向物件（下）】（內部類）
     
 
							
							
							內部類
內部類就是定義在類內部的類，可以 是成員內部類（類的第五種成員，分為靜態內部類和非靜態內部類），也可以定義在方法內部（區域性內部類）。宿主類不能訪問內部類的成員。可以通過”靜態內部類名.靜態內部類靜態成員“和”內部類物件.內部類成員“來訪問
非靜態內部類 

  
 

    

    
    
《瘋狂Java講義（第4版）》-----第2章【UML】
     
 
								
								            
							
							
							UML(Unified Modeling Language)
PowerDesigner16.5建模工具提供了UML的如下12種圖

一、Use Case Diagram（用例圖）

用例圖用於描述系統 

  
 

    

    
    
《瘋狂Java講義（第4版）》-----第3章【資料型別與運算子】
     
 
							
							
							Java的官方API下載
Java語言是一門強型別語言。強型別含義：

所有變數必須先宣告，後使用；
指定型別的變數只能接受型別與之匹配的值

註釋
//單行註釋
/*
多行註釋
*/

/**
*文件註釋
*/

識別符號
字母、下劃線、美元符號、數字組成。字 

  
 

    

    
    
《瘋狂Java講義（第4版）》-----第4章【流程控制與陣列】
     
 
							
							
							Java7增強後的switch語句
switch後的控制表示式只能是byte、short、char、int、列舉型別和java.lang.String型別。
char c = 'A';
switch(c){
	case 'A':
		System.out.pri 

  
 

    

    
    
《瘋狂Java講義（第4版）》-----第7章【Java基礎類庫】
     
 
							
							
							筆者認為，《瘋狂Java講義（第4版）》這本書的前6章是Java語言的核心，前4章是結構化程式設計的核心，第5章和第6章是Java面向物件的核心。從第七章開始，都是在這些核心基礎知識上的擴充套件了，很多內容可以先熟悉一遍即可，用的時候多查本書以及多檢視官方文件即 

  
 

    

    
    
《瘋狂Java講義（第4版）》-----第8章【Java集合】（Collection、Iterator、Set）
     
 
							
							
							Java集合概述
Java集合本身是封裝的幾種常見的資料結構，只要學習過基本的資料結構課程，便可理解清楚底層的實現細節。由於Java提供封裝好的集合眾多，每個集合暴露的方法眾多，一般記住常用的，其他的知道有就行了，用的時候查詢官方API即可。
Java集合裡存放 

  
 

    

    
    
《瘋狂Java講義（第4版）》-----第8章【Java集合】（Map、Collections）
     
 
							
							
							Map

import java.util.Map;
import java.util.HashMap;

public class Hello{

	public static void main(String[] args){
		Map map = new 

  
 

    

    
    
《瘋狂Java講義（第4版）》-----第10章【異常處理】
     
 
							
							
							異常處理可以提高程式的健壯性、呈現功能給使用者更加友好。Java異常機制主要關鍵字：try、catch、finally、throw、throws。throws關鍵字在宣告方法時候使用，用於宣告該方法可能丟擲的異常。而throw關鍵字用於丟擲一個實際的異常。Jav 

  
 

    

    
    
《瘋狂Java講義（第4版）》-----第11章【AWT程式設計】（AWT常用元件、事件處理）
     
 
							
							
							AWT常用元件
雖說是常用元件，如果不經常使用，還是比較陌生的！！！暫且根據書本列出來一些，先結合書上例項認識之，待之後結合實際案例選擇用之、研究之（參看官方API）！
Button
Canvas（用於繪圖的畫布）
Checkbox
CheckboxGroup（ 

  
 

    

    
    
《瘋狂Java講義（第4版）》-----第18章【類的載入機制與反射】
     
  
 
  
  
 JVM程序終止的情況 
  
  程式執行到最後正常結束 
  程式執行到System.exit()或Runtime.getRuntime().exit() 
  程式執行過程中遇到未捕獲的異常或錯誤而結束 
  程式所在平臺強制結束了JVM程序 
  
 類的載入 
 下圖摘自《深入理