Java数组：多维数组（二维），Arrays类，冒泡排序

Arrays类
数组工具类：java.util.Arrays
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而”不用“使用对象来调用

具有以下常用功能：
给数组赋值：通过fill方法
对数组排序：通过sort方法，按升序
比较数组：通过equals方法比较数组中元素值是否相等
查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

冒泡排序：
两层循环，外层冒泡轮数，里层依次比较，时间复杂度：O(n^2)

package com.zdz.array;

import java.util.Arrays;

public class ArrayDemo {
    public static void main(String[] args) {
        //[8][2]数组里面存数组
        int[][] array = {{1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}, {10, 11}, {12, 13}, {14, 15}};
        printArray(array[0]);

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
        System.out.println("=======================================");
        //Arrays类
        int[] a = {1, 2, 3, 4, 9099, 312213, 543, 32, 4, 23};
        System.out.println(a);//[I@1b6d3586
        System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 9099, 312213, 543, 32, 4, 23]
        printArray(a);//重复的方法
        Arrays.sort(a);//数组排序：升序
        System.out.println(Arrays.toString(a));
        //Arrays.fill(a,0);//填充覆盖，全覆盖
        System.out.println(Arrays.toString(a));

        System.out.println("=======================================");
        System.out.println(Arrays.toString(sort(a)));//冒泡排序
    }

    /**
     * 打印数组元素 //重复造轮子，多余了，都有；相当于Arrays.toString(a)
     *
     * @param arrays 数组
     */
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            if (i == 0)
                System.out.print("[");
            if (i == arrays.length - 1) {
                System.out.print(arrays[i] + "]");
            } else
                System.out.print(arrays[i] + ",");
        }
        System.out.println();
    }

    /**
     * 冒泡排序
     * 1.比较数组中，两个相邻的元素，如果第一个数比第二个大，我们就交换他们的位置
     * 2.每一次比较，都会产生一个最大，或者最小的数字
     * 3.下一轮可以少一次排序
     * 4.依次循环，直到结束
     * @param array 需要排序的数组
     * @return 排好后的数组
     */
    public static int[] sort(int[] array){
       //临时变量
        int temp=0;

        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length; i++) {
            boolean flag=false;//优化语句，可以删除
            //内层循环，比较判断两个数，如果第一个数比第二个数大则交换位置
            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;
                    flag=true;//优化语句，可以删除
                }
            }
            //优化语句，可以删除
            if (flag==false){
                break;
            }
        }
        return array;
    }
}