Java自学（五、Java数组）

最新推荐文章于 2024-06-17 13:56:54 发布

IPostYellow

最新推荐文章于 2024-06-17 13:56:54 发布

阅读量134

点赞数

分类专栏： Java自学文章标签： java

本文链接：https://blog.csdn.net/Doraemon_Nobita/article/details/115330149

版权

Java自学专栏收录该内容

15 篇文章 1 订阅

订阅专栏

记录自己在狂神说java中的学习情况，文章里有自己学习的理解和扩展，新手难免有理解偏差或者错误，恳请大佬指正。

Java自学（五、Java中的数组）

Java数组

Java数组

数组概述

数组是相同类型数据的有序集合（比如都是int{1,2,3,4,5}，或者都是String{“张三”,“李四”}）
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们（下标从0开始）

数组声明创建

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

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

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

dataType[] arrayRefVar = new dataType[arraySize];

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

获取数组长度：

arrays.length

package com.hbq.arrays;
public class defineArray {
    // 变量类型 变量的名字 = 变量的值
    // 数组类型
    public static void main(String[] args) {
        int[] nums; //定义数组
        int nums2[]; //定义数组2
        nums = new int[10]; //这里面可以存放10个int类型的数据
        nums2 = new int[5]; //这里面可以存放5个int类型的数据
        //给数组元素中赋值
        for (int i = 0; i < nums.length; i++) {
            nums[i] = i;
        }
        int sum=0;
        //计算数组的和
        for (int num : nums) {
            sum += num;
        }
        System.out.println(sum);
    }
}

内存分析

Java内存分析

在这里插入图片描述
定义一个数组和创建一个数组的内存分配过程如下图所示：

数组的三种初始化状态

静态初始化

int[] a = {1,2,3};
Man[] men={new Man(1,1),new Man(2,2)};

动态初始化
```
int[] a = new int[2];
a[0]=1;
a[1]=2;
```

数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也按照实例变量同意的方式被隐式初始化。

package com.hbq.arrays;
public class ArrayInit {
    public static void main(String[] args) {
        //静态初始化
        int[] a = {1, 2, 3, 4, 5, 6, 7}; //初始化后数组长度就固定了，不可改变长度
        System.out.println(a[0]);
        a[0] = 10;
        System.out.println(a[0]);
        //动态初始化
        int[] b = new int[a[0]];
        b[0] = 10;
        b[1] = 1;
        // b[2]~b[9]都是默认值0
        for (int i : b) {
            System.out.println(i);
        }
    }
}

数组的四个基本特点

其长度是固定的。数组一旦被创建，它的大小就是不可以改变的。
其元素必须是相同类型，不允许出现混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

相当于：
class Array{
	public int a0;
	public int a1;
	public int a2;
	...
	public int an-1;
}
只不过取成员变量的时候使用的是a[0],a[1]这种方式。

数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型他是其他对象类型，数组本身还是在堆中的。

数组边界

下标的合法区间：[0,数组.length-1]，如果越界就会报错

public static void main(String[] args){
	int[] a=new int[2];
    System.out.println(a[2]);//报错ArrayIndexOutOfBoundsException：数组下标越界异常
}

小结：

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

数组使用

package com.hbq.arrays;
public class ArrayUse {
    public static void main(String[] args) {
        int[] a = new int[10];
        // 赋值数组里的所有元素
        // idea里a.length.for回车会自动出这个for循环
        for (int i = 0; i < a.length; i++) {
            a[i] = i;
        }
        // 输出数组的值
        // idea里a.for回车会自动出这个增强for循环
        for (int i : a) {
            System.out.print(i+" ");
        }
        printArraySum(a);
        int [] tmp=reverseArray(a);
        for (int value : tmp) {
            System.out.print(value+" ");
        }
    }

    // 作参数传入
    public static void printArraySum(int[] array) {
        int sum = 0;
        for (int value : array) {
            sum += value;
        }
        System.out.println(sum);
    }

    // 作返回值
    public static int[] reverseArray(int[] array) {
        int[] tmp = new int[array.length];
        for (int i = array.length - 1,j=0; i >= 0; i--,j++) {
            tmp[j] = array[i];
        }
        return tmp;
    }
}

多维数组

套娃！！数组的数组。就是数组里每一个元素都是数组。比如二维数组就是一个特殊的一维数组，这个一维数组里每一个元素都是一个一维数组。

//二维数组
int[][] a=new int[2][5] //2行5列的数组

在这里插入图片描述
图里展示的是两行两列的数组，其中array[0]和array[1]存储的是两个数组。

多维数组的定义和使用：

