Java——数组的简单应用

数组的简单应用

1. 数组

一组连续的存储空间，存储多个相同数据类型的值。
定义一个数组就要在内存空间中开辟一组连续的空间。
数组名代表代表存储空间的地址值，可以通过数组名访问存储空间中的元素。
每个数组可以用length属性来表明它的长度。
数组既可以存储基本数据类型，也可以存储引用数据类型。

2. 数组的格式

格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];
注意：此时数组中没有元素值。

3. 数组的初始化

Java中的数组必须先初始化,然后才能使用，且数组长度一旦确定，不可改变。
初始化就是指为数组开辟内存空间，并为每个元素赋值。

1. 动态初始化

格式：数据类型[] 数组名 = new 数据类型[数组长度];
举例： int[] arr = new int[5];
解释：定义了一个int类型的数组，可以存储5个int类型的元素。

2. 静态初始化

格式： 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例： int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，可以存储3个int类型的元素，分别是1,2,3。
简化写法： 数据类型[] 数组名 = {元素1,元素2,…};

4. 常见的运行时报错

1. 数组索引越界

ArrayIndexOutOfBoundsException
访问到了数组中的不存在的索引时发生。

2. 空指针异常

NullPointerException
数组引用没有指向实体，却在操作实体中的元素时发生。

5. 数组遍历

//遍历数组
class Array {
	public static void main(String[] args){
		//定义一个数组arr,存储1，2，3，4，5这几个元素。
		int[] arr = {1, 2, 3, 4, 5};
		//开始遍历（优雅格式）
		System.out.print("[");
		/*
		采用循环，循环次数为arr.length(数组的长度),每次循环输出arr[i]的值，便可将
		所有元素打印输出到控制台.
		*/
		for(int i = 0; i < arr.length; i++){
			if(i == arr.length - 1){
				System.out.println(arr[i] + "]");
			} else {
				System.out.print(arr[i] + ", ");   //[1， 2， 3， 4， 5]
			}
		}
	}
}

6. 获取最大值

//获取数组中的最大值
class Array {
	public static void main(String[] args){
		//定义一个数组arr,存储1，2，3，4，5这几个元素。
		int[] arr = {1, 2, 3, 4, 5};
		/*
		定义一个第三方变量max，将arr数组的第一个元素默认为最大值赋值给变量max，然后让数组中的
		每个元素依次和变量max进行比较，如果某个元素大于变量max，则将其值赋给变量max。最终变量max
		中的数值即是数组中元素的最大值。
		*/
		int max = arr[0];
		for(int i = 1; i < arr.length; i++){
			if(arr[i] > max){
			max = arr[i];
			}
		}
		System.out.println("max:" + max);   //max：5
	}
}

7. 元素逆序

//元素逆序
class Array {
	public static void main(String[] args){
		//定义一个数组arr,存储1，2，3，4，5这几个元素。
		int[] arr = {1, 2, 3, 4, 5};
		/*
		将索引值0对应的元素和arr.length-1对应的元素进行互换
		将索引值1对应的元素和arr.length-1-1对应的元素进行互换
		依次循环...
		循环次数为arr.length/2，因为要前面的元素和倒数的元素进行互换，所以只需要执行数组长度
		一半的整数值即可(不能四舍五入)。数组长度为奇数时，最中间的元素不参与互换。
		*/
		for(int i = 0; i < arr.length/2; i++){
		int x = arr[i];
		arr[i] = arr[arr.length - 1 - i];
		arr[arr.length - 1 - i] = x;
		}
		//遍历数组
		System.out.print("[");
		for(int i = 0; i < arr.length; i++){
			if(i == arr.length - 1){
				System.out.println(arr[i] + "]");
			} else {
				System.out.print(arr[i] + ", ");   //[5, 4, 3, 2, 1]
			}
		}
	}
}

8. 元素查找

//数组元素查找
class Array {
	public static void main(String[] args){
		//定义一个数组arr,存储1，2，3，4，5这几个元素。
		int[] arr = {1, 2, 3, 4, 5};
		//定义一个变量y，代表想查要找的元素
		int y = 3;
		/*
		先假设找不到对应的元素输出-1，定义一个变量index，将-1赋值给它。
		然后循环数组，让每一个元素依次和变量y进行比较，如果相等则将对应的索引值赋值给
		变量index。如果没有相等的元素不进行操作。
		最后输出变量index，如果找到对应元素输出其对应的索引值，如果没有则输出-1。
		*/
		//假设找不到
		int index = -1 ;
		for(int x = 0 ; x < arr.length ; x ++){
			if(arr[x] == y){
				index = x ;
			}
		}
		System.out.println("index:" + index);   //index:2
	}
}

9. 冒泡排序

//冒泡排序
class Array {
	public static void main(String[] args){
		//定义一个数组arr,存储1，2，3，4，5这几个元素。
		int[] arr = {22, 35, 68, 12, 9};
		/*
		将数组中的元素依次进行两两比较，大的往后放,第一次比较完毕,最大值就出现在最大索引处!
		循环依次执行，每一次比前一次少比较一次，因为每一次都会确定一个最大值放在对应的位置。
		设置一个第三方变量max，将第一个元素的值赋给变量max，然后从第一个元素开始依次两两比
		较，如果第一个元素的值大于第二个元素，将第二个元素的值赋给第一个元素，然后将变量max
		的值赋值给第二个元素，实现位置互换，大的值往后放。依次这样执行，每一轮会得出一个最
		大值放在对应的索引值上。
		*/
		for(int i = 0; i < arr.length - 1; i++){
			for(int j = 0; j < arr.length - 1 - i; j++){
				//定义第三方变量
				int max = arr[j];
				//两两比较，大的值往后放
				if(arr[j] > arr[j + 1]){
					arr[j] = arr[j + 1];
					arr[j + 1] = max;
				}
			}
		}
		//遍历数组
		System.out.print("[");
		for(int i = 0; i < arr.length; i++){
			if(i == arr.length - 1){
				System.out.println(arr[i] + "]");
			} else {
				System.out.print(arr[i] + ", ");   //[9, 12, 22, 35, 68]
			}
		}
	}
}