数组

 棋子输赢判断还有一些欠缺，以后会及时补进。

import java.io.*;
public class Chessboard {

    /**
     * @param args
     */
    private String[][] board;
    private static int Size=10;//棋盘大小
    public void initBoard()//初始化棋盘
    {
        board=new String[Size][Size];
        for(int i=0;i<Size;i++)
        {
            for(int j=0;j<Size;j++)
            {
                board[i][j]="+";
            }
        }
    }
    public void printBoard()//打印棋盘
    {
        for(int i=0;i<Size;i++)
        {
            for(int j=0;j<Size;j++)
            {
                System.out.print(board[i][j]);
            }
            System.out.print("
");
        }
        
    }
    public static int computerPos()
    {
            int cPos;
            cPos=1+(int)(Math.random()*9);
            return cPos;
    }
    
    public static void main(String[] args)throws Exception
    {
        // TODO Auto-generated method stub

        Chessboard test=new Chessboard();
        test.initBoard();
        test.printBoard();
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String inputStr=null;
        System.out.println("请输入棋子的位置（以x，y的形式）");
        while((inputStr=br.readLine())!=null)
        {
            //用户棋子位置
            String[] posStrArr=inputStr.split(",");
            int xPos=Integer.parseInt(posStrArr[0]);
            int yPos=Integer.parseInt(posStrArr[1]);
            test.board[xPos-1][yPos-1]="●";
            //电脑棋子位置
            int arr[]=new int[2];
            for(int i=0;i<2;i++)
            {
                arr[i]=computerPos();
            }
            if(test.board[arr[0]][arr[1]]!="●"&&test.board[arr[0]][arr[1]]!="o")
            {
                test.board[arr[0]][arr[1]]="o";
            }
            else
            {
                for(int i=0;i<2;i++)
                {
                    arr[i]=computerPos();
                }
                test.board[arr[0]][arr[1]]="o";
            }
            //判断输赢
            int judgeUser=0;//满5用户胜利
            int judgeComputer=0;//满5电脑胜利
            //纵向判断
            for(int i=0;i<Size-1;i++)
            {
                for(int j=0;j<Size-1;j++)
                {
                    if(test.board[i][j]==test.board[i][j+1])
                    {
                        if(test.board[i][j].equals("●"))
                        {
                            judgeUser++;
                            
                        }
                        if(test.board[i][j].equals("o"))
                        {
                            judgeUser++;
                            
                        }
                    }
                }
                if(judgeUser==5)
                {
                    System.out.println("用户胜利");
                    break;
                }
                if(judgeComputer==5)
                {
                    System.out.println("电脑胜利");
                    break;
                }
                //如果一次判断中棋子没有连续5个，清零，重新计数
                if(judgeUser!=5)
                {
                    judgeUser=0;
                }
                if(judgeComputer!=5)
                {
                    judgeComputer=0;
                }
            }
            //横向判断
            for(int i=0;i<Size-1;i++)
            {
                for(int j=0;j<Size-1;j++)
                {
                    if(test.board[j][i]==test.board[j+1][i])
                    {
                        if(test.board[i][j].equals("●"))
                        {
                            judgeUser++;
                            
                        }
                        if(test.board[i][j].equals("o"))
                        {
                            judgeUser++;
                            
                        }
                    }
                }
                if(judgeUser==5)
                {
                    System.out.println("用户胜利");
                    break;
                }
                if(judgeComputer==5)
                {
                    System.out.println("电脑胜利");
                    break;
                }
                //如果一次判断中棋子没有连续5个，清零，重新计数
                if(judgeUser!=5)
                {
                    judgeUser=0;
                }
                if(judgeComputer!=5)
                {
                    judgeComputer=0;
                }
            }
            //斜向判断
            for(int i=0;i<Size-1;i++)
            {
                for(int j=0;j<Size-1;j++)
                {
                    if(test.board[i][j]==test.board[i+1][j+1])
                    {
                        
                            if(test.board[i][j].equals("●"))
                            {
                                judgeUser++;
                                
                            }
                            if(test.board[i][j].equals("o"))
                            {
                                judgeComputer++;
                                
                            }
                        
                    }
                }
                if(judgeUser==5)
                {
                    System.out.println("用户胜利");
                    break;
                }
                if(judgeComputer==5)
                {
                    System.out.println("电脑胜利");
                    break;
                }
                //如果一次判断中棋子没有连续5个，清零，重新计数
                if(judgeUser!=5)
                {
                    judgeUser=0;
                }
                if(judgeComputer!=5)
                {
                    judgeComputer=0;
                }
            }
                
            test.printBoard();
            System.out.println("请输入棋子的位置（以x，y的形式）");
            if(judgeUser==5||judgeComputer==5)
            {
                System.out.println("游戏结束");
                break;
            }
        }
    }

}

运行结果截图：

import java.util.*;
public class ChineseNum {

