JAVA数组

数组概述

数组是相同类型数据的有序集合，按一定的先后次序组合而成。

每一个数据称为一个数组元素，每个数组元素可以通过一个下标来访问。

数组声明创建

定义数组

变量类型 变量名字 = 变量的值

int[] nums;//首选
int nums[];//次选
//未赋值默认为空 即 int[] array = null;

初始化数组

nums = new int[10]

定义并初始化数组

int[] a = {1,2,3,4,5};`
int[] array = new int[10];
int[] arr = new int[]{3,5,1,7};

赋值

int[0] = 0;
//省略1~8
int[9] = 9;

获取数组长度

array.length

内存分析（堆和栈）

堆：存放new的对象和数组，可以被所有的线程共享，不会存放别的对象引用。

栈：存放基本变量类型（包含具体数值）、引用对象的变量（堆的具体地址）

三种初始化

静态初始化：创建+赋值

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

动态初始化：包含默认初始化

int[] b = new int[10];//默认值为0

默认初始化（默认赋值）

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

运用

//使用循环赋值
public static void main(String[] args) {
    int[] arr = new int[10];
    for (int i = 0; i < arr.length; i++) {
        arr[i] = i;
        System.out.println(arr[i]);
    }
}

基本特点

1. 长度确定。定义完不可改变。
2. 类型固定。不存在混合类型数组。
3. 元素任意。数组中的元素可以是基本类型，可以是引用类型。
4. 数组也是对象。数组保存在堆中，数组元素相当于对象的成员变量。
5. 不可越界。数组[0, n]，越界报错"ArrayIndexOutOfBoundsException:数组下标越界异常！"

数组使用

For循环

int[] arrays = {1, 2, 3, 4};
for(int i=0; i<arrays.length;i++){
    System.out.println(arrays[i]); 
}

For-Each循环

//idea输入array.for->
//增强型for循环：只能访问不可改变，没有下标
int[] arrays = {1, 2, 3, 4};
for(int array : arrays){
    System.out.println(arrays); 
}

数组作为方法入参及返回值

public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4};
        printArray(arrays);
        int[] result = reverse(arrays);
        printArray(result);
    }
    //打印数组元素
    public static void printArray(int[] arrays){
        System.out.println("数组元素为："+Arrays.toString(arrays));
    }
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        //反转的操作
        for (int i = 0, j=result.length-1; i < arrays.length; i++,j -- ) {
            result[j] = arrays[i];
        }
        return result;
    }

多维数组

二维数组

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

三维数组

//必须输入数据成为一个完整的数组，否则会报错
int[][][] arr1 = {{{0, 1},{2, 3}},{{4, 5}, {6, 7}}};
int[][][] arr2 = new int[10][10][5];

示例：二维遍历输出

int[][] array ={{1, 2}, {2, 3}, {3, 4}, {4, 5}};
for (int i = 0; i < array.length ; i++) {
	for (int j = 0; j <array[i].length ; j++) {
		System.out.println(array[i][j]);
	}
}

拓展

Arrays类

使用：Array.方法名（数组名）//Array.sort(arr)

常见功能：

1. 给数组赋值：通过fill方法。

   arr 数组名，[min, max) 区间，x是填充值

   Array.fill(arr, x); Array.fill(arr, min, max, x);

2. 对数组排序：通过sort方法，按升序。

   Array.sort(arr)

3. 比较数组：通过equals方法比较数组中元素值是否相等。

   Array.equals(arr1, arr2)

4. 查找数组元素：通过 binarySearch方法能对排序好的数组进行二分查找法操作。

   arr 数组名，[min, max) 区间，x是搜索值

   Array.binarySearch(arr, x);Array.binarySearch(arr, min, max, x)

5. 打印数组：通过toString方法，以字符串的形式打印。

   System.out.println(Array.toString(arr));

冒泡排序

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

时间复杂度O(n2)

public static void main(String[] args) {
        int[] ints = {1,24,53,42,5};
        int[] sort = sort(ints);
        System.out.println(Arrays.toString(sort));
}
//增加了flag优化
public static int[] sort(int[] array){
    //临时变量
    int temp = 0;
    //外层循环,判断我们这个要走多少次;
    for (int i = 0; i < array.length-1; i++) {
        boolean flag=false;//通过fLag标识位减少没有意义的比较
        //内层循环,比价判断两个数,如果第一个数,比第二个数大,则交换位置
        for (int j = 0; j < array. length-1-i ; j++) {
            if (array[j+1]<array[j]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
                flag = true;
            }
        }
        if (flag == false){
        	break;
        }
    }
	return array;
}

稀疏数组

当数组中存在大量的相同的数据，记录下不同的数据的信息，压缩数组。

定义：array[count+1] [3]

array[0] 存放 [总行] [总列] [个数]

从下标为一开始记录数据：

array[x] [行] [列] [数据]

public static void main(String[] args) {
    //示例
    //1. 创建一个二维数组 11* 11 0:没有棋子 1:黑棋 2:白棋
    int[][] array1 = new int[11][11];
    array1[1][2] = 1;
    array1[2][3] = 2;

    //输出原始的数组
    System.out.println("输出原始的数组");
    for (int[] ints : array1) {
        for (int anInt : ints) {
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }

    //转换为稀疏数组保存
    //获取有效值的个数
    int sum = 0;
    for (int i = 0; i < 11; i++) {
        for (int j = 0; j < 11; j++) {
            if (array1[i][j] != 0){
                sum++;
            }
        }
    }
    System.out.println("有效值的个数:"+sum);

    //2.创建一个稀疏数组的数组
    int[][] array2 = new int[sum+1][3];

    array2[0][0] = 11;
    array2[0][1] = 11;
    array2[0][2] = sum;

    //遍历二维数组,将非零的值,存放稀疏数组中
    int count=0;
    for (int i = 0; i < array1.length ; i++) {
        for (int j = 0; j < array1[i].length; j++) {
            if (array1[i][j] != 0){
                count++;
                array2[count][0] = i;
                array2[count][1] = j;
                array2[count][2] = array1[i][j];
            }
        }
    }

    //输出稀疏数组
    System.out.println("稀疏数组");

    for (int i = 0; i < array2.length; i++) {
        System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
    }

    System.out.println("还原");
    //1.读取稀疏数组
    int[][] array3 = new int[array2[0][0]][array2[0][1]];

    //2.给其中的元素还原它的值
    for (int i = 1; i < array2.length; i++) {
        array3[array2[i][0]][array2[i][1]] = array2[i][2];
    }

    //3.打印
    System.out.println("输出还原的数组");
    for (int[] ints : array3) {
        for (int anInt : ints) {
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }
}