Java工程师成长修炼手册：02--数组

た入场券 2023-02-12 10:25 13阅读 0赞

### 数组是用来存储固定大小的同类型元素。数组是 Java 编程中最重要的数据结构之一，也是最基本的数据结构，可以通过下标访问数值中的所有元素。 ###

### 数组的特点： ###

● 数组可以是一维数组、二维数组或多维数组。  
● 数值数组元素的默认值为 0，而引用元素的默认值为 null。  
● 数组的索引从 0 开始，如果数组有 n 个元素，那么数组的索引是从 0 到（n-1）。

### 声明数组变量 ###

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

int[] arrays;
    或
    int arrays[];

### 注意： ###

1.首选第一种方法声明数组。int\[\] arrays;  
2.在声明数组时不需要规定数组的长度，例如：

int arrays[10];    //这是错误的

### 数组初始化 ###

数组变量的声明，和创建数组可以用一条语句完成，如下所示：

int[] arrays = new int[n];

声明了 n 个元素，每个元素初始化为 0  
也可以直接赋值

int[] arrays = { value0, value1, ..., valueN};
    
    int[] arr1 = new int[10];
    int[] arr2 = { 1, 2, 3};

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrays.length-1。  
注意：数组初始化如果声明了数组长度，则不能直接赋值。例如，int\[\] arr = new int\[5\]\{1, 2, 3, 4, 5\}; 一旦声明了数组的大小，就不能再修改。

### 数组遍历 ###

数组遍历的常见方式有三种：传统的 for 循环、for each 遍历、Lambda 表达式（这个是JDK8新增的，会专门用一节讲解Lambda 表达式）。  
方式一：传统 for 循环

int[] arrays = { 1, 2, 3};
    for(int i = 0;i < arrays.length;i++){ 
        System.out.println(arrays[i]);
    }

方式二：for each

String[] str = { "aa", "bb", "cc"};
    for (String s : str) { 
        System.out.println(s);
    }

for each是for循环的增强版  
方式三：JDK 8 中的 Lambda 表达式

int[] arrays = { 1, 2, 3};
    Arrays.stream(arrays).forEach(x -> System.out.println(x));

这里简单解释一下，arrays数组后面的stream方法，是把数组转化成流的形式，后面的forEach是进行遍历。再往后，有个->函数，是从右往左运算，就跟java中的“=”赋值运算一样。System.out.println(x)每一次输出数组的值。

### 排序 ###

（关于数组排序的，会另外一节详细讲解）  
数组排序  
使用 Arrays.sort() 方法

String[] str = { "aa", "cc", "bb"};
    Arrays.sort(str);
    System.out.println(Arrays.toString(str));
    
    输出结果：
    [aa, bb, cc]

数组逆序  
使用 org.apache.commons.lang3.ArrayUtils.reverse(arr) 方法：

int[] arr = { 7, 8, 2, 16, 6, 13, 0, 9, 3};
    // 先进行数组正序（排序）
    Arrays.sort(arr);
    // 再进行数组逆序
    ArrayUtils.reverse(arr);
    System.out.println(Arrays.toString(arr));
    
    输出结果
    [16, 13, 9, 8, 7, 6, 3, 2, 0]

int[] arr = { 7, 8, 2, 16, 6, 13, 0, 9, 3};
    
    // 如果没有进行排序，直接进行逆序
    ArrayUtils.reverse(arr);
    System.out.println(Arrays.toString(arr));
    
    输出结果如下：
    [3, 9, 0, 13, 6, 16, 2, 8, 7]

### 多维数组 ###

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其中每一个元素都是一个一维数组。  
声明一个二维数组：String str\[\]\[\] = new String\[3\]\[4\];  
创建了一个三行四列的数组  
多维数组的动态初始化（以二维数组为例）

直接为每一维分配空间，格式如下：  
type\[\]\[\] typeName = new type\[typeLength1\]\[typeLength2\];  
type 可以为基本数据类型和复合数据类型，typeLength1和 typeLength2 必须为正整数，typeLength1为行数，typeLength2为列数。  
例如：  
int a\[\]\[\] = new int\[2\]\[3\];  
初始化二维数组

我们之前使用的数组可以称之为一维数组，而多维数组可以理解为数组的数组，可以用二维数组来举例，二维数组也是一种特殊的多维数组。  
比如我们声明一个二维数组：int\[\]\[\] arr = new int\[2\]\[4\];  
这就相当于我们创建了一个两行四列的表，它的使用、赋值与取值，请查看下面代码示例：

// 声明二维数组
    int[][] arr = new int[2][4];
    //循环二维数组
    for (int i = 0; i < arr.length; i++) { 
        for (int j = 0; j < arr[0].length; j++) { 
            // 二维数组赋值
            arr[i][j] = j;
        }
    }
    // 二维数组取值
    System.out.println(arr[0][1]);
    // 打印二维数组
    System.out.println(Arrays.toString(arr[0]));
    System.out.println(Arrays.toString(arr[1]));
    
    以上程序执行的结果是：
    1
    [0, 1, 2, 3]
    [0, 1, 2, 3]

数组类型转换  
字符串转数组  
使用 split 分隔字符串就形成了数组，请参考以下代码：

String str = "laowang,stone,wanglei";
    String[] arr = str.split(","); // 字符串转数组
    System.out.println(arr[0]);