    /**
     * @param args
     */
    private static String[] ChArr={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
    private static String[] UnitArr={"十","百","千","万","十万","百万","千万","亿"};
    private static String intoChStr(String numStr)
    {
        String result="";
        int numL=numStr.length();
        for(int i=0;i<numL;i++)
        {
            int num=numStr.charAt(i)-48;
            if(i!=numL-1&&num!=0)
            {
                result=result+ChArr[num]+UnitArr[numL-2-i];
            }
            else
            {
                if(result.length()>0&&ChArr[num].equals("零")&&result.charAt(result.length()-1)=='零')
                    continue;
                result=result+ChArr[num];
            }
        }
        if(result.length()==1) return result;
        int index=result.length()-1;
        while(result.charAt(index)=='零')
        {
            index--;
        }
        if(index!=result.length()-1)
            return result.substring(0,index+1);
        else
            return result;
    }
    
    
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        ChineseNum test=new ChineseNum();
        Scanner in=new Scanner(System.in);
        String Usernum;
        System.out.println("任意输入一个数字（最大位数在亿以内）");
        Usernum=in.next();
        System.out.println(Usernum+"的汉语表示为"+intoChStr(Usernum));
    }

}

运行结果截图：

 

import java.util.*;
public class Rmb {

    /**
     * @param args
     */
    
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        System.out.println("输入一个钱数：");
        double a;
        a=in.nextDouble();
        System.out.println(digitUppercase(a));
        }
        public static String digitUppercase(double n) { 
        String fraction[] = { "角", "分"}; 
        String digit[] = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"}; 
        String unit[][] = { { "元", "万", "亿"}, { "", "拾", "佰", "仟"}}; 

        String head = n < 0 ? "负" : ""; 
        n = Math.abs(n); 

        String s = ""; 
        for (int i = 0; i < fraction.length; i++) { 
        s += (digit[(int) (Math.floor(n * 10 * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", ""); 
        } 
        if (s.length() < 1) { 
        s = "整"; 
        } 
        int integerPart = (int) Math.floor(n); 

        for (int i = 0; i < unit[0].length && integerPart > 0; i++) { 
        String p = ""; 
        for (int j = 0; j < unit[1].length && n > 0; j++) { 
        p = digit[integerPart % 10] + unit[1][j] + p; 
        integerPart = integerPart / 10; 
        } 
        s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i] + s; 
        } 
        return head + s.replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整"); 
        }
    }

运行结果截图：

import javax.swing.JOptionPane;

public class TenRandom {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int arr[]=new int[10];
        int rand;
        int sum=0;
        String result="";
        for(int i=0;i<10;i++)
        {
            rand=1+(int)(Math.random()*100);
            arr[i]=rand;
            sum=sum+arr[i];
            result=result+arr[i]+" ";
        }
        String sumup="";
        sumup=sumup+sum;
        JOptionPane.showMessageDialog(null,result,"Ten random numbers",JOptionPane.INFORMATION_MESSAGE);
        JOptionPane.showMessageDialog(null,sumup,"Ten random numbers`s sum",JOptionPane.INFORMATION_MESSAGE);


运行结果截图：

 设计思路：

定义一个长度为10的数组，用来存放随机数。再定义一个String类型变量result用来记录所有随机数，int类型变量sum用来随机数求和，最后输出。

程序流程图：

import java.util.*;
public class BigNum {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner in=new Scanner(System.in);
        System.out.println("输入两个大数");
        String s1=in.next();
        String s2=in.next();
        System.out.println(add(s1,s2));
        System.out.println(sub(s1,s2));

        }

        private static String add(String s1, String s2) 
        { 
        System.out.print("加法:" + s1+ "+" + s2 + "=");
        char[] aa = new StringBuffer(s1).reverse().toString().toCharArray(); 
        char[] bb = new StringBuffer(s2).reverse().toString().toCharArray(); 
        int aLen = aa.length; 
        int bLen = bb.length; 

        int len = aLen > bLen ? aLen : bLen; 

        int[] result = new int[len + 1]; 
        for (int i = 0; i < len + 1; ++i) { 
        int aint = i < aLen ? aa[i] - '0' : 0; 
        int bint = i < bLen ? bb[i] - '0' : 0; 
        result[i] = aint + bint; 
        } 

        for(int i=0;i<result.length-1;++i){ 
        if(result[i]>=10){ 
        result[i+1] += result[i]/10; 
        result[i] %= 10; 
        } 
        } 

        boolean flag = true; 
        StringBuffer sb = new StringBuffer(len); 
        for(int i=len;i>=0;--i){ 
        if(result[i]==0&&flag){ 
        continue; 
        }else{ 
        flag=false; 
        } 
        sb.append(result[i]); 
        } 
        return sb.toString(); 
        } 
        public static String sub(String s1, String s2) { 
        System.out.print("减法:" + s1 + "-" + s2 + "="); 
        // 将字符串翻转并转换成字符数组 
        char[] a = new StringBuffer(s1).reverse().toString().toCharArray(); 
        char[] b = new StringBuffer(s2).reverse().toString().toCharArray(); 
        int lenA = a.length; 
        int lenB = b.length; 
        // 找到最大长度 
        int len = lenA > lenB ? lenA : lenB; 
        int[] result = new int[len]; 
        // 表示结果的正负 
        char sign = '+'; 
        // 判断最终结果的正负 
        if (lenA < lenB) { 
        sign = '-'; 
        } else if (lenA == lenB) { 
        int i = lenA - 1; 
        while (i > 0 && a[i] == b[i]) { 
        i--; 
        } 
        if (a[i] < b[i]) { 
        sign = '-'; 
        } 
        } 
        // 计算结果集，如果最终结果为正，那么就a-b否则的话就b-a 
        for (int i = 0; i < len; i++) { 
        int aint = i < lenA ? (a[i] - '0') : 0; 
        int bint = i < lenB ? (b[i] - '0') : 0; 
        if (sign == '+') { 
        result[i] = aint - bint; 
        } else { 
        result[i] = bint - aint; 
        } 
        } 
        // 如果结果集合中的某一位小于零，那么就向前一位借一，然后将本位加上10。其实就相当于借位做减法 
        for (int i = 0; i < result.length - 1; i++) { 
        if (result[i] < 0) { 
        result[i + 1] -= 1; 
        result[i] += 10; 
        } 
        } 

        StringBuffer sb = new StringBuffer(); 
        // 如果最终结果为负值，就将负号放在最前面，正号则不需要 
        if (sign == '-') { 
        sb.append('-'); 
        } 
        // 判断是否有前置0 
        boolean flag = true; 
        for (int i = len - 1; i >= 0; i--) { 
        if (result[i] == 0 && flag) { 
        continue; 
        } else { 
        flag = false; 
        } 
        sb.append(result[i]); 
        } 
        // 如果最终结果集合中没有值，就说明是两值相等，最终返回0 
        if (sb.toString().equals("")) { 
        sb.append("0"); 
        } 
        // 返回值 
        System.out.println(sb.toString()); 
        return sb.toString(); 
    }

}

运行结果截图：