JavaSE基础入门_006_数组

数组

数组的概念

为什么使用数组

• 如何储存100名学生的成绩？

  • 办法：使用变量储存，重复声明100个double类型变量即可。

  • 缺点：麻烦，重复操作过多

• 如何让100名学生成绩全部 +1 ？

  • 办法：100个变量重复相同操作，直至全部完毕

  • 缺点：无法进行统一的操作

 

• 数组概念：一组连续的存储空间，存储多个相同数据类型的值。

  • 特点：

    1. 类型相同

    2. 长度固定

数组的声明与赋值

数组的创建

//数据类型[] 变量名 = new 数据类型[长度];
int[] nums = new int[5];

数组的使用

• 数组的每个数据格被称为“数组元素”。

• 对每个元素进行赋值或取值的操作被称为“元素的访问”。

• 访问元素时，需要使用“下标”（从0开始，依次+1，自动生成）。

• 访问的语法：数组名[下标]；//例如 存：a[0] = 10; 取：a[0];

 

 

数组的下标

下标的范围

• 有效下标范围: 0 ~ 数组长度-1

• 访问无效下标, 会导致数组下标越界[编译可以通过, 运行时会异常]

 

数组的遍历

• 遍历: 从头至尾, 逐一对数组的每个元素进行访问.

• 数组名.length 可动态获得数组长度

 

数组的默认值

• 在没有为数组元素赋值的情况下, 依旧可以正确访问.

• 数组默认值:

  • 数据类型	默认值
    整数	0
    小数	0.0
    字符	u0000
    布尔	false
    其他	null

 

数组创建语法

• 先声明, 再分配空间:

  • 数据类型[ ] 数组名;

  • 数组名 = new 数据类型[长度];

• 声明并分配空间:

  • 数据类型[ ] 数组名 = new 数据类型[长度];

• 声明并赋值(繁): // 推荐用法, 可换行

  • 数据类型[ ] 数组名 = new 数据类型[ ]{ value1, value2, value3, ... } ;// 长度就是值的数量

  • 换行操作:

  • int[] intArray;
    intArray = new int[]{11,22,33,44}
    =====上下两种方式等价=====
    int[] intArray = new int[]{11,22,33,44}

• 声明并赋值(简):

  • 数据类型[] 数组名 = { value1, value2, value3, ... }; //显式初始化, 注意: 不可换行

数组的扩容

• 非java官方提供的方式, 我们自己应用的一种方式.

• 创建数组时, 必须显示指定长度, 并在创建之后不可更改长度

• 扩容思路:

  • 创建大于原数组长度的新数组

  • 将原数组中的元素依次复制到新数组中

复制的方式

• 循环将原数组中所有元素逐一赋值给新数组.

• System.arraycopy( 原数组, 原数组起始, 新数组, 新数组起始, 长度 );
  // 长度: 要拷贝元素的个数

• java.util.Arrays.copyOf(原数组, 新长度); //返回带有原值的新数组
  //实际操作步骤:
  ​
  //1.导包:
  import java.util.Arrays;
  //2.调用函数:
  int[] newArray =  Arrays.copyOf(oldArray, oldArray.length*2);

地址的替换

• 数组作为引用类型之一, 其变量中存储的是数组的地址.

• 完成元素复制后, 需将新数组地址, 赋值给原变量进行替换.

 

数组类型的参数

• 赋值 == 复制

• 数组直接赋值: 将原变量的地址复制给新变量. 此时二者指向同一个数组.

 

数组类型的返回值

• 创建新数组, 长度为原数组的2倍, 新数组中保留原有数据, 返回新数组

 

可变长参数

• 概念: 可接受多个同类型的实参, 个数不限, 使用方式与数组相同.

• 语法：数据类型... 形参名 // 必须定义在形参列表的最后, 且只能有一个.

public static void  printArray(int... array)
    {
        for(int i = 0; i< array.length; i++)
        {
            System.out.print(array[i]+", ");
        }
    }

 

数组的排序

冒泡排序: 相邻的两个数值比较大小, 互换位置

• // 外层还剩多少个数需要比较, 比较的次数 = 还剩数的个数 - 1
  

  for(int i = 0;i < array.length - 1;i++)
          {
              // 内层(每一轮的操作)i
              for(int j = 0; j < array.length - 1 - i; j++)
              {
                  if(array[j]>array[j+1])
                  {
                      int temp = array[j];
                      array[j] = array[j+1];
                      array[j+1] = temp;
                  }
              }
          }

 

选择排序: 固定值与其他值依次比较大小, 互换位置

• for(int i  = 0; i < nums.length-1; i++)
          {
              //每次比较: 固定值与固定值后面的第一个值开始
              for(int j = i + 1; j < nums.length ;j++)
              {
                  
                  if(nums[i] > nums[j])
                  {
                      int temp = nums[i];
                      nums[i] = nums[j];
                      nums[j] = temp;
                  }
                  
              }
          }

 

• JDK排序: 

  java.util.Arrays.sort( 数组名 ); // JDK只提供 ( 升序 )

 

二维数组

• 概念: 一维数组中的一维数组; 数组中的元素, 还是数组.

二维数组的赋值

• 使用双下标访问二维数组中的元素

  • 第一个下标代表: 行号 (高维下标),

  • 第二个下标代表: 列号 (低维下标)

二维数组的内存分配

• int array[3][5]; // 定义一个三行五列的二维数组 array

• 高维数组中的每一个元素, 保存了低维数组的地址. 访问 array[0] 等价于访问 array中第一个一维数组的地址

二维数组的创建语法

• 先声明, 在分配空间:

  • 数据类型[ ][ ] 数组名;
    数组名 = new 数据类型[高维长度][低维长度];

• 声明并分配空间:

  • 数据类型[][] 数组名 = new 数据类型[高维长度][低维长度];

• 声明并赋值(繁):

  • 数据类型[][] 数组名 = new 数据类型[高维长度][]; 
    // 不规则数组,自行 new 低维数组, 自行指定低维数组长度
    int[][] array = new int[3][];
            array[0] = new int[3];
            array[1] = new int[4];
            array[2] = new int[5];

• 声明并赋值(简):

  • 数据类型[][] 数组名 = new int[][]{{v1,v2,v3},{v4,v5},{v6,v7,v8,v9}}; //显示初始化
    // 实例
    int[][] nums = new int[][]{{1,2,3},{4,5},{6,7,8,9,0}};

 

总结

• 数组的概念:

  • 一组连续的存储空间, 存储多个相同数据类型的值

• 数组的声明与赋值:

  • 数据类型[] 数组名 = new 数据类型[长度];

  • 数组名[下标] = 值;

• 数组的遍历:

  • 从头至尾, 逐一对数组的每个元素进行访问

• 数组的排序:

  • 冒泡排序, 选择排序, JDK快速排序

• 数组的应用:

  • 数组复制, 数组扩容, 数组参数, 数组返回值,二维数组