Java之数组常用知识点

JAVASE---数组
数组定义：多个相同类型的数据的组合。

数组的说明：

定义：多个相同类型的数据的组合。
目的：为了在内存中对数据进行统一的管理。
1.数组本身，属于引用数据类型
2.数组的元素，可以是基本数据类型，也可以是引用数据类型

一：一维数组的声明与初始化
正确的方式：
//静态初始化:数组的声明、初始化和数组元素的赋值是同时进行的。
String[] names = new String[]{"赵宇","张恺","江运","曹林"};
//简化：
String[] names1 = {"赵宇","张恺","江运","曹林"};

//动态初始化:数组的声明、初始化和数组元素的赋值是分开进行的。
int[] ages = new int[4];

//结论：不管是静态初始化还是动态初始化，一旦数组声明创建完成，数组的长度就确定了。
而且长度不可改变！注：不管是动态还是静态初始化数组，一定在创建的时候，就指明了数组的长度！

错误的声明方式：
//String[] names2 = new String[4]{"赵宇","张恺","江运","曹林"};
//String[4] names3 = new String[]{"赵宇","张恺","江运","曹林"};

3.数组元素的引用
通过数组的角标，调用数组的指定的元素。角标从0开始，到数组的长度-1结束。

4.数组的属性：length:数组的长度

5.数组的遍历
for(int i = 0;i < ages.length;i++){
System.out.println(ages[i]);
}

6.数组元素的默认初始化值
//5.1 整型（byte\short\int\long的数组元素：0
//5.2 浮点型（float\double的数组元素：0.0
//5.3字符型（char的数组元素：'\u0000' 或 0,不是'0'
//5.4 布尔型（boolean)的数组元素：false
//5.5 引用数组类型的数组元素：null  不同于"null"

2.二维数组的声明与初始化

//二维数组的静态初始化
String[] arr2[] = new String[][]{{"abc","abb"},{"abd"}};
//二维数组的动态初始化1
int[][] arr3 = new int[4][3];
//二维数组的动态初始化2
int[][] arr4 = new int[2][];//定义了2个一维数组，arr4[0]和arr4[1]一位数组的长度没有确定
arr4[0] = new int[3];  //  其中arr4[0]默认为null,而arr4[0][0]默认为0.
arr4[1] = new int[5];  //一维数组的长度为5.

错误的初始化方式：
//String[][] arr5 = new String[4][3]{{"abc","abb"},{"abb"}};
//int[3][4] arr4 = new int[][];
//int[][] arr6 = new int[][4];
 注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。

2.如何引用二维数组元素:调用下角标的方式
String[][] arr2 = new String[][]{{"AA","BB"},{"CC"}};
arr2[0];
arr2[0][0];
sysout(arr2[0]);//地址值

3.二维数组的属性：长度
arr2.length;//2
arr2[0].length;//2
arr2[1].length;//1

4.遍历二维数组元素
for(int i = 0;i < arr2.length;i++){
for(int j = 0;j < arr2[i].length;j++){
System.out.print(arr2[i][j] + "\t");
}
System.out.println();
}

5.二维数组元素的默认初始化值
//如果判断二维数组中作为元素的一维数组，则默认值为null
//如果判断二维数组中一维数组的元素,那么与一维数组的不同数据类型的默认初始化值相同。

数组中的常见异常

1.数组角标越界异常:ArrayIndexOutOfBoundsException

int[] arr = new int[10];//0-9
arr[1] = 10;

// arr[10] = 10;//

// arr[-1] = 10;

2.空指针异常：NullPointerException

//情况一：

// int[] arr1 = new int[10];

// arr1 = null;

// System.out.println(arr1[0]);

//情况二：

// int[][] arr2 = new int[4][];

// System.out.println(arr2[1]);//null

// System.out.println(arr2[1][1]);//空指针异常

//情况：

// String[] arr3 = new String[]{"AA","BB","CC"};

// arr3[0] = null;

// System.out.println(arr3[0].toString());

重点：.二维数组元素的默认初始化值
int[][] arr1 = new int[3][];
arr1[0] = new int[3];

System.out.println(arr1[0]);//地址值 ，因为已经new创建对象了，堆中分配了空间。
System.out.println(arr1[1]);//null  ，因为创建对象。
System.out.println(arr1[0][0]);//0

//如果判断二维数组中作为元素的一维数组，则默认值为null
//如果判断二维数组中一维数组的元素。那么与一维数组的不同数据类型的默认初始化值相同。

3.数组中的常见操作

1.针对于数值型的数组：求最大值、最小值、总和、平均数。

2.复制一个数组，实现数组元素的反转

int[] array1,array2;

array1 = new int[]{1,2,3};

//赋值（赋值不是复制）

array2 = array1;（操作修改array2中的值，array1中的值也会被修改，两者在内存中指向同一对象）

//复制

array2 = new int[array1.length];

for(int i = 0;i < array2.length;i++){

array2[i] = array1[i];

}
3.数组的反转： 重点

// 数组元素的反转

// for(int i = 0;i < arr.length/2;i++){

// int temp = arr[i];

// arr[i] = arr[arr.length-1 - i];

// arr[arr.length - 1 - i] = temp;

// }

for (int x = 0, y = arr.length - 1; x < y; x++, y--) {
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;

}

4.数组的排序算法

选择排序

直接择排序、堆排序

交换排序

冒泡排序、快速排序

插入排序

直接插入排序、折半插入排序、Shell排序

归并排序

桶式排序

基数排序

/ 使用冒泡排序使数组元素从小到大排列

// for (int i = 0; i < arr.length - 1; i++) {

// for (int j = 0; j < arr.length - 1 - i; j++) {

// if (arr[j] > arr[j + 1]) {

// int temp = arr[j];

// arr[j] = arr[j + 1];

// arr[j + 1] = temp;

// }

// }

// }

// //使用直接选择排序使数组元素从小到大排列

// for(int i = 0; i < arr.length - 1; i++){

// int t = i;//默认i处是最小的

// for(int j = i;j < arr.length;j++){

// //一旦在i后发现存在比其小的元素，就记录那个元素的下角标

// if(arr[t] > arr[j]){

// t = j;

// }

// }

// if(t != i){

// int temp = arr[t];

// arr[t] = arr[i];

// arr[i] = temp;

// }

// }

          //调用Arrays工具类的sort()实现排序

// Arrays.sort(arr);//内部使用的是快速排序