Java 井字棋小结

1.井字棋获胜的四种情况

横行全为同一符号
竖行全为同一符号
斜对角线为同一符号
反对角线为同一符号

2.编程思路

构建数组(二维)读入数据

分四个部分，分别判断横行，竖行，对角线，反对角线是否满足条件

输出结果，存在两种情况，有胜负，无胜负

3.上代码

 import java.util.Scanner;
 public class 井字棋 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        int size = 3;
        int [][] board = new int[3][3];
        boolean getresult = false;
        int xnum = 0;
        int ynum = 0;
        
        for(int i=0;i<board.length;i++)
        {
              //内层循环的board[i].length是防止索引超出范围，若是j.length会出现board[3].length的情况
            for(int j=0;j<board[i].length;j++)
            {
                
                board[i][j] = in.nextInt();
                
                
            }
            
            
        
        }
        for(int i=0;i<board.length;i++)
        {
            for(int j=0;j<board[i].length;j++)
            {
                
                if (board[i][j] == 1)
                {
                    
                    xnum += 1;
        
                }
                else
                {
                    
                    ynum += 1;
                    
                }
                
                
                    
                }
                if(xnum ==3|| ynum==3)
                {
                    getresult = true;
                    break;
                    
                }
                xnum = 0;

                ynum = 0;
          //初始化计数，防止到下一行叠加
            }
            
    //  判断竖行
        if(!getresult)
        {   for(int j=0;j<board.length;j++)
            {
                for(int i=0;i<board.length;i++)
                
                {
                    
                    if (board[i][j] == 1)
                    {
                        
                        xnum += 1;
            
                    }
                    else
                    {
                        
                        ynum += 1;
                        
                    }
                    
                    
                        
                    }
                    if(xnum ==3|| ynum==3)
                    {
                        getresult = true;
                        break;
                        
                    }
                    xnum = 0;
                    ynum = 0;
                }
        }

     // 判断斜对角       
        if(!getresult)
        {
            for(int i=0;i<board.length;i++)
            {
                for(int j=0;j<board[i].length;j++)
                {
                    
                    if(i==j)
                    {
                        
                        if(board[i][j]==1)
                        {
                            xnum += 1;
                            
                            
                        }
                        else
                        {
                            ynum += 1;
                        }
                    }
                    
                }
                if(xnum ==3|| ynum==3)
                {
                    getresult = true;
                    break;
                    
                }
            
            
            }
            
        }
        
     //判断反斜对角线
        if(!getresult)
        {
            for(int i=0;i<board.length;i++)
            {
                for(int j=0;j<board[i].length;j++)
                {
                    
                    if(i+j==2)
                    {
                        
                        if(board[i][j]==1)
                        {
                            xnum += 1;
                            
                            
                        }
                        else
                        {
                            ynum += 1;
                        }
                    }
                    
                }
                if(xnum ==3|| ynum==3)
                {
                    getresult = true;
                    break;
                    
                }
                
            
            }
        }
            
        if(getresult)
        {
            
            if(xnum ==3)
            {
                System.out.println("x");
            }
            else
            {
                System.out.println("o");
            }
                
            
        }
        else
        {
            System.out.println("NO");
        }
    
    }

}

4.小结

遍历二维数组时可以让第二维度的j放到外循环，从而达到控制列不变行变

数据处理过后要考虑数据的初始化，以防下次处理数据造成数据叠加

可以定义一个布尔值来判断是否达成条件，分隔不同的程序情况