Java数组

1. 数组概述

相同类型的若干数据，按一定先后次序排列的有序集合
每个数据被称作一个数组元素，可通过他的下标来访问

2. 数组声明创建

声明与创建
- 首先声明数组变量
```
int[] aname;//首选方法
int aname[];
```
- Java使用new操作符来创建数组
```
int[] aname = new int[size];
```
- 数组元素通过索引访问，数组索引从0开始
- 获取数组长度：arrays.length
内存分析

Java：
- 堆
  - 存放new对象和数组
  - 可以被线程共享，不会存放在别的对象引用
- 栈
  - 存放基本数据类型
  - 引用对象的变量，存放引用在堆地址
- 方法区
  - 可以被线程共享
  - 包含所有class和static变量
三种初始化
- 静态初始化
```
int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};
```
- 动态初始化
```
int[] a = new int[2];
a[0] = 1;
```
- 数组默认初始化
  
  数组是引用类型，相当于类的实例变量，按同样方式隐式初始化。
数组四个基本特点
- 长度确定，大小不变
- 元素必须是相同类型
- 可任意类型
- 数组变量是引用类型，数组对象存放在堆中
数组下标越界
- 下标合法区间：[0,length-1],越界报错.
  
  ArrayIndexOutOfBoundsException:数组下标越界异常
- 小结:
  - 数组是相同类型有序集合
  - 数组是对象
  - 数组长度不可变，超出报越界异常

3. 数组使用

for each
数组作方法入参

数组作返回值入参

public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //1.for循环
//        for (int i = 0; i <arrays.length ; i++) {
//            System.out.println(arrays[i]);
//        }
        //2.for each
//        for (int array:arrays) {
//            System.out.println(array);
//        }
        //3.调用入参方法
//        printArray(arrays);
        //4.数组作返回值
        int[] reverse = reverse(arrays);
        printArray(reverse);
        System.out.println("=====================");
        int[][] array = {{1,2},{3,4},{5,6},{7,8}};
        for (int i = 0; i < array.length ; i++) {
            for (int j = 0; j < array[i].length ; j++) {
                System.out.println(array[i][j]);
            }
        }
    }

    //3.方法入参
    public static void printArray(int[] arrays){
        for (int array:arrays) {
            System.out.println(array);
        }
    }

    //4.数组作返回值
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        for (int i = 0; i < arrays.length ; i++) {
            result[i] = arrays[arrays.length-i-1];
        }
        return result;
    }

4. 多维数组

多维数组定义：可看成是数组的数组，二维数组是特殊的一维数组，其中每个元素都是一维数组。
```
int[][] a = new int[2][3];
```

5. Arrays类

数组工具类Arrays:java.util.Arrays
数组对象本身没什么方法，可调用Arrays类中的
查看java API手册
Arrays类中方法有static修饰，可直接调用
功能:
- 给数组赋值:fill
- 排序：sort,升序
- 比较数组：equals,比较数组中元素是否相等
- 查找数组元素：binarySearch,对已排序数组二分查找

public static void main(String[] args) {
        int[] a = {1,2,3,87,2678,431,17,77899};

        //System.out.println(a); //[I@531be3c5
        //1.输出数组
        //System.out.println(Arrays.toString(a)); //依次输出数组元素
        //自写toString
        //printArrays(a);

        //2.升序排序
        //Arrays.sort(a);
        //System.out.println(Arrays.toString(a));

        //3.填充
        //Arrays.fill(a,0);
        Arrays.fill(a,2,4,0);
        System.out.println(Arrays.toString(a));

        //4.比较 ==与equals
        int[] b = a;
        System.out.println(a==b);
        System.out.println(Arrays.equals(a,b));
        Integer i1 = 128;
        Integer i2 = 128;
        System.out.println(i1==i2);
        System.out.println(i1.equals(i2));

        //5.二分查找
        System.out.println(Arrays.binarySearch(a,17));
        System.out.println(Arrays.binarySearch(a,77899));
    }

    public static void printArrays(int[] a){
        for (int i = 0; i < a.length ; i++) {
            if (i == 0){
                System.out.print("[");
            }
            if (i == a.length-1){
                System.out.print(a[i]+"]");
            }else{
                System.out.print(a[i]+", ");
            }
        }
    }

6. 稀疏数组

介绍：
- 一个数组大部分元素为0，或同一值可用稀疏算法
- 处理方式：
  - 记录数组中一共几行几列，有多少个不同值
  - 把巨头不通知的元素和行列及值记录在小规模数组中，从而缩小规模

//稀疏数组
        //1.创建一个二维数组 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+"	");
            }
            System.out.println();
        }
        //2.稀疏数组
        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("======================================");
        System.out.println("有效值个数："+sum);
        //打印稀疏数组
        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]+"	"+
                    array2[i][1]+"	"+
                    array2[i][2]+"	"
            );
        }

        //3.还原
        System.out.println("==========================");
        System.out.println("还原稀疏数组");
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //还原其他元素
        for (int i = 1; i < array2.length ; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        for (int[] ints:array3) {
            for (int anInt:ints) {
                System.out.print(anInt+"	");
            }
            System.out.println();
        }