萌新学Java之二维数组、Arrays 类、冒泡排序

public class Erwei {
    public static void main(String[] args) {
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};

        printArray(array[0]);

        System.out.println("\n"+"======");
        System.out.println(array[2][0]);
        System.out.println(array[2][1]);
        System.out.println(array.length);
        System.out.println(array[0].length);
        System.out.println("==================");

        //遍历数组
        for (int i = 0; i < array.length; i++) { //外面{1,2}...
            for (int j = 0; j < array[i].length; j++) { //里面
                System.out.print(array[i][j]+" ");
            }
        }
    }

    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
}

运行结果如下：

Arrays 类：

导入包 import java.util.Arrays;

打印数组元素 Arrays.toString

运行结果：

Arrays.fill()：给数组赋值

Arrays.sort()：对数组排序

Arrays.equals()：比较数组中元素值是否相等

Arrays.binarySearch()：对排序好的数组进行二分查找

冒泡排序：时间复杂度O(n^2)

import java.util.Arrays;

public class Mao {
    public static void main(String[] args) {

        //冒泡排序
        int[] a = {3, 5, 1, 2};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
    }

    public static int[] sort(int[] n) {
        //临时变量
        int temp = 0;
        //外层循环，判断走多少次
        for (int i = 0; i < n.length - 1; i++) { //防止栈溢出

            //通过flag标识位减少没有意义的比较，比如已经有序
            boolean flag = false;

            //内层循环，比较两个数，交换位置
            for (int j = 0; j < n.length - 1 - i; j++) {
                if (n[j + 1] > n[j]) {
                    temp = n[j];
                    n[j] = n[j + 1];
                    n[j + 1] = temp;
                    flag = true;
                }
            }
            if(flag==false) break;
        }
        return n;
    }
}

运行结果：