在Java中的数组，与我们在PHP中对数组的理解不太一样。

Java中的数组下标是强制从`0`开始，而且不能为字符串，而能够使用字符串作为下标的数组结构，在Java中称之为**集合**，是数组的一个延伸。

但在学习集合之前，我们需要先掌握数组的知识结构。

### 1、数组的声明方式
语法：
```
1、数据类型[ ] 数组名；// 推荐使用这种
2、数据类型 数组名[ ]；
```
代码示例：
```java
int [] scores; // 用来存储学生成绩
double [] height; // 用来存储学生身高
String [] names; // 用来存储学生姓名
```

### 2、空间分配
语法：
```
1、数组名 = new 数据类型[数组长度];// 其长度就是数组中能存放元素的个数
```
代码实例:
```java
int [] scores = new int[5]; // 用来存储学生成绩
double [] height = new int[5]; // 用来存储学生身高
String [] names = new int[5]; // 用来存储学生姓名
```
上面的`5`则表示可以存放到`0-4`个下标元素，因为java中的下标是从`0`开始算起。

### 3、赋值
数组中元素都是通过下标来访问的。

语法:
```
1、数组名[下标] = 值;
```
代码示例：

例如向 `scores` 数组中存放学生成绩:
```java
scores[0] = 61;
scores[1] = 52;
scores[2] = 33;
scores[3] = 64;
scores[4] = 85;
scores[5] = 16; // 这一行会报错，因为我们上面只定义了5个长度
```

### 4、创建数组时直接赋值
在 Java 中还提供了另外一种直接创建数组的方式，它将声明数组、分配空间和赋值合并完成，例如：
```java
// 创建一个长度为5的整型数组
int [] scores = {11,12,13,14,15};
```
还有一种写法：
```java
int [] scores = new int[]{11,12,13,14,15};
```
上面的代码中需要注意：`new int[]`的中括号里必须为空，不能指定长度。

### 5、使用循环操作数组
上一节我们已经提过如何使用`for`循环简单的操作数组，下面我们再来学习另一种用法：

示例代码：
```java
/**
 * 通过arrays对象遍历数组的简单案例
 * @author 牛牛
 * @version v1.0
 */
public class Test1 {

public static void main(String[] args) {
        // 创建一个数组
        int [] array = new int[3];
        array[0] = 10;
        array[1] = 20;
        array[2] = 30;

// 获取数组长度
        int length = array.length;
        // 遍历数组
        for (int i=0; i<length; i++) {
            System.out.println("数组中第"+(i+1)+"个元素的值为："+array[i]);
        }
    }
}
```
其中，`数组名.length`，用于**获取数组的长度**。

### 6、使用 Arrays 类操作 数组
`Arrays` 类是 Java 中提供的一个工具类，在 `java.util` 包中。

该类中包含了一些方法用来直接操作数组，比如可直接实现数组的排序、搜索等。

`Arrays` 中常用的方法有：
```
1、排序
2、将数组转换成字符串
3、数组查询
4、复制
5、比较
```
下面我们就来一一学习下。

在调用`Arrays`工具类之前，我们需要先引入该类包：

`import java.util.Arrays;`

#### 1、排序
`Arrays.sort()`方法用于对数组进行**升序**排序，而降序排序则需要特殊处理，在本章节中不深入讲解，有兴趣的小伙伴可以自行百度实现。

下面我们来看下案例代码：
```java
// 引入Array工具包
import java.util.Arrays;

/**
 * 通过arrays对象遍历数组的简单案例
 * @author 牛牛
 * @version v1.0
 */
public class Test1 {

public static void main(String[] args) {
        // 创建一个数组
        int [] array = new int[3];
        array[0] = 50;
        array[1] = 20;
        array[2] = 30;
        // 对数组升序排序
        Arrays.sort(array);
        // 获取数组长度
        int length = array.length;
        // 遍历数组
        for (int i=0; i<length; i++) {
            System.out.println("数组中第"+(i+1)+"个元素的值为："+array[i]);
        }
    }
}
```
最终得到结果：
```
数组中第1个元素的值为：20
数组中第2个元素的值为：30
数组中第3个元素的值为：50
```
从上面我们可以看出，`Arrays.sort()`方法的排序方式是会重置数组的下标元素的，跟PHP中的`sort()`函数一致。

#### 2、将数组转换成字符串
可以使用`Arrays.toString(数组名)`方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开：

下面我们来看下案例代码：
```java
// 引入Array工具包
import java.util.Arrays;

/**
 * 通过arrays对象将数组转换成字符串
 * @author 牛牛
 * @version v1.0
 */
public class Test1 {

public static void main(String[] args) {
        // 创建一个数组
        int [] array = new int[3];
        array[0] = 50;
        array[1] = 20;
        array[2] = 30;

System.out.println("数组中的元素为："+Arrays.toString(array));
    }
}
```
最终得到结果：
```
数组中的元素为：[50, 20, 30]
```

####3、数组查询
`Arrays.binarySearch()`采用二分查找的方式查找某个元素，可以在整个数组中查找，也可以在某个范围内查找。

