【Java基础编】数组

数组的定义

1. 数组是相同类型数据的有序集合
2. 数组描绘的是相同类型的若干个数据，按照一定的先后次序排列组合而成
3. 每一个数组中的数据都称为一个数组元素，每一个数组元素可以通过一个下标来访问他们

数组声明与创建

必须声明数组变量，才能在程序中使用数组

java语言是用new操作符来创建数组，并给定数组的长度

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

数组的长度 数组名字.length

    int [] num ;        //设置变量
    num = new int[10];      //定义数组长度  动态初始化
    //或则直接写成int[] num = new int [10]
    num [0] = 1;
    num [1] = 4;
    num [2] = 5;
    num [3] = 7;
    num [4] = 6;
    num [5] = 4;
    num [6] = 2;
    System.out.println(num[7]);    //如果输出一个未设置默认数据的元素，就输出默认值，int类型为0

内存分配

数组的三种初始化

• 静态初始化: int []a = {1,2,3};
• 动态初始化int [] a = new int[2]; a[0] = 2;
• 数组的默认初始化: 数组也是应用类型（除了8大基本类型都是），它的元素相当于类的实例变量，因此数组一经分配空间，其中的每一个元素也会按照实例变量同样的方式被隐式初始化—就相当于定义了一个数据长度为10的int型的数值，当没给它赋值时，它的每个元素都默认为0

数组的四个基本特点

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

数组的使用

1. 普通的For循环

2. For-Each循环

3. 数组作为方法入参

4. 数组做返回值

多维数组

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

二维数组 int a[] [] = new int[2] [5];可以看成一个俩行五列的数组

  int [][]a = new int[4][3];
        a[0][0] = 1;
        a[0][1] = 31;
        a[0][2] = 12;
        a[1][0] = 13;
        a[2][1] = 21;
        for (int i = 0;i<a.length;i++){
            for (int j = 0;j<a[i].length;j++){
                System.out.println(a[i][j]);

            }
        }

Arrays类

)]

• 数组的工具Java.util.Arrays

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

• 查看jdk帮助文档

• Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用,而“不用”使用对想来调用（注意：是不用，而不是不能）

• 具有一下常用功能：

  ​ 1.给数组赋值：通过fill方法

  ​ 2.对数组排列：通过sort方法，按升序

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

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

冒泡排序 —江湖上人尽皆知

 /*
      冒泡排序
            1.比较数组中两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
            2.每次比较都会产生一个最大的或者最小的数字
            3.下一轮则会少一次排序
            4.依次排序直至结束
     */

int [] num = {5,8,948,454,8455,45,21,78,22,3333,11};
int temp =0; //设置一个中间变量
for (int b = 0; b< num.length; b++){
    for (int j = 0; j< num.length-b-1; j++){
        if (num[j]> num[j+1]){
            temp = num[j];
            num[j] = num[j+1];
            num[j+1]= temp;

        }
    }
}

稀疏数组

  //0代表没旗。1代表黑棋。2代表白棋
    int [] [] array = new int [10][9];   // 数组是几行几列
    array [1] [2] =1;//第二行，3列
    array [3] [5] =2;//第四行，6列
    for (int[] ints : array) {
        for (int ints1:ints){
            System.out.print(ints1+"\t");
        }
        System.out.println();
    }

    //转换为稀疏数组保存
    //获取有效值的个数
    int tmp =0;
    for (int i =0;i<array.length;i++)
    {
        for (int j =0;j<array[i].length;j++)
        {
            if (array[i][j]!=0){
                tmp++;
            }
        }
    }
    System.out.println("有效值的个数为"+tmp+"个");

    //创建一个稀疏数组
    int [][]array2 = new int [tmp+1][3];
    array2 [0][0] =10;
    array2 [0][1] =9;
    array2 [0][2] =2;
    int cont =0;
    for (int i =0;i<array.length;i++)
    {
        for (int j =0;j<array[i].length;j++)
        {
            if (array[i][j]!=0){
                array2 [cont+1] [0]=i;
                array2 [cont+1] [1]=j;
                array2 [cont+1] [2]=array[i][j];
                cont++;
            }
        }
    }
    System.out.println("=============================");
    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");
    }
    //还原稀疏数组
    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("打印还原的数组");
    System.out.println("打印"+array2[0][1]);
    for (int[] ints : array3) {
        for (int ints1:ints){
            System.out.print(ints1+"\t");
        }
        System.out.println();
    }