Java 数组概要

1. 数组的基本点：

​ 1.长度是确定的,创建后不可改变.
​ 2.元素必须是相同类型的,不允许混搭.
​ 3.数组中的元素可以是任何类型的（基本类型,引用类型）.
​ 4.数组变量属于引用类型,可以看成是对象.
​ 5.数组本身就是对象,Java中对象是在堆中的，因此数组保存类型都是在堆中的.

注：

出现错误：ArrayIndexOutOfBoundsException 为：下标越界异常

2. 声明和创建

//声明数组：
	int[]arrays; //声明 JAVA推荐使用 首选
	int arrays1[];//JAVA为了从让C程序员过度 而特意添加的
 //创建数组
    arrays= new int[10]; //配合上面声明使用
 //声明和创建 一起使用
    int[] arrays2 = new int[10];//这个用的多

3. 数组变量赋值

//静态赋值
		int[] a = {10,9,8,7,6,5,4,3,2,1};

//动态初始化
       int[] b = new int[10];
        b[0] = 10;
        b[1] = 1;
		b[2] = 3;

4. 内存分析（堆 栈）

5. 数组的使用

1. For-Each循环

//打印arrays数值   for增强型没有下标（一般作为输出使用）
	System.out.println("打印Arrays数组中的全部数值：");
	for (int ai = 0; ai < arrays.length; ai++) {
    	System.out.print(arrays[ai]+" ");
	}
	System.out.println("\n=====================");

2. 数组入参数

   public static void ergodic(int[][] arr){}
   

3. 数组作返回值

   public static int[][] ergodic(int[][] arr){}
   

6. 多维数组

1. 数组的数值 （套娃）

7. Arrays工具类使用：

	//Arrays 类工具包使用
  		public static void arr(){
    		int[] arrays1 = new int[] {1,2,3,4,5,6,7,8,9,10,12,54,11,23,14};
    		System.out.println(Arrays.toString(arrays1));//数组打印
    		Arrays.sort(arrays1);//数组排序
    		System.out.println(Arrays.toString(arrays1));//数组打印
    		Arrays.fill(arrays1,1,3,0);//数组填充（数组,填充的数值）（数组,指定位置开头,指定位置结尾,值）
    		System.out.println(Arrays.toString(arrays1));//数组打印
   			int a = Arrays.binarySearch(arrays1,3);//在数组中寻找3 并返回索引
      		System.out.println(a);//数组打印
}

8. 冒泡排序

​ 冒泡排序是最出名的排序算法之一，一共有八大排序。

​ 两层循环，外层冒泡轮数，内层依次比交。

//猫泡排序 例子
public static void bubBing(){
    int [] arr = new int[]{1,3,5,7,9,2,4,6,8,100,10,22,66,45,33};//声明创建一个数组 并赋值
    
    //临时变量 中间商
    int temp = 0;
    //第一层 判断 要循环多少次
    for (int i = 0; i < arr.length-1; i++) { //下标区间 【0，lenght-1】
        //第二次 判断数值,第一个比第二个大，交换
        for (int j = 0; j < arr.length-1-i; j++) {
            if (arr[j+1]<arr[j]){ //判断 数值第二个元素比第一个元素小
                temp = arr[j+1];//  temp = 第二个元素
                arr[j+1]=arr[j];//第二个元素 被 第一个元素 覆盖
                arr[j] =temp; //第一个元素 被 temp 覆盖
            }
        }

    }
    System.out.println(Arrays.toString(arr));//打印数组
    
}

9. 稀疏数组

代码示例：

public static void test (){
    int[][] spare = new int[6][6];
    spare[0][0] = 1;
    spare[1][1] = 2;
    spare[2][2] = 3;
    spare[3][3] = 4;
    spare[4][4] = 5;
    //spare[5][5] = 6;

    //打印原始数组
    System.out.println("原始数组：");
    priArr(spare);
    System.out.println("===========================");

    //压缩成稀疏数组
    int[][] spare1 = ergodic(spare);
    //打印稀疏数组
    System.out.println("稀疏数组：");
    priArr(spare1);
    System.out.println("===========================");

    //还原稀疏数组
    System.out.println("还原稀疏数组");
    int[][] spare2 =reduction(spare1);
    //打印还原的稀疏数组
    priArr(spare2);
    System.out.println("===========================");

}
//打印原始数组
public static void priArr(int[][] spare1){

    for (int[] arr1 : spare1) { //for增强型一般用于打印输出结果 返回到 arr1
        for (int arr2 : arr1) { //返回到 arr2
            System.out.print(arr2 + "\t"); //打印 arr2
        }
        System.out.println();//换行
    }

}

// 压缩到稀疏数组(ergodic压缩)
public static int[][] ergodic(int[][] arr){
    //第一步
    // 遍历数组：取出原始数组中有几个不同的数字
    int sum = 0;//初始一个用来记录有几个不同的数值
    for (int i = 0; i < arr.length; i++) {         //外循环 行  第一个括号内的值
        for (int j = 0; j < arr[i].length; j++) {  //内循环 列  第二个括号内的值
            if (arr[i][j]!=0){ //判断 值不等于0
                sum ++;   //数量加1
            }
        }
    }
    //第二步
    //创建稀疏数组 并创建目录和空间
    int[][] spare = new int[sum+1][3]; //创建空间
    spare[0][0] = arr.length;     //行   大数组个数
    spare[0][1] = arr[0].length;  //列   小数组个数
    spare[0][2] = sum;           //个数  不同的数值有几个

    //遍历原始数组中 不同数字所在位置的： 行 列 值（数值）           赋值到稀疏数组中
    int value =0;//用来记录 几行
    for (int i = 0; i < arr.length; i++) {          //外循环 行   第一个括号内的值
        for (int j = 0; j < arr[i].length; j++) {   //内循环 列   第二个括号内的值
            if (arr[i][j]!=0){//判断 值不等于0
                value ++; //行+1
                spare[value][0] = i; //行的 位置
                spare[value][1] = j; //列的 位置
                spare[value][2] = arr[i][j];//不同的数值
            }
        }
    }

    return spare;//返回 数组
}

//还原稀疏数组（reduction还原）

public static int[][] reduction (int[][] arr1){
    //创建 数组空间
    int[][] arrays1 = new int[arr1[0][0]][arr1[0][1]];//arr1[0][0]记录的是行 arr1[0][1]记录的是列
    for (int i = 1; i < arrays1.length; i++) {//遍历赋值
        //arrays1 i=行  列的下标是固定的(0 1 2)   [i][0]存放的是X坐标  [i][1]存放的是Y坐标 [i][2]存放的是数值
        arrays1[arr1[i][0]][arr1[i][1]] = arr1[i][2];
    }
    return arrays1;//返回 数组
}