JavaSE 基础（八）数组

Uanmo

已于 2023-09-25 21:25:02 修改

阅读量99

点赞数

分类专栏： Java 文章标签： java javase 编程语言

于 2021-03-18 14:33:01 首次发布

本文链接：https://blog.csdn.net/qq_42651415/article/details/114977513

版权

Java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1. 数组的定义

数组是相同类型数据的有序集合。
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
其中，每一个数组称作一个数组元素，每个数组元素可以通过一个下标来访问它们。

2. 数组的声明和创建

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

dataType[] arrayName; //首选方法（Java风格）
dataType arrayName[]; //次选方法（C/C++风格）

Java 语言使用 new 操作符来创建数组，语法如下：

dataType[] arrayName;					//声明
arrayName = new dataType[arraySize];	//创建
arrayName[arrayOrder] = value;			//赋值

数组的元素是通过索引访问的，数组索引从 0 开始。

获取数组长度：arrays.length

//示例
int[] nums;         //声明
nums = new int[10]; //创建
nums[0] = 1;        //赋值

3. 数组的基本特点

数组的长度是确定的。数组一旦被创建，它的大小就是不可改变的。
其元素必须是相同类型，不允许出现混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量，声明在栈中，创建保存在堆中。

4. 初始化

静态初始化

dataType[] arrayName = {value1, value2, ......}

动态初始化

dataType[] arrayName = new dataType[arraySize];
arrayName[arrayOrder] = value;

默认初始化
- 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素被按照实例变量的类型进行初始化。
- int 的默认值为 0；float 的默认值为 0.0，double 的默认值为 0.0，boolean 的默认值为 false，除基本类型外其余全部为null。
数组越界
- 数组创建时，数组的下标是从0开始计算的，其合法区间为 [0, length-1]。
```
int[] nums;         //声明
nums = new int[10]; //数组下标为[0,1,2,3,4,5,6,7,8,9]
System.out.println(nums[10]);
```
- 上面的程序控制台会提示信息 ArrayIndexOutOfBoundsException，这就是数组越界异常。

5. 数组的使用

循环遍历数组

普通 for 循环

//含下表，适合编写业务逻辑
for(int temp = 0; temp < arrays.length; temp++){
    System.out.println(arrays[temp]); //打印
}

增强 for 循环

//无下标，适合打印
for(int array : arrays){
    System.out.println(array); //打印
}

取到数组的每个元素后，就可以利用数组元素编写业务逻辑了。

/**
 *示例：反转数组
 * @param   arrays 待处理数组
 * @return  result 返回结果
 */
public static int[] reverse(int[] arrays){
    int[] result = new int[arrays.length];
    for (int i = 0, j = result.length-1; i < arrays.length ; i++, j--) {
        result[j] = arrays[i];
    }
    return result;
}
//运行结果
数组: [1,2,3,4]
反转: [4,3,2,1]

6. 多维数组

多为数组可视为数组中嵌套数组，即数组的元素还是数组。

以二维数组为例

此数组可视为2行3列的数组
```
int arrays[][] = new int [2][3];
```

更具体一点

/**
 *	可将其视为从0行0列开始的矩阵（表）来理解
 *	1,2,3
 *	4,5,6
 */
int[][] arrays = {{1,2,3},{4,5,6};

二维数组的使用

/**
 * 打印二维数组
 * @param arrays
 */
public static void printTwoArrays(int[][] arrays){
    for (int i = 0; i < arrays.length; i++) {
        for (int j = 0; j < arrays[i].length; j++) {
            System.out.println(arrays[i][j]);
        }
    }
}

理解了二维数组后，三维数组就不难理解了。

/**
 *	本质就是数组嵌套数组，套就完了
 *	{1,2},{3,4}
 *	{5,6},{7,8}
 */
int[][][] arrays = {{{1,2},{3,4}},{{5,6},{7,8}};

7. Arrays类

Arrays类中包装了很对多操作数组的方法
- 通过 JDK 的帮助文档查看类
  
  $[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0QIdHiQj-1616048486461)(E:\Program Files\Typora\files\JavaSE基础\image\javaApi1.8_Arrays.jpg)]$
- 通过 IDEA 查看类
  - 新建类 --> 在 main 方法中键入 Arrays --> 按住 Ctrl 点击 Arrays --> 点击IDEA 窗口左下角的 Structure
  - 打开 Structure 窗口：点击 IDEA 工具栏的 View --> 点击 Tool Windows --> 点击 Structure

举个栗子

对数组进行排序

int[] arrays = {2, 6, 8, 9, 0, 1, 4, 7};        //定义数组
System.out.println(Arrays.toString(arrays));    //转换为字符串输出
Arrays.sort(arrays);                            //字典排序
System.out.println(Arrays.toString(arrays));    //转换成字符串输出
//结果
[2, 6, 8, 9, 0, 1, 4, 7]
[0, 1, 2, 4, 6, 7, 8, 9]

字典排序：数字从小到大，字母从 a-z，A-Z。

8. 冒泡排序

原理：
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
  
  $[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9T8Gm92i-1616048486469)(E:\Program Files\Typora\files\JavaSE基础\image\BubbleSort.gif)]$

Java 实现

