数组

数组

数组概述

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

数组声明创建

• 首先必须声明数组变量，才能在程序中使用数组，下面是声明数组变量的语法：

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

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

  dataType[] arrayRefvar =new dataType[arraysize];
  

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

• 静态创建:

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

• 获取数组长度：

array.length

例：

 
        int sum=0;
        int [] array=new int[10];//给数组分配空间
        array[0]=1;
        array[1]=2;
        array[2]=3;
        array[3]=4;
        array[4]=5;
        array[5]=6;
        array[6]=7;
        array[7]=8;
        array[8]=9;
        array[9]=10;//给数组赋值
        for (int s:array){
            int k=s;
            System.out.println(k);
        } //遍历数组

数组对应的存储模式：

数组的特点

• 其长度是确定的。数组一旦被创建，它的大小就是不可改变的。
• 其元素必须是相同类型，不允许出现混合类型。
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组变量属于引用类型，数组也可以看成是对象，数组中的每一个元素相当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数字无论保存原始类型还是其他对象类型，数组本身都是在堆中的
• 数组越界会爆出异常： java.lang.ArrayIndexOutOfBoundsException

例：数组反转

int [] arr={1,2,3,4,5,6,7,8,9,10};
    int []reverse_arr =new int[arr.length];   //定义一个新数组为reverse_arr长度和arr长度一样
    for (int i = 0,j = arr.length-1; i <arr.length; i++,j--) {    // 通过下标来赋值  将arr的第一个元素赋值给reverse_arr的最后一个元素
       reverse_arr[j] =arr[i];
    }
    for (int i : reverse_arr) {
        System.out.println(i);
    }
}

多维数组

• 二维数组：

  int a[][]=new int[2][5];
  

  这个数组可以看成是一个2行5列的数据

Arrays类

• 数组工具类java.util.Arrays

• 由于书组队想本身并没有什么办法可以供我们调用，但api中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作

• Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用

• 具有一下常用功能

• 1. 给数组赋值:通过fill方法

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

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

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

     int[] a={12,155,15,15,2,266,236,21,4,56,998,2351};
      System.out.println(Arrays.toString(a));  //打印数组a
     Arrays.sort(a); //对数组a进行排序
      System.out.println(Arrays.toString(a)); 
      Arrays.fill(a,20);//用20填充数组a
      System.out.println(Arrays.toString(a));
     

测试结果如下：

稀疏数组

• 当一个数组中大部分元素都为0或者为同一个值的数组时，我们可以用稀疏数组来保存该数组
• 稀疏数组的处理方式：
• 1. 记录数组一共有几行几列，有多少不同值
  2. 吧具有不同值的元素和行列及值记录在一个小规模数组中，从而减少程序的规模

例：

int a[][]=new int[11][12];
    a[1][2]=1; a[2][3]=2;     //定义一个新的数组为a 一共有11行11列
System.out.println("原始数组为:");  //用两个for循环来找出原数组有效的值记录有效值的个数并且遍历原数组并输出
int num=0;
for (int i = 0; i <a.length ; i++) {
    for (int j = 0; j <a.length ; j++) {
        if (a[i][j]!=0){  //判断在i行j列的数据是否为0 如果为否 则num++                     
            num++;
            System.out.print(a[i][j]+"\t");
        }else {System.out.print(a[i][j]+"\t");}
    }
    System.out.println();
}
System.out.println("有效数据有:"+num+"个");
//创建一个数组来表示稀疏数组
int [][]a2=new int[num+1][3]; //定义一个新的数组a2 ,a2的第一行存储数组的行数列数和有效值个数
a2[0][0]=11;
a2[0][1]=11;
a2[0][2]=num;
int cont=0;
for (int i = 0; i <a.length ; i++) {
    for (int j = 0; j <a.length ; j++) {
        if (a[i][j]!=0){
            /*遍历原数组 用cont来表示行数 每寻找到一个有效数据 
            cont++ 在第cont行的第0列表示有效数据在原函数的行数
            在第1列表示在原函数的列数 第2列表示有效数据的值
            */
            cont++;
            a2[cont][0]=i;
            a2[cont][1]=j;
            a2[cont][2]=a[i][j];
        }
    }
}
System.out.println("稀疏数组为:");
for (int[] ints : a2) {
    for (int i : ints) {  //运用两个增强for循环来遍历稀疏数组
        System.out.print(i+"\t");
    }
    System.out.println();
}
System.out.println("====================================================");
//还原稀疏数组
int[][]a3=new int[a2[0][0]][a2[0][1]];
for (int i = 1; i <a2.length ; i++) {
    for (int j = 0; j <a2.length; j++) {  //用两个嵌套的for循环来遍历稀疏数组
        a3[a2[i][0]][a2[i][1]]=a2[i][2];    
        /*还原数组的有效数据的行为稀疏数组的第i行的第0列
           列为稀疏数组的第i行第1列 值为稀疏数组的第i行第2列*/
    }
}
System.out.println("还原后的数组为:");
for (int[] ints : a3) {
    for (int i : ints) {
        System.out.print(i+"\t");  
    }
    System.out.println();
}

测试结果如下所示：