数组

数组

数组的定义

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

数组声明的创建

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

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

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

  dataType[] arrayRefVar = new dataType[arraySize];
  

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

• 获取数组长度:

  arrays.length
  

内存分析

• java内存分析

• 错误类型:(下标越界异常)ArrayIndexOutOfBoundsException

三种初始化

• 静态初始化（一步创建+赋值）

  int[] a = {1,2,3};
  Man[] mans = {new Man(1,1) , new Man(2,2)}
  

• 动态初始化（两步创建+赋值）

  int[] a = new int[2];
  a[0]=1;
  a[1]=2;
  

• 数组的默认初始化

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

数组的基本特点

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

数组的边界

• 下标的合法区间: [0, length-1],如果越界就会报错;

  public static void main(String[] args) {
      int[] a=new int[2];
      System. out. println(a[2]);//下标越界异常
  }
  

  • ArrayIndexOutOfBoundsException :数组下标越界异常!

  • 注意

    for (int i = 0; i <=a.length ; i++) {
        System.out.println(a[i]);//下标越界，i不能等于数组长度
    }
    

• 小结:

  • 数组是相同数据类型(数据类型可以为任意类型)的有序集合
  • 数组也是对象。数组元素相当于对象的成员变量
  • 数组长度的确定的，不可变的。如果越界，则报: ArrayIndexOutofBounds

数组的使用

• 基础

  public static void main(String[] args) {
          int[] arrary={1,2,3,4,5,6,7,8};
  
          //打印所有元素
          for (int i = 0; i < arrary.length; i++) {
              System.out.println(arrary[i]);
          }
          System.out.println("===========");
          //计算所有元素的和
          int s=0;
          for (int i = 0; i < arrary.length; i++) {
              s+=arrary[i];
          }
          System.out.println("数组和为："+s);
          System.out.println("===========");
          //查找最大元素
          int max=arrary[0];
          for (int i = 0; i < arrary.length; i++) {
              if (max<arrary[i]){
                  max=arrary[i];
              }
          }
          System.out.println("数组最大值为："+max);
      }
  

