Day12 Arrays 类

Arrays 类

1. 数组的工具类java.util.Arrays
2. 由于数组对象本身并没有什么方法可以供我们带哦用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
3. 查看JDK帮助文档
4. Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：“不用”而不是“不能”——
5. 具有一下常用功能：
   • 给数组赋值：通过fill方法
   • 对数组排序：通过sort方法，按升序
   • 比较数组：通过equals方法比较数组中元素值是否相等
   • 查找数组元素：通过binarySearch 方法能对排序号的数组进行二分查找发操作

冒泡排序

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

2. 冒泡的代码两层循环，外出冒泡轮数，里层依次比较。

   package com.FlyFish.array;
   
   import java.util.Arrays;
   
   /**
    * @auther FlyFish
    * @company wu
    * @create 2021-03-17 20:54
    */
   public class ArrayDemo05 {
       /**
        * 1.比较数组中，两个相邻的元素，如果第一个比第二个大，则交换位置
        * 2.每一次比较，都会产出一个最大，或最小的数字
        * 3.下一轮则可以减少一次排序！
        * 4.依次循环，知道结束
        */
       public static void main(String[] args) {
           int[] array = {1,45,6,78,2,34,56,72,4,67,54};
           int[] a = sort(array);//调用完我们自己写的排序方法后，返回一个排序后的数组
           System.out.println(Arrays.toString(a));
       }
       public static int[] sort(int[] array) {
           //临时变量
           int temp = 0;
           //外层循环，判断我们要循环多少次
           for (int i = 0; i < array.length - 1; i++) {
               //内层循环，比较两个数，如果第一个数大与第二个数，则交换位置
               for (int j = 0; j < array.length - 1 - i; j++) {
                   if (array[j + 1] < array[j]) {
                       temp = array[j];
                       array[j] = array[j+1];
                       array[j+1] = temp;
                   }
               }
           }
           return array;
       }
   }
   //输出结果
   [1, 2, 4, 6, 34, 45, 54, 56, 67, 72, 78]
   

   稀疏数组

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

   package com.FlyFish.array;
   
   /**
    * @auther FlyFish
    * @company wu
    * @create 2021-03-17 21:37
    */
   public class ArrayDemo06 {
       public static void main(String[] args) {
           //1.创建一个二维数组 11*11  0：没有棋子  1：黑棋   2：白棋
           int[][] array1=new int[11][11];
           array1[2][3] =1;
           array1[3][4] =2;
           //输出原始值
           System.out.println("输出原始的数组");
   
           for (int[] ints : array1) {
               for (int anInt : ints) {
                   System.out.print(anInt+"\t");
               }
               System.out.println();
           }
           System.out.println("=============");
           //转换为稀疏数组保存
           //获取有效值的个数
           int sum = 0;
           for (int i = 0; i < 11; i++) {
               for (int j = 0; j < 11; j++) {
                   if (array1[i][j]!=0){
                       sum++;
                   }
               }
           }
           System.out.println("有效值的个数："+sum);
   
           //2.创建一个稀疏数组的数组
           int[] [] array2= new int[sum+1][3];
           array2[0][0]=11;
           array2[0][1]=11;
           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];
                   }
               }
           }
           //输出稀疏数组
           System.out.println("输出稀疏数组");
           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("============");
           System.out.println("还原");
           //1.读取稀疏数组
           int[][] array3=new int[array2[0][0]][array2[0][1]];
           //给其中的元素还原值
           for (int i = 1; i < array2.length; i++) {
               array3[array2[i][0]][array2[i][1]]=array2[i][2];
           }
           //3.打印
           System.out.println("输出还原的数组");
   
           for (int[] ints : array3) {
               for (int anInt : ints) {
                   System.out.print(anInt+"\t");
               }
               System.out.println();
           }
       }
   }
   //输出结果
   输出原始的数组
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	1	0	0	0	0	0	0	0	
   0	0	0	0	2	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   =============
   有效值的个数：2
   输出稀疏数组
   11	11	2	
   2	3	1	
   3	4	2	
   ============
   还原
   输出还原的数组
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	1	0	0	0	0	0	0	0	
   0	0	0	0	2	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0	
   0	0	0	0	0	0	0	0	0	0	0