Java知识点整理——数组

一、数组

1. 概述：

     数组是相同数据类型的多个数据的容器。

     这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个 元素外，每一个元素都有唯一的后继元素。（“简单理解就是：一个跟一个按照顺序排列”）。

2. 创建格式：

     格式 1. 数据类型[] 数组名称 = new 数据类型[数组长度];

     格式 2. 数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3...数组内容 n};

     格式 3. 数据类型[] 数组名;

           格式 3 属于只创建了数组引用名， 并未在内存创建数组空间。

     格式 4. 数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3...内容 n};

3. 下标：

     可以理解为数组中内容的数字序号，从 0 开始 ，对于长度为 n 的数组，下标的范围是 0~n-1。

     可以通过下标的方式访问数组中的每一个元素。

     例如： 创建 int 类型数组 arr ， 给数组 arr 的 5 下标赋值数据 ， 然后打印

int[] arr = new int[10];
arr[5] = 123;
System.out.println(arr[5]);

4. 数组长度获取：

     数组名称.length

5. 注意：

     使用数组不当， 会出现如下问题：

        数组未赋值： 空指针异常

        超出长度的下标操作： 数组越界异常

   注意：数组的长度在创建时就固定了。

package com.kaikeba.demo1;

public class Demo2 {
	public static void main(String[] args) {
		//常见问题：
		// 1. 数组下标越界问题：
		//int[] nums = {10,11,12,13,14};
		//System.out.println(nums[5]);
		// 2. 空指针问题
		int[] nums = null;
		System.out.println(nums[1]);
	}

}

补充：找出无序数组中的最大/最小值。

package com.kaikeba.demo1;

public class Demo3 {

	//寻找数组中的最大值 | 最小值
	public static void main(String[] args) {
		int[] nums = {10,30,40,33,22,20,11,0};
		//1.	创建一个变量， 用于存储遍历数组时发现的最大值
		int n = nums[0];
		//2.	循环取出数组中的每一个内容， 从1开始
		for(int i=1;i<nums.length;i++) {
			//将数组中的每一个内容与n比较， 如果比n大， 则将n的值赋值为这个内容。
			n = n<nums[i]?n:nums[i];
		}
		System.out.println(n);
	}

}

 

二、数组常用算法

1. 冒泡排序：

原理：

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的 数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

名字由来：

     是因为最小（或最大）的元素会经由交换慢慢“浮”到数列的顶端（降序或升序），就如同水中的气泡最终会上浮到顶端一样，故名“冒泡排序”。

升序排列的口诀: 
    N个数字来排队 
    两两相比小靠前, 
    外层 循环length-1 
    内层循环length-i-1 

降序排序的口诀: 
    N个数字来排队 
    两两相比大靠前, 
    外层 循环length-1 
    内层循环length-i-1

冒泡排序代码示例：

package com.kaikeba.demo1;

public class Demo4 {

	/**
	 * 冒泡排序
	 * @param args
	 */
	public static void main(String[] args) {
		int[] nums = {20,15,18,13,30,60};
		int temp;
		//外层循环控制的是， 比较的轮数。
		//外层循环次数： length-1
		for(int i=0;i<nums.length-1;i++) {
			//内层循环控制的是，每轮比较的次数
			//第i轮（i从0开始计算）， 比较次数为：length-i-1
			for(int j=0;j<nums.length-i-1;j++) {
				if(nums[j]>nums[j+1]) {
					//两两相比， 满足移动条件
					temp = nums[j];
					nums[j] = nums[j+1];
					nums[j+1] = temp;
				}
			}
		}
		
		
		//排序已经完成。 下面是遍历打印查看的过程
		for(int i=0;i<nums.length;i++) {
			System.out.println(nums[i]);
		}
		
		
		
	}

}

2. 二分查找（折半查找）：

概述：

     二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，二分查找要求数组数据必须采用顺序存储结构有序排列。

原理：

     首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功；否则利用 中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数组，否则进一步查 找后子数组。

     重复以上过程，直到找到满足条件的数据，则表示查找成功， 直到子数组不存在为止，表示查找不成功。

二分查找代码示例：

package com.kaikeba.demo1;

public class Demo5 {

	/**
	 * 二分查找（折半查找）
	 */
	public static void main(String[] args) {
		int[] nums = {10,20,30,40,50,60,70,80,90};
		
		//要查找的数据
		int num = 20;
		
		//关键的三个变量：
		//1.	最小范围下标
		int minIndex = 0;
		//2.	最大范围下标
		int maxIndex = nums.length-1;
		//3.	中间数据下标
		int centerIndex = (minIndex+maxIndex)/2;
		while(true) {
			System.out.println("循环了一次");
			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);
		
	}
}