Java基础之数组

1.一维数组

1.1定义

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

这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个

元素外，每一个元素都有唯一的后继元素。（“简单理解就是：一个跟一个顺序排列”）。

1.2格式

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

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

格式3. （不常用）数据类型[] 数组名;

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

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

public class Demo1 {
   

	public static void main(String[] args) {
   
	
		//格式1.创建数组的同时，制定数组中的内容。
		int[] ages = {
   10,11,12,13,14};
		//格式2.创建数组， 并指定长度， 不指定数组中的内容。
		int[] ages2 = new int[10];
	
		System.out.println("------------------------");
		
		//数组不常用的创建方式：
		//1.	创建数组 ， 不初始化
		//格式：	数据类型[] 数组名;
		int[] nums;
		//2.	创建数组， 并指定数组中的内容
		//格式：	数据类型[] 数组名称 = new 数据类型[]{内容1,内容2,内容3...内容n};
		int[] ages = new int[] {
   11,12,13,14};
	}

1.3下标

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

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

public class Demo1 {
   
		
	public static void main(String[] args) {
   
        int[] ages = {
   10,11,12,13,14};
		int[] ages2 = new int[10];
	//通过下标操作数组数据的方式：
		//1.	给数组某个下标 赋值：   数组名称[下标] = 值;
		ages[0] = 100;
		//2.	从数组某个下标 取值： 数组名称[下标]
		System.out.println(ages[0]);
		ages2[0] = 99;
		System.out.println(ages2[0]);
    }
}

1.4数组常见问题

1.4.1数组的遍历

public class Demo2 {
   
		
	public static void main(String[] args) {
   
         int[] ages = {
   10,11,12,13,14};
        
        //如何获取数组的长度：  数组名称.length
		//数组的遍历
		for(int index=0;index<ages.length;index++) {
   
			//index: 0 1 2 3 4 
			System.out.println(ages[index]);
		}
	
	}

}

1.4.2数组未赋值

空指针异常 (NullPointerException)

通常在引用数据中发生异常

public class Demo3 {
   
	public static void main(String[] args) {
   
	
		//	空指针问题
		int[] nums = null;
		System.out.println(nums[1]);
	}

}

1.4.3超出长度的下标操作

数组越界异常 （ArrayIndexOutOfBoundsException）

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

public class Demo4 {
   
	public static void main(String[] args) {
   
		//		数组下标越界问题：
		//int[] nums = {10,11,12,13,14};
		//System.out.println(nums[5]);

	}

}

1.5数组常用算法

1.5.1冒泡排序

1.5.1.1原理

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

升序排列的口诀:

N个数字来排队

两两相比小靠前,

外层 循环length-1

内层循环length-i-1

降序排序的口诀

N个数字来排队

两两相比大靠前,

外层 循环length-1

内层循环length-i-1

1.5.1.2代码示例

public class Demo5 {
   

	/**
	 * 冒泡排序
	 * @param args
	 */
	public static void main(String[] args) {
   
		int[] nums = {
   20,15,185,123,350,609};
		int temp;
   
          /*
          "20 15" 158 123 350 609
          15 "20 158" 123 350 609
          15 20 "158 123" 350 609
          15 20 123 "158 350" 609
          15 20 123 158 "350 609"
          15 20 123 158 350 609
          */
		//外层循环控制的是， 比较的轮数。
		//外层循环次数： 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