Java数组

一.数组的定义

数组是一种线性数据结构，是一个使用连续的内存空间存放相同的数据类型的集合容器，与其他容器相比，数组的区别主要在于性能与保存基本类型的能力。

        在Java中，数组是一种效率最高的存储和随机访问对象的方式，通过寻址公式，随机访问的时间复杂可以达到O(1)，但是为了保持空间的连续性，在数组中插入、删除数据时，都需要移动后面数据，该操作的时间复杂度为O(n)。另外，由于空间上连续，所以数组对CPU缓存比较友好，借助CPU的缓存机制，预读数组中的数据，提高访问效率。但是，由于数组是定长的，一旦声明之后就不可以改变长度，所以如果长度声明过大或者过小都会造成问题。

        数组可以自动给数组中的元素从0开始编号，方便操作这些元素。数组属于引用变量，并且数组的长度是固定的，数组的使用有四个步骤，声明数组，分配空间，赋值，处理。

[一维数组]

1.一维数组的定义

一维数组，是由数字组成的以单纯的排序结构排列的结构单一的数组，是计算机程序中最基本的数组。二维及多维数组可以看作是一维数组的多次叠加产生的。

在程序中可以使用下标变量，即说明这些变量的整体为数组，数组中的每个变量的数据类型是相同的。

当数组中每个元素都只带有一个下标时，称这样的数组为一维数组。

2.一维数组的性质​​

(1)一维数组的引用

通过给出的数组名称和这个元素在数组中的位置编号（即下标），程序可以引用数组中的任意一个元素。

在C++中，一维数组的引用格式为：数组名[下标]

例如： int a[10];

其中，a是一维数组的数组名，该数组有10个元素，依次表示为a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]。需要注意的是，a[10]不属于这一个数组的空间范围中。当在说明部分定义了一个数组变量后，编译程序会在内存空间中开辟一串连续的存储单元。对于数组而言，程序的执行部分使用的是数组变量而不是数组类型。需要注意的是：在引用时，下标可以是整型变量或整型表达式。如果使用表达式，会先计算表达式以确定下标。程序只能逐个应用数组中的元素而不能一次引用整个数组。如： [2] 

1	int a[100],b[100]; a=b;                   //这是非法的

数组名不能与其他变量名相同，如：

1 2 3 4 5

int a;     float a[10];                               //这是非法的

不能在方括号中用变量来表示元素的个数，如：

1 2 3 4

int n=5;     int a[n];                                 //这是非法的

但可以是符号常数或常量表达式

1	int a[3+2];                               //这是合法的

 

(2)一维数组的初始化

数组的初始化可以在定义时一并完成。格式如下：

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

c++语言对数组的初始化赋值还有以下几点规定：

（1）可以只给部分元素赋初值

当{}中值的个数小于元素的个数时，只给前面部分元素赋值，例如：

1	int a[10]={0,1,2,3,4};

表示只给a[0]~a[4]五个元素赋值，后面的元素自动赋0。

（2）只能给元素逐个赋值，不能给数组整体赋值。

例如给十个元素全部赋1值，只能写成

1	int a[10]={1,1,1,1,1,1,1,1,1,1};

而不能写成

1	int a[10]=1;

（3）如给全部元素赋值，则在数组中说明，可以不给出数组元素的个数，例如：

1	int a[5]={1,2,3,4,5}

可写成

1	int a[]={1,2,3,4,5}

[二维数组]

1.二维数组的定义

二维数组本质上是以数组作为数组元素的数组，即“数组的数组”，类型说明符 数组名[常量表达式][常量表达式]。二维数组又称为矩阵，行列数相等的矩阵称为方阵。对称矩阵a[i][j] = a[j][i]，对角矩阵：n阶方阵主对角线外都是零元素。

2、二维数组的初始化

整体赋值只能在定义的时刻进行

eg：int arr[3][4]={{1，2，3，4}，{5，6，7，8}，{9，10，11，12}}   3行4列

        int arr[3][4]={{1，2，3，4}，{5，6，7，8}，{9，10，11，12}，13}     错误，初始值给太多，因为设置的只有3行

        int arr[3][4]={1，2，3，4，5，6，7，8，9，10，11，12}     也可以表示3行4列

                                                        1   2   3   4

                                                        5   6   7  8

                                                        9  10   11 12

         int arr[3][4]={{1，2，3，4}，{5，6}，{9，10}} ，表示：

                                                        1   2   3   4

                                                        5   6   0   0

                                                        9  10   0  0

          int arr[][]={{1，2，3，4}，{5，6，7，8}，{9，10，11，12}} ，代表3行4列，默认行优先

          int arr[3][]={1，2，3，4，5，6，7，8，9，10，11，12} ；错误，只告诉行，不告诉列不能使用

          int arr[][4]={1，2，3，4，5，6，7，8，9，10，11，12} ；因为行优先 ，所以可以省略行号

          int arr[][4]={1，2，3，4，5，6，7，8，9，10}，二维指针为：

                                                        1   2   3   4

                                                        5   6   7   8

                                                        9  10   0  0

3.二维数组的应用

有一个3*4的矩阵，求出最大的元素，和其对应的行号和列号

方法1：

1. int main()

2. {

3. int arr[3][4] = { 12,23,3,4,56,62,7,81,89,10,11,12 };

4. int max = 0;

5. int max_i = 0;

6. int max_j = 0;

7. for (int i = 0; i < 3; i++)

8. {

9. for (int j = 0; j < 4; j++)

10. {

11. if (arr[i][j] > max)

12. {

13. max = arr[i][j];

14. max_i = i;

15. max_j = j;

16. }

17. }

18. }

19. printf("%d %d %d\n", max, max_i, max_j);

20. }

方法2：

 

void fun1(int arr[3][4],int low)

{

 int max = arr[0][0];

 int c = 0;

 int d = 0;

 for (int i = 0; i <low; i++)

 {

  for (int j = 0; j < 4; j++)

  {

   if (arr[i][j] > max)

   {

    max= arr[i][j];

    c = i;

    d = j;

   }

  }

 }

 printf("%d %d\n", c, d);

}

int main()

{

 int arr[3][4] = { 12,23,3,4,56,62,7,81,89,10,11,12 };

    int low = sizeof(arr) / sizeof(arr[0]);//计算行数

    fun1(arr,low);

}