Java数组（Array）

àì夳堔傛蜴生んèń 2023-07-17 04:44 253阅读 0赞

数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

数组相关的概念：

  • 数组名
  • 元素
  • 角标、下标、索引
  • 数组的长度：元素的个数

数组的特点：

  1. 数组是按序排列的
  2. 数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
  3. 创建数组对象会在内存中开辟一整块连续的空间
  4. 数组的长度一旦确定，就不能修改。

数组的分类：

  • ① 按维数：一维数组、二维数组、… 、n维数组
  • ②按数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

一维数组

声明与初始化

  1. //正确的方式：
  2.         int num;//声明
  3.         num = 10;//初始化
  4.         int id = 1001;//声明 + 初始化
  6.         int[] ids;//声明
  7.         //1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
  8.         ids = new int[]{ 1001,1002,1003,1004};
  9.         //1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
  10.         String[] names = new String[5];
  12.     int[] arr4 = { 1,2,3,4,5};//类型推断

错误的方式：

  1. // int[] arr1 = new int[];
  2. // int[5] arr2 = new int[5];
  3. // int[] arr3 = new int[3]{1,2,3};

一维数组元素的引用：通过角标的方式调用。
//数组的角标（或索引从0开始的，到数组的长度-1结束。

  1. names[0] = "王铭";
  2. names[1] = "王赫";
  3. names[2] = "张学良";
  4. names[3] = "孙居龙";
  5. names[4] = "王宏志";//charAt(0)

数组的属性：length

  1. System.out.println(names.length);//5
  2. System.out.println(ids.length);

说明：
数组一旦初始化，其长度就是确定的。arr.length
数组长度一旦确定，就不可修改。
4.一维数组的遍历
for(int i = 0;i < names.length;i++){
System.out.println(names[i]);
}
5.一维数组元素的默认初始化值

数组元素是整型：0

  • 数组元素是浮点型：0.0

  • 数组元素是char型：0或’\u0000’，而非’0’

  • 数组元素是boolean型：false

  • 数组元素是引用数据类型：null

6.一维数组的内存解析
在这里插入图片描述

二维数组

  • 数组属于引用数据类型
  • 数组的元素也可以是引用数据类型
  • 一个一维数组A的元素如果还是一个一维数组类型的，则，此数组A称为二维数组。

二维数组的声明与初始化
正确的方式：

  1. int[] arr = new int[]{ 1,2,3};//一维数组
  2.     //静态初始化
  3.     int[][] arr1 = new int[][]{ { 1,2,3},{ 4,5},{ 6,7,8}};
  4.     //动态初始化1
  5.     String[][] arr2 = new String[3][2];
  6.     //动态初始化2
  7.     String[][] arr3 = new String[3][];
  8. //也是正确的写法：
  9.     int[] arr4[] = new int[][]{ { 1,2,3},{ 4,5,9,10},{ 6,7,8}};
  10.     int[] arr5[] = { { 1,2,3},{ 4,5},{ 6,7,8}};//类型推断

错误的方式：

  1. // String[][] arr4 = new String[][4];
  2. // String[4][3] arr5 = new String[][];
  3. // int[][] arr6 = new int[4][3]{ {1,2,3},{4,5},{6,7,8}};

如何调用二维数组元素:

  1. System.out.println(arr1[0][1]);//2
  2.         System.out.println(arr2[1][1]);//null
  4.         arr3[1] = new String[4];
  5.         System.out.println(arr3[1][0]);
  6.     System.out.println(arr3[0]);//

二维数组的属性：

  1. System.out.println(arr4.length);//3
  2.         System.out.println(arr4[0].length);//3
  3.         System.out.println(arr4[1].length);//4

遍历二维数组元素：

  1. for(int i = 0;i < arr4.length;i++){ 
  3.             for(int j = 0;j < arr4[i].length;j++){ 
  4.                 System.out.print(arr4[i][j] + " ");
  5.             }
  6.             System.out.println();
  7.     }

二维数组元素的默认初始化值

  • 规定：二维数组分为外层数组的元素，内层数组的元素
    int[][] arr = new int[4][3];
    外层元素：arr[0],arr[1]等
    内层元素：arr[0][0],arr[1][2]等

    数组元素的默认初始化值
    针对于初始化方式一：比如：int[][] arr = new int[4][3];
    外层元素的初始化值为：地址值
    内层元素的初始化值为：与一维数组初始化情况相同

    针对于初始化方式二：比如：int[][] arr = new int[4][];
    外层元素的初始化值为：null
    内层元素的初始化值为：不能调用，否则报错。

