• 数组是连续的内存空间，因此支持索引
  • 数组是一个容器，存储相同类型的一组数据
  • 数组的索引从0开始

  • 数组引用类型的变量的默认值为 null。当数组变量实例后，如果没有没有显示的为每个元素赋值，Java 就会把该数组的所有元素初始化为其相应类型的默认值。int型的默认值为0

    1.数据声明

    1. @Test
    2. public void test_9() {
    3.   int[] arr;
    4.   int arr1[];
    5.   int[] a, b, c; 
    6. }

    2. 数组的初始化

    初始值：整数 0， 浮点数 0.0， 字符’\u0000’, 布尔 false, 引用类型 null。

    1. @Test
    2. public void test_9() {
    3.   //动态初始化
    4.   int[] arr = new int[10]; //此时数组中的元素是 对应数据类型的默认值
    5.   int[] arr1 = new int[]{1,2,1,231,66};
    6.   //静态初始化
    7.   int[] arr2 = {1, 2, 3, 4, 7, 2, 3};
    8. }

    3. 数组遍历

    1. @Test
    2. public void test_9() {
    3.   int[] arr2 = {1, 2, 3, 4, 7, 2, 3};
    5.   for (int i : arr2) {
    6.       System.out.println(i);
    7.   }
    8.   System.out.println("------");
    9.   for (int i = 0; i < arr2.length; i++) {
    10.       System.out.println(arr2[i]);
    11.   }
    12.   System.out.println("------");
    13.   for (int i = arr2.length - 1; i >= 0; i--) {
    14.       System.out.println(arr2[i]);
    15.   }
    16. }

    基本for 和 增强for不同

  • 增强for只能遍历数组的所有元素

  • 遍历范围用基本for
  • 增强for只能顺序遍历数组的元素
  • 逆序遍历使用基本for
  • 增强for循环不能修改数组元素的值（可以修改对象属性的值）
  • 修改元素值用基本for
    1. @Test
    2. public void test_9() {
    3.   int[] arr2 = {1, 2, 3, 4, 7, 2, 3};
    4.   //增强for循环不能修改数组元素的值（可以修改对象属性的值）
    5.   for (int i : arr2) {
    6.       i = i+2;
    7.   }
    8.   System.out.println("------");
    9.   for (int i : arr2) {
    10.       System.out.println(i);
    11.   }
    12. }
    1. @Test
    2. public void test_9() {
    3.   int[] arr2 = {1, 2, 3, 4, 7, 2, 3};
    4.   // 修改元素的值用基本for循环
    5.   for (int i = 0; i < arr2.length; i++) {
    6.       arr2[i] += 2;
    7.   }
    8.   for (int i : arr2) {
    9.       System.out.println(i);
    10.   }
    11. }

    4. 数组是引用数据类型

    ```java

@Test public void test_9() { int n1 = 55; // 基本类型直接存储在栈中 int n2 = 66; n1 = n2; System.out.println(n1); //66 n2 = 77; System.out.println(n1); //66

  1. int[] arr1 = {55}; //引用类型中，栈中只存储引用地址
  2. int[] arr2 = {66};
  3. arr1 = arr2;
  4. System.out.println(arr1[0]); //66
  5. arr2[0] = 77;
  6. System.out.println(arr1[0]); //77

}

  1. <a name="uvcHO"></a>
  2. #### 5. 数组复制
  3. ```java
  4.     @Test
  5.     public void test_13() {
  6.         int[] oldArr = {1, 2, 3, 4, 7, 2, 3};
  7.         int[] newArr = new int[oldArr.length];
  8.         for (int i = 0; i < oldArr.length; i++) {
  9.             newArr[i] = oldArr[i];
  10.         }
  11.         System.out.println(Arrays.toString(newArr)); // [1, 2, 3, 4, 7, 2, 3]
  12.     }
  1.     @Test
  2.     public void test_14() {
  3.         int[] oldArr = {1, 2, 3, 4, 7, 2, 3};
  4.         int[] newArr = oldArr.clone(); // clone返回的是新的数组
  5.         System.out.println(Arrays.toString(newArr)); // [1, 2, 3, 4, 7, 2, 3]
  6.     }
  1. @Test
  2. public void test_12() {
  3.     int[] oldArr = {1, 2, 3, 4, 7, 2, 3};
  4.     int[] newArr = new int[oldArr.length * 2];
  5.     //System.arraycopy() 是native的方法
  6.     /**
  7.          * 第一个参数：原数组
  8.          * 第二个参数：原数组从那个索引开始被复制
  9.          * 第三个参数：目标数组
  10.          * 第四个参数：目标数组从哪个索引开始被填充
  11.          * 第五个参数：原数组从指定索引开始复制的元素的个数
  12.          */
  13.     System.arraycopy(oldArr, 2, newArr, 4, 3);
  14.     System.out.println(Arrays.toString(newArr));//[0, 0, 0, 0, 3, 4, 7, 0, 0, 0, 0, 0, 0, 0]
  15. }
  1. @Test
  2. public void test_20() {
  3.     int[] arr1 = {1, 2, 3, 4, 7, 2, 3};
  4.     //从0开始复制3个元素，返回新的数组
  5.     int[] arr2 = Arrays.copyOf(arr1,3);
  6.     System.out.println(Arrays.toString(arr2)); //[1, 2, 3]
  7.     //从指定开始索引到指定的结束索引的元素，返回新的数组
  8.     int[] arr3 = Arrays.copyOfRange(arr1,1,5);
  9.     System.out.println(Arrays.toString(arr3)); //[2, 3, 4, 7]
  10. }

6. 二维数组

Java实际上没有多维数组，本质上都是一维数组。

二维数据的存储示意图
image.png
二维数据可以用矩阵表示
比如： int[][] arr = new int[2][3]; 表示2行3列， 每一行表示一个一维数组


 0列 1列 2列
0行 0 0 0
1行 0 0 0

int[][] arr = { {0,0,0}, {0,0,0} }
int[][] arr = new int[][]{ {0,0,0}, {0,0,0} };

  1. @Test
  2. public void test_21() {
  3.     int[][] arr = new int[2][3];
  5.     //2 说明arr二维数组有两个元素，每个元素是一个数组，每个元素数组的长度是3
  6.     System.out.println(arr.length); //2 
  8.     //[ [I@b7dd107, [I@42eca56e ] [2]代表的是有两个一维数组
  9.     System.out.println(Arrays.toString(arr)); //[ [I@b7dd107, [I@42eca56e ]
  11.     for (int i = 0; i < arr.length; i++) {
  12.         System.out.println();
  13.         for (int j = 0; j < arr[i].length; j++) {
  14.             System.out.print(arr[i][j]);
  15.         }
  16.     }
  17. }
  1. // 增强for循环
  2. @Test
  3. public void test_21() {
  4.     int[][] arr = new int[2][3];
  5.     for (int[] ints : arr) {
  6.         System.out.println();
  7.         for (int anInt : ints) {
  8.             System.out.print(anInt + "\t");
  9.         }
  10.     }
  11. }