java基础---数组总结2

​

数组的应用总结

1.Arrays类

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));
        
    }

}

---

---

2.冒泡排序

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);
        }
    }
}

---

---

3.稀疏数组

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();
        }



    }

}