JavaSE基础入门Day6、7

数组

数组的概念

为什么使用数组

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

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

    • 缺点:麻烦,重复操作过多

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

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

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

 

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

    • 特点:

      1. 类型相同

      2. 长度固定

数组的声明与赋值

数组的创建

1 //数据类型[] 变量名 = new 数据类型[长度];
2 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, ... } ;// 长度就是值的数量

    • 换行操作:

    • 1 int[] intArray;
      2 intArray = new int[]{11,22,33,44}
      3 =====上下两种方式等价=====
      4 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快速排序

  • 数组的应用:

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

猜你喜欢

转载自www.cnblogs.com/77-is-here/p/12889102.html
今日推荐