package com.hbq.arrays;
public class TwoDArray {
    public static void main(String[] args) {
        int[][] array = {{1,2,3}, {1,5,3,7}};//每维长度可以不一样
        System.out.println(array[0][0]+" "+array[0][1]+" "+array[0][2]);
        System.out.println(array[1][0]+" "+array[1][1]+" "+array[1][2]+" "+array[1][3]);
        System.out.println("----------------------------------------------------------");
        int [][] array2={{1,3,8},{96,8,4,2},{5,7,8,2,7,1,30}};
        for(int i=0;i<array2.length;i++){
            for (int j=0;j<array2[i].length;j++){
                System.out.print(array2[i][j]+" ");
            }
            System.out.println();
        }
    }
}

Arrays类

数组的工具类java.util.Arrays

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

查看JDK帮助文档

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

具有以下的常用功能：

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

冒泡排序

冒泡排序是出名的排序算法之一

冒泡代码比较简单，两层循环，外层冒泡轮数，里层依次比较。

时间复杂度为O(n²)

思考：如何优化？

在一次循环没有交换以后，直接结束。

package com.hbq.arrays;
import java.util.Arrays;
public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {1, 85, 8, 64, 2, 231, -56, 4651, 6};
        int[] b = bubble(a);
        System.out.println(Arrays.toString(a));//[4651, 231, 85, 64, 8, 6, 2, 1, -56]
        System.out.println(Arrays.toString(b));//[4651, 231, 85, 64, 8, 6, 2, 1, -56]
    }
    public static int[] bubble(int[] a) {
        //冒泡排序
        //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
        //2.每一次比较，都会产生一个最大或者最小的数字
        //3.下一轮则可以少一次排序
        //4.依次循环，直到结束
        //外层循环，判断走多少次,这里是a.length-1，因为最后一个数没得和数比较了
        int temp;
        boolean flag;//判断是否一轮下来都没有发生交换
        for (int i = 0; i < a.length - 1; i++) {
            flag=false;
            //内层循环,判断两个数，如果第一个比第二个大，则交换位置
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j + 1] > a[j]) { //从大到小排序，大的往前放
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    flag=true;
                }
            }
            if (!flag) break;
        }
        return a;
    }

稀疏数组

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

在这里插入图片描述
分析问题：因为该二维数组中的很多值默认为0，因此记录了很多没有意义的数据

解决：稀疏数组

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

稀疏数组的处理方式是：

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

如图所示：左边是原始数组，右边是稀疏数组

在这里插入图片描述
三元组的信息。第一行6，7，8表示这个矩阵是6X7的，有8个有效值。

第二行开始，就是存储的有效值的行列值。

package com.hbq.arrays;
public class SparseArrays {
    public static void main(String[] args) {
        // 创建一个6*7数组
        int[][] a = {{0, 0, 0, 22, 0, 0, 15}, {0, 11, 0, 0, 0, 17, 0}, {0, 0, 0, -6, 0, 0, 0}, {0, 0, 0, 0, 0, 39, 0}, {91, 0, 0, 0, 0, 0, 0}, {0, 0, 28, 0, 0, 0, 0}};
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j] + "  ");
            }
            System.out.println();
        }
        //转化为稀疏数组
        int row = a.length, col = a[0].length, var = 0;
        //获取有效值的个数
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] != 0) var += 1;
            }
        }
        int[][] sparse = new int[var + 1][3];
        sparse[0][0] = row;
        sparse[0][1] = col;
        sparse[0][2] = var;
        int count = 1;//计数
        // 遍历原数组，将不等于0的数存入稀疏数组
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] != 0) {
                    sparse[count][0] = i;
                    sparse[count][1] = j;
                    sparse[count][2] = a[i][j];
                    count++;
                }
            }
        }
        //打印稀疏数组
        for (int i = 0; i < sparse.length; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(sparse[i][j] + " ");
            }
            System.out.println();
        }
        //根据稀疏数组还原二维数组
        int[][] newarray = new int[sparse[0][0]][sparse[0][1]];
        for (int i = 1; i <= sparse[0][2]; i++) {
            newarray[sparse[i][0]][sparse[i][1]] = sparse[i][2];
        }
        //打印还原后的数组
        for (int i = 0; i < newarray.length; i++) {
            for (int j = 0; j < newarray[i].length; j++) {
                System.out.print(newarray[i][j] + "  ");
            }
            System.out.println();
        }
    }
}

IPostYellow

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java自学（五、Java数组）

记录自己在狂神说java中的学习情况，文章里有自己学习的理解和扩展，新手难免有理解偏差或者错误，恳请大佬指正。Java自学（五、Java中的数组）Java数组数组概述数组声明创建内存分析数组的三种初始化状态数组的四个基本特点数组边界数组使用多维数组Arrays类冒泡排序稀疏数组Java数组数组概述数组是相同类型数据的有序集合（比如都是int{1,2,3,4,5}，或者都是String{“张三”,“李四”}）数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成其中，每一个数据称作一个
复制链接

扫一扫