java数组(二)

java - 数组（二）

命令行参数

每一个Java应用程序都有一个带String[] args 参数的main方法，这个参数表明main方法将接收一个字符串数组，也就是命令行参数。

public class commandLine {
    public static void main(String[] args){
        if(args.length ==0 || args[0].equals("-h"))
            System.out.print("Hello,");
        else if (args[0].equals("-g"))
            System.out.print("Goodbye,");
        for (int i = 1;i< args.length; i++)
            System.out.print(" "+args[i]);
        System.out.println("!");
    }
}

在命令行界面执行参数可以看出来程序名并没有存储在args数组中：

//第一种
PS D:\java\study\learn\src> java baseProgram.commandLine
Hello,!
//第二种
PS D:\java\study\learn\src> java baseProgram.commandLine -h
Hello,!
//第三种
PS D:\java\study\learn\src> java baseProgram.commandLine -g cruel world
Goodbye, cruel world!

上面的第三种args数组包含下列内容：

args[0]:"-g"
args[1]:"cruel"
args[2]:"world"

数组排序

对数值型数组排序，可以使用Arrays类中的sort方法：

import java.util.*;

public class LotteryDrawing {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        System.out.print("本期中奖号码为多少个？");
        int k = in.nextInt();

        System.out.print("本期彩票大小最大不超过多少？");
        int n = in.nextInt();

        int[] numbers = new int[n];
        for (int i=0; i< numbers.length; i++)
            numbers[i] = i +1;

        int[] result = new int[k];
        for (int i=0; i<result.length; i++){
           int r = (int)(Math.random() * n);
           result[i] =numbers[r];
           numbers[r] = numbers[n-1];
           n --;
        }

        Arrays.sort(result);
        System.out.println("本期中奖号码如下：");
        for (int r: result)
            System.out.println(r);
    }
}

java.util.Arrays中的方法

static String toString(type[] a)
/**返回包含a中数据元素的字符串，这些数据元素被放在括号内，并用逗号分隔 **/

static type copyOf(type[] a,int length)
static type copyOfRange(type[] a,int start, int end)
/**返回与a类型相同的一个数组，其长度为length或者end-start，数据元素为a的值 **/

static void sort(type[] a)
/**采用优化的快速排序算法对数组进行排序 **/

static int binarySearch(type[] a,type v)
static int binarySearch(type[] a,int start,int end, type v)
/**采用二分搜索算法查找值v。如果查找成功，则返回相应的下标值；否则，返回一个负数值r **/

static void fill(type[] a,type v)
/**将数组的所有数据元素值设置为V **/

static boolean equals(type[] a,type[] b)
/**如果两个数组大小相同，并且下标相同的元素都对应相等，返回true **/

“多维数组”

多维数组可以使用多个下标访问数组元素，适用于表示表格或更加复杂的排列形式。

声明一个二维数组：

double[][] balances;

与一维数组一样，在调用new对多维数组进行初始化之前不能使用。

balances = new double[NYEARS][NRATES];

如果知道数组元素，就可以不调用new,可以直接使用简写的书写形式对多维数组进行初始化。

int [][] magicSquare = {
    {21,32,13,24},
    {35,16,27,48},
    {19,10,11,12},
    {13,14,15,16}
};

一旦数组被初始化，就可以利用两个方括号访问每个元素。

注意：for each循环语句不能自动处理二维数组的每一个元素，它是按照行，也就是一维数组处理的。因此要这样处理：

for (double[] row : a)
    for (double value : row)
        do something with value

当然也可以快速打印一个二维数组的数据元素列表，如

System.out.println(Arrays.deepToString(a));

这里举一个例子说明一下多维数组：

public class CompoundInterest {
    public static void main(String[] args){
        final double STARTRATE =10;
        final int NRATES = 6;
        final int NYEARS = 10;

        // 设置利率从10~15%
        double[] interestRate = new double[NRATES];
        for (int j = 0; j < interestRate.length; j++)
            interestRate[j] = (STARTRATE + j) / 100.0;

        double[][] balances = new double[NYEARS][NRATES];

        //设置初始结余为10000
        for (int j = 0; j < balances[0].length; j++)
            balances[0][j] = 10000;

        //计算未来年数的利率
        for (int i = 1; i < balances.length; i++)
        {
            for ( int j = 0; j <balances[i].length ; j++)
            {
                //从上一行得到去年的余额
                double oldBalance = balances[i-1][j];

                //计算利率
                double interest = oldBalance * interestRate[j];

                //计算这一年的结余
                balances[i][j] = oldBalance + interest;
            }
        }

        // 打印利率
        for (int j = 0; j < interestRate.length ;j++)
            System.out.printf("%9.0f%%",100 * interestRate[j]);

        System.out.println();

        //打印结余表
        for (double[] row : balances)
        {
            //打印表行
            for (double b : row)
                System.out.printf("%10.2f",b);
            System.out.println();
        }
    }
}

不规则数组

java实际上没有多维数组,只有一维数组，所以我才在上面给多维数组加上引号。多维数组被解释为“数组的数组”。

以上面的例子说明一下，balances数组实际上是一个包含10个元素的数组，而每个元素又是由6个浮点数组成的数组，由于可以单纯地存取数组的某一行，所以可以让两行交换。

double[] temp = balances[i];
balances[i] = balances[i+1];
balances[i+1] = temp;

java可以方便的构造一个“不规则”数组，即数组的每一行有不同的长度，下面举个例子，创建一个数组，第i行第j列讲存放”从i个数值中抽取j个数值”产生的结果。

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1

public class LotteryArray
{
    public static void main(String[] args)
    {
        final int NMAX = 10;

        //分配三角形数组
        int[][] odds = new int[NMAX+1][];
        for (int n = 0; n <= NMAX; n++)
            odds[n] = new int[n + 1];

        //填充三角形区域
        for (int n=0; n < odds.length; n++)
            for (int k=0; k<odds[n].length ; k++)
            {
                //计算二项式系数 n*(n-1)*(n-2)*...*(n-k+1)/(1*2*3*...*k)
                int lotteryOdds =1;
                for (int i=1 ; i <= k; i++)
                    lotteryOdds = lotteryOdds * (n-i+1)/ i;

                odds[n][k] = lotteryOdds;
            }

            //打印三角区域
            for (int[] row : odds)
            {
                for (int odd : row)
                    System.out.printf("%4d",odd);
                System.out.println();
            }
    }
}