JAVA基础学习--数组总结

Posted 2021-08-14 炒股不如炒菜

 

<center>数组的应用总结</center>

 

数组的应用总结1.Arrays类2.冒泡排序3.稀疏数组

 

 

 

<center>1.Arrays类</center>

1. Arrays类里面包含许多应用于数组的方法，它们都是人写的用于实现某些功能,当然你也可以自己写。

在IDEA中可以 Ctrl+点击Arrays 查看里面的源码。

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

 

3. 查看JDK帮助文档 

JDK帮助文档 中有Java各种类包含的方法的使用方法，其中就包括Arrays类里面的各种方法的使用

下图为JDK1.8帮助文档

下面的地址为其官方在线查找地址，目前JDK帮助文档没有出中文版，但是网上可以下载其破解的中文版

官网地址

 

4. 数组的工具类  java.util.Arrays 在使用的其中的时候要导入这个类

import java.util.Arrays;

 

下面是一些具体的应用

package array;
import java.util.Arrays;   //首先导入Arrays这个类
​
public class Excercise9 {
                //Arrays工具类
    public static void main(String[] args) {
​
        int[] a ={15,5,4,8,6,4};
        
        System.out.println(Arrays.toString(a));//输出这个数组
​
        Arrays.sort(a);   //对数组进行升序排序
        System.out.println(Arrays.toString(a));
​
        Arrays.fill(a,2);       //对数组进行填充
        System.out.println(Arrays.toString(a));
​
        Arrays.fill(a,2,4,12);     //下标2-4之间用12填充
        System.out.println(Arrays.toString(a));
        
    }
​
}

 

---

---

 

<center>2.冒泡排序</center>

1. 冒泡排序是一种最为出名的排序算法之一(总共有八大排序)

其代码还是相当简单的，两层循环，外层冒泡轮数，里层依此比较（江湖中，人人皆知）

举例如下图所示:

把{1，2，3，4，5} 排序为{5，4，3，2，1}

其原理是外层每一轮循环依次比较把最小的值传递到最右边，一轮循环下来排好一个数。因此下一轮循环少比较一个数，一直传递下去直到最后的结果。

如果要给某个数组排序，那么其外层最多要循环（array.length-1）次 ，内层每轮最多比较循环（array.length-1-i）次

其中，i 为外层循环 0 <= i <（array.length-1）

 

2. 算法的优化

优化的方法有多种，这里介绍一种

先在外层轮数定义一个boolean变量为false,再在里层循环里赋值为true,最后判断变量值有没有变化，若没有变化为还是为false则用

break语句打断循环。

 

3. 程序如下

package array;
​
public class Exercise8 {
    //冒泡排序
    public static void main(String[] args) {
              int[] a = {1,2,3,4,5};
         sort(a);
    }
​
    public static void sort(int[] array){
​
​
        int temp = 0;  //定义一个临时变量
​
        for (int i = 0; i < array.length-1; i++) {    //外层循环  最多的循环轮数： array.length-1
​
            boolean flag = false;        //算法优化
            for (int j = 0; j < array.length-1-i; j++) {  //里层循环  每一轮外层循环后少一次比较
                if (array[j+1] > array[j]){  //按从大到小排列，相邻两个值进行比较，第一轮循环把最小的数传到最后面                                                    //这里注意array[j]和array[j+1]数组溢出问题
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;       //如果没有走这个里循环，说明flag一直为false
                }
            }
            if (flag = false ) {
                break;
            }
        }
​
        for (int x : array) {     
            System.out.print(x);
        }
    }
}
​

 

---

---

 

<center>3.稀疏数组</center>

1. 应用稀疏数组的地方：比如在编写五子棋游戏中，其中二维数组的很多值默认值为0，因此记录了很多没有意义的数据

 

2. 稀疏数组：当一二维数组中大部分元素是零，或者为同一值的时候，可以用稀疏数组来保存该数组。

 

3. 处理方式： 先记录原始数组有几行几列，有多少个不同值。然后把不同值元素的行，列，值记录在一个小规模数组中，从而缩小程序的规模

 

原始数组

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

 

稀疏数组

	行（row）	列(col)	值(value)
[0]	6	7	8
[1]	0	3	22
[2]	0	6	15
[3]	1	1	11
[4]	1	5	17
[5]	2	3	-6
[6]	3	5	39
[7]	4	0	91
[8]	5	2	28

稀疏数组的格式：

行数：原始数组中不同值的个数+1

列数： 3列

第1行：表示原始数组有几行几列几个不同值

 

程序如下：

package practice;
​
public class Practice7 {
    //稀疏数组练习2.0
    public static void main(String[] args) {
        //输出一个原始数组 array1
           int[][] array1 = new int[6][7];
           array1[0][3] = 22;
           array1[0][6] = 15;
           array1[1][1] = 11;
           array1[1][5] = 17;
           array1[2][3] = -6;
           array1[3][5] = 39;
           array1[4][0] = 91;
           array1[5][2] = 28;
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\\t");
            }
            System.out.println();
​
        }
​
        //把原始数组array1==>稀疏数组array2
​
        // 第一步 计算非零值的个数
​
               int sum = 0;       //定义原始数组array1中非零值的个数sum
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("非零值的个数sum:"+sum);
​
        //第二步 定义一个稀疏数组array2
        int[][] array2 =new int[sum+1][3];    //稀疏数组行数；sum+1, 列数；3
        array2[0][0] = 6;                     //给稀疏数组第一行赋值
        array2[0][1] = 7;
        array2[0][2] = sum;
​
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0){
                    count++;                     //给稀疏数组每一行排值
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
​
                }
            }
        }
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\\t"+array2[i][1]+"\\t"+array2[i][2]+"\\t");
​
        }
        System.out.println("=================================================================");
        //把稀疏数组array2==>转换成原始数组array3
​
        int[][] array3 =new int[6][7];  //根据稀疏数组定义原始数组
​
        for (int i = 1; i < array2.length; i++) {
​
            int x = array2[i][0];   //定义原始数组array3行,列,值分别为x,y,z
            int y = array2[i][1];
            int z = array2[i][2];
​
            array3[x][y] = z;
        }
        for (int[] ints : array3) {     //输出原始数组array3
            for (int anInt : ints) {
                System.out.print(anInt+"\\t");
            }
            System.out.println();
        }
​
​
​
    }
​
}