9、数组

9、数组

9.1、数据概念

数组的定义：

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

9.2、数据声明创建

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

  • dataType[] arrayRefvar; // 首选方法

    或者

    dataType arrayRefvar[]; // 首选方法

• java语言使用new操作符来创建数据

  • 语法

  • dataType[] arrayRefvar = new dataTyoe[arraySize];

    public static void main(String[] args) {
      int[] ints = new int[3]; // 定义并分配空间
    
      ints[0] = 1;  // 赋值
      ints[1] = 2;
      ints[2] = 3;
      int sum = 0;
      for (int i = 0; i < ints.length; i++) {
          sum = sum + ints[i];
      }
      System.out.println(sum);
    }
    

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

• 获取数组的长度：arrays.length

内存分析：

三种初始化方式

1. 静态初始化

           // 静态初始化：创建+赋值
           int[] a = {1, 2, 3};
   

2. 动态初始化

           //动态初始化
           int[] b = new int[10];
           b[0] = 1;
   

3. 数组的默认初始化

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

数组的四个基本特点

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

9.3、数组使用

For-ecah循环

 public static void main(String[] args) {

        int[] arrays = {1, 2, 3, 4, 5};

        for (int array : arrays) {
            System.out.println(array);
        }
    }

9.4、多维数据

• 多维数组可以堪称数组的数组，比如二维数组就是一个特殊的数组，其中一个元素都是一个一个数组

• 二维数组

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

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

遍历二维数组

  public static void main(String[] args) {
        int[][] array = {{1, 2}, {3, 4}, {5, 6}};

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

9.5、Arrays类

• 数组的工具类java.util.Arrays

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

   System.out.println(Arrays.toString(a)); 
  

• 具有以下常用的功能：

  • 给数组赋值：通过fill方法
  • 对数组排序：通过sort方法，按升序
  • 比较数组：通过eqeuals方法比较数组中元素值是否相符
  • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找

冒泡排序

 //冒泡排序
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5, 9, 8, 6, 10};

        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));

    }

    public static int[] sort(int[] array) {
        int temp = 0;
        for (int i = 0; i < array.length - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] < array[j]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = true;
                }
            }
            if (flag == false) {
                break;
            }
        }
        return array;
    }

稀疏数组

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[] ints : array1) {
        for (int anInt : ints) {
            System.out.print(anInt + "\t");
        }
        System.out.println();
    }
    //转换为稀疏数组
    //获取有效值的个数

    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(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] + "\t" + array2[i][1] + "\t" + array2[i][2] + "\t");

    }

    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];

    }

    System.out.println("输出原始的数组");
    for (int[] ints : array3) {
        for (int anInt : ints) {
            System.out.print(anInt + "\t");
        }
        System.out.println();
    }
}