数组问题（课后作业）

一、动手动脑

　　1、qipan.java

　　　　(1)源代码　　　　　

package Guidang6;

import java.io.BufferedReader;
import java.io.InputStreamReader;
public class QiPan
{
    //定义一个二维数组来充当棋盘
    private String[][] board;
    //定义棋盘的大小
    private static int BOARD_SIZE = 15;
    public void initBoard()
    {
        //初始化棋盘数组
        board = new String[BOARD_SIZE][BOARD_SIZE];
        //把每个元素赋为"╋"，用于在控制台画出棋盘
        for (int i = 0 ; i < BOARD_SIZE ; i++)
        {
            for ( int j = 0 ; j < BOARD_SIZE ; j++)
            {
                board[i][j] = "╋";
            }
        }
    }
    //在控制台输出棋盘的方法
    public void printBoard()
    {
        //打印每个数组元素
        for (int i = 0 ; i < BOARD_SIZE ; i++)
        {
            for ( int j = 0 ; j < BOARD_SIZE ; j++)
            {
                //打印数组元素后不换行
                System.out.print(board[i][j]);
            }
            //每打印完一行数组元素后输出一个换行符
            System.out.print("
");
        }
    }
    public static void main(String[] args)throws Exception
    {
        QiPan gb = new QiPan();
        gb.initBoard();
        gb.printBoard();
        //这是用于获取键盘输入的方法
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String inputStr = null;
                System.out.println("请输入您下棋的座标，应以x,y的格式：");
        //br.readLine()：每当在键盘上输入一行内容按回车，刚输入的内容将被br读取到。
        while ((inputStr = br.readLine()) != null)
        {
            //将用户输入的字符串以逗号（,）作为分隔符，分隔成2个字符串
            String[] posStrArr = inputStr.split(",");
            //将2个字符串转换成用户下棋的座标
            int xPos = Integer.parseInt(posStrArr[0]);
            int yPos = Integer.parseInt(posStrArr[1]);
            //把对应的数组元素赋为"●"。
            gb.board[xPos - 1][yPos - 1] = "●";                
            /*
             电脑随机生成2个整数，作为电脑下棋的座标，赋给board数组。
             还涉及
                1.座标的有效性，只能是数字，不能超出棋盘范围
                2.如果下的棋的点，不能重复下棋。
                3.每次下棋后，需要扫描谁赢了
             */
            gb.printBoard();
            System.out.println("请输入您下棋的座标，应以x,y的格式：");
        }
    }
}

　　　　(2)、结果

　　　　　　　　　

　　　　(3)、流程

　　　　　　用for循环进行棋盘的输出，用二维数组，之后输入坐标，再进行替换。

二、汉化

　　（1）、数字转换成汉字的源代码

package Guidang6;

import java.util.Scanner;

public class Changnum {  
    public static void main(String[] args) {   
        Changnum t2r = new Changnum();  
        String s = t2r.cleanZero(t2r.numFormat((t2r.getNum())));  
        // 如果转换过后是一个空串，则不输出屏幕  
        if(!"".equals(s)) {  
            System.out.println("转换成中文后为：" + s);  
        }   
    }  
      
    private String getNum() {  
        String s = null;  
        System.out.println("请输入一个整数（非负数）：");  
        // 从命令行输入这个数  
        Scanner scanner = new Scanner(System.in);  
        s = scanner.next();  
        scanner.close();  
        return s;  
    }  

    private String numFormat( String s) {  
        int sLength = s.length();  
        // 货币大写形式  
        String bigLetter[] = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};  
        // 货币单位  
        String unit[] = {" ", "十", "百", "千", "万",  "十", "百", "千", "亿", "十", "百", "千", "万"};  
 
        // 用来存放转换后的新字符串  
        String newS = "";  
        // 逐位替换为中文大写形式  
        for(int i = 0; i < sLength; i ++) {  
            newS = newS + bigLetter[s.charAt(i) - 48] + unit[sLength - i - 1];  
        }
        return newS;  
    }  
    
