CoreJava 数组

数组

一、数组的基本使用

1. 概念：数组是内存中的一串连续的空间，用来储存同一类型的数据

2. 语法：

   1. 声明：数据类型[] 数组名；

   2. 开辟空间：数组名 = new 数据类型[数组容量/数组长度]；

      public class TestArray {
      	public static void main(String[] args) {
      		int[] a;//声明数组
      		a = new int[5];//开辟空间
      	}
      }
      

   3. 其他的声明方式：

      1. 声明的同时开辟空间

         int[] a = new int[5];
         

      2. 声明的同时给元素赋值

         int[] a = new int[]{10,8,7,8,6};
         

         注意：不能在中括号中写入数组长度

      3. 数组的显示声明

         int[] a = {10,8,7,8,6};
         

         注意：数组的显示声明不能分为两部分写

         int[] a;
         a = {10,8,7,8,6}; //error
         

二、数组的特点

1. 数组是一段连续的空间
2. 数组的长度是固定的，一旦创建不可改变
3. 数组只能存储同一类型的数据
4. 数组内的元素具有默认值
   整数--0 小数---0.0 char--'\u0000' 布尔类型---false
5. 当使用的下标超过数组最大下标值的时候，会出现 java.lang.ArrayIndexOutOfBoundsException 异常
6. 数组的声明变量中，所存储的是 数组中第一个元素所在的内存地址 ---->首地址
7. 数组的查询速率快

三、数组的扩容

1. 手动扩容

   1. 核心思路：声明一个新数组，将原数组中的每一个元素依次放入新数组
   2. 代码

   public static void main(String[] args) {
   	//源数组
   	int[] a = {4,5,1,3,9,8,2,7,6};
   	//声明一个新数组，长度大于源数组的长度
   	int[] b = new int[a.length * 2];
   	//将源数组的元素依次存入新数组中
   	for (int i = 0; i < a.length; i++) {
   		b[i] = a[i];
   	}
   	//使用新数组覆盖源数组
   	a = b;
   }
   

2. System扩容

   1. 使用System中的arraycopy()函数进行扩容
   2. 参数列表(原数组名，原数组起始下标，新数组名，新数组起始下标，需要复制的长度)
   3. 代码

   public static void main(String[] args) {
   	//源数组
   	int[] a = {4,5,1,3,9,8,2,7,6};
   	//声明一个新数组，长度大于源数组的长度
   	int[] b = new int[a.length * 2];
   	System.arraycopy(a, 0, b, 0, a.length);
   	//使用新数组覆盖源数组
   	a = b;
   }
   

3. Arrays扩容

   1. 使用java.util.Arrays中的copyOf()函数进行扩容
   2. 参数列表(原数组名，需要扩容的长度)，返回值是一个新数组
   3. 代码

   public static void main(String[] args) {
   	//源数组
   	int[] a = {4,5,1,3,9,8,2,7,6};
   	//使用新数组覆盖源数组
   	a = java.util.Arrays.copyOf(a, a.length*2);
   }
   

四、数组的排序

1. 冒泡排序

   1. 相邻的两个元素间两两对比，对比的下标每次后移一位
   2. 代码

   public class TestBubbleSort {
   	public static void main(String[] args) {
   		int[] a = { 4, 5, 1, 3, 9, 8, 2, 7, 6 };
   		
   		for (int i = 0; i < a.length - 1; i++) {
   			for (int j = 0; j < a.length - 1 - i; j++) {
   				if (a[j] > a[j + 1]) {
   					int temp = a[j];
   					a[j] = a[j + 1];
   					a[j + 1] = temp;
   				}
   			}
   		}
   	}
   }
   

2. 选择排序

   1. 固定一个下标，使用该下标之后的每个一个元素依次与其对比，全都对比完之后，固定的这个下标，后移一位
   2. 代码

   public class TestSelectedSort {
   	public static void main(String[] args) {
   		int[] a = { 4, 5, 1, 3, 9, 8, 2, 7, 6 };
   
   		for (int i = 0; i < a.length - 1; i++) {
   			for (int j = i + 1; j < a.length;j++){
   				if (a[i] > a[j]) {
   					int temp = a[i];
   					a[i] = a[j];
   					a[j] = temp;
   				}
   			}
   		}
   	}
   }
   

3. 快速排序

   1. 使用java.util.Arrays.sort()函数，参数为 数组名
   2. 代码

   public class TestJDKSort {
   	public static void main(String[] args) {
   		int[] a = { 4, 5, 1, 3, 9, 8, 2, 7, 6 };
   		java.util.Arrays.sort(a);
   	}
   }
   

五、二维数组

1. 二维数组的声明：数据类型 [ ] [ ] 数组名;

2. 二维数组的空间分配：new 数据类型 [低维度长度] [高维度长度];

3. 二维数组的使用：

   1. 元素的访问：通过每个维度的标号进行访问，比如a[1] [2]
   2. 数组的遍历：
      1. 先通过低纬度遍历，长度是 数组名.length
      2. 在通过高纬度遍历，长度是 数组名[i].length
   3. 二维数组就是一维数组的一维数组

4. 二维数组的其他定义方式：

   1. 声明的同时开辟空间：

      int[][] a = new int[2][3];
      

   2. 声明的同时给元素赋值：

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

   3. 显示声明：

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

5. 不规则二维数组：

   1. 定义方式：

      数据类型[][] 数组名 =new 数据类型 [低维度长度][];
      数组名[0] = new 数据类型[长度];
      数组名[1] = new 数据类型[长度];
      

   2. 显示定义方式：例如：

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