• 进阶

  • 增强for循环

    public static void main(String[] args) {    int[] arrays={1,2,3,4,5,6,7};    //增强for循环  省去数组下标    for (int array : arrays) {        System.out.println(array);    }}
    

  • 数组作为方法入参

    //打印数组元素public static void printArry(int[] arrays){    for (int i = 0; i < arrays.length; i++) {        System.out.print (arrays[i]+"\t");    }}
    

  • 数组作返回值

    //反转数组(法一)public static int[] reverse1(int[] arrays){    for (int i = 0; i < (arrays.length/2); i++) {        int a;        a=arrays[i];        arrays[i]=arrays[arrays.length-1-i];        arrays[arrays.length-1-i]=a;    }    return (arrays);}//法二public static int[] reverse2(int[] arrays){    int[] result=new int[arrays.length];    for (int i = 0; i < arrays.length; i++) {        result[i]=arrays[arrays.length-1-i];    }return result;}
    

多维数组

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

• 二维数组

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

  • 解析:以上二维数组a可以看成一个两行五列的数组。

• 思考:多维数组的使用?

  public static void main(String[] args) {    //[3][2] 3行2列的一个数组    /*    1 2  array[0]    3 4  array[1]    5 6  array[2]     */    int arrays[][]={{1,2},{3,4},{5,6}};    for (int i = 0; i < arrays.length; i++) {        for (int j = 0; j < arrays[i].length; j++) {            System.out.println(arrays[i][j]);        }    }}
  

Arrays类

• 数组的工具类java.util.Arrays
• 由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使
  用,从而可以对数据对象进行一些基本的操作。
• 查看JDK帮助文档
• Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不
  用"使用对象来调用(注意:是"不用"而不是"不能")
• 具有以下常用功能: .
  • 给数组赋值:通过fill方法。
  • 对数组排序:通过sort方法,按升序。
  • 比较数组:通过equals方法比较数组中元素值是否相等。
  • 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。

冒泡排序

• 冒泡排序无疑是最为出名的排序算法之一， 总共有八大排序!

• 冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较。

• 我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为0(n2)。

  /*冒泡排序1.比较数组中，两个相邻的元素，如果第一个数比第二个数大,我们就交换他们的位置2.每一次比较。 都会产生出一个最大的数字:3.下轮则可以少一次排序!4.依次循环，直到结束! */public static int[] sort(int[] arrays){    //临时变量    int x=arrays[0];    //外层循环  判断要走多少次    for (int j = 0; j <arrays.length-1 ; j++) {        //内层循环  判断相邻两个数大小，并交换        for (int i = 0; i < arrays.length-1; i++) {            if (arrays[i]>arrays[i+1]){                x=arrays[i];                arrays[i]=arrays[i+1];                arrays[i+1]=x;            }        }    }    return arrays;}
  

• 思考:如何优化?（假如这个数组有100个元素，按照上面的方法，这个数组需要循环判断走99次，但是如果循环到55次时，数组已经排好序，则flag==false，跳出循环，省去了剩下的44次）

  public static int[] sort(int[] arrays){    //临时变量    int x=arrays[0];    //外层循环  判断要走多少次    for (int j = 0; j <arrays.length-1 ; j++) {        boolean flag=false;//通过flag标识位减少没有意义的比较        //内层循环  判断相邻两个数大小，并交换        for (int i = 0; i < arrays.length-1; i++) {            if (arrays[i]>arrays[i+1]){                x=arrays[i];                arrays[i]=arrays[i+1];                arrays[i+1]=x;                flag=true;            }        }        if (flag==false){//若数组已经排好序，后面就不再循环            break;        }    }    return arrays;}
  

稀疏数组（数据结构）

• 需求:编写五子棋游戏中，有存盘退出和续上盘的功能。
• 分析问题:因为该二维数组的很多值是默认值0,因此记录了很多没有意义的数据。
• 解决:稀疏数组

稀疏数组介绍

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

• 稀疏数组的处理方式是:

  • 记录数组一共有几行几列，有多少个不同值
  • 把具有不同值的元素和行列及值记录在一个小规模的数组中， 从而缩小程序的规模

• 如下图:左边是原始数组，右边是稀疏数组：

public static void main(String[] args) {
    //创建一个二维数组  11*11  0：没有棋子  1：黑棋  2：白棋
    int[][] array1=new int[11][11];
    array1[1][2]=1;
    array1[2][3]=2;
    //输出原始数组
    System.out.println("输出原始数组：");
    for (int i = 0; i < array1.length; i++) {
        for (int j = 0; j < array1[i].length; j++) {
            System.out.print(array1[i][j]+"\t");
            if (j==array1[i].length-1){
                System.out.print("\n");
            }
        }
    }
    System.out.println("==================");
    //转换位稀疏数组保存
    //获取有效值的个数
    int sum=0;
    for (int i = 0; i < array1.length; i++) {
        for (int j = 0; j < array1[i].length; j++) {
            if (array1[i][j]!=0){
                sum++;
            }
        }
    }
    System.out.println("有效值个数:"+sum);
    //1.创建一个稀疏数组
    int array2[][]=new int[sum+1][3];
    array2[0][0]=11;
    array2[0][1]=11;
    array2[0][2]=sum;
    //遍历一遍数组，将非零的值存放到稀疏数组中
    int a=0;
    for (int i = 0; i < array1.length; i++) {
        for (int j = 0; j < array1[i].length; j++) {
            if (array1[i][j] != 0) {
                a++;
                array2[a][0] = i;
                array2[a][1] = j;
                array2[a][2] = array1[i][j];

            }
        }
    }
    //输出稀疏数组
    System.out.println("输出稀疏数组：");
    for (int i = 0; i < array2.length; i++) {
        for (int j = 0; j < array2[i].length; j++) {
            System.out.print(array2[i][j]+"\t");
            if (j==array2[i].length-1){
                System.out.print("\n");
            }
        }

    }
    System.out.println("==================");
    System.out.println("还原稀疏数组：");
    //1.读取稀疏数组数据
    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 i = 0; i < array3.length; i++) {
        for (int j = 0; j < array3[i].length; j++) {
            System.out.print(array3[i][j]+"\t");
            if (j==array3[i].length-1){
                System.out.print("\n");
            }
        }
    }

}