数组
数组:同一种类型数据的集合.其实数组就是一个容器,它的好处是可以从0开始编号,方便操作这些元素
定义数组的格式：
格式一：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] arr = new int[5]; //创建数组实体的关键字
格式二：
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
int[] arr = new int[]{3,5,1,7};
int[] arr = {3,5,1,7};
静态初始化：初始化时由程序员显式指定每个数组元素的初始值，由系统决定数组长度。
动态初始化：初始化时程序员只指定数组长度，由系统为数组元素分配初始值。
当不明确数组中的元素时使用动态初始化，当明确数组中的元素时使用静态初始化
操作数组最常见的问题:
A：当你访问到数组中的最后一个元素时，还想继续访问，这个时候，会发生角标越界异常。
**ArrayIndexOutOfBoundsException
**举例 int[] arr = new int[3];
System.out.println(arr[3]);
B：当数组不在指向某个实体时，你还继续访问，就会发生空指针异常。
**NullPointerException
**举例 int[] arr = new int[3];
arr = null;
System.out.println(arr[0]);
数组的操作:
1、遍历
for (int x=0;x < arr.length ;x++ ){ //length代表长度
System.out.println("arr["+x+"]="+ arr[x]);
}
2、获取最值
//获取最大值
public static void main(String[] args) {
int[] arr = {3,2,1,4,5,6};
int x = getMax(arr);
System.out.println(x);
}
public static int getMax(int[] arr){
int max = arr[0];
//i从1开始，因为第一个数不用跟自己比
for(int x=1; x<arr.length; x++) {
if(arr[x]>max) {
max = arr[x];
}
}
return max;
}
//获取最小值
public static int getMin(int[] arr) {
int min = arr[0];
//i从1开始，因为第一个数不用跟自己比
for(int i=1; i<arr.length; i++) {
if(arr[i]<min){
min = arr[i];
}
}
return min;
}
3、排序
选择排序
原理：如果拿0角标上的元素依次和后面的元素进行比较， 第一次内循环结束后，最小值出现在了0角标位置。
当数组长度为6时
arr[0]与arr[1-5]比了五次
arr[1]与arr[2-5]比了四次
arr[2]与arr[3-5]比了三次
arr[3]与arr[4-5]比了二次
arr[4]与arr[5]比了一次
根据下面的图形
****
***
**
*
arr[x]与arr[y]比较
for (int x = 0;x < arr.length - 1;x++){
for (int y = x + 1;y < arr.length;y++){
if (arr[x] > arr[y]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
冒泡排序
原理：两个相邻元素进行比较，第一次比较完以后，最大值出现在了最大角标处。
第一次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4],arr[4]与arr[5],比了五次
第二次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4]比了四次
第三次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3]比了三次
第四次:arr[0]与arr[1],arr[1]与arr[2]比了二次
第五次:arr[0]与arr[1]比了一次
for (int x = 0;x < arr.length - 1; x++){
//-1防止角标越界
//-x为了提高效率
for (int y = 0;y < arr.length - 1 - x;y++){
if (arr[y] > arr[y+1]){
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
查找：
1：无序数组
public static int getIndex(int[] arr,int key) {
for (int x = 0;x < arr.length;x++){
if (key == arr[x]){
return x;
}
}
return -1;
}
2：有序数组 二分查找
数组长度是6,最大角标值是5
public static int getIndex(int[] arr,int key) {
int min = 0;
int max = arr.length-1;
int mid = (min + max)/2;
while (key != arr[mid]){
if (key > arr[mid]){
min = mid + 1;
}else if (key < arr[mid]){
max = mid - 1;
}
if (min > max){
return -1;
}
mid = (min + max)/2;
}
return mid;
}
数组的反转：
public static void main(String[] args) {
int[] arr = {3,2,1,5,4,6};//6,4,5,1,2,3;
revArray(arr);
System.out.println(print(arr));
}
//定义反转的方法,经过分析发现需要对调的角标是两个变化的变量
//第一次让头角标和尾角标对调,然后让头角标自增,尾角标递减再对调
public static void revArray(int[] arr) {
for (int start=0,end = arr.length-1;start<end ;start++, end--){
//角标值每变化一次就对调一次
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}
数组初始化过程：
<1> 主函数进栈,然后在main()中有一个数组的引用arr
<2> 在堆内存中开辟空间，分配内存地址值
<3> 在堆内存中建立数组对象，并进行默认初始化
<4> 如果有显示初始化值的,对它进行显示初始化
<5> 将内存地址赋给栈内存中的arr变量
二维数组[][]：
格式1：
int[][] arr = new int[3][2];
定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为1写法是：arr[0][1] = 1;
格式2：
int[][] arr = new int[3][];
二维数组中有3个一维数组
每个一维数组都是默认初始化值null
可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
格式3：
int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
定义一个名称为arr的二维数组
二维数组中的有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组 arr[0] = {3,8,2};
第二个一维数组 arr[1] = {2,7};
第三个一维数组 arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;
二维数组的遍历：
int[][] arr2 = new int[2][3];
public static void printArray2(int[][] arr2){
for(int i=0; i<arr2.length; i++){
for(int j=0; j<arr2[i].length; j++){
System.out.print(arr2[i][j]+" ");
}
System.out.println();
}
}
总结：当要操作的同种数据类型的数据是多个的时候，就得想着先把这些数据用数组进行存储、然后进行操作
当查着有序数组是利用二分法查找也就是折半查找、改变角标指针的位置进行比较从而得到最后的角标
