Java入门第31课——数组

逃离我推掉我的手 2022-01-30 14:19 674阅读 0赞

1.1 什么是数组

1.1.1 什么是数组

· 程序=算法+数据结构；

· 前面学习的if、if-else、switch、循环解决的都是流程问题，即算法问题。

· 所谓数据结构，简单说就是把数据按照特定的某种结构来保存，设计合理的数据结构是解决问题的前提。

· 数组就是最基本的一种数据结构。

image.png

什么是数组(续1)

· 相同数据类型的元素组成的集合

· 元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素(“一个跟一个”)

· 可以通过元素所在位置的顺序号(下标)做标识来访问每一个元素(下标从0开始，最大到元素个数-1)


















a[0] a[1] a[2] … … …  a[n-1]
10 23 30 … … …  

1.2 数组的定义

1.2.1 定义基本类型数组

· 声明数组的语法：

数据类型[] 数组名=new 数据类型[大小];

image.png

定义基本类型数组(续1)

· 定义基本类型数组的要点：

- 确切的数据类型

- 整体的数组名字

- 不能缺少的”[]“

· 执行new语句才能使得数组分配到了指定大小的空间

· int[] arr与int arr[]两种写法均可

· 声明数组时不规定数组长度，new关键字分配空间时需指定分配的空间大小

1.3 数组的初始化

1.3.1 初始化数组

· 基本类型的数组创建后，其元素的初始值：byte、short、char、int、long为0；float和double为0.0;boolean为false

· 可以在数组声明的同时对数组的元素进行初始化，例如：

int [] arr={10,23,30,-10,21};

元素的个数即为数组的长度

· 此种写法只能用于声明时的初始化，不能用于赋值。如下面代码会有编译错误。

  1. int[] arr;
  2. arr={10,23,30,-10,21}

初始化数组(续1)

· 可以通过下面的方式给已经声明的数组类型变量进行初始化：

  1. int[] arr;
  2. arr=new int[]{10,23,30,-10,96};

注意：[]中不可以写长度，元素的个数就是数组的长度。

1.4 数组的访问

1.4.1 获取数组的长度

· 调用数组的length属性可以获取数组的长度：

  1. int[] arr=new int[]{3,6,8,9}
  2. int len=arr.length;
  3. System.out.println("数组长度为:"+len);
  4. 上述代码输出结果为:数组长度为：4

1.4.2 通过下标访问数组元素

· 数组中的元素通过下标的方式进行访问：

注意：下标从0开始，最大到length-1

· 例如：

  1. int[] arr=new int[]{4,5,6,8}
  2. int temp=arr[2];//获取第3个元素——6
  3. //交换数组下标为2和3的两个相邻元素的值
  4. int temp=arr[2];
  5. arr[2]=arr[3];
  6. arr[3]=temp;
  7. //交换后结果：4,5,8,6

1.4.3 遍历数组元素

· 遍历数组元素，通常选择for循环语句，循环变量作为访问数组元素的下标，即可访问数组中的每一个元素

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

· 注意：循环的计数器的变化范围从0~length-1

遍历数组元素(续1)

· 遍历数组元素，正序输出

  1. int[] arr=new int[]{10,20,30,40,50};
  2.     for(int i=0;i<arr.length;i++){
  3.         System.out.println(arr[i]);
  4.     }

· 遍历数组元素，逆序输出

  1. int[] arr=new int[]{10,20,30,40,50};
  2.     for(int i=(arr.length-1);i>=0;i--){
  3.         System.out.println(arr[i]);
  4.     }

1.5 数组的复制

1.5.1 System.arraycopy方法用于数组复制

· 使用System.arraycopy()方法可以实现数组的复制

  1.     public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
  2.         src        - 源数组
  3.         srcPos     - 原数组中的起始位置
  4.         dest       - 目标数组
  5.         destPos    - 目标数组中的起始位置
  6.         length     - 要复制的数组元素的数量

System.arraycopy方法用于数组复制(续1)

  1.  int[] a={10,20,30,40,50};
  2.     int[] a1=new int[6];
  3.     System.arraycopy(a,1,a1,0,4);

image.png

1.5.2 Arrays.copyOf方法用于数组复制

· 使用java.util.Arrays类的copyOf方法可实现数组的复制

类型[] newArray=Arrays.copyOf(类型[] original,int newLength);

· 特点：生成的新数组时原始数组的副本

newLength小于源数组，则进行截取

newLenth大于源数组，则用0或null进行填充

· 所以产生的新数组可以大于源数组的长度

  1. int[] a={10,20,30,40,50};
  2.     int[] a1=Arrays.copyOf(1,6);

a1数组元素为：10 20 30 40 50 0

1.5.3 数组的扩容

· 数组的长度在创建后是不可改变的，所谓扩容是指创建一个更大的新数组并将原有数组的内容复制到其中。

· 可以通过Arrays.copyOf()方法，简便实现数组的扩展。

  1. int[] a={10,20,30,40,50};
  2. a=Arrays.copyOf(a,a.length+1);

扩展后的数组 原数组 扩展后的长度

输出a数组元素：10,20,30,40,50,0

1.6 数组排序

1.6.1 数组的排序

· 排序是对数组施加的最常用的算法；

· 所谓排序，是指将数组元素按照从小到大或从大到小的顺序重新排列；

· 对于元素较多的数组，排序算法的优劣至关重要；

· 一般情况下，通过排序过程中数组元素的交换次数来衡量排序算法的优劣；

· 常用的排序算法有：插入排序、冒泡排序、快速排序等。

1.6.2 数组冒泡排序算法

· 冒泡排序的原则：比较相邻的元素，如果违反最后的顺序准则，则交换

· 可以简化理解为：

- 第一次找到所有元素中最大的放在最后一个位置上，不再变动；

- 第二次找到剩余所有元素中最大的放在倒数第二个位置上，不再变动。

- 以此类推，直到排序完成。

· 比较时既可以采用”下沉”的方式，也可以使用”上浮”的方式实现。

数组冒泡排序算法(续1)

image.png

1.6.3 Arrays.sort方法用于数组排序

· JDK提供的Arrays.sort()方法封装了数组的排序算法：

  1. int[] arr={49,81,1,64,77,50,0,54,77,18};
  2.     Arrays.sort(arr);
  3.     for(int i=0;i<arr.length;i++){
  4.         System.out.println(arr[i]);
  5.     }

输出结果：0 1 18 49 50 54 64 77 77 81

学习网址：http://java.itkzhan.com/

发表评论

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

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

相关阅读