Java数组知识整理

一、数组的概念

数组是相同数据类型元素的集合。

数组本身是引用数据类型，但它可以存储基本数据类型和引用数据类型。

二、数组的声明

语法一：数据类型[] 数组名;

语法二：数据类型 数组名[];

三、数组的创建

两个要素：数据类型、长度。

语法一：数据类型[] 数组名 = new 数据类型[长度];(动态初始化，先定义数组，然后初始化数据)

语法二：数据类型[] 数组名 = new 数据类型[]{初始化数据};(静态初始化，定义数组的同时，初始化数据)

语法三：数据类型[] 数组名 = {初始化数据};(静态初始化)

例：

1. //定义数组语法一

2. @Test

3. public void test_01(){

4. int[] arr = new int[3];

5. System.out.println(arr.length);

6. }

7. //定义数组语法二

8. @Test

9. public void test_02(){

10. int[] arr = new int[]{12,11,10};

11. System.out.println(arr.length);

12. }

13. //定义数组语法三

14. @Test

15. public void test_03(){

16. int[] arr = {12,11,10};

17. System.out.println(arr.length);

18. }

四、数组的特点

数组一旦定义，长度不变。

存储的数据类型相同。

数组的长度length是属性。

数组在内存当中处于连续的内存空间。

五、访问数组元素

访问数组元素需要使用索引，数组的索引从0开始，最大值为数组的长度减一。

语法：数组名[索引]

例：

1. //访问数组元素

2. @Test

3. public void test_04(){

4. int[] arr = {11,12,13};

5. //输出数组的第一个元素

6. System.out.println(arr[0]);

7. }

六、数组的遍历

数组遍历就是通过索引获取数组中的每个元素。

例：

1. //for循环遍历数组

2. @Test

3. public void test_05(){

4. int[] arr = {1,2,3,4,5,6};

5. for(int i= 0; i < arr.length; i++){

6. System.out.println(arr[i]);

7. }

8. }

9.  

10. //while循环遍历数组

11. @Test

12. public void test_06(){

13. int[] arr = {1,2,3,4,5,6};

14. int i = 0;

15. while(i < arr.length){

16. System.out.println(arr[i]);

17. i++;

18. }

19. }

七、数组中常见的异常

ArrayIndexOutOfBoundsException：数组索引越界异常。

NullPointerException：空指针异常。

八、获取数组中的最大值

例：

1. //获取数组中的最大值

2. @Test

3. public void test_07(){

4. int[] arr = {89,66,8,5,99,3,5,66,78,100};

5. int max = arr[0];

6. for (int i = 1; i < arr.length; i++){

7. if(arr[i] > max){

8. max = arr[i];

9. }

10. }

11. System.out.println("数组中的最大值为："+max);

12. }

九、数组的逆序

原理：首尾元素两两交换。

逆序不等于反向遍历。

例：

1. //数组的逆序

2. @Test

3. public void test_13(){

4. //定义数组

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

6. int temp;

7. for(int i = 0;i <=(arr.length/2); i++){

8. temp = arr[i];

9. //数组的长度比索引大1,所以要减去1

10. arr[i] = arr[arr.length-1-i];

11. arr[arr.length-1-i] = temp;

12. }

13. //遍历输出逆序后的数组

14. for (int i = 0; i < arr.length;i++){

15. System.out.println(arr[i]);

16. }

17. }

十、二维数组的声明

语法：数据类型[][] 数组名;

十一、二维数组的创建

语法一：数据类型[][] 数组名 = new int[二维数组的长度][一维数组的长度];

语法二：数据类型[][] 数组名 = new int[二维数组的长度][];(此种方式定义的一维数组需要另外分配长度，其长度可以不相同)

语法三：数据类型[][] 数组名 = new int[][]{{初始化数据},{初始化数据}};(每一对花括号是一个一维数组，使用逗号分割。此种方式定义的一维数组的长度可以不相同)

例：

1. //二位数组的创建方式一

2. @Test

3. public void test_08(){

4. int[][] arr = new int[3][5];

5. //输出二位数组的长度

6. System.out.println(arr.length);

7. //输出第一个一维数组的长度

8. System.out.println(arr[0].length);

9. }

10. //二位数组的创建方式二

11. @Test

12. public void test_09(){

13. int[][] arr = new int[3][];

14. arr[0] = new int[5]; //给第一个一维数组分配大小

15. arr[1] = new int[6]; //给第二个一维数组分配大小

16. //输出二位数组的长度

17. System.out.println(arr.length);

18. //输出第一个一维数组的长度

19. System.out.println(arr[0].length);

20. //输出第二个一维数组的长度

21. System.out.println(arr[1].length);

22. }

23. //二位数组的创建方式三

24. @Test

25. public void test_10(){

26. int[][] arr = new int[][]{{10,11,12},{10,11,12,13}};

27. //输出二位数组的长度

28. System.out.println(arr.length);

29. //输出第一个一维数组的长度

30. System.out.println(arr[0].length);

31. //输出第二个一维数组的长度

32. System.out.println(arr[1].length);

33. }

十二、通过索引访问二维数组中的数据

语法：数组名[二维数组的索引][一维数组的索引]

例：

1. //访问数组中的元素

2. @Test

3. public void test_11(){

4. int[][] arr = new int[][]{{10,20},{50,66}};

5. //输出第二个一维数组中的第一个元素

6. System.out.println(arr[1][0]);

7. }

十三、二维数组的遍历

思路：for循环的嵌套，外层循环遍历二维数组，内层循环遍历一维数组。

例：

1. //for循环遍历二维数组

2. @Test

3. public void test_12(){

4. int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};

5. //外层循环遍历二维数组

6. for(int i = 0; i < arr.length; i++){

7. //内层循环遍历一维数组

8. for (int j = 0; j < arr[i].length; j++){

9. //输出每次遍历所获取的元素

10. System.out.println(arr[i][j]);

11. }

12. }

13. }

十四、选择排序

原理：数组中的每个元素和其他的元素比较大小，根据排序要求交换位置。

思路：使用for的嵌套循环。外层循环控制比较次数，内循环控制每次比较的元素。

例：

1. //选择排序

2. @Test

3. public void test_14(){

4. //定义一维数组

5. int[] arr = {56,98,36,33,88,77,88,4,6,99};

6. //最后剩余的一个元素不用比较，所以要减1

7. for (int i = 0; i < arr.length - 1; i++){

8. for (int j = 1+i; j < arr.length; j++){

9. if(arr[i] > arr[j]){

10. int temp = arr[i];

11. arr[i] = arr[j];

12. arr[j] = temp;

13. }

14. }

15. }

16. //遍历输出数组元素

17. for (int i = 0; i < arr.length;i++){

18. System.out.print(arr[i]+" ");

19. }

20. }

十五、冒泡排序

原理：每轮冒泡，数组中相邻元素两两比较，根据排序要求交换位置。外层循环控制冒泡的次数，内层循环控制每次比较的元素。

例：

1. //冒泡排序

2. @Test

3. public void test_15(){

4. //定义一维数组

5. int[] arr = {88,66,23,44,5,6,77,99,52,-9};

6. for (int i = 0; i < arr.length-1; i++){

7. for (int j = 0; j < arr.length-i-1; j++){

8. if(arr[j] > arr[j+1]){

9. int temp = arr[j];

10. arr[j] = arr[j+1];

11. arr[j+1] = temp;

12. }

13. }

14. }

15. //遍历输出数组元素

16. for (int i = 0; i < arr.length;i++){

17. System.out.print(arr[i]+" ");

18. }

19. }