java自我学习第五章：数组

数组

数组的概念

数组概念： 数组就是用于存储数据的长度固定的容器，保证多个数据的数据类型要一致。

所谓数组(array)，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，以便统一管理他们，然后用编号区分他们，这个名字称为数组名，编号称为下标或索引(index)。组成数组的各个变量称为数组的元素(element)。数组中元素的个数称为数组的长度(length)。

数组的特点：

1、数组的长度一旦确定就不能修改

2、创建数组时会在内存中开辟一整块连续的空间。

3、存取元素的速度快，因为可以通过[下标]，直接定位到任意一个元素。

数组的定义

方式一：静态初始化

数据类型[] 数组名 = {元素1,元素2,元素3...};//必须在一个语句中完成，不能分开两个语句写

举例：

int[] arr = {1,2,3,4,5};//正确

int[] arr;
arr = {1,2,3,4,5};//错误

方式二：静态初始化

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
或
数据类型[] 数组名;
数组名 = new 数据类型[]{元素1,元素2,元素3...};

举例：

int[] arr = new int[]{1,2,3,4,5};//正确

int[] arr;
arr = new int[]{1,2,3,4,5};//正确

int[] arr = new int[5]{1,2,3,4,5};//错误的，后面有{}指定元素列表，就不需要在[长度]指定长度。

方式三：动态初始化

格式： 

数组存储的元素的数据类型[] 数组名字 = new 数组存储的元素的数据类型[长度];
 
  或

 数组存储的数据类型[] 数组名字;
 数组名字 = new 数组存储的数据类型[长度];

数组定义格式详解：

• 数组存储的元素的数据类型： 创建的数组容器可以存储什么数据类型的数据。

• 元素的类型可以是任意的Java的数据类型。例如：int, String, Student等

• [] : 表示数组。

• 数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。

• new：关键字，创建数组使用的关键字。因为数组本身是引用数据类型，所以要用new创建数组对象。

• [长度]：数组的长度，表示数组容器中可以存储多少个元素。

• 注意：数组有定长特性，长度一旦指定，不可更改。

  • 和水杯道理相同，买了一个2升的水杯，总容量就是2升，不能多也不能少。

举例：

int[] arr = new int[5];

int[] arr;
arr = new int[5];

数组元素的访问

• 索引： 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

• 索引范围：[0, 数组的长度-1]

• 格式：数组名[索引]

索引访问数组中的元素：

• 数组名[索引]=数值，为数组中的元素赋值

• 变量=数组名[索引]，获取出数组中的元素   

• 举例：

  //定义存储int类型数组，赋值元素1，2，3，4，5
    int[] arr = {1,2,3,4,5};
    //为0索引元素赋值为6
    arr[0] = 6;
    //获取数组0索引上的元素
    int i = arr[0];
    System.out.println(i);
    //直接输出数组0索引元素
    System.out.println(arr[0]);

数组的遍历

• 数组的长度属性： 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为：数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为数组名.length-1。

• 数组遍历： 就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

int[] arr = new int[]{1,2,3,4,5};
  	//打印数组的属性，输出结果是5
  	System.out.println("数组的长度：" + arr.length);
    
    //遍历输出数组中的元素
    System.out.println("数组的元素有：");
    for(int i=0; i<arr.length; i++){
        System.out.println(arr[i]);
    }

数组元素的默认值

数组存储的元素的数据类型[] 数组名字 = new 数组存储的元素的数据类型[长度];

数组使用过程中常见异常

数组越界异常

public static void main(String[] args) {
    int[] arr = {1,2,3，6,8};
    System.out.println(arr[10]);
}

创建数组，赋值5个元素，数组的索引就是0，1，2，3,4没有10索引，因此我们不能访问数组中不存在的索引，程序运行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

数组空指针异常

public static void main(String[] args) {
    int[] arr = {1,2,3};
    arr = null;
    System.out.println(arr[0]);
｝

arr = null这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

数组的常见操作

实现思路：

• 定义变量，保存数组0索引上的元素

• 遍历数组，获取出数组中的每个元素

• 将遍历到的元素和保存数组0索引上值的变量进行比较

• 如果数组元素的值大于了变量的值，变量记录住新的值

• 数组循环遍历结束，变量保存的就是数组中的最大值

 

实例代码

int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){
    if(arr[i] > max){
        max = arr[i];
    }
}