数组转字符串  
使用 Arrays.toString() 方法，请参考以下代码：

String[] arr = { "laowang", "stone", "wanglei"};
    String str = Arrays.toString(arr);
    System.out.println(str);

若要查看更多数组转字符串的方式，请查看本文面试部分的介绍。  
数组转集合  
使用 Arrays.asList() 方法，请参考以下代码：

String[] strArr = { "cat", "dog"};
    List list = Arrays.asList(strArr);
    System.out.println(list);

集合转数组  
使用 List.toArrray() 方法，请参考以下代码：

List<String> list = new ArrayList<String>();
    list.add("cat");
    list.add("dog");
    // 集合转换为数组
    String[] arr = list.toArray(new String[list.size()]);
    System.out.println(Arrays.toString(arr));

### 相关面试题 ###

1、数组和集合有什么区别？  
答：数组和集合的区别如下：  
集合可以存储任意类型的对象数据，数组只能存储同一种数据类型的数据；  
集合的长度是会发生变化的，数组的长度是固定的；  
集合相比数组功能更强大，数组相比集合效率更高。  
2、 以下代码访问数组元素打印的结果是多少？

int[] arr = new int[5] { 1, 2, 3, 4, 5};
    System.out.println(arr[4]);

答：程序编译报错，在 Java 中初始化数组时，如果直接给数组赋值，不能声明数组长度；如果声明了数组长度，则不能赋值给数组，否则编译器报错。  
正确的写法如下：

int[] arr = new int[]{ 1, 2, 3, 4, 5};
    System.out.println(arr[4]);

输出的结果为：5，访问元素从 0 开始。  
3、 执行以下代码会输出什么结果？

public static void main(String[] args) { 
        int[] arr = { 2, 3, 4, 8};
        change(arr);
        System.out.println(arr[2]);
    }
    private static void change(int[] arr) { 
        for (int i = 0; i < arr.length; i++) { 
            if (i % 2 == 0) { 
                arr[i] *= i;
            }
        }
    }

答：输出的结果是 8。  
题目解析：在 Java 中数组本质是引用类型，因此在调用方法中修改数组，就是对原数组本身的修改。  
4、以下程序打印的结果是多少？

int[] intArr = new int[3];
    String[] StrArr = new String[3];
    System.out.println(intArr[1]);
    System.out.println(StrArr[1]);

答：以上程序打印的结果是：0 和 null。  
题目解析：new int\[3\] 相当于声明了数组的长度为 3，每个元素初始化为 0，而 new String\[3\] 相当于声明了数组的长度为 3，每个元素初始化为 null。  
5、数组转换字符串有哪些方式？  
答：数组转换字符串，有以下几种方式。  
方式一：遍历拼接，完整代码如下：

String[] arr = { "laowang", "stone", "wanglei"};
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < arr.length; i++) { 
        sb.append(arr[i]);
        if (i != arr.length - 1)
            sb.append(",");
    }
    System.out.println(sb.toString());

方式二：Arrays.toString() 转换，完整代码如下：

String[] arr = { "laowang", "stone", "wanglei"};
    String str2 = Arrays.toString(arr);
    System.out.println(str2);

方式三：StringUtils.join() 转换，完整代码如下：

String[] arr = { "laowang", "stone", "wanglei"};
    String str3 = StringUtils.join(Arrays.asList(arr), ","); // 使用英文逗号分隔
    System.out.println(str3);

6、数组遍历有哪几种方式？  
答：常见的数组遍历有以下三种方式。

传统 for 循环，如 for (int i = 0; i < arr.length; i++) {  //...... }
    for each 循环，如 for (int i : arr) {  //...... }
    jdk 8 Lambda 方式，如 Integer[] arr = { 2, 3, 6, 7, 9}; Arrays._asList_(arr).forEach(x -> System._out_.println(x));

7、以下数组比较的结果分别是什么？

String[] strArr = { "dog", "cat", "pig", "bird"};
    String[] strArr2 = { "dog", "cat", "pig", "bird"};
    System.out.println(Arrays.equals(strArr, strArr2));
    System.out.println(strArr.equals(strArr2));
    System.out.println(strArr == strArr2);
    
    答：上面代码执行的结果，分别为：true、false、false。

题目解析：strArr == strArr2 为引用比较，因此结果一定是 false，而数组本身的比较也就是 strArr.equals(strArr2) 为 false 的原因是因为数组没有重写 equals 方法，因此也是引用比较。数组 equals 源码实现如下：

public boolean equals(Object obj) { 
      return (this == obj);
    }

而 Arrays.equals 的结果之所以是 true 是因为 Arrays.equals 重写了 equals 方法。源代码实现如下：

public static boolean equals(Object[] a, Object[] a2) { 
            if (a==a2)
                return true;
            if (a==null || a2==null)
                return false;
            int length = a.length;
            if (a2.length != length)
                return false;
            for (int i=0; i<length; i++) { 
                Object o1 = a[i];
                Object o2 = a2[i];
                if (!(o1==null ? o2==null : o1.equals(o2)))
                    return false;
            }
            return true;
        }

## 本人能力有限，错误之处还请指出 ##

## 更多后续内容及文章，百度：暗影月色程序猿 ##