Day04数组-CSDN博客

本文链接：https://blog.csdn.net/weixin_42837652/article/details/115250091

第一章数组的定义和访问

1.1 容器概述

容器概念

容器：是将多个数据存储到一起，每个数据称为该容器的元素。
生活中的容器：水杯，衣柜，教室。

1.2 数组概念

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

1.3 数组的定义

方式一

格式：

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

数组定义格式详解：
- 数组存储的数据类型：创建的数组容器可以存储什么数据类型。
- []：表示数组
- 数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
- new：关键字，创建数组使用的关键字。
- 数组存储的数据类型：创建的数组容器可以存储什么数据类型。
- [长度]：数组的长度，表示数组容器可以存储什么数据类型。
- 注意：数组有定长特性，长度一旦指定，不可改变。
  - 和水杯道理想通，买了一个水杯，它不能变大也不能变小
举例：定义可以存储三个整数的数组容器，代码如下：

int[] arr = new int[3];

方式二

格式

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

举例：定义存储1.2.3.4.5整数的数组容器

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

方式三

格式

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

举例：定义存储1.2.3.4.5整数的数组容器

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

1.4 数组的访问

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

数组名[索引]

数组的长度属性：每个数组都具有长度，而且是固定的，Java中赋予了数组一个属性，可以获得数组的长度，语句为数组名.length，属性length的执行结果是数组的长度，int类型结果。由此可以推断出，数组的最大索引值为数组名.length-1。
索引访问数组中的元素：
- 数组名[索引] = 数值，为数组中的元素赋值
- 变量 = 数组名[索引],获取出数组中的元素。

public static void main(String[] args) { 
    //定义存储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]);
}

~~ # 第二章数组原理内存图~~

~~ ## 2.1 内存概述~~

内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。

第三章数组的常见操作

3.1 数组越界异常

观察一下代码，运行后会出现什么结果：

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

创建数组，赋值3个元素，数组的索引就是0,1,2，没有3索引，因此我们不能访问数组中不存在的索引，程序运行后，将会抛出ArrayIndexOutOfBoundsException数组越界异常。

3.2 数组空指针异常

观察一下，运行后会出现什么结果：

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

arr = null这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许在操作数组了，因此运行的时候会抛出NullPointerException空指针异常。

3.3 数组遍历

数组遍历就是将数组中的每个元素分别获取出来
一般用for循环实现

public static void main(String[] args) { 
    int[] arr = { 1, 2, 3, 4, 5 }; 
    for (int i = 0; i < arr.length; i++) { 
        System.out.println(arr[i]); 
    } 
}

3.4 获取数组的最大/小值元素

最大值的获取：从数组的所有元素中找出最大值。
实现思路：
- 定义变量，保存数组0索引上的元素
- 遍历数组，获取数组中的每个元素
- 将遍历到的元素和保存数组0索引上值的变量进行比较
- 如果数组元素的值大于了变量的值，变量记录新的值
- 数组循环遍历结束，变量保存的就是数组中的最大值

/**
 * 找出数组的最值 定义一个长度为 10 的整型数组 nums ，
 * 循环输入 10 个整数。输出数组 的最大值、最小值。
 * */
public class demo02 {
	public static void main(String[] args) {
		//最值 定义一个长度为 10 的整型数组nums
		int[] nums = new int[10]; 
		//循环输入 10 个整数
		System.out.println("请输入10个整数：");
		for (int i = 0; i < nums.length; i++) {
			Scanner scanner = new Scanner(System.in);
			nums[i] = scanner.nextInt();
		}
		//输出数组 的最大值、最小值。
		int max = nums[0];
		int min = nums[0];
		for (int i = 1; i < nums.length; i++) {
			//三元不等式c=a>b?a:b;
			max = max > nums[i] ? max : nums[i];
			min = min < nums[i] ? min : nums[i];
		}
		System.out.println("最大值："+max);
		System.out.println("最小值："+min );
	}

}

3.5 冒泡排序

原理：
- 比较相邻元素，如果第一个比第二个大，就叫换他们两个
- 每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
- 针对所有元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，知道没有任何一对数字需要比较。
升序排列口诀：
- N个数字来排队
- 两两相比小靠前
- 外层循环length-1
- 内层循环length-i-1
降序排列口诀：
- N个数字来排队
- 两两相比大靠前,
- 外层循环length-1
- 内层循环length-i-1

//冒泡排序
public class ArrayDemo01 {
	public static void main(String[] args) {
		int[] arr = {12,54,545,5,2312,656,55,56,56,4,6};
		int temp;
		//外层循环，控制的是比较的轮数
		for (int i = 0; i < arr.length-1; i++) {
			//内层循环  每轮比较的次数
			for (int j = 0; j < arr.length-i-1; j++) {
				 if (arr[j]>arr[j+1]) {
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				} 
			}
		}	
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
}

3.6 二分查找

概述：二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，二分查找要求数组数据必须采用顺序存储结构有序排列。
原理：
- 首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功；
- 否则利用中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数组，否则进一步查找后子数组。
- 重复以上过程，直到找到满足条件的数据，则表示查找成功，直到子数组不存在为止，表示查找不成功。

//二分查找
public class ArrayDemo02 {
	public static void main(String[] args) {
		int[] nums = {10,20,30,40,50,60,70,80,90};
		//要查的数据30
		int num = 30;
		//关键的三个变量
		int minIndex = 0;
		int maxIndex = nums.length-1;
		int centerIndex = (minIndex + maxIndex)/2;
		//循环次数未知，用while
		while (true) {
			if(nums[centerIndex]>num) {
				//中间数据大
				maxIndex = centerIndex - 1;
			}else if (nums[centerIndex]<num) {
				//中间数据小
				minIndex = centerIndex + 1;
			}else {
				//找到了数据，数据位置centerIndex
				break;
			}
			if (minIndex>maxIndex) {
				centerIndex = -1;
				break;
			}
			centerIndex = (minIndex + maxIndex)/2;
		}
		System.out.println("位置："+centerIndex);
	}
}