Java数组03

Arrays类

• 数组的工具类java.util.Arrays

• 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays，完成对数据对象的一些基本操作

• 善于查阅JDK文档

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

• 常用的功能

  • 给数组赋值：fill方法

  • 数组排序：sort方法，升序

  • 比较数组：通过equals方法比较数组中元素值是否相等

  • 查找数据元素：binarySearch方法能对排序好的数组进行二分查找法操作

 package array;
 ​
 import java.util.Arrays;
 ​
 /**
  * @author IT_Jay
  * @date 2022/1/21 18:58
  */
 ​
 public class arrayDemo06 {
     public static void main(String[] args) {
         int[] a = {1, 2, 4, 5456, 67777, 9999, 6, 8};
         System.out.println(a);      //[I@776ec8df
 ​
         //打印数组
         System.out.println(Arrays.toString(a));
         //调用自定义方法实现同样效果
         printArray(a);
 ​
 ​
         Arrays.sort(a);     //对数组进行排序
         System.out.println("\n"+Arrays.toString(a));        //打印排序后数组
 ​
 ​
         Arrays.fill(a,0);       //数组填充
         System.out.println(Arrays.toString(a));
         Arrays.fill(a,2,4,9);       //将下标2到3的元素填充为9   注意：左闭右开：[2,4)
         System.out.println(Arrays.toString(a));
 ​
     }
 ​
     //也可以自己定义方法，打印数组
     public static void printArray(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] + ", ");
             }
         }
     }
 }

 

 

 

 

冒泡排序

• 冒泡排序最出名的排序算法只一，共八大排序

• 代码相对简单，两层循环，外层冒泡轮数，内层依次比较

• 嵌套循环，==时间复杂度O(n²)

 package array;
 ​
 import java.util.Arrays;
 ​
 /**
  * @author IT_Jay
  * @date 2022/1/21 19:33
  */
 ​
 public class arrayDemo07 {
     public static void main(String[] args) {
         int[] a = {1,33,0,0,99,5,2,0};
         int[] mysort = mySort(a);
         System.out.println(Arrays.toString(a));
     }
 ​
     //冒泡排序
 ​
     /**
      * 1、比较数组中相邻两个元素值，如果当前比后一个大（小），交换次序
      * 2、每次比较都将产生一个最大（小）的元素
      * 3、下一轮则可少一次排序
      * 4、依次循环，直到结束
      */
     public static int[] mySort(int[] array) {
         //临时变量
         int temp = 0;
         //外层循环，判断要走多少次
         for (int i = 0; i < array.length - 1; i++) {
             //优化冒泡，设置监视哨
             boolean flag =false;    //通过flag标示位减少无意义的比较（即本来就有序的时候）
 ​
 ​
             //内层循环，判断两个数，当前数值比后一个数值大，则交换位置
             for (int j = 0; j < array.length - 1 - i; j++) {
                 if (array[j]>array[j+1]){
                     temp = array[j];
                     array[j]=array[j+1];
                     array[j+1]=temp;
 ​
                     //优化部分
                     flag=true;
                 }
             }
 ​
             //优化部分
             if (flag==false){
                 break;
             }
         }
         return array;
     }
 }