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