JavaSE学习——数组相关声明创建多维数组稀疏数组

Java数组相关

数组概述

数组的定义

• 数组是相同类型数据的有序集合

• 数组描述的是相同类型的若干个数据，按照一定先后次序组合而成

• 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们，下标从0开始

例子：一个球队中的不同号码的队员

代码

public static void main(String[] args) {
        int[] nums={10,20,30,40,50};
        for(int i=0;i<5;i++)
        {
            System.out.println("这是第"+(i+1)+"个元素，其下标为："+i);
        }
    }

运行结果

数组特点

• 数组长度确定。一旦被创建，大小不可变
• 元素必须是相同类型的
• 元素的类型可以是任何类型，基本数据类型或者引用类型
• 数组属于对象，处于堆中，数组元素相当于对象的成员变量，它的名字存在栈中，指向实际位置在堆中的元素

数组的边界问题

合法的下标区间为[0 — length-1]，越界就会报错

public static void main(String[] args) {
    int[] nums = new int[10];
    System.out.println(nums[11]);
    }

会报异常：ArrayIndexOutOfBoundsException
数组下标越界

---

数组声明创建

数组的声明创建

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

dataType[] arrayname;//首选方法，java风格
//或者
dataType arrayname[];//效果相同，但是非首选。c/c++风格

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

dataType[] arrayname = new dataType[arraySize];

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

arrays.length();

小例子

public static void main(String[] args) {
        //声明数组
        int[] nums;
        //开辟空间
        nums =new int[5];
        for(int i=0;i<5;i++)
        {
            nums[i]=i;//给数组元素赋值
        }
        for(int i=0;i<5;i++)
        {
            System.out.println("这是第"+(i+1)+"个元素，值为"+nums[i]+"，其下标为："+i);
        }
        //计算数组的和
        int i;
        int sum=0;
    	//nums.length可以获取数组的长度
        for (i = 1; i<=nums.length; i++)
        {
            sum += nums[i-1];
        }
        System.out.println("数组的和为："+sum);
    }

输出结果

三种初始化以及内存分析

Java内存

• 堆：
  • 存放new的对象和数组
  • 可以被所有的线程共享，不会存放避恶恶的呃对象引用
• 栈：
  • 存放基本数据类型
  • 引用对象的变量（会存放这个引用在堆里面的具体地址）
    • 比如数组只声明了，却没有new
    • 因此如果直接输出数组会输出对象的名字
• 方法区：
  • 可以被所有的线程所共享
  • 包含了所有的class和static变量

声明数组时，在栈中注册array

开辟空间时，（new关键字），在堆中开辟空间

静态初始化

//声明创建以及赋值一起做
int a[]={0,1,2,3,4,5};
int[] a={0,1,2,3,4,5};

动态初始化

//声明创建空间一起做，默认初始值为0，需要手动赋值
int a[]=new int[5];
a[2]=10;

数组的默认初始化

数组为引用类型，它的元素相当于类的实例变量，因此一经分配空间，就会被隐式初始化

//一经初始化，a[0]到a[4]的值都会被初始化为0
int a[]=new int[5];

数组使用

for-each循环

代码

public static void main(String[] args) {
        int a[]={1,2,3,4,5};
        for (int x : a) {
            System.out.println(x);
        }
    }

运行结果

数组作方法参数以及返回值

数组也可以用作方法的参数以及返回值

小例子

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

        printArrays(reverse(a));

    }
    //反转数组
    public static int[] reverse(int[] Arrays)
    {
        int a[]=new int[Arrays.length];
        for(int c=0;c<Arrays.length;c++){
            a[Arrays.length-1-c]=Arrays[c];
        }
        return a;
    }
    //输出数组元素
    public static void printArrays(int[] Arrays)
    {
        for (int x : Arrays) {
            System.out.print(x+" ");
        }
    }

运行效果

这里提一嘴，数组入参，是引用传参，如果在函数中修改数组的值，会直接将原数组的数修改

多维数组

以二维数组为例：二维数组可以理解为一维数组的每一个元素都是一个数组

• 二维数组

//一个两行五列的数组
int[][] a = new int[2][5];

小例子

public static void main(String[] args) {
        int[][] a={{1,2},{2,3},{3,4}};
        /*
        实际情况
        a[0][0],a[0][1]中存储的是 1,2
        2,3
        3,4
         */
        //输出数组元素
        System.out.println(a[0][1]);
        //函数输出二维数组的值
        printArrays(a);
    }
    //输出数组元素
    public static void printArrays(int[][] Arrays)
    {
        for (int[] x : Arrays) {
            for (int a : x) {
                System.out.print(a+" ");
            }
            System.out.println();
        }
    }

