数组

概述

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

数据名

下标或索引

元素

数组的长度

定义一个数组类型的变量，使用数组类型“类型[]”，例如，int[]。和单个基本类型变量不同，数组变量初始化必须使用new int[5]表示创建一个可容纳5个int元素的数组。
要访问数组中的某一个元素，需要使用索引。数组索引从0开始，例如，5个元素的数组，索引范围是0~4。
可以修改数组中的某一个元素，使用赋值语句，例如，ns[1] = 79;。

Java的数组有几个特点：

  • 数组是引用数据类型
  • 数据元素既可以是基础数据类型也可以是引用数据类型
  • 数据在内存中是连续的（链表是分散的）
  • 数据的长度一旦创建后，不可修改
  • 数组所有元素初始化为默认值，整型都是0，浮点型是0.0，布尔型是false，对象是null,详见，下面代码；

    分类

    维数

    一维数组、二维数组、多维数组

    元素

    基本数据类型的数组、引用数据类型的数组

    数组的使用

  1. 一维数组的声明和初始化
  2. 如何调用数组的指定位置和元素
  3. 如何获取数组的长度
  4. 如何遍历数组
  5. 数组元素的默认初始值
  6. 数组的内存解析
  1. public static void main(String args[]){
  2.     //声明
  3.     int ids[];
  4.     //静态初始化：数组初始化和元素复制同时进行
  5.     ids = new int[]{1,2,3,4};
  6.     //动态初始化：数组的初始化和数组元素的赋值分开进行
  7.     String names = new String[4];
  8.     //初始化的定义
  9.     String[] a = {"22","44"};
  11.     //错误定义 
  12.     //未定义长度
  13.     String a = new String[];
  14.     //[10]这里声明，定义长度在等号右边
  15.     String[10] b = new String[10];
  16.     //动态数组，先声明再赋值
  17.     String[] a = new String[12]{"22","44"};
  20.     //调用数组指定位置和元素
  21.     //声明数组后在初始化数组
  22.     names[0] = "1";
  23.     names[1] = "2";
  24.     names[2] = "3";
  25.     names[3] = "4";
  26.     //此时后面的数据将不能赋值，数组下标越界，初始化的时候数组长度只有4
  27.     names[4] = "5";
  28.     names[5] = "6";
  29.     //获取数组长度
  30.     String length = names.length();
  32.     //遍历数组
  33.     for(int a=0; a< length; a++){
  34.         System.out.println(names[a]);
  35.     }
  36.     //数组元素的初始化值
  37.     //数组元素是整数 初始化的值为 0
  38.        // 数组元素是浮点型 初始化的值为 0.0
  39.     // 数组元素是char型，初始化的值为 '0' 不是数值类型的0
  40.     // 布尔类型 ，初始化的值为 false
  41.     // 引用数据类型，初始化的值为null
  42.     int intArr = new int[3];
  44. }

数组的内存解析

  1. public static void main(String[] args){
  3.     int arr[] = new int[]{1,2,3};
  6.     String[] arr1 = new String[4];
  7.     arr1[1] = "哈";
  8.     arr1[2] = "你";
  9.     arr1 = new String[3];
  13. }

多维数组的使用

二维数组

  1. 一维数组的声明和初始化
  2. 如何调用数组的指定位置和元素
  3. 如何获取数组的长度
  4. 如何遍历数组
  5. 数组元素的默认初始值

  6. 数组的内存解析 ```java public static void main(String[] args){ // 1、二维数组的声明和初始化 // 一维数组初始化 int[] arr = new int[]{1,2,3}; // 静态初始化 int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}}; // 动态初始化1 String[][] arr2 = new String[2][3]; // 动态初始化2 String[][] arr3 = new String[2][]; // 错误的情况 String[][] arr4 = new String[][2]; String[2][3] arr5 = new String[][]; int[][] arr6 = new int[3][2]{{1,2,3},{4,5},{6,7,8}};

    // 2、获取指定位置的元素

    1. arr6[2][1];

    // 获取数组的长度 // 3、获取的是一维数组的长度 arr6.length();// 3 // arr6[0]的长度 3 // 4、数组遍历 for(int i=0; i < arr6.length; i++){

     for(int j=0; j<arr6[i].length; j++){
     System.out.println(arr6[i][j]);
 }

    } // 5、数组元素的默认初始化值 int[][] arr = new int[3][4]; System.out.println(arr[0]); // 是个地址值 [@1312321 System.out.println(arr[0][0]); // 0 System.out.println(arr); // [[@6546545

    String[][] arr = new String[3][4]; System.out.println(arr[0]); // 是个地址值 [@1312321 System.out.println(arr[0][0]); // null System.out.println(arr); // [[@6546545

int[][] arr = new int[3][];
System.out.println(arr[0]); // null
System.out.println(arr[0][0]); // 报错，空指针

// 初始化值 ： 总结
   初始化方式一： int[][] arr = new int[3][4];
    外层元素的初始化值为：地址值
    内层元素的初始化值为：与一维数组的初始化情况相同

初始化方式二： int[][] arr = new int[3][];
    外层元素的初始化值为：null
    内层元素的初始化值为：空指针异常

} ```

二维数组的内存结构

数组的常见算法

1、数组元素的赋值（杨辉三角、回形数）

2、求数值类型数组中元素的最大值、最小值、平均数、总和等

3、数组的复制、反转、查找（线性查找、二分法查找）

4、数组元素的排序算法

冒泡排序（降序、升序）

快速排序

Arrays 工具类 操作数组工具类

equals(int[] a, int[] b)

toString(int[] a)

fill(int[] a, int val)

sort(int[] a)

binarySearch(int[] a, int key)

数组中的异常

数组角标越界的异常
空指针异常