二维数组的内存结构

在这里插入图片描述

数组常见用法

1.数组的创建与元素赋值：
杨辉三角（二维数组）、回形数（二维数组）、6个数，1-30之间随机生成且不重复。
2.针对于数值型的数组：
最大值、最小值、总和、平均数等
3.数组的赋值与复制

  1. int[] array1,array2;
  2. array1 = new int[]{ 1,2,3,4};

3.1 赋值：

  1. array2 = array1;

如何理解：将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。
在这里插入图片描述
3.2 复制：

  1. array2 = new int[array1.length];
  2. for(int i = 0;i < array2.length;i++){ 
  3. array2[i] = array1[i];
  4. }

在这里插入图片描述
如何理解：我们通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。
4.数组元素的反转

  1. //方法一：
  2. // for(int i = 0;i < arr.length / 2;i++){ 
  3. // String temp = arr[i];
  4. // arr[i] = arr[arr.length - i -1];
  5. // arr[arr.length - i -1] = temp;
  6. // }
  8. //方法二：
  9. // for(int i = 0,j = arr.length - 1;i < j;i++,j--){ 
  10. // String temp = arr[i];
  11. // arr[i] = arr[j];
  12. // arr[j] = temp;
  13. // }

5.数组中指定元素的查找：搜索、检索
5.1 线性查找：
实现思路：通过遍历的方式，一个一个的数据进行比较、查找。
适用性：具有普遍适用性。
5.2 二分法查找：
实现思路：每次比较中间值，折半的方式检索。
适用性：（前提：数组必须有序）

6.数组的排序算法
在这里插入图片描述

理解：
1）衡量排序算法的优劣：
时间复杂度、空间复杂度、稳定性

2）排序的分类：内部排序 与 外部排序（需要借助于磁盘）

3）不同排序算法的时间复杂度

在这里插入图片描述
4）手写冒泡排序

  1. int[] arr = new int[]{ 43,32,76,-98,0,64,33,-21,32,99};
  3.     //冒泡排序
  4.     for(int i = 0;i < arr.length - 1;i++){ 
  6.         for(int j = 0;j < arr.length - 1 - i;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.             }
  14.         }
  16.     }

数组的常见异常

1.数组角标越界异常：ArrayIndexOutOfBoundsException

  1. int[] arr = new int[]{ 1,2,3,4,5};
  4. // for(int i = 0;i <= arr.length;i++){ 
  5. // System.out.println(arr[i]);
  6. // }
  8. // System.out.println(arr[-2]);
  10. // System.out.println("hello");

2.空指针异常：NullPointerException

  1. //情况一：
  2. // int[] arr1 = new int[]{1,2,3};
  3. // arr1 = null;
  4. // System.out.println(arr1[0]);
  6.         //情况二：
  7. // int[][] arr2 = new int[4][];
  8. // System.out.println(arr2[0][0]);
  10.         //情况：
  11.         String[] arr3 = new String[]{ "AA","BB","CC"};
  12.         arr3[0] = null;
  13.         System.out.println(arr3[0].toString());

小知识：一旦程序出现异常，未处理时，就终止执行。

发表评论

表情：
评论列表 （有 0 条评论，253人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java 数组Array

    > 数组 （ Array ）是有序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。 组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变

    比眉伴天荒比眉伴天荒/ 0 赞/ 180 阅读

    相关 Java之数组（Array）

    1.概念 数组 （Array）是有序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。 组成数组的各个变量称为数组的分量，也称为数组的元素，有时

    快来打我*快来打我*/ 0 赞/ 191 阅读

    相关 数组Array

    定义 有限个相同数据类型的变量的集合 数组属于引用数据类型，要先实例化 堆内存用来存放由new运算符创建的对象和数组，同一块堆内存空间可以由不同的栈内存

    清疚清疚/ 0 赞/ 148 阅读

    相关 数组Array

      对象数组和基本类型数组在使用上几乎是一致的，唯一的区别是对象数组保存的是对象引用， 基本类型数组直接保存基本类型的值。   新生成一个数组时，会初始化，如果是对象数组，

    偏执的太偏执、偏执的太偏执、/ 0 赞/ 367 阅读

    相关 数组_array

    数组:存储同一种数据类型的多个元素的容器。 定义格式： 　　A:数据类型\[\] 数组名; 　　B:数据类型 数组名\[\]; 举例： 　　A:

    短命女短命女/ 0 赞/ 542 阅读