    private String cleanZero(String s) {  
        // 如果传入的是空串则继续返回空串  
        if("".equals(s)) {  
            return "";  
        }  
        // 如果用户开始输入了很多 0 去掉字符串前面多余的'零'，使其看上去更符合习惯  
        while(s.charAt(0) == '零') {  
            // 将字符串中的 "零" 和它对应的单位去掉  
            s = s.substring(2);  
            // 如果用户当初输入的时候只输入了 0，则只返回一个 "零"  
            if(s.length() == 0) {  
                return "零";  
            }  
        }  
        // 字符串中存在多个'零'在一起的时候只读出一个'零'，并省略多余的单位  
        String regex1[] = {"零千", "零百", "零十"};  
        String regex2[] = {"零亿", "零万"};  
        String regex3[] = {"亿", "万"};   
        // 第一轮转换把 "零仟", 零佰","零拾"等字符串替换成一个"零"  
        for(int i = 0; i < 3; i ++) {  
            s = s.replaceAll(regex1[i], "零");  
        }  
        // 第二轮转换考虑 "零亿","零万","零元"等情况  
        // "亿","万","元"这些单位有些情况是不能省的，需要保留下来  
        for(int i = 0; i < 2; i ++) {  
            // 当第一轮转换过后有可能有很多个零叠在一起  
            // 要把很多个重复的零变成一个零  
            s = s.replaceAll("零零零", "零");  
            s = s.replaceAll("零零", "零");  
            s = s.replaceAll(regex2[i], regex3[i]);  
        }  

        // 当"万"到"亿"之间全部是"零"的时候，忽略"亿万"单位，只保留一个"亿"  
        s = s.replaceAll("亿万", "亿");  
        return s;  
    }  
} 

　　（2）、结果截图

　　　　

　　2、数字汉化成大写的汉字

　　　　（1）、源代码

package Guidang6;

import java.util.Scanner;

public class Changrmb {  
    public static void main(String[] args) {   
        Changrmb t2r = new Changrmb();  
        String s = t2r.cleanZero(t2r.splitNum(t2r.roundString(t2r.getNum())));  
        // 如果转换过后是一个空串，则不输出屏幕  
        if(!"".equals(s)) {  
            System.out.println("转换成中文后为：" + s);  
        }   
    }  
      
    private String getNum() {  
        String s = null;  
        System.out.println("请输入一个数字（非负数，精确到小数点后两位）：");  
        // 从命令行输入这个浮点数  
        Scanner scanner = new Scanner(System.in);  
        s = scanner.next();  
        scanner.close();  
        return s;  
    }  

    /** 
     * 把用户输入的数以小数点为界分割开来，并调用 numFormat() 方法 
     */  
    private String splitNum(String s) {  
        // 如果传入的是空串则继续返回空串  
        if("".equals(s)) {  
            return "";  
        }  
        // 以小数点为界分割这个字符串  
        int index = s.indexOf(".");  
        // 截取并转换这个数的整数部分  
        String intOnly = s.substring(0, index);  
        String part1 = this.numFormat(1, intOnly);  
        // 截取并转换这个数的小数部分  
        String smallOnly = s.substring(index + 1);  
        String part2 = this.numFormat(2, smallOnly);  
        // 把转换好了的整数部分和小数部分重新拼凑一个新的字符串  
        String newS = part1 + part2;  
        return newS;  
    }  
          
    /** 
     * 对传入的数进行四舍五入操作 
     * @param s String 从命令行输入的那个数 
     * @return 四舍五入后的新值 
     */  
    private String roundString(String s) {  
        // 如果传入的是空串则继续返回空串  
        if("".equals(s)) {  
            return "";  
        }  
        // 将这个数转换成 double 类型，并对其进行四舍五入操作  
        int index = s.indexOf(".");  
        // 这个数的整数部分  
        String intOnly = s.substring(0, index);  
        // 规定数值的最大长度只能到万亿单位，否则返回 "0"  
        if(intOnly.length() > 13) {  
            System.out.println("输入数据过大！（整数部分最多13位！）");  
            return "";  
        }  
        // 这个数的小数部分  
        String smallOnly = s.substring(index + 1);  
        // 如果小数部分大于两位，只截取小数点后两位  
        if(smallOnly.length() > 2) {  
            String roundSmall = smallOnly.substring(0, 2);  
            // 把整数部分和新截取的小数部分重新拼凑这个字符串  
            s = intOnly + "." + roundSmall;  
        }  
        return s;  
    }  
      
