数组

一、概述

相同类型数据的有序集合

每个数组元素可以通过下标来访问它们(0~length-1)

数组的长度是确定的，一旦被创建，它的大小就不可改变

数组属于引用类型，也可以看成对象，每个数组元素相当于改对象的成员变量

数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

二、声明与创建

1 //首选声明方式
2 dateType[] arrayRefVar = new dateType[arraySize];
3 //次选
4 dateType arrayRefVar[];
5 //下标从0开始访问，获取长度
6 arrayRefVar.length;

1、初始化

1 //静态初始化
2 int[] array1 = {1,2,3,4};
3 //动态初始化(包含默认初始化，值都是0)
4 int[] array2 = new int[10];

2、内存分析

1 //声明数组，在栈里压入一个array,堆里还是空的
2 int[] array = null;
3 //创建数组，在堆里开辟了一个内存
4 array = new int[10];

三、数组的使用

 1 int[] arrays = new int[10];
 2 //打印数组元素，以下方式只适用于遍历每个元素，但不能操作
 3 for(int array : arrays)
 4 {
 5     System.out.println(array);
 6 }
 7 
 8 //反转数组1
 9 int[] arrays2 = new int[arrays.length];
10 for(int i = 0,int j = arrays.length - 1; i < arrays.length; i++,j--)
11 {
12     arrays2[i] = arrays[j];
13 }
14 
15 //反转数组2
16 for(int i = arrays.length - 1; i >= 0; i--)
17 {
18     arrays2[(arr.length-1)-i] = arr[i];
19 }

四、多维数组

 1 int[][] array = {{1,1}，{2,2}};
 2 int[][] array = new int[2][2];
 3 
 4 for(int i = 0; i < array.length; i++)
 5 {
 6     for(int j = 0; j < array[i].length; j++)
 7     {
 8         System.out.print(array[i][j] + " ");
 9     }
10     System.out.println();
11 }

五、Arrays类

1 java.util.Arrays
2 //打印数组元素
3 System.out.println(Array.toString(arr));
4 //排序(升序)
5 Arrays.sort(arr);
6 //给数组赋值(填充)
7 Arrays.fill(a,0)
8 //给一定范围内的元素赋值
9 Arrays.fill(a,2,4,0)

冒泡排序

 1 //每次比较都会出现一个最大或者最小的元素，下次循环就少一次比较
 2 //外层循环为比较次数
 3 for(int i = 0; i < array.length-1; i++)
 4 {
 5     int tem = 0;
 6     //优化，如果已经为有序序列，则不再循环
 7     boolean flag = false;
 8     //内存循环为两两比较,如果第一个数比第二个数大，就交换其位置
 9     for(int j = 0; j < array.length-1-i; j++)
10     {
11         if(array[j+1] < array[j])
12         {
13             tem = array[j+1];
14             array[j+1] = array[j];
15             array[j] = tem;
16             flag = ture；
17         }
18     }
19     if(flag == false)
20     {
21         break;
22     }
23     
24 }

时间复杂度为O(n2)

六、稀疏数组

当一个数组中大部分元素的值为0，或者为同一值时，可以用稀疏数组来保存该数组

稀疏数组的处理方式：记录数组有几行几列，有多少个不同值，将其记录在一个小规模的数组中，从而缩小规模

应用例子：五子棋程序中，存盘、续盘时，保存和读取。

 1 int[][] array = new int[11][11];
 2 array[1][2] = 1;
 3 array[2][3] = 2;
 4 
 5 //遍历得到有效的值的个数
 6 int sum = 0;
 7 for(int i = 0; i < 11; i++)
 8 {
 9     for(int j = 0; j < 11; j++)
10     {
11         if(array[i][j] != 0)
12         {
13             sum++;
14         }
15     } 
16 }
17 int
18 //创建稀疏数组(二维)，行数为有效数个数+1，列数为3
19 int[][] array2 = new int[sum+1][3];
20 //第一列分别是原数组行数、列数、有效数个数
21 array2[0][0] = 11;
22 array2[0][1] = 11;
23 array2[0][2] = sum;
24 
25 int count = 0;
26 for(int i = 0; i < 11; i++)
27 {
28     for(int j = 0; j < 11; j++)
29     {
30         if(array[i][j] != 0)
31         {
32             count++;
33             array2[count][0] = i;
34             array2[count][1] = j;
35             array2[count][2] = array[i][j];
36         }
37     } 
38 }
39 
40 //还原,数组行列数为稀疏数组第一行的前两个数值
41 int[][] array3 = new int[array2[0][0]][array2[0][1]];
42 //从第二行开始，还原有效数值
43 for(int i = 1; i < array2.length; i++)
44 {
45     array3[array2[i][0]][array2[i][1]] = array2[i][2];
46 }

Java从零开始学习——Java数组

数组