运行结果

Arrays类

java.util中的Arrays类

Arrays类中实现了好多方法，Arrays类被用static修饰，因此调用该类的方法需要直接使用类名进行调用

• 给数组赋值：fill方法
• 最数组排序：通过sort方法，默认升序
• 比较数组：通过equals方法比较数组中元素值是否相等
• 查找元素：通过binarySearch方法能对排好序的数组进行二分查找法操作

public static void main(String[] args) {
        int a[]={10,2,55,85,45,78};
        int a2[]={10,2,55,85,45,78};
        //对数组进行排序，升序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //用fill对数组进行赋值
        Arrays.fill(a,0);
        //fill方法重载
        Arrays.fill(a,1,3,9);
        System.out.println(Arrays.toString(a));
        //equals方法的使用
        if(Arrays.equals(a,a2)){
            System.out.println("这两个数组一样");
        }
        else{
            System.out.println("这两个数组不一样");
        }
        //binarySearch方法来查找数字
        //首先需要排好序
        Arrays.sort(a2);
        System.out.println("这里输出的是待查找数字的下标："+Arrays.binarySearch(a2,45));
    }

运行结果

经典排序算法

• 江湖上人尽皆知！！！
• 插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序、计数排序

冒泡排序

思想类似泡泡从水底产生，不断地浮上水面，浮到水面变成最大的
双层嵌套循环，时间复杂度：O(n^2)

public static void main(String[] args) {  
    //冒泡排序演示  
    int []a={12,55,89,57,15,21,3,78,6};  
    System.out.println(Arrays.toString(a));  
    bubble(a);  
    System.out.println(Arrays.toString(a));  
}  
//冒泡排序主函数  
public static void bubble(int[] arrays){  
    int temp = 0;  
    int count = 0;  
    //每一趟都能找出一个当前未排好序元素中的最大  
    for(int i=0;i<arrays.length;i++)  
    {  
        //每趟排序后，需要排序的数字就少一个，不需要每一趟排序都到最后一个数  
        for (int j=0;j<arrays.length-1-i;j++)  
        {  
            //每趟比较相邻地两个元素，若下标小的大于下标大的，则交换位置  
            count++;  
            if(arrays[j]>arrays[j+1])  
            {  
                temp=arrays[j];  
                arrays[j]=arrays[j+1];  
                arrays[j+1]=temp;  
            }  
        }  
    }  
    System.out.println("比较次数:" + count);  
}

运行结果

稀疏数组

需求提出，在五子棋或者围棋游戏中涉及到存档问题，可以使用数组进行存储，但是如果棋面上只有几颗棋，那么数组中存储的很多值都是0，可以说存储了许多没有意义的数据

解决方法

稀疏数组

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

如图所示：

public static void main(String[] args) {  
    //创建二位数组11*11，0：没有棋子 1：黑棋 2：白棋  
    int[][] nums = new int[11][11];  
    nums[1][2] = 1;  
    nums[2][3] = 2;  
    System.out.println("输出原始数据");  
    for (int[] num : nums) {  
        System.out.println(Arrays.toString(num));  
    }  
  
    System.out.println("转换为稀疏数组");  
    //1.获取有效值的个数  
    int sum =0;  
    for (int i = 0; i < 11; i++) {  
        for (int j = 0; j < 11; j++) {  
            if (nums[i][j]!=0)  
                sum++;  
        }  
    }  
    System.out.println("有效值的个数为：" + sum);  
  
    //2.创建稀疏数组，行固定为有效值个数+1，列固定为3列  
    int[][] array = new int[sum + 1][3];  
    array[0][0] = 11;  
    array[0][1] = 11;  
    array[0][2] = sum;  
  
    //遍历二维数组，将非零元素，放入稀疏数组中  
    int count = 1;  
    for (int i = 0; i < nums.length; i++) {  
        for (int j = 0; j < nums[i].length; j++) {  
            if(nums[i][j] != 0)  
            {  
                array[count][0] =i;  
                array[count][1] =j;  
                array[count][2] =nums[i][j];  
                count++;  
            }  
        }  
    }  
  
    //输出稀疏数组  
    System.out.println("输出稀疏数组");  
    for (int[] ary : array) {  
        System.out.println(Arrays.toString(ary));  
    }  
  
    System.out.println("还原");  
    int[][] trans = new int[array[0][0]][array[0][1]];  
    for (int i = 1; i <= array[0][2]; i++) {  
  
        trans[array[i][0]][array[i][1]] =array[i][2];  
    }  
  
  
    System.out.println("输出还原后的数组");  
    for (int[] tra : trans) {  
        System.out.println(Arrays.toString(tra));  
    }  
  
}

运行结果

---