Java之数组篇

动手动脑，第六次Tutorial——数组

这次的Tutorial讲解了Java中如何进行数组操作，包括数组声明创建使用和赋值运算，写这篇文章的目的就是通过实际运用已达到对数组使用的更加熟练，下面是实践代码之后的感悟与总结：

动手动脑1：PassArray.java

// PassArray.java
// Passing arrays and individual array elements to methods

public class PassArray {
    
    public static void main(String[] args) {
        int a[] = { 1, 2, 3, 4, 5 };
        String output = "The values of the original array are:
";

        for (int i = 0; i < a.length; i++)
            output += "   " + a[i];

        output += "

Effects of passing array " + "element call-by-value:
"
                + "a[3] before modifyElement: " + a[3];

        modifyElement(a[3]);

        output += "
a[3] after modifyElement: " + a[3];

        output += "
 Effects of passing entire array by reference";

        modifyArray(a); // array a passed call-by-reference

        output += "

The values of the modified array are:
";

        for (int i = 0; i < a.length; i++)
            output += "   " + a[i];
        
        System.out.println(output);
    }

    public static void modifyArray(int b[]) {
        for (int j = 0; j < b.length; j++)
            b[j] *= 2;
    }

    public static void modifyElement(int e) {
        e *= 2;
    }

}

观察并分析程序的输出结果：

可以得出如下结论：

• 按引用传递与按值传送数组类型方法参数的最大关键在于：
  • 使用前者时，如果方法中有代码更改了数组元素的值，实际上是直接修改了原始的数组元素。
  • 使用后者则没有这个问题，方法体中修改的仅是原始数组元素的一个拷贝。

动手动脑2：QiPan.java

import java.io.*;

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的格式：");
        }
    }
}

程序运行输出结果：

 

棋盘是如何表示的？

整个棋盘是用一个个“+”组成的，共15行15列，所以可以使用一个15X15的二维数组表示，用户下棋的位置用行列位置表示，这样用户下棋的位置所对应的数组元素将由“+”变为“·”。棋盘类结构如下：

1. 私有静态变量BOARD_SIZE，初始值为15；

2. 私有变量二维字符串数组board[][]；

3. 共有方法InitBoard()，初始化棋盘；

4. 共有方法PrintBoard()，打印棋盘；

动手动脑3：IntToChinese.java

问题描述：

请编写一个程序将一个整数转换为汉字读法字符串。比如“1123”转换为“一千一百二十三”。

设计思想：

假如说这个整数最高位数不超过9位，那么问题其实并不是很复杂。实现这个功能的方法可以这么定义：

1. 定义一个大小为10的字符串型数组chineseNumber，初值为："零","一","二","三","四","五","六","七","八","九";
2. 定义一个大小为5的字符串型数组chinesePost，初值为："","十","百","千","万";
3. 对函数获取的参数num，进行拆解分析位数以及每位上的数字，num如果是String类型的可能会方便一些，结合上面两个数组进行转化汉字即可；

源代码：

import java.util.Scanner;
public class IntToChinese {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        System.out.print("请输入一个99999以内的一个整数：");
        int number = in.nextInt();
        System.out.println("转换中。。。。");
        System.out.println( ToChinese(number) );
    }
    
    public static String ToChinese(int num) {
        // 将阿拉伯数字用汉字表示
        String chineseNumber[] = {"零","一","二","三","四","五","六","七","八","九"};
        String chinesePost[] = {"","十","百","千","万","十","百","千","亿"};
        String wanAndyi[] = {"","万","亿"};
        String result = "";               // 存放结果
        String n = Integer.toString(num); // 将数字转化为字符串
        
        char c[] = n.toCharArray();
        // int m = n.length()/4;
        int k = 0;
        for (int i = 0; i < n.length()-1; i++) {
            if(n.length()-i-1 != 4) {  // 不是万位
                if(c[i] != '0' && k != 0) {  // 非零且前一个位上是0
                    result += chineseNumber[c[i-1]-'0']+chineseNumber[c[i]-'0']+chinesePost[n.length()-i-1];
                    k = 0;
                    continue;
                }
                else if(c[i] == '0') {  // 零
                    k++;
                    continue;
                }
                result += chineseNumber[c[i]-'0']+chinesePost[n.length()-i-1];
            }
            else {            // 万位是0的时候需要区分
                if(c[i] == '0')
                    result +=chinesePost[n.length()-i-1];
                else
                    result += chineseNumber[c[i]-'0']+chinesePost[n.length()-i-1];
            }
        }
        if(n.length()>1) {
            if(c[n.length()-2] == '0'&&c[n.length()-1] !='0')
                result += chineseNumber[0]+chineseNumber[c[n.length()-1]-'0'];
            else if(c[n.length()-2] != '0'&&c[n.length()-1] !='0')
                result += chineseNumber[c[n.length()-1]-'0'];
        }
        else
            result += chineseNumber[c[n.length()-1]-'0'];
        
        return result;
    }
}

