基本概念

  1. java中的数组属于引用数据类型（数组的父类是Object）
  2. 数组是一个容器，可以容纳多个元素
  3. 可储存的元素
    • 基本数据类型的数据
    • 引用数据类型的数据
  4. 数组存储在堆内存中
  5. 数组中如果存储的是java对象，实际上是存储的对象的引用
  6. 所有的数组都有length属性，用来获取数组中元素的个数
  7. java中的数组要求数组中的元素类型统一
    • 例如： int数组只能存储int类型元素
  8. 数组在内存方面存储的时候数组中的元素内存地址是连续的
  9. 所有数组都是拿着首元素的内存地址当作整个数组的内存地址

  10. 数组中的下标从0开始，以1递增 最后一个 length-1

    创建数组

  11. 静态初始化

语法：int[] array = {1,2,3,4,5,6};

  1. 动态初始化

语法：int[] array = new int[5];// 这里面的5代表的是元素个数
初始化5个元素的一维数组int类型，默认值为0；

  1. 创建数组时 ，如果知道数组的值 直接静态初始化，否则动态初始化
  2. 在java中创建数组可以以c++的方式写
    • int[] a = {}; java风格
    • int a[] = {}; c++风格

读和改

  • 所有的数组都有length属性
  • 读
    • **数组名[下标] **
    • 数组名[a.length-1] //访问最后一个元素
  • 改
    • **a[下标] = 值;**
  • Object数组
    • Object数组什么样的数据都可以储存，万能的口袋

优缺点

优点

检索效率高

  1. 每一个元素的内存地址在空间存储上是连续的
  2. 每一个元素类型相同，所占用的空间大小一样

  3. 知道一个元素的内存地址，知道每一个元素占用空间的大小，又知道下标，所以通过一个数学表达式，就可以计算出某个下标元素的地址，直接通过地址定位，所以检索效率是最高的

    缺点

  4. 由于为了保证内存地址的连续，增删改效率较低

    • 因为在增删改时，后面的元素都要向前或者向后位移
  5. 数组不能储存大数据量
    • 很难在堆内存中找到一块特别大的且连续的内存空间
  6. 对于数组中最后一个元素的增删改是没有任何效率影响的

深入一维数组

  1. 对于数组来说：实际上只能存储java对象的内存地址
  2. 数组存入的元素是引用
  3. 父类型的数组是可以储存子类型对象的

例如：Animal[] animals ={ new Cat(), new Dog()}
有继承关系
数组的扩容

  1. 在java中数组一旦长度确定不可以改变，满了就需要扩容
  2. 先创建一个大容量的数组，将小容量的数组拷贝到大容量数组中

数组拷贝： System.arraycopy(五个参数);
拷贝源 2.源的起点 3. 目标 4.目标的起点 5.要烤多长

Arrays工具类的使用

  • java.util.Arrays; 包下
  • 排序 Arrays.sort(数组)
  • 二分法查找 Arrays.binarySearch(数组，要查找的值)

二维数组

  • 二维数组是特殊的一维数组
  • 特殊在这个一维数组中没一个元素都是一维数组

创建二维数组

静态初始化:

  1. int[][] a = {
  2.     { }
  3.     { }
  4. };

动态初识化:

  1. int[][] a1 = new int [3][4];"
  2. //表示三行四列 三个一维数组，每个一维数组里面有4个元素

二维数组的length属性

  • **a.length** 是二维数组中有几个一维数组
  • **a[0].length** 是二维数组中下标为0的以为数组中有几个元素

二维数组的读和改

读
**数组名[1][1];** 表示第二个一维数组中第二个元素
改
**数组名[下标][下标] = 值；**

二维数组的遍历

  1. //二维数组的遍历
  2. int[][] arr={
  3.     {1,2,3},
  4.     {2,3,4},
  5.     {3,4,5}
  6. };
  7. for(int i = 0; i < arr.length;i++){
  8.     for(int j = i; j < arr[i].length;j++){
  9.         System.out.println(arr[i][j]);
  10.     }
  11. }