08.Java数组

JAVA数组

1、数组概述

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

2、数组声明创建

• 首先必须声明数组变量，才能再程序中属于数组。下面是声明数组的语法：

  dataType[] arrayRefVar; //首选方法
  或
  dataType arrayRefVar[]; //效果相同，但是不是首选方法
  

• Java语言使用new操作符来创建数组，语法如下：

  dataType[] arrayRrefVar = new dataType[arraySize];
  

• 数组的元素是通过索引访问的，数组索引从0开始

• 获取数组长度：

  arrays.length
  

• 数组的四个特点：

  • 其长度是确定的，数组一旦被创建，他的大小就是不可以改变的。
  • 其元素必须是相同类型，不允许出现混合类型。
  • 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
  • 数组变量属于引用类型，数组也可以看成是对象，数组中的没个袁术相当于该对象的成员变量。数组本身就是对象，Java中对象是堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

• 数组边界

  • 下标合法区间：[0,length-1]

3、数组使用

//普通的For循环
//For-Fach循环
//数组作方法的参数
//数组作返回值

package com.chao.array;

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        arrays = reverseArray(arrays);
        printArray(arrays);
    }

    //打印数组元素
    public static void printArray(int[] arrays){
        for (int array : arrays){
            System.out.print(array+" ");
        }
    } 
    //反转数组
    public static int[] reverseArray(int[] arrays){
        int [] reverse = new int[arrays.length];
        for (int i = 0, j = arrays.length-1; i < arrays.length; i++,j--) {
            reverse[j] = arrays[i];
        }
        return reverse;
    }
}

4、多维数组

• 多维数组可以看成数组的数组

• 二维数组的声明和创建如下

  int a[][] = new int[2][5];//2行5列的数组
  

5、Arrays 类

• 数组的工具类java.util.Arrys(参照对应jdk帮助文档)

• 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用

• Arrays类中方法都是Static修饰的静态方法，在使用的时候可以之间使用类名调用，而“不用”使用对象来调用（注：“不用”不是“不能”）。

• 常用的方法

  Arrays.toString(array);//打印数组
  Arrays.sort(array);//对数组进行排序
  Arrays.binaySeach(array,key);//查找排序后的数组的值对应的索引
  Arrays.equals(array1,array2);//比较两个数组是否相等
  

6、稀疏数组

• 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。

• 稀疏数组的处理方式：

  • 记录数组一共几行几列，有多少个有效值
  • 把有效值的元素和行列记录在小规模的数组中。

• 如下图：左边为元素数组，右边为稀疏数组（第0行表示原二维数组为6行7列有8个有效值；第1行表示原二维数组的第一个有效值为8其位置为0行3列，以此类推）

  

• 代码实现如下：

  package com.chao.array;
  
  import java.util.Arrays;
  
  public class ArrayDemo08 {
      public static void main(String[] args) {
          //创建一个二维数组11*11,并赋初始值
          int[][] array = new int[11][11];
          array[1][2] = 1;
          array[2][3] = 2;
          
          //输出原始数组
          System.out.println("输出原始数组：");
          for (int[] ints : array){
              for (int anInt : ints ){
                  System.out.print(anInt+"\t");
              }
              System.out.println();
          }
          
          System.out.println("转化为稀疏数组如下：");
          int[][] sparseArray = arrayToSparse(array,0);
          //打印稀疏数组
          for (int[] ints : sparseArray){
              for (int anInt : ints ){
                  System.out.print(anInt+"\t");
              }
              System.out.println();
          }
          
          System.out.println("还原的二维数组如下：");
          int[][] array1 = sparseToArray(sparseArray,0);
          //打印还原的二维数组
          for (int[] ints : array1){
              for (int anInt : ints ){
                  System.out.print(anInt+"\t");
              }
              System.out.println();
          }
      }
  
      public static int[][] arrayToSparse(int[][] array,int invalidValue){
          //该函数将二维数组转化为稀疏数组,输入参数为原始二维数组和无效值
          //1、计算有效值个数
          int effectiveValueSum = 0;
          for (int i = 0; i < 11; i++) {
              for (int j = 0; j < 11; j++) {
                  if (array[i][j] != invalidValue)
                  {
                      effectiveValueSum++;
                  }
              }
          }
          //2、定义一个稀疏数组，并赋初始值
          int[][] sparseArray = new int[effectiveValueSum+1][3];
          sparseArray[0][0] = array.length;
          sparseArray[0][1] = array[0].length;
          sparseArray[0][2] = effectiveValueSum;
  
          //3、遍历原数组，转化为稀疏数组。
          int count = 0;
          for (int i = 1;i < array.length;i++){
              for (int j = 0; j < array[i].length; j++) {
                  if (array[i][j] != 0){
                      count++;
                      sparseArray[count][0]=i;
                      sparseArray[count][1]=j;
                      sparseArray[count][2]=array[i][j];
                  }
              }
          }
          return sparseArray;
      }
      public static int[][] sparseToArray(int[][] sparseArray,int invalidValue){
          //该函数将稀疏数组转化为二维数组,输入参数为稀疏数组和无效值
  
          //1、创建一个二维数组
          int[][] array= new int[sparseArray[0][0]][sparseArray[0][1]];
  
          //2、给二维数组赋无效值填充整个数组,这里使用了java.util.Arrays类方法fill。
          for (int[] ints : array) {
              Arrays.fill(ints, invalidValue);
          }
  
          //2、遍历稀疏数组，还原二维数组
          for (int i = 1; i < sparseArray.length ; i++) {
              for (int j = 0; j < sparseArray[i].length; j++) {
                  array[sparseArray[i][j]][sparseArray[i][j]] = sparseArray[i][2];
              }
          }
          return array;
      }
  }