2021-05-11

最新推荐文章于 2021-11-05 18:47:52 发布

小张今天元气满了吗？

最新推荐文章于 2021-11-05 18:47:52 发布

阅读量73

点赞数

分类专栏： 0基础学习Java

本文链接：https://blog.csdn.net/weixin_48959650/article/details/116663278

版权

0基础学习Java 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

多维数组

多维数组可以看成数组的数组，比如二维数组就是一个特殊的一堆数组，其每个元素都是一个一weight数组。
二维数组
```
int a[][]=new int[2][5];
```
解析：二维数组a可以看成一个两行三列的数组

在这里插入图片描述

package com.zhangyu.array;

public class ArrayDemo05 {
    public static void main(String[] args) {
        //[4][2]
        /*
        1,2   i[0]
        2,3   i[1]
        3,4   i[2]
        4,5   i[3]
         */
        int [][] i={{1,2},{2,3},{3,4},{4,5}};
        
        //打印多维数组
        for (int i1 = 0; i1 < i.length; i1++) {
            for (int i2 = 0; i2 < i[i1].length; i2++) {
                System.out.println(i[i1][i2]);

            }




        }



    }

Arrays类

数组的工具类java.utli.Arrays
由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用

从而介意对数据对象进行一些基本操作。
查看JDK帮助文档
Arrays类中的方法都是static的修饰的静态方法，在使用中的时候可以直接使用类名进行调用，而不

用使用对象来调用（注意是“不用”而不是不能）
具有以下常用功能：
- 给数组赋值，通过fill方法
- 对数组排序：通过Sort方法，按升序。
- 比较数组：通过equals方法比较数组中元素值是否相等。
- 查找数组元素:通过binarySearch方法对排序好的数组进行二分查找法操作。

冒号排序

冒号排序无疑是最出名的排序算法之一，总共有八大排序！！
冒泡的代码还是相当简单，两层循环，外层冒泡轮数，里层依次比较，江湖中人人尽皆知。
我们看到嵌套循环，应该立马可以看得出这个算法的时间复杂度为O（n2）。

package com.zhangyu.array;

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a={1,255,15,451,4564321,5};
        int[] sort = sort(a);//调用完自己写的排序方法后，返回一个排序后的数组
        System.out.println(Arrays.toString(sort));


    }

    /*
    冒泡排序
    1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    2.每一次比较，产生出一个最大，或者最小的数字
    3.下一轮可以少一次排序
    4.依次循环，知道结束
     */
    public static int[] sort(int[] a){
        //临时变量
        int b=0;
        ///外层循环控制排序趟数
        for (int i = 0; i < a.length-1; i++) {//
            boolean c=false;//通过flag标示位减少没有意义的比较
            //内存循环，比较判断两个数，如果第一个数，比第二数大，则交换位置
            for (int i1 = 0; i1 < a.length-1-i; i1++) {//内层循环控制每一趟排序多少次
                if (a[i1+1]>a[i1]){
                    b=a[i1];
                    a[i1]=a[i1+1];
                    a[i1+1]=b;
                    c=true;
                }
            }
            if (c==false);
            break;
        }
        return a;





    }


}

稀疏数组 -----数据结构

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

解决：稀疏数组

稀疏数组介绍

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

package com.zhangyu.array;

import java.util.Arrays;

public class ArrayDemo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组  11*11    0：没有棋子   1：黑棋  2：白棋
        int[][] a = new int[11][11];
        a[1][2] = 1;
        a[2][3] = 2;
        //输出原始的数组
        System.out.println("输出原始的数组");
        for (int[] ints : a) {// 循环ints里面的int型数组
            for (int anInt : ints) {// 循环int型数组里面的每个数
                System.out.print(anInt + "\t");

            }
            System.out.println("");

        }
        System.out.println("================================");
        //转换为稀疏数组保存
        //获取有效值的个数
        int f = 0;
        for (int i = 0; i < 11; i++) {
            for (int i1 = 0; i1 < 11; i1++) {
                if (a[i][i1] != 0) {
                    f++;
                }

            }

        }
        System.out.println("有效值的个数" + f);


        // 2.创建一个稀疏数组的数组
        int[][] a2 = new int[f + 1][3];
        a2[0][0] = 11;
        a2[0][1] = 11;
        a2[0][2] = f;
        //遍历二维数组，将非零的值存放在稀疏数组中
        int c = 0;
        for (int i = 0; i < a.length; i++) {
            for (int i1 = 0; i1 < a[i].length; i1++) {
                if (a[i][i1] != 0) {
                    c++;
                    a2[c][0] = i;
                    a2[c][1] = i1;
                    a2[c][2] = a[i][i1];
                }
            }
        }

        //输出稀疏数组
        System.out.println("输出稀疏数组");
        for (int i = 0; i < a2.length; i++) {
            System.out.println(a2[i][0] + "\t" + a2[i][1] + "\t" + a2[i][2] + "\t");

        }
        System.out.println(" ");
        System.out.println("===============================");
        System.out.println("还原");
        int[][] a3 = new int[a2[0][0]][a2[0][1]];
        //2.给其中的元素还原它的值
        for (int i = 1; i < a2.length; i++) {
            a3[a2[i][0]][a2[i][1]] = a2[i][2];

        }
        //输出原始的数组
        System.out.println("输出还原的数组");
        for (int[] ints : a) {// 循环ints里面的int型数组
            for (int anInt : ints) {// 循环int型数组里面的每个数
                System.out.print(anInt + "\t");

            }
            System.out.println("");

        }
    }
}