    /** 
     * 把传入的数转换为中文金额大写形式  
     */  
    private String numFormat(int flag, String s) {  
        int sLength = s.length();  
        // 货币大写形式  
        String bigLetter[] = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};  
        // 货币单位  
        String unit[] = {"元", "拾", "佰", "仟", "万",  "拾", "佰", "仟", "亿", "拾", "佰", "仟", "万"};  
        String small[] = {"分", "角"};  
        // 用来存放转换后的新字符串  
        String newS = "";  
        // 逐位替换为中文大写形式  
        for(int i = 0; i < sLength; i ++) {  
            if(flag == 1) {  
                // 转换整数部分为中文大写形式（带单位）  
                newS = newS + bigLetter[s.charAt(i) - 48] + unit[sLength - i - 1];  
            } 
            else if(flag == 2) {  
                // 转换小数部分（带单位）  
                newS = newS + bigLetter[s.charAt(i) - 48] + small[sLength - i - 1];  
            }  
        }  
        return newS;  
    }  
    
    private String cleanZero(String s) {  
        // 如果传入的是空串则继续返回空串  
        if("".equals(s)) {  
            return "";  
        }  
        // 如果用户开始输入了很多 0 去掉字符串前面多余的'零'，使其看上去更符合习惯  
        while(s.charAt(0) == '零') {  
            // 将字符串中的 "零" 和它对应的单位去掉  
            s = s.substring(2);  
            // 如果用户当初输入的时候只输入了 0，则只返回一个 "零"  
            if(s.length() == 0) {  
                return "零圆";  
            }  
        }  
        // 字符串中存在多个'零'在一起的时候只读出一个'零'，并省略多余的单位  
        String regex1[] = {"零仟", "零佰", "零拾"};  
        String regex2[] = {"零亿", "零万", "零元"};  
        String regex3[] = {"亿", "万", "元"};  
        String regex4[] = {"零角", "零分"};  
        // 第一轮转换把 "零仟", 零佰","零拾"等字符串替换成一个"零"  
        for(int i = 0; i < 3; i ++) {  
            s = s.replaceAll(regex1[i], "零");  
        }  
        // 第二轮转换考虑 "零亿","零万","零元"等情况  
        // "亿","万","元"这些单位有些情况是不能省的，需要保留下来  
        for(int i = 0; i < 3; i ++) {  
            // 当第一轮转换过后有可能有很多个零叠在一起  
            // 要把很多个重复的零变成一个零  
            s = s.replaceAll("零零零", "零");  
            s = s.replaceAll("零零", "零");  
            s = s.replaceAll(regex2[i], regex3[i]);  
        }  
        // 第三轮转换把"零角","零分"字符串省略  
        for(int i = 0; i < 2; i ++) {  
            s = s.replaceAll(regex4[i], "");  
        }  
        // 当"万"到"亿"之间全部是"零"的时候，忽略"亿万"单位，只保留一个"亿"  
        s = s.replaceAll("亿万", "亿");  
        return s;  
    }  
} 

　　（2）、结果截图

　　　　

　三、大数类

　　　(1）、源代码

package Guidang6;

import java.util.Scanner;

public class Dashu {

    public static void main(String[] args) {
            // TODO Auto-generated method stub
        String s1,s2;
        Scanner in=new Scanner(System.in);
        System.out.println("输入第一个大数：");
        s1=in.next();
        System.out.println("输入第二个大数：");
        s2=in.next();
        System.out.println(add(s1,s2));
        System.out.println(sub(s1,s2));
        in.close();
}

private static String add(String a, String b) 
{ 
    System.out.print("加法结果:");
    char[] aa = new StringBuffer(a).reverse().toString().toCharArray(); 
    char[] bb = new StringBuffer(b).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 f, String s) { 
    System.out.print("减法结果:"); 
    // 将字符串翻转并转换成字符数组 
    char[] a = new StringBuffer(f).reverse().toString().toCharArray(); 
    char[] b = new StringBuffer(s).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 ""; 

    } 
}

　　　　(2)、结果截图

　　　　　　

　　　　(3)、阅读BigInteger类源码，弄清楚它是使用什么算法实现加减乘除四种运算的

　　　　BigInteger是不可变的任意精度的整数。所有操作中，都以二进制补码形式表示 BigInteger（如 Java 的基本整数类型）。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。

四、随机数组

　　（1）、源代码

　　　　

package Guidang6;

import javax.swing.JOptionPane;
public class Shuzu {
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        int[] arr = new int[10];//定义数组
        int num=0; 
        String output="";
        for(int i=0;i<10;i++){//循环赋值
            arr[i] = (int)(Math.random()*10);//随机0-10范围内的整数
        }
        output+="十个元素："+"
";
        for(int i=0;i<10;i++)//循环输出
            {
                output+=arr[i]+" ";
                num=num+arr[i];
            }
        output+="
";
        output+="十个元素相加结果:"+"
";
        output+=num;
        JOptionPane.showMessageDialog( null,output, "数组",JOptionPane.PLAIN_MESSAGE);
    }
}

　　　　（2）、设计思路

　　　　　　首先定义一个长度为十的数组，在运用for循环进行数组的赋值，赋值运用随机数发生器赋值，最后再运用消息框输出结果。

　　　　（3）程序流程图

　　　　　　

　　　　（4）结果截图