/**
 * 冒泡排序
 * @param  arrays   待排序数组
 * @return arrays   返回结果
 */
public static int[] sort(int[] arrays){
    //临时变量
    int temp = 0;                                      
    //遍历数组，length-1 防止数组越界
    for (int i = 0; i < arrays.length-1; i++) {        
		//遍历数组，length-1-i去除多余循环
        //每次循环都会找出一个最大值，确定的最大值不需要再次比较
        for (int j = 0; j < arrays.length-1-i; j++) {  
            if(arrays[j+1] < arrays[j]){			   //比较
                temp = arrays[j];                      //交换元素
                arrays[j] = arrays[j+1];
                arrays[j+1] = temp;
            }
        }
    }
    return arrays;                                     //返回结果
}

/**
 * main 方法，测试使用
 * @param args
 */
public static void main(String[] args) {
    int[] arrays = {54,2,14,11,10,48,91,52,20};         //定义数组
    int[] result = sort(arrays);                        //调用函数
    System.out.println(Arrays.toString(result));        //打印数组
}

//结果
[2, 10, 11, 14, 20, 48, 52, 54, 91]

9. 稀疏数组

当一个数组中大部分元素为0，或者为同一值时，可以使用稀疏数组来保存该数组，以节省存储空间。
处理方式如下：
- 记录数组的行列及有效值个数（下图中表的第一行）。
- 记录数组有效值下标及值（下图中表的余下行）。
如下图：左边为原始数组，右边为稀疏数组。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u3UMHd1B-1616048486475)(E:\Program Files\Typora\files\JavaSE基础\image\稀疏数组.jpg)]$

实现上图稀疏数组：

创建原始数组

/**
 * 创建数组
 * @return arrays 返回数组
 */
public static int[][] createArrays(){
    int[][] arrays = new int[6][7];
    arrays[0][2] = 2;
    arrays[1][1] = 3;
    arrays[2][6] = 1;
    arrays[3][4] = 7;
    arrays[4][0] = 4;
    arrays[5][5] = 1;
    return arrays;
}

转换原始数组为稀疏数组

/**
 * 转换为稀疏数组
 * @param  arrays       原始数组
 * @return sparseArrays 稀疏数组
 */
public static int[][] transSparse(int[][] arrays){

    //计算有效值个数
    int sum = 0;
    for (int i = 0; i < arrays.length; i++) {
        for (int j = 0; j < arrays[i].length; j++) {
            if(arrays[i][j] != 0){
                sum++;
            }
        }
    }

    //初始化稀疏数组的第一行
    int[][] sparseArrays = new int[sum+1][3];
    sparseArrays[0][0] = 6;
    sparseArrays[0][1] = 7;
    sparseArrays[0][2] = sum;

    //初始化稀疏数组的余下行（遍历原始数组，赋值给稀疏数组）
    int count = 0;
    for (int i = 0; i < arrays.length; i++) {
        for (int j = 0; j < arrays[i].length; j++) {
            if(arrays[i][j] != 0){
                count++;
                sparseArrays[count][0] = i;
                sparseArrays[count][1] = j;
                sparseArrays[count][2] = arrays[i][j];
            }
        }
    }
    return sparseArrays;
}

还原稀疏数组为原始数组

/**
 * 还原稀疏数组
 * @param  sparseArrays 稀疏数组
 * @return arrays       原始数组
 */
public static int[][] restoreArrays(int[][] sparseArrays){

    //读取稀疏数组
    int[][] arrays = new int[sparseArrays[0][0]][sparseArrays[0][1]];
    //还原值，i=1，稀疏数组第一行是行列及有效值个数，不需要还原
    for (int i = 1; i < sparseArrays.length; i++) {
        arrays[sparseArrays[i][0]][sparseArrays[i][1]] = sparseArrays[i][2];
    }
    return arrays;
}

打印二维数组

/**
 * 打印二维数组
 * @param arrays
 */
public static void printTwoArray(int[][] arrays){
    for (int[] array : arrays){
        for (int arr : array){
            System.out.print(arr + "\t");
        }
        System.out.println();
    }
}

测试

/**
 * main 方法，测试使用
 * @param args
 */
public static void main(String[] args) {
    System.out.println("======== 原始数组 ========");  //华丽的分割线
    int[][] arrays1 = createArrays();                 //创建原始数组
    printTwoArray(arrays1);                           //打印原始数组
    System.out.println("======== 稀疏数组 ========");  //华丽的分割线
    int[][] sparseArrays = transSparse(arrays1);      //转换稀疏数组
    printTwoArray(sparseArrays);                      //打印稀疏数组
    System.out.println("======== 原始数组 ========");  //华丽的分割线
    int[][] arrays2 = restoreArrays(sparseArrays);    //还原稀疏数组
    printTwoArray(arrays2);                           //打印原始数组
}

测试结果

稀疏数组的代码不难理解，对照着图来看代码会简单得多。

Uanmo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE 基础（八）数组

1. 数组的定义数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数组称作一个数组元素，每个数组元素可以通过一个下标来访问它们。2. 数组的声明和创建首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：dataType[] arrayName; //首选方法（Java风格）dataType arrayName[]; //次选方法（C/C++风格）Java 语言使用 new 操作符来创建数组，语法如下：
复制链接

扫一扫

专栏目录