为了做出springboot前后端分离的科研项目管理系统努力学习12

Arrays类

详细可查JDK帮助文档

import java.util.Arrays;

 工具类不用过度依赖，我们也能写出

package com.study.array;

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a={1,32,4335,3232,54,2312,43,221};

        //直接打印a数组名，是打印数组a的哈希code
        System.out.println(a);      //[I@1b6d3586

        //打印数组元素    Arrays.toString
        System.out.println(Arrays.toString(a));     //[1, 32, 4335, 3232, 54, 2312, 43, 221]

        printArrays(a);
    }

    //类里面的方法都是别人写好的，我们也可以自己实现
    //但是没必要重复造轮子
    public static void printArrays(int[] a){

        for (int i = 0; i < a.length; i++) {
            if (i==0){
                System.out.print("[");
            }
            if (i==a.length-1){
                System.out.print(a[i]+"]");
            }else {
                System.out.print(a[i]+", ");
            }
        }
    }
}

 排序并输出

Arrays.sort(); 

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用

常用的功能：

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

---

冒泡排序

两层循环，外层冒泡轮数，里层依次比较。时间复杂度为O(n2)。

package com.study.array;

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a ={22, 3232, 42, 432, 11        };
        sort(a);
        System.out.println(Arrays.toString(a));
    }

    //冒泡排序：比较数组中相邻的两个元素
    // 如果第一个数比第二个数大，就交换他们的位置
    // 则下一轮就可以少一次排序
    // 依次循环，直到结束
    public static void sort(int[] a) {
        //外层循环
        int temp;
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {
                temp = a[j];
                if (temp > a[j + 1]) {
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }

            }
        }
    }
}

 

---

稀疏数组

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

稀疏数组的处理方式：

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

java算法--稀疏数组 - TimothyRasinski - 博客园 (cnblogs.com)

package com.study.array;

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) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

        //转换为稀疏数组保存
        //1、获取有效值的个数（遍历数组，计数不为0的元素）
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (a[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值有" + sum + "个");
        //创建一个存储稀疏数组的数组
        int[][] b = new int[sum + 1][3];

        //稀疏数组的头：几行几列 有效值有几个
        b[0][0] = 11;
        b[0][1] = 11;
        b[0][2] = sum;

        //遍历二维数组，将非0的值放进稀疏数组中
        int count = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] != 0) {
                    count++;
                    b[count][0] = i;        //横坐标
                    b[count][1] = j;        //纵坐标
                    b[count][2] = a[i][j];    //值

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

package com.study.array;

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) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

        //转换为稀疏数组保存
        //1、获取有效值的个数（遍历数组，计数不为0的元素）
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (a[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值有" + sum + "个");
        //创建一个存储稀疏数组的数组
        int[][] b = new int[sum + 1][3];

        //稀疏数组的头：几行几列 有效值有几个
        b[0][0] = 11;
        b[0][1] = 11;
        b[0][2] = sum;

        //遍历二维数组，将非0的值放进稀疏数组中
        int count = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] != 0) {
                    count++;
                    b[count][0] = i;        //横坐标
                    b[count][1] = j;        //纵坐标
                    b[count][2] = a[i][j];    //值

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

        System.out.println("还原稀疏数组:");
        int[][] c = new int[b[0][0]][b[0][1]];

        //还原值：c[横坐标][纵坐标]=值
        //      横坐标 b[i][0]
        //      纵坐标 b[i][1]
        //      值    b[i][2]

        for (int i = 1; i < b.length; i++) {
            int x = b[i][0];
            System.out.println(x);
            int y = b[i][1];
            System.out.println(y);
            int m = b[i][2];
            System.out.println(m);
            c[x][y] = m;
        }

        //打印
        for (int[] ints : c) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}