Java数组相关知识

1. 数组概述

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

2. 数组声明与创建

（1）如定义int数组nums的方式：
int[] nums； //首选，Java风格
int nums[]； //效果相同，非首选，c/c++风格
（2）Java语言使用new操作符来创建数组，语法如下

dataType[] arrayRefVar = new dataType[arraySize];
//example
int[] nums;//声明
nums = new int[10];//创建
int[] nums2 = new int[10];//声明和创建
//数组元素赋值
nums[0] = 1;
//获取数组长度
int l = nums.length;

3. 数组初始化和内存分析

（1）Java内存分析：
堆： 存放new的对象和数组；可以被所有的线程共享，不会存放别的对象引用。
栈： 存放基本变量类型（会包含这个基本类型的具体数值）；引用对象的变量（会存放这个引用在堆里面的具体地址）。
方法区： 可以被所有线程共享；包含了所有的class和static变量。
（2）举例：
a. 声明数组int[] array;

b. 创建数组array = new int[6];//未赋值为null

c. 给数组元素赋值

for(int i = 0 ; i < array.length;i++){
     array[i] = i + 1 ;
}

（3）数组三种初始化
a. 静态初始化 ：创建 + 赋值，int[] a = {1,2,3}; Man[] mans = {new Man(1,1), new Man(2,2)};
b. 动态初始化 new开辟新的空间，包含默认初始化，int[] a = new int[2]; a[0] =1; a[1] = 2;
c. 数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数据一经分配空间，其中的每个元素也被按实例变量同样的方式被隐式初始化。
不同的初始化默认值：
byte，short，int，long类型定义的数组，初始化默认是0；
float、double类型定义的数组，默认值是0.0；
String类型定义的数组，默认值是null；
char类型定义的数组，默认值是‘0’（’\u0000’）；
boolean类型定义的数组，默认值是false。

4. 数组的下标越界问题

（1）数组的基本特点：
a. 数组长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
b. 数组元素必须是相同类型，不允许出现混合类型。
c. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
d. 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
（2）下标合法区间：[0, length-1]
数组下标越界异常：ArrayIndexOutOfBoundsException

5. 数组使用

（1）增强型for循环(For-Each循环)遍历数组，不用数组下标

int[] arrays = {1,2,3,4,5};
// 增强型for循环遍历数组，输入arrays.for按Tab键
for(int array : arrays){
      System.out.println(array);//无下标
}

（2）反转数组

//自定义反转数组方法（函数）
public static int[] reverse(int[] arrays){
      int[] result = new int[arrays.length];

      //反转操作一
      for(int i=0;i<arrays.length;i++){
           result[arrays.length-i-1] = arrays[i];
    }
    //反转操作二
    //for(int i=0,j=result.length-1;i<arrays.length;i++,j--){
    //      result[j] = arrays[i];
    //}

      return result;
}

6. 多维数组

（1）多维数组可以看成是数组的数组，比如二维数组就是特殊的一维数组，其每一个元素都是一个一维数组。

a. 一维数组：int[] arrays = {1,2,3}
b. 二维数组：原本1，2 ，3的位置变成数组，int[][] arrays = {{1,2},{2,3},{3,4}};
arrays.length;为3；
arrays[0].length;、arrays[1].length;、arrays[2].length;为2。
遍历：

for(int i=0;i<arrays.length;i++){
      for(int j=0;j<arrays[i].length;j++){
           System.out.println(arrays[i][j]);
      }
}

c. 三维数组：原本1，2 ，2， 3，3， 4的位置变成数组，三层大括号

7. Arrays类

import java.util.Arrays;
public class data {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,9090,31231,543,21,3,23};
        //使用1 输出
        System.out.println(arrays);
        System.out.println(Arrays.toString(arrays));
        System.out.println("*********************");
        //使用2 升序排序
        Arrays.sort(arrays);
        System.out.println(Arrays.toString(arrays));
        System.out.println("*********************");
        //使用3 数组的下标为2-4之间元素用0填充，左闭右开区间
        Arrays.fill(arrays,2,4,0);
        System.out.println(Arrays.toString(arrays));
    }
}

除此之外还包括其他，比如比较数组元素是否相等的equals方法，对排序好的数组进行二分查找法操作的binarySearch方法。

8. 冒泡排序

两层循环，外层冒泡轮数，内层依次比较，嵌套循环，该算法时间复杂度为O(n^2)

//冒泡排序，比较数组中，两个相邻的元素，如果第一个数比第二个数大，则交换位置
    public static void sort(int[] a){
        int temp = 0;
        for(int i = 0;i<a.length-1;i++){
            for(int j = 0;j<a.length-1-i;j++){
                if(a[j+1]>a[j]){ //降序排序
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
    }

9. 稀疏数组

（1）当一个数组中大部分元素为0，或者为同一数值，可以使用稀疏矩阵来保存该数组。
（2）稀疏矩阵处理方式：
记录数组一共几行几列，有多少不同值；
把具有不同值的元素和行列及值记录在一个小规模的数组里，从而缩小程序的规模。

原始数组及其稀疏数组：

其中，稀疏数组第一行表示原始数组共6行7列，有效值有8个。

//原始数组和稀疏数组的相互变换

//原始矩阵arrays转换为稀疏矩阵,假设其大量重复数字是0
//获取有效值个数,arrays.length是行数，arrays[0].length是列数
int count = 0；
for(int i = 0;i<arrays.length;i++){
   for(int j = 0;j<arrays[0].length;j++){
        if(arrays[i][j]!=0){
           count++;
       }
   }
//创建稀疏数组
int[][] arrays1 new int[count+1][3];
arrays1[0][0] = arrays.length;
arrays1[0][1] = arrays[0].length;
arrays1[0][2] = count;

int count1 = 0;
for(int i = 1;i<arrays.length;i++){//遍历原始二维数组，将非零值存放在稀疏数组中
   for(int j = 0;j<arrays[0].length;j++){
        if(arrays[i][j]!=0){
           count1++;
           arrays1[count1][0] = i;
           arrays1[count1][1] = j;
           arrays1[count1][2] = arrays[i][j];
       }
   }
}  

//由稀疏数组还原原始数组
int[][] arrays2 = new int[arrays1[0][0]][arrays1[0][1]];
for(int i = 1 ; i < arrays1.length ; i++){
arrays2[arrays1[i][0]][arrays[i][1]] = arrays1[i][2]
}