数组中找最值及其下标

思路：

（1）先假设第一个元素最大/最小

（2）用max/min变量表示最大/小值，用max/min与后面的元素一一比较

（3）用index时刻记录目前比对的最大/小的下标

 

实例代码：

int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
int index = 0;
for(int i=1; i<arr.length; i++){
    if(arr[i] > max){
        max = arr[i];
        index = i;
    }
}

数组统计：求总和、均值、统计偶数个数等

思路：遍历数组，挨个的累加，判断每一个元素

示例代码：

int[] arr = {4,5,6,1,9};
//求总和、均值
int sum = 0;//因为0加上任何数都不影响结果
for(int i=0; i<arr.length; i++){
    sum += arr[i];
}
double avg = (double)sum/arr.length;

示例代码2：

int[] arr = {4,5,6,1,9};

//求总乘积
long result = 1;//因为1乘以任何数都不影响结果
for(int i=0; i<arr.length; i++){
    result *= arr[i];
}

示例代码3：

int[] arr = {4,5,6,1,9};
//统计偶数个数
int even = 0;
for(int i=0; i<arr.length; i++){
    if(arr[i]%2==0){
        even++;
    }
}

复制

应用场景：

1、扩容

2、备份

3、截取

4、反转

示例代码：扩容，新增一个位置来存储10

int[] arr = {1,2,3,4,5,6,7,8,9};

//如果要把arr数组扩容，增加1个位置
//(1)先创建一个新数组，它的长度 = 旧数组的长度+1
int[] newArr = new int[arr.length + 1];

//(2)复制元素
//注意：i<arr.length   因位arr比newArr短，避免下标越界
for(int i=0; i<arr.length; i++){
    newArr[i] = arr[i];
}

//(3)把新元素添加到newArr的最后
newArr[newArr.length-1] = 10;

//(4)如果下面继续使用arr，可以让arr指向新数组
arr = newArr;

//(4)遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

示例代码：备份

int[] arr = {1,2,3,4,5,6,7,8,9};

//1、创建一个长度和原来的数组一样的新数组
int[] newArr = new int[arr.length];

//2、复制元素
for(int i=0; i<arr.length; i++){
    newArr[i] = arr[i];
}

//3、遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

示例代码：截取[start,end)范围

int[] arr = {11,22,33,44,55,66,77,88,99};

int start = 2;
int end = 6;

//1、创建一个新数组，新数组的长度 = end-start ;
int[] newArr = new int[end-start];

//2、赋值元素
for(int i=0; i<newArr.length; i++){
    newArr[i] = arr[start + i];
}

//3、遍历显示
for(int i=0; i<newArr.length; i++){
    System.out.println(newArr[i]);
}

反转

方法有两种：

1、借助一个新数组

2、首尾对应位置交换

第一种：

int[] arr = {1,2,3,4,5,6,7,8,9};

//(1)先创建一个新数组
int[] newArr = new int[arr.length];

//(2)复制元素
int len = arr.length;
for(int i=0; i<newArr.length; i++){
    newArr[i] = arr[len -1 - i];
}

//(3)舍弃旧的，让arr指向新数组
arr = newArr;//这里把新数组的首地址赋值给了arr

//(4)遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

第二种：

int[] arr = {1,2,3,4,5,6,7,8,9};

//(1)计算要交换的次数：  次数 = arr.length/2
//(2)首尾对称位置交换
for(int i=0; i<arr.length/2; i++){//循环的次数就是交换的次数
    int temp = arr[i];
    arr[i] = arr[arr.length-1-i];
	arr[arr.length-1-i] = temp;
}

//（3）遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

• 实现反转，就需要将数组对称位置的元素进行交换

• 定义两个变量，保存数组的最小索引和最大索引

• 两个索引上的元素交换位置

• 最小索引++，最大索引--

• 最小索引超过了最大索引，数组反转操作结束

 

public static void main(String[] args){
		int[] arr = {1,2,3,4,5,6,7,8,9};

		//首尾交换
		for(int min=0,max=arr.length-1; min<max; min++,max--){
		    //首  与  尾交换
		    int temp = arr[min];
		    arr[min] = arr[max];
			arr[max] = temp;
		}

		//（3）遍历显示
		for(int i=0; i<arr.length; i++){
		    System.out.println(arr[i]);
		}
	}