以int数组来分析，其他类型的数组原理一样：
```java
// 引入Array工具包
import java.util.Arrays;

/**
 * 通过arrays对象在数组中查找内容
 * @author 牛牛
 * @version v1.0
 */
public class Test1 {

public static void main(String[] args) {
        // 创建一个数组
        int [] array = new int[6];
        array[0] = 1;
        array[1] = 2;
        array[2] = 3;
        array[3] = 4;
        array[4] = 5;
        array[5] = 6;

System.out.println("查找到的元素下标为："+Arrays.binarySearch()(array, 4));
    }
}
```
最终得到结果：
```
查找到的元素下标为：3
```

#### 4、复制
`Arrays.copyOf()`：将原始数组的元素，复制到新的数组中，可以设置复制的长度（即需要被复制的元素个数）。

`Arrays.copyOfRange()`：将某个范围内的元素复制到新的数组中。

以int数组来分析，其他类型的数组原理一样:
```java
// 引入Array工具包
import java.util.Arrays;
/**
 * 通过arrays对象对数组进行复制
 * @author 牛牛
 * @version v1.0
 */
public class Test1 {

public static void main(String[] args) {
        // 创建一个数组
        int [] array = new int[4];
        array[0] = 1;
        array[1] = 2;
        array[2] = 3;
        array[3] = 4;

System.out.println("原始数组："+Arrays.toString(array));

// 复制
        int [] a;
        int [] b;
        // 将array数组的内容复制到a数组中，如果新的数组长度大于原来数组的长度，那么用0来填充元素内容
        a = Arrays.copyOf(array,7);
        b = Arrays.copyOf(array,3);

System.out.println("数组a："+Arrays.toString(a));
        System.out.println("数组b："+Arrays.toString(b));

// 范围复制
        int [] c;
        c = Arrays.copyOfRange(array,2,4);
        System.out.println("数组c："+Arrays.toString(c));
    }
}
```
最终得到结果：
```
原始数组：[1, 2, 3, 4]
数组a：[1, 2, 3, 4, 0, 0, 0]
数组b：[1, 2, 3]
数组c：[3, 4]
```

#### 5、比较
`Array.equals()`，用于判断两个数组中的元素是否一一对应相等。

以int数组来分析，其他类型的数组原理一样：
```java
// 引入Array工具包
import java.util.Arrays;

/**
 * 通过arrays对象对数组进行集合比较
 * @author 牛牛
 * @version v1.0
 */
public class Test1 {

public static void main(String[] args) {
        // 创建数组
        int[] a = new int[]{1,2,3};
        int[] b = null;
        int[] c = new int[]{};
        int[] d = new int[]{1,2,3};

// 比较
        System.out.println(Arrays.equals(a, b));
        System.out.println(Arrays.equals(a, c));
        System.out.println(Arrays.equals(a, d));
        System.out.println(Arrays.equals(b, c));
        System.out.println(Arrays.equals(b, d));
        System.out.println(Arrays.equals(c, d));
    }
}
```
最终得到结果：
```
false
false
true
false
false
false
```

### 二维数组相关
###1、声明数组并分配空间
语法：
```
数据类型 [][] 数组名 = new 数据类型[行的个数][列的个数]
```
例如：
```java
int [][] age = new int[3][2];
```

###2、赋值
二维数组的赋值，和一维数组类似，可以通过下标来逐个赋值，注意索引从 `0` 开始。

语法:
```
数组名[行的索引][列的索引] = 值;
```
例如:
```java
age[0][0] = 12;
age[0][1] = 34;
```

###3、遍历二维数组
在输出二维数组元素时，与一维数组类似，需要使用循环，二维数组需要使用**多重循环**:
```java
/**
 * 二维数组遍历
 * @author 牛牛
 * @version v1.0
 */
public class Test1 {

public static void main(String[] args) {
        // 创建一个两行三列的二维数组
        int [][] array = new int[][]{{1,2,3}, {4,5,6}};
        // 定位行
        for (int i=0; i<array.length;i++) {
            // 定位每行的元素
            for (int k=0; k<array[i].length;k++) {
                // 依次输出每个元素
                System.out.println(array[i][k]);
            }
        }
    }
}
```
结果自行测试。

### 4、不规则二维数组
在定义二维数组时也可以只指定行的个数，然后再为每一行分别指定列的个数。

如果每行的列数不同，则创建的是不规则的二维数组：

代码示例:
```java
// 引入Array工具包
import java.util.Arrays;

/**
 * 不规则二维数组
 * @author 牛牛
 * @version v1.0
 */
public class Test1 {

public static void main(String[] args) {
        // 创建一个指定三行的不规则二维数组
        int [][] array = new int[3][];
        array[0] = new int[]{1,2,3};
        array[1] = null;
        array[2] = new int[4];
        array[2][2] = 3;

// 定位行
        for (int i=0; i<array.length;i++) {
            // 依次输出每列的一维数组
            System.out.println(Arrays.toString(array[i]));
        }
    }
}
```
最终结果如下:
```
[1, 2, 3]
null
[0, 0, 3, 0]
```

已有0条评论

添加新评论☺

如果认为本文对您有所帮助请赞助本站

支付宝扫一扫赞助

已有0条评论

添加新评论☺