数组

数组

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

数组的声明和创建

数组需要先声明再创建
创建和声明可以汇总成一行代码
代码如下

public class ArrayDemo01 {
    public static void main(String[] args) {
        /*  int [] num ;       声明数组
        num = new int [10];     定义数组
        */
         //上面的两行代码可以用一行代替
        int [] num = new int[10];
        //赋值
        num[0]=1;
        num[1]=2;
        num[2]=3;
        num[3]=4;
        num[4]=5;
        num[5]=6;
        num[6]=7;
        num[7]=8;
        num[8]=9;
        num[9]=10;

        int sum = 0;
        //array.length  数组长度
        for (int i = 0;i<num.length;i++){
            sum = sum+num[i];
        }
        System.out.println(sum);

    }
}

数组的三种初始化

• 静态初始化
• 动态初始化
• 数组的默认初始化

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化
        int [] num = {1,2,3,4,5,6,7};
        for (int i=0;i<num.length;i++){
            System.out.println(num[i]);
        }
        //动态初始化
        int [] nums;
        nums=new int[7];
        nums[0]=10;
        System.out.println(nums[0]);
    }
}

有一点要提的是关于数组的下标问题
数组有自己的数组长度，寻找元素的时候注意不要下标越界

数组的使用

下面两组代码在主函数的调用方法的层面展示了数组的使用

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

        //打印数组所有的元素
        for (int i = 0; i < num.length; i++) {
            System.out.println(num[i]);
        }
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < num.length; i++) {
            sum+=num[i];
        }
        System.out.println("sum="+sum);
        //查找最大元素
        int max = num[0];
        for (int i = 0; i < num.length; i++) {
            if (max<num[i]){
                max=num[i];
            }
        }
        System.out.println(max);

    }
}

public class ArrayDemo04 {
    public static void main(String[] args) {
        int [] nums = {1,2,3,4,5};
        /*
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
        */
        int [] reverse = reverse(nums);
        Arrayprint(reverse);

    }
    //打印数组所有元素
    public static void Arrayprint(int [] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }
    //反转数组
    public static int[] reverse(int [] array){
        int [] result = new int[array.length];
        for (int i = 0,j=array.length-1; i < array.length; i++,j--) {
            result[j] = array[i];
        }
        return result;
    }


}

二维数组

为了方便组织各种信息，计算机常将信息以表的形式进行组织，然后再以行和列的形式呈现出来。二维数组的结构决定了其能非常方便地表示计算机中的表，以第一个下标表示元素所在的行，第二个下标表示元素所在的列。

在 Java 中二维数组被看作数组的数组，即二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。Java 并不直接支持二维数组，但是允许定义数组元素是一维数组的一维数组，以达到同样的效果。

public class ArrayDemo05 {
    public static void main(String[] args) {
        int [][] nums = {{1,2},{3,4},{5,6},{7,8}};
        //System.out.println(nums[0][0]);
        //printArray(nums[0]);
        for (int i=0;i<nums.length;i++){
            for (int j=0;j<nums[i].length;j++){
                System.out.print(nums[i][j]+" ");
            }
            System.out.println();
        }
    }

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

Arrays类

• 数组的工具类 java.util.Arrays
• 由于数组对象本身没有什么方法可以供我们调用，API中提供了一个工具类供我们使用，从而可以对数据对象进行一些基本的操作。
• 查看jdk帮助文档
• Arrays类中的方法可以直接调用

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int [] nums = {1,2,3,4,5,6,12,9,88,60};
        //System.out.println(nums);
        //打印数组元素 Array类 toString
        //System.out.println(Arrays.toString(nums));
        //对数组进行排序
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));//排序后进行输出
    }
}

冒泡排序

冒泡排序是八大排序之一
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

冒泡排序中，比较相邻两个数的大小，如果后一个数比前一个数大，则交换两数位置
每一次比较会产生一个最大或者最小的数
每比较一次之后，下一次可以少比较一次
依次循环，直到结束

import java.util.Arrays;

public class ArrayDemo07 {
    //冒泡排序
    public static void main(String[] args) {
        int [] std = {7,85,4,1,6,45,61,65,16};
        System.out.println(Arrays.toString(sort(std)));


    }
    //冒泡排序中，比较相邻两个数的大小，如果后一个数比前一个数大，则交换两数位置
    //每一次比较会产生一个最大或者最小的数
    //每比较一次之后，下一次可以少比较一次
    //依次循环，直到结束
    public static int [] sort(int [] nums) {
        int temp = 0;
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = 0; j < nums.length - 1 - i; j++) {
                if (nums[j] < nums[j + 1]) {
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
        return nums;
    }
}

冒泡排序非常重要 必须要详细理解

稀疏数组

当一个元素大部分为0的时候，我们可以用稀疏数组代替原来的数组
把具有不同行列的值记录在一个小规模的数组中从而缩小程序的规模。
下图中，左边是原始数组，右边是稀疏数组。

我们现在要制作一个五子棋棋游戏
需要先构建一个二维数组。

用0表示没有被下过的地方.
用1表示黑子.
用2表示白子

代码如下

public class ArrayDemo08 {
    public static void main(String[] args) {
        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();
        }
        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];
        }
        //打印还原后的数组
        for (int i = 0; i < array3.length; i++) {
            for (int i1 = 0; i1 < array3[i].length; i1++) {
                System.out.print(array3[i][i1]+"\t");
            }
            System.out.println();
        }

    }
}

写在最后
成长本就是一个孤立无援的过程你必须得学会独当一面