2021-06-29数组相关

数组

数组的声明创建

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

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

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

dataType[] arrayRefVar=new dataType[arraySize];

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

获取数组长度：arrays.length

代码演示：

 public static void main(String[] args) {
        int[] nums;//1.定义
        int nums2[];//不建议使用
        nums=new int[10];//2.创建一个数组  这里面可以存放10个int类型的数字
        //3.给数组元素中赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;//剩余没有赋值的默认为0
    }

对应的内存图：

数组的四个基本特点：

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

数组的使用：

for-each循环

 public static void main(String[] args) {
       int[] arrays={1,2,3,4,5};
       //增强for循环  可使用快捷键：array.for即可打出来
        for (int array : arrays) {
            System.out.println(array);
        }
       //打印全部的数组元素
        for (int i=0;i<arrays.length;i++){
            System.out.println(arrays[i]);
        }
        //输出数组元素的总和
        int sum=0;
        for (int i=0;i<arrays.length;i++){
            sum+=arrays[i];
        }
        System.out.println("和为："+sum);
        //输出数组中的最大元素
        int temp=arrays[0];
        for (int i=0;i<arrays.length;i++){
            if(arrays[i]>temp)
                temp=arrays[i];
        }
        System.out.println("最大值为："+temp);
    }

数组作方法入参

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

数组作返回值

//反转数组
public static int []  reverse(int[] array){
    int[] reverse=new int[array.length];
    for (int i=array.length-1;i>=0;i--){
        reverse[array.length-1-i]=array[i];
    }
    return reverse;
}

多维数组

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

二维数组

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

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

public static void main(String[] args){
    int [][] array={{1,2},{2,3},{3,4},{4,5}}
    //[4][2]
    /*
    1,2 ->  array[0]
    2,3 ->  array[1]
    3,4 ->  array[2]
    4,5 ->  array[3]
    */
}

二维数组的图说明：

数组应用：

Arrays类：专门用于操作数组的类

toString():打印数组元素

  public static void main(String[] args) {
     int[] array={1,2,3,4,5,4,4,45,56};
        System.out.println(array);
        System.out.println(Arrays.toString(array));
    }

输出结果图：

sort():对数组进行排序

public static void main(String[] args) {
 int[] array={1,2,3,4,5,4,4,45,56};
    System.out.println(array);
    System.out.println(Arrays.toString(array));
    Arrays.sort(array);
    System.out.println(Arrays.toString(array));

}

输出结果图：

冒泡排序：

//冒泡排序
    /*
    * 1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    * 2.每一次比较，都会产生一个最大，或者最小的数字
    * 3.下一轮则可以少一次排序
    * 4.依次循环，直到结束！
    * */
public static void bubbleSort(int[] array){
    int temp=0;
    for(int i=0;i<array.length-1;i++){
        for(int j=0;j<array.length-i-1;j++){
            if(array[j]>array[j+1]){
            temp=array[j];
            array[j]=array[j+1];
            array[j+1]=temp;
            }
        }
    }
}

稀疏数组：是一种数据结构

需求：编写五子棋的游戏中，有存盘退出和续上盘的功能。

**分析问题：**因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据。

**解决：**稀疏数组

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

稀疏数组的处理方式是：

1. 记录数组一共有几行几列，有多少个不同值

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

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

具体代码展示：

  public static void main(String[] args) {
     //1.创建一个二维数组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 count=0;
        for (int i = 0; i < 11; i++) {
            for(int j=0;j<11;j++){
                if(array1[i][j]!=0)
                    count++;
            }
        }
        System.out.println("有效值的个数:"+count);
        //2.创建一个稀疏数组的数组
        int[][] array2=new int[count+1][3];
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=count;
        //遍历二维数组，将非零的值，存放在稀疏数组中
        int temp=0;
        for(int i=0;i<array1.length;i++){
            for (int j=0;j<array1[i].length;j++){
                if (array1[i][j]!=0){
                    temp++;
                    array2[temp][0]=i;
                    array2[temp][1]=j;
                    array2[temp][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][0]+"\t");
        }
    }

输出效果图：

自己可以自行敲一下试试哦！！！