本文主要是介绍JAVA学习笔记08-二维数组、稀疏数组、Arrays类以及冒泡排序，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

• 二维数组
  • 定义与初始化
  • 获取单个元素
  • 获得每个元素
  • 获得整行元素
• Arrays类
• 冒泡排序
• 稀疏数组

二维数组

定义与初始化

二维数组就是在一维数组的基础上，一维数组中的变量不再是普通的变量，而是数组。
二维数组的定义方式如下：

int[][] nArry;

二维数组的初始化方式如下：

方式一、int[][] nArry = new int[][]{{value},{value}...};
方式二、int[][] nArry = new int[size][size];
方式三、int[][] nArry = new int[size][];

获取单个元素

int[][] nArrys = new int[][]{{1, 2}, {3, 4}, {5, 6}};
System.out.println(nArrys[0][0]);

获得每个元素

//获取每个元素
int[][] nArrys = new int[][]{{1, 2}, {3, 4}, {5, 6}};
for (int i = 0; i < nArrys.length; i++) {
  for (int j = 0; j < nArrys[i].length; j++) {
    System.out.println(nArrys[i][j]);
  }
}

获得整行元素

//获取第二行的元素
int[][] nArrys = new int[][]{{1, 2}, {3, 4}, {5, 6}};
for (int i = 0; i < nArrys[1].length; i++) {
  System.out.println(nArrys[1][i]);
  }

Arrays类

由于数组本身并没有什么方法供我们调用，所以API中提供了一个Arrays类供我们使用。Arrays就是一个数组的工具类，里面包括了很多操作数组的方法java.util.Arrays。
需要注意的时，Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用。

以下展示一些Arrays类中常用的功能：

• fill方法给数组赋值

int[] nArry = new int[10];
Arrays.fill(nArry, 9);
for (int i = 0; i < nArry.length; i++) {
  System.out.print(nArry[i]+" ");
}

运行结果：

• 通过sort方法排序

int[] nArry = new int[]{1, 5, 2, 9, 4};
Arrays.sort(nArry);
System.out.println(Arrays.toString(nArry));

运行结果：

可以看出Arrays类是一个很好的操作数组的类，平时在使用过程中有遇到可以查看API帮助文档进行学习。

冒泡排序

原理：比较数组中，两个相邻的元素，如果第一个数字比第二个数字打，我们就交换他的位置：

 public static void main(String[] args) {
        int[] nArry = new int[]{1, 5, 2, 9, 4};
        int nTem = 0;
        for (int i = 0; i < nArry.length; i++) {
            for (int j = 0; j < nArry.length; j++) {
                if (nArry[i] < nArry[j]) {
                    nTem = nArry[i];
                    nArry[i] = nArry[j];
                    nArry[j] = nTem;
                }
            }
        }
        System.out.println(Arrays.toString(nArry));
}

稀疏数组

在我们平时的数组使用过程中，有时候会出现一个数组中有大量重复数据的情况，这个时候显然是浪费了很多空间的。
比如以下这个实际情况，一个棋盘中，我们用1表示表示黑棋，用2表示蓝棋，其他地方我们用0表示，这个时候有大量的数字相同的0，此时我们就可以用稀疏数组来代替我们这个复杂的，拥有许多相同数值的数组：

稀疏数组中的第一行代表了原数组有几行几列，并且记录与0不相同的数字的值的个数。
接下来的每一行就代表了与0不相同的数字在原数组中的具体坐标以及值。

接下来我们用代码实现一个稀疏数组：

public class Sparse_Array {
    public static void main(String[] args) {
        int[][] a = former_Arry();
        print_Delimiter();
        int[][] b = sparse_Arry(a);
        print_Delimiter();
        backArry(b);
    }

    public static int[][] former_Arry() {
        //画出原棋盘
        int[][] formerarry = new int[11][11];
        formerarry[1][2] = 1;
        formerarry[2][3] = 2;
        for (int i = 0; i < formerarry.length; i++) {
            for (int j = 0; j < formerarry[i].length; j++) {
                System.out.print(formerarry[i][j] + " ");
            }
            System.out.println();
        }
        return formerarry;
    }

    //稀疏数组
    public static int[][] sparse_Arry(int[][] formerArry) {
        //判断有几个数字不等于0
        int notEqual = 0;
        for (int i = 0; i < formerArry.length; i++) {
            for (int j = 0; j < formerArry[i].length; j++) {
                if (formerArry[i][j] != 0) {
                    notEqual++;
                }
            }
        }
        //创建稀疏数组
        int[][] sparseArry = new int[notEqual + 1][3];
        sparseArry[0][0] = formerArry.length;
        sparseArry[0][1] = formerArry[0].length;
        sparseArry[0][2] = notEqual;

        int nCount = 1;

        for (int i = 0; i < formerArry.length; i++) {
            for (int j = 0; j < formerArry[i].length; j++) {
                if (formerArry[i][j] != 0) {
                    sparseArry[nCount][0] = i;
                    sparseArry[nCount][1] = j;
                    sparseArry[nCount][2] = formerArry[i][j];

                    nCount++;
                }
            }
        }
        //打印稀疏数组
        for (int i = 0; i < sparseArry.length; i++) {
            for (int j = 0; j < sparseArry[i].length; j++) {
                System.out.print(sparseArry[i][j] + "   ");
            }
            System.out.println();
        }
        return sparseArry;
    }

    //从稀疏数组还原原数组
    public static int[][] backArry(int[][] sparseArry)
    {
        int[][] backAryy = new int[sparseArry[0][0]][sparseArry[0][1]];
        for (int i = 1; i <= sparseArry[0][2] ; i++) {
            backAryy[sparseArry[i][0]][sparseArry[i][1]] = sparseArry[i][2];
        }
        //打印原数组
        for (int i = 0; i < backAryy.length; i++) {
            for (int j = 0; j < backAryy[i].length; j++) {
                System.out.print(backAryy[i][j]+" ");
            }
            System.out.println();
        }
        return backAryy;
    }

    //打印分隔符
    public static void print_Delimiter()
    {
        System.out.println("===============================");
    }
}

运行结果：

这篇关于JAVA学习笔记08-二维数组、稀疏数组、Arrays类以及冒泡排序的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！