运行结果：

 

拓展程序：

更进一步，能否将数字表示的金额改为“汉字表达？ 比如将“￥123.52”转换为“壹佰贰拾叁元伍角贰分”。

实现代码：

public static String ToBigLetter(double money) {
        // 将金额转换为大写
        String chineseNumber[] = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
        String chinesePost[] = {"圆","拾","佰","仟","万","拾","佰","仟","亿"};
        String jiaoAndFen[] = {"角","分"};
        String result = "";               // 存放结果
        String n = Double.toString(money); // 将数字转化为字符串
        String n_front = n.substring(0,n.indexOf('.'));
        String n_back =n.substring(n.indexOf('.')+1);
        char c[] = n_front.toCharArray();
        // int m = n.length()/4;
        
        int k = 0;
        for (int i = 0; i < n_front.length(); i++) {
            if(n_front.length()-i-1 != 4) {
                if(c[i] != '0' && k != 0) {
                    result += chineseNumber[c[i-1]-'0']+chineseNumber[c[i]-'0']+chinesePost[n_front.length()-i-1];
                    k = 0;
                    continue;
                }
                else if(c[i] == '0') {
                    k++;
                    continue;
                }
                result += chineseNumber[c[i]-'0']+chinesePost[n_front.length()-i-1];
            }
            else {
                if(c[i] == '0')
                    result +=chinesePost[n_front.length()-i-1];
                else
                    result += chineseNumber[c[i]-'0']+chinesePost[n_front.length()-i-1];
            }
        }
        if(n_front.length()!=1 && k!=0)     // 位数大于1     并且   个位不是0（即k!=0） 
            result += chinesePost[0];
        
        //更进一步，能否将数字表示的金额改为“汉字表达？ 比如将“￥123.52”转换为“壹佰贰拾叁元伍角贰分”。

        
        char s[] = n_back.toCharArray();
        for(int i = 0; i < n_back.length(); i++) {
            if(s[i] == '0')
                continue;
            else
                result += chineseNumber[s[i]-'0']+jiaoAndFen[i];
        }
        return result;
    }

结果截图：

设计思想：

只需将小数点前面与后面分开，然后分别拆分即可，所用到的方法有：

　　String.subString();

　　String.indexOf();

具体思想可根据代码中注释加深理解。

动手动脑4：BigNumber.java

问题描述：

利用数组实现大数相加减。

设计思想：

一个数组元素存取一位数字，无论加法还是减法，都是从低位开始运算，即数组的最后一个元素开始运算，加法满10进1，每个数组元素的最高值为9，相加的和a超过9就让前一个数组+a/10，新的元素值就是a%10，如：

 源代码：

import java.util.Scanner;
public class BigNumber {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        System.out.print("请输入大数a：");
        String a = in.nextLine();
        System.out.print("请输入大数b：");
        String b = in.nextLine();
        in.close();
        System.out.println("a+b = "+sumArray(a,b));
    }
    public static String sumArray(String A, String B) {
        // 数组求和
        char charA[] = A.toCharArray();
        char charB[] = B.toCharArray();
        String result = "";
        int max = A.length() > B.length() ? A.length()+1 : B.length()+1;
        int a[] = new int[max] , b[] = new int[max];
        for (int i = 0; i < max; i++) {
            if(i<max-A.length())
                a[i] = 0;
            else
                a[i] = charA[i-(max-A.length())] - '0';
            if(i<max-B.length())
                b[i] = 0;
            else
                b[i] = charB[i-(max-B.length())] - '0';
        }
        int sum = 0;
        int jin = 0;
        int k = 0;
        for(int i = max-1; i >= 0; i--) {
            sum = a[i] + b[i] + jin;      // 每位上的和
            a[i] = sum%10;          // 取sum的个位
            jin = sum/10;           // 取sum的十位
        }
        for(int i = 0; i < max; i++) {
            if(a[i] == 0)
                k++;
            else
                break;
        }
        for(int i = 0; i < max; i++) {
            if(i<k) continue;    // 前面0去掉
            result += String.valueOf(a[i]);
        }
        
        return result;
    }
}

运行结果：