数组
- 数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理
- 数组的常见概念：
- 数组名
- 下标(或索引)
- 元素
- 数组的长度
- 数组的特点：
- 数组是有序排列的
- 数组属于引用数据类型的变量。数组的元素可以是基本数据类型，也可以是引用数据类型
- 创建数组对象会在内存中开辟一整块连续的空间
- 数组的长度一旦确定，就不能修改
- 数组的分类：
- 按维度：一维数组、二维数组...
- 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组
- 一维数组的使用
- 一维数组的声明和初始化
int[] ids;//声明 //1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行 ids =new int[]{1001,1002,1003,1004}; //1.2动态初始化数组的初始化和数组元素的赋值操作分开进行 String[] names = new String[5]; //总结：数组一旦初始化完成，其长度就确定了。 - 如何调用数组指定位置的元素
//数组的角标（或索引）从0开始的，到数组的长度-1结束 names[0]="张三"; names[1]="李四"; names[2]="校长"; names[3]="王五"; names[4]="小明"; //names[5]="赵六";//数越界异常- 如何获取数组的长度
//如何获取数组的长度 //属性：length System.out.println(names.length);//5- 如何遍历数组
//如何遍历数组 for(int i=0;i<names.length;i++){ System.out.println(names[i]); }- 数组元素的默认初始化值
- 数组元素是整型：0
- 数组元素是浮点型：0.0
- 数组元素是char类型：0或'\u0000',不是'0'
- 数组元素是boolean类型：false
- 数组元素是引用类型：null
//数组元素的默认初始化值 int[] arr = new int[4]; for(int i=0;i<arr.length;i++){ System.out.println(i);//0 0 0 0 } float[] arr2 = new float[5]; for(int i=0;i<arr2.length;i++){ System.out.println(arr2[i]);//0.0 } char[] arr3 = new char[4]; for(int i =0;i<arr3.length;i++){ System.out.println("----"+arr3[i]+"****"); } String[] arr4 = new String[3]; System.out.println(arr4[0]);- 数组的内存解析
内存的简化结构：栈（stack）：局部变量；堆（heap）：new出来的结构：对象数组；方法区：常量池和静态域
把变量名和变量对应值的首地址值存储在栈区，其值存储在堆区
- 一维数组的声明和初始化
- 二维数组
理解：对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组- 二维数组的声明和初始化
//静态初始化 int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}}; int[][] arr4 = {{1,2,3},{4,5},{6,7,8}}; //动态初始化1 String[][] arr2 = new String[3][2]; //动态初始化2 String[][] arr3 = new String[3][]; - 如何调用数组指定位置的元素
System.out.println(arr1[0][1]);//2 System.out.println(arr2[2][2]);//null System.out.println(arr3[1][0]);//空指针异常- 如何获取数组的长度
System.out.println(arr4.length);//3 System.out.println(arr4[0].length);//3 System.out.println(arr4[1].length);//2- 如何遍历数组
for(int i=0;i<arr4.length;i++){ for(int j =0;j<arr4[i].length;i++){ System.out.print(arr4[i][j]); } System.out.println(); }- 数组元素的默认初始化值、
规定：二维数组分为外层元素的数组，内层元素的数组
int[] arr = new int[4][3];
外层元素：arr[0],arr[1]等
内层元素：arr[0][0],arr[1][2]等
针对于初始化一：比如：int [][] = new int[4][3]; System.out.println(arr[0]);//[I@15db9742地址值 System.out.println(arr[0][0]);//0 System.out.println(arr);//[[I@地址值 double[][] arr3 = new double[4][]; System.out.println(arr3[1]);//null System.out.println(arr3[0][1]);//空指针异常int[][] arr = new int[4][3];外层元素的初始化值为：地址值。内层元素的初始化值为：与一维数组初始化情况相同
针对于初始化方式二：比如:int[][] arr = new int[4][]外层元素的初始化值为null,内层元素的初始化值为不能调用，否则报错。
6. 数组的内存解析int arr1[]=new int[]{123,1,2}; int arr2[]=new int[arr1.length]; arr2 = arr1;//不能称作数组的复制,只是把arr1的地址值给了arr2 //真正的复制 for(int i=0;i<arr1.length;i++){ arr2[i] = arr1[i]; } - 二维数组的声明和初始化
数组中常见的算法：
杨辉三角
//1.声明并初始化二维数组
int yangHui[][] = new int[10][];
//2.给数组元素赋值
for(int i = 0;i<yangHui.length;i++){
yangHui[i] = new int[i+1];
//2.1给首末元素赋值
yangHui[i][0]=yangHui[i][i] = 1;
//2.2给每个元素赋值
for(int j =1;j<yangHui[i].length-1;j++){
yangHui[i][j]=yangHui[i-1][j-1]+yangHui[i-1][j];
}
}
//3.遍历二维数组
for(int i =0;i<yangHui.length;i++){
for(int j =0;j<yangHui[i].length;j++){
System.out.print(yangHui[i][j]+" ");
}
System.out.println();
}
数组的反转、查找
/*数组的反转\查找*/
public class ArrayTest1 {
public static void main(String[] args){
String[] arr = new String[]{"1","2","3","4","5","6"};
/*数组的反转：方法一*/
for (int i = 0; i < arr.length/2; i++) {
String temp = arr[i];
arr[i] = arr[arr.length-i-1];
arr[arr.length-i-1] = temp;
}
// /*数组的反转：方法二*/
// for(int i=0,j=arr.length-1;i<j;i++,j--){
// String temp = arr[i];
// arr[i] =arr[j];
// arr[j] = temp;
// }
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"\t");
}
/*线性查找、二分法查找*/
/*线性查找*/
String dest = "1";
boolean flag = true;
for (int i = 0; i < arr.length; i++) {
if (dest.equals(arr[i])){
System.out.println("找到了指定元素，位置为:"+i);
flag=false;
break;
}
}
if (flag){
System.out.println("很遗憾，未找到指定元素！");
}
/*二分法查找：*/
//前提：所要查找的数组必须有序。
int arr2[] = new int[]{-10,-5,-3,-1,0,1,2,3,4,5,6,7};
int dest1 = -5;
int head=0;
int end = arr2.length-1;
boolean flag1 = true;
while (head<=end){
int middle = (head+end)/2;
if (arr2[middle]==dest1){
flag1 = false;
System.out.println("找到了，元素索引为:"+middle);
break;
}else if (arr2[middle]>dest1){
end = middle -1;
}else{
head = middle+1;
}
}
if (flag1){
System.out.println("很遗憾未找到");
}
}
}
数组的排序
排序算法分类:内部排序和外部排序
内部排序:整个排序过程不需要借助于外部存储器(如磁盘等)，所有排序操作都在内存中完成。
外部排序:参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器(如磁盘)。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。
十大内部排序算法：
- 选择排序：直接选择排序、堆排序
- 交换排序：冒泡排序、快速排序
- 插入排序：直接插入排序、折半排序、shell排序
- 归并排序
- 桶式排序
- 基数排序
冒泡排序：冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
排序思想:
1.比较相邻的元素。如果第一个比第二个大(升序)，就交换他们两个
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。
/*冒泡排序 */
public class BubbleSort {
public static void main(String[] args) {
int[] arr = new int[]{43,1,1,1,1,23,13,15,24,54,26,63,47,78,71,47};
//冒泡排序
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length -1 -i; j++) {
if (arr[j]>arr[j+1]){
int flag = arr[j];
arr[j] = arr[j+1];
arr[j+1] = flag;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
}
快速排序：
介绍：快速排序通常明显比同为O(nlogn)的其他算法更快，因此常被采用，而且快排采用了分治法的思想，所以在很多笔试面试中能经常看到快排的影子。可见掌握快排的重要性。
快速排序(Quick Sort) 由图灵奖获得者Tony Hoare发明，被列为20世纪十大算法之一，是迄今为止所有内排序算法中速度最快的一种。冒泡排序的升级版，交换排序的一种。快速排序的时间复杂度为O(nlog(n))
排序思想：
1.从数列中挑出一个元素，称为"基准”(pivot)
2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准2值大的摆在基准的后面（相同的数可以到任一边)。在这个分区结束之后该基准就处于数列的中间位置。这个称为分区 (partition)操作。
3.递归地 (recursive) 把小于基准值元素的子数列和大于基准值元素的子数列排序。
4.递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代(iteration)中，它至少会把一个元素摆到它最后的位置去。
数组工具类Arrays的使用
java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法
boolean equals(int[]a,int[]b);判断两个数组是否相等
String toString(int[] a);输出数组信息
void fill(int a[],int val);将指定值填充到数组中
void sort(int[] a);对数组进行排序
int binarySearch(int[] a,int key);对排序后的数组进行二分法检索指定的值
/*
* java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法
*/
public class ArraysTest {
public static void main(String[] args){
//boolean equals(int[]a,int[]b);判断两个数组是否相等
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,3,2,4};
boolean isEquals = Arrays.equals(arr1, arr2);
System.out.println(isEquals);
//String toString(int[] a);输出数组信息
System.out.println(Arrays.toString(arr1));
//void fill(int a[],int val);将指定值填充到数组中
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));//[10, 10, 10, 10]
//void sort(int[] a);对数组进行排序
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//int binarySearch(int[] a,int key);对排序后的数组进行二分法检索指定的值
int index = Arrays.binarySearch(arr2,2);
System.out.println(index);
}
}
数组使用中的常见异常
1.数组角标越界异常：ArrayIndexOutOfBoundsException
2.空指针异常：NullPointerException
