Java基础学习(5)---Java数组

一、数组概述

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

二、数组声明创建

数组的声明和创建

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

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

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

	//数组类型[] 数组名 =  new 数组类型[数组长度];
	dataType[] arrayRefVar = new dataType[arraySize];

• 数组的元素是通过索引访问的，数组索引从0开始
• 获取数组长度：arrays.length

        int[] nums; //1.首选声明一个数组
        nums = new int[10]; //2.创建一个数组（开辟了一段空间）
        //3.给数组元素中赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        //nums[9] = 10;
        System.out.println(nums[0]);//1
        System.out.println(nums[9]);//0

        //计算所有元素的和
        int sum = 0;
        //获取数组长度：arrays.length
        for (int i = 0; i < nums.length ; i++){
            sum = sum + nums[i];
        }
        System.out.println("总和为："+sum);//45

内存分析

注：在声明的时候，数组并不存在；只要创建的时候，数组才存在。一般情况下，数组的声明和创建会写在一起。 int[] nums = new int[10];
引用类型：栈中存放的是引用类型在堆中的地址，在堆中才是存放实际的值。

数组的三种初始化

• 静态初始化

	//静态初始化：创建 + 赋值
	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]);
	}

• ArraylndexOutOfBoundsException：数组下标越界异常！

小结：

• 数组是相同数据类型（数据类型可以为任意类型）的有序集合。
• 数组也是对象，数组元素相当于对象的成员变量。
• 数组长度的确定的，不可变的。如果出现数组下标越界，则会报：ArraylndexOutOfBoundsException

三、数组使用★

For循环

        int[] arrays = {1,2,3,4,5};
        //打印全部的数组元素
        for (int i = 0 ; i<arrays.length ; i++){
            System.out.print(arrays[i]+"\t");
        }
        System.out.println();
        System.out.println("====================");
        //计算所有元素之和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum = sum +arrays[i];
        }
        System.out.println("sum="+sum);
        System.out.println("===================");
        //查找数组内的最大元素
        int max = arrays[0] ;
        for (int i = 1; i < arrays.length; i++) {
            if ( arrays[i] > max ){
                max = arrays[i];
            }
        }
        System.out.println("max="+max);

For-Each循环

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

        //JDK1.5 没有下标
        for (int array : arrays) {
            System.out.println(array);
        }

数组作为方法的参数

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

数组作为返回值

    //反转数组 printArray(reverse(arrays));
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        //反转的操作
        for (int i = 0,j = arrays.length-1; i < arrays.length; i++,j--) {
            result[i] = arrays[j];
        }
        return result;
    }

四、多维数组

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

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

        int[][] array = {{1,2},{3,4},{5,6}};
        //打印二维数组所有元素 三行两列
        //1 2  array[0]  {1，2}
        //3 4  array[1]
        //5 6  array[2]
        //二维数组的使用: array[0]={1，2}   array[0][0]=1  array[1][1]=4
        //array.length=3  array[i].length=2  三行两列
        for (int i = 0; i < array.length; i++) { //arrays.length=3
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println(array[0][1]);//2

五、Arrays 类

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

        int[] a = {1,2,3,4,9000,32145,451,21,3,23};
        System.out.println(a); // [I@1b6d3586

        //打印数组元素 Arrays.toString
        System.out.println(Arrays.toString(a)); //[1, 2, 3, 4, 9000, 32145, 451, 21, 3, 23]

        //数组进行排序：升序排序
        //Arrays.sort(a);
        //System.out.println(Arrays.toString(a)); //[1, 2, 3, 3, 4, 21, 23, 451, 9000, 32145]

        //填充
        //Arrays.fill(a,0);//全部填充0
        Arrays.fill(a,2,4,0); //在数组[a[2]~a[4])之间填充0  左闭右开
        System.out.println(Arrays.toString(a)); //[1, 2, 0, 0, 9000, 32145, 451, 21, 3, 23]

        //查找数组元素: 首先要进行排序！！！二分法查找某值 返回对应的下标
        System.out.println(Arrays.binarySearch(a, 9000)); // [1, 2, 0, 0, 4, 21, 23, 451, 9000, 32145]  8

冒泡排序

• 冒泡排序是最为出名的排序算法之一，总共有八大排序！
• 冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较。
• 我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为o(n2)。

    public static void main(String[] args) {
        int[] a={1,5,2,6,3,2,22,-12,-1,23};
        System.out.println(Arrays.toString(sort(a))); //[-12, -1, 1, 2, 2, 3, 5, 6, 22, 23]
    }
    //冒泡排序
    //1.比较数组中两个相邻的元素，如果第一个数大于第二个数，交换它们位置
    //2.每一次比较，都会产生一个最大或最小的数字(升序为最大数)
    //3.下一轮则可以少一次排序
    //4.依次循环，直到结束
    public static int[] sort(int[] array){
        int temp=0;//临时变量
        //外层循环，判断循环走几次，次数length-1
        for (int i = 0; i < array.length-1; i++) {
            //内层循环：如果第一个数大于第二个数，则交换它们位置
            boolean flag=false;//通过flag标识位减少没有意义的比较
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j]>array[j+1]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    flag=true;
                }
            }
            if(flag == false){
                break;
            }
        }
        return array;
    }

• 思考：如何优化？

六、稀疏数组

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

稀疏数组介绍：

• 当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
• 稀疏数组的处理方式是：
  • 记录数组一共有几行几列，有多少个不同值。
  • 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模。

        //创建一个二维数组 11*11  0：没有棋子，1：黑棋  2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始的数组
        System.out.println("原始的数组：");
        for (int[] array : array1) {
            for (int i : array) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }
        /*原始的数组：
        0	0	0	0	0	0	0	0	0	0	0
        0	0	1	0	0	0	0	0	0	0	0
        0	0	0	2	0	0	0	0	0	0	0
        0	0	0	0	0	0	0	0	0	0	0
        0	0	0	0	0	0	0	0	0	0	0
        0	0	0	0	0	0	0	0	0	0	0
        0	0	0	0	0	0	0	0	0	0	0
        0	0	0	0	0	0	0	0	0	0	0
        0	0	0	0	0	0	0	0	0	0	0
        0	0	0	0	0	0	0	0	0	0	0
        0	0	0	0	0	0	0	0	0	0	0
        */
        //转换为稀疏数组保存
        //1.获取有效值的个数
        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);//2
        //2.创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //3.遍历二维数组，将有效值(非零的值),存放到稀疏数组
        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];
                }
            }
        }

        //4.输出稀疏数组
        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");
            }
            System.out.println();
        }
        /*稀疏数组：
        11	11	2
        1	2	1
        2	3	2
        */
        //还原
        System.out.println("还原原始数组：");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];//确认原始数组整体大小
        //2.给其中的元素还原它的值
        for (int i = 1; i <array2.length ; i++) {
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

稀疏数组：记录原始数组大小、有效值的坐标和值，将其构建成一个新的数组。