数组

数组定义

• 数组是相同类型数据的有序集合
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
• 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们

数组的声明和创建

• 初始化

  • 动态初始化
    • 数据类型[] 变量名字= new 数据类型[定义的数据大小]。
    • 变量名[索引] = 值，来赋值

  package com.ling.java_base;
  
  public class Array {
      public static void main(String[] args) {
          int[] arr1;
          arr1 = new int[2];
          arr1[0] = 1;
          arr1[1] = 2;
      }
  }
  

  • 静态初始化
    • 数据类型[] 变量名字 =
    • 在声明变量的时候同时进行赋值

  int[] arr1 = {1,2,3,4,5}
  

  • 默认初始化
    • 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化
    • 数值型的元素默认是0，字符为null。

初始化时候的内存分配（先简单理解）

• 当对一个数组进行声明的时候，在将变量压进cpu的栈空间
• 当对数组进行赋值的时候，会在堆空间进行分配空间，如果没有赋值会设定成默认值

数组反转（小例题）

package com.ling.java_base;

public class array02 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] arr2 = reverse(arr);//翻转
        printArr(arr2);//打印
    }
    public static int[] reverse(int[] arr){//数组进行翻转的函数，新建一个数组，然后在这个数组的第一个位置填入最后一个元素，第二个填入倒数第二个，以此类推
        int[] arr2 = new int[arr.length];
        for(int i = 0,j = arr.length- 1;i<(arr2.length); i++,j--){
            arr2[i] = arr[j];
        }
        return arr2;
    }
    public static void printArr(int[] arr){//打印数组的函数
        for (int i : arr) {
            System.out.print(i + " ");

        }
    }
}

二维数组

• 二维数组的定义

  • 动态定义

    int[][] arr = new int[2][2];//在栈中压进一个变量，在堆中开辟一个空间
    arr[0][0] = 1;//对各个元素进行定义
    arr[0][1] = 2;
    arr[1][0] = 3;
    arr[1][1] = 4;
    

  • 静态定义

    int[][] arr = {{1,2},{3,4}};
    

Arrays类

• fill方法
  • 给数组赋值
• sort方法
  • 通过sort方法，按升序
• equals方法
  • 通过equals方法比较数组中元素值是否相等
• binarySearch方法
  • 通过binartSearch方法能对排序好的数组进行二分查找法操作

这些方法都可以通过查看文档来查看怎么使用（参数，作用，返回值）

稀疏数组

• 当一个数组中有许多重复的值，而只有一些数组有意义的时候，可以使用稀疏数组来节省空间
• 得到的稀疏数组：
  • 第一行是 行数 列数 有意义的值个数
  • 其余行是 行数 列数 值（有意义的值的坐标）

package com.ling.java_base;

import javax.swing.*;
import java.util.Arrays;

public class Array05 {
    public static void main(String[] args) {
        int[][] test = {{1, 1, 3}, {2, 2, 6}};
        int[][] original_Array = createArray(11, 11, test);
        printArray(original_Array);
        System.out.println("==================================");
        int[][] zipArray = createZipArray(original_Array);
        printArray(zipArray);
        System.out.println("==================================");
        int[][] retu = retu(zipArray);
        printArray(retu);
    }

    /**
     * 这是用于创建初始化列表的方法
     *
     * @param r         生成的行数
     * @param c         生成的列数
     * @param workValue 数组中有效的值
     * @return 返回一个原始数组
     */
    public static int[][] createArray(int r, int c, int[][] workValue) {
        int[][] original_Array = new int[r][c];
        for (int[] ints : workValue) {
            original_Array[ints[0]][ints[1]] = ints[2];
        }
        return original_Array;
    }

    public static void printArray(int[][] array) {   //打印出二数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println("");
        }
    }

    public static int[][] createZipArray(int[][] originalArray) {  //生成压缩数组
        int num = 0;
        int work_index = 0;
        int zip_index = 1;
        int[][] workArray = new int[10][3];
        for (int i = 0; i < originalArray.length; i++) {
            for (int j = 0; j < originalArray.length; j++) {
                if (originalArray[i][j] != 0) {
                    num++;
                    workArray[work_index][0] = i;
                    workArray[work_index][1] = j;
                    workArray[work_index][2] = originalArray[i][j];
                    work_index++;
                }
            }
        }
        int[][] zipArray = new int[num + 1][3];
        zipArray[0][0] = originalArray[0].length;
        zipArray[0][1] = originalArray.length;
        zipArray[0][2] = num;
        for (int i = 0; i < num; i++) {
            zipArray[zip_index] = workArray[i];
            zip_index++;
        }
        return zipArray;
    }

    public static int[][] retu(int[][] arr){  //还原数组
        int[][] retuArray = new int[arr[0][0]][arr[0][1]];
        for(int i = 1;i < arr.length;i++){
            int r = arr[i][0];
            int c = arr[i][1];
            int v = arr[i][2];
            retuArray[r][c] = v;
        }
        return retuArray;
    }
}