Java核心卷 卷一 自我笔记 3.6Java的基本程序设计结构---数组

数组

数组是一种数据结构，用来存储同一类型值的集合。通过一个整型下标可以访问数组中的每一个值。在声明数组变量时，需要指出数组类型和数组变量的名字。下面声明了整型数组a：

int[] a;

不过，这条语句只声明了变量a，并没有将a初始化为一个真正的数组。应该使用new运算符创建数组。

int[] a=new int[100];

这条语句创建了一个可以存储100个整数的数组。数组长度不要求是常量：new int[n]会创建一个长度为n的数组。
我们可以使用两种形式来声明数组：

int[] a;

或

int a[];

上面我们刚刚创建的数组的下标从0~99（注意不是1到100）；一旦创建了数组，我们就可以给数组元素赋值。我们可以使用循环来赋值：

  int[] ints = new int[100];
        for (int i = 0; i < ints.length; i++) {
            ints[i]=i;
        }

当Java创建一个数字数组时，所有的元素都初始化为0；Boolean数组的元素初始化为false；对象数组的元素初始化为一个特殊值null，这表示这些元素还未存放如何对象。

我们需要注意的是，编写程序的时候，如果使用到了数组，一定要注意到它的下标使用。例如，你创建了一个100个元素的数组，并且试图访问元素a[100]，程序就会引发异常而终止执行。

一旦我们创建了数组，就不能改变它的大小。如果经常需要在运行过程中扩展数组的大小，就需要使用另一种数据结构——数据列表。

对于数组元素的处理，可以使用for each循环或者其他循环。循环的使用，请看：https://blog.csdn.net/weixin_43790623/article/details/102224263

在Java中，它给我们提供了一种创建数组对象并同时赋予初始值的简化书写形式。例：

int[] small={1,2,1,1,2};

使用这种语句时，不需要使用new。
当然还可以初始化一个匿名数组：

new int[] {1,2,4,1,7};

这种表示法将创建一个新数组并利用括号中提供的值进行初始化，数组的大小就是初始化值的个数。我们可以用这种方法重写初始化一个数组。例如：

small=new int[]{1,2,4,2,5};

在Java中，允许数组的长度为0。在编写一个结果为数组的方法时，如果碰巧结果为空，那么这种语法形式就显得非常有用。我们需要注意的是，数组长度为0与null不同。

在java中，允许数组拷贝，即两个变量共同指向一个地址。如果希望将一个数组的所有值拷贝到另一个新的数组中去，我们可以使用Arrays类的copyOf方法：

lucky=Arrays.copyOf(small,small.length);

第二个参数是新数组的长度。这个方法通常用来增加数组的大小。如果数组元素是数值型，那么多余的元素将被赋值为0；如果数组元素是布尔型，那么将赋值为false。相反，如果长度小于原始数组的长度，就拷贝最前面的数组元素。

对数组元素排序的方法很多。Arrays类就给我们提供了sort方法：

int[] a=new int[1000];
//赋值语句
....
Arrays.sort(a): 

这个方法使用了优化的快速排序方法。快排对于大多数数据集合来说都是效率较高的。我们用下面一个例子详细说明一下：

 public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("how many number do you need to draw?");
        int k = in.nextInt();
        System.out.println("what is the highest number you can draw?");
        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("bet the following combination.it will make you rich");
        for (int r : result) {
            System.out.println(r);
        }
    }

我们在下面列出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。-r-1是为保持a有序v应插入的位置。
• static void fill(type[ ] a,type v)
  将数组的所有数据元素值设置为v
• static boolean equals（type[ ] a,type[ ] b）
  如果这两个数组大小相同，并且下标元素都对应相等，返回true。

多维数组

我们以二维数组为例，在Java中，额、声明一个二维数组去相当简单。例如：

double[][] balance；

与一维数组一样，在调用new对多维数组进行初始化之前不能使用它。我们可以这样初始化：

balance=new double[4][4];

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

int [][]magic={
{1,1,1,1},
{2,2,2,2},
{3,3,3,3},
{4,4,4,4}
};

一旦数组被初始化，就可以利用两个方括号访问每一个元素。例如，balance[i][j]。

我们需要注意的是，因为二维数组是一维数组嵌套组成的。所以，使、循环输出的时候，也要使用他嵌套循环。例如：

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

我们用一个示例来看一下二维数组的使用，在程序中，使用了一个存储利率的一维数组interest与一个存储余额的二维数组balance。一维用于表示年，二维表示利率。

 public static void main(String[] args) {
        final double STARTRATE=10;
        final int NRATES=6;
        final int NYEARS=10;
        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];
        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 i = 0; i < interestrate.length; i++) {
            System.out.println(100*interestrate[i]);
        }
        for (double[] row : balances) {
            for (double v : row) {
                System.out.println(v);
            }
        }

    }