Java数组、冒泡排序、快速排序、Arrays工具类常用的方法

数组的概述

• 数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
• 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。 
• 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。 
• 数组的长度一旦确定，就不能修改。 
• 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。

   

---

一维数组

一维数组的声明方式：type var[] 或 type[] var；

一维数组的初始化：

• 动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行
• 静态初始化：在定义数组的同时就为数组元素分配空间并赋值。

一维数组的使用：

• 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
• 数组元素的引用方式：数组名[数组元素下标] 
• 每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)
• 数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。

二维数组

动态初始化：

• 格式1：int[][] arr = new int[3][2];
• 格式2：int[][] arr = new int[3][];

静态初始化：

• int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

  ---

   

算法：

冒泡排序

冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

public class BubbleSort {
    public static void main(String[] args) {
        BubbleSort bubbleSort = new BubbleSort();
        int[] arr = {3, 4, 2, 7, 4, 9, 0};
        int[] sort = bubbleSort.bubbleSort(arr);
        for (int i = 0; i < sort.length; i++) {
            System.out.print(sort[i] + "\t");

        }
    }
    public int[] bubbleSort(int[] arr) {
        int temp;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }

        }
        return arr;
    }
}

结果：0    2    3    4    4    7    9    

快速排序

• 第一步：随便找一个数作为基准数，比如就找第一个数。
• 第二步：从两端开始“探测”，先从右往左找一个小于基准数的数，再从左往右找一个大于基准数的数，然后交换他们。
• 第三步：把基准数和i=j处的值进行交换，即i=j处的值替换原先等于基准数的值，然后再把基准数赋给i=j的索引处。
• 第四步：递归右边和左边。

细节注意：判断low和high的大小，保证i是小于基准数的左边，j是大于基准数的右边。

public class QuickSort {
    public static void main(String[] args) {
        QuickSort Sort = new QuickSort();
        int[] arr = {9, 4, 9, 0, 4, 2, 4, 5, 7, 6};
        quickSort(arr, 0, arr.length - 1);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");

        }
    }

    public static void quickSort(int[] arr, int low, int high) {
        int i, j, temp, t;
        if (low > high) {
            return;
        }
        temp = arr[low];
        i = low;
        j = high;
        while (i < j) {
            while (temp <= arr[j] && i < j) {
                j--;
            }
            while (temp >= arr[i] && i < j) {
                i++;
            }
            if (i < j) {
                t = arr[i];
                arr[i] = arr[j];
                arr[j] = t;
            }
        }
        arr[low] = arr[i];
        arr[i] = temp;
        quickSort(arr, low, j - 1);
        quickSort(arr, i + 1, high);
    }
}

结果：0    2    4    4    4    5    6    7    9    9

Arrays工具类的使用

• boolean equals(int[] a,int[] b)

public class ArraysTest {
    @Test
    public void test1(){
        int[]arr1 = {1,4,6,9,3,9,2};
        int[]arr2 = {1,4,6,9,3,9,2};
        int[]arr3 = {1,4,6,7,3,4,2};
        boolean equals = Arrays.equals(arr1, arr2);
        System.out.println(equals);
        boolean equals1 = Arrays.equals(arr1, arr3);
        System.out.println(equals1);
    }
}

结果：

true
false

• void fill(int[] a,int val) 

public class ArraysTest {
    @Test
    public void test1() {
        int[] arr1 = {1, 4, 6, 9, 3, 9, 2};
        int[] arr2 = {1, 4, 6, 9, 3, 9, 2};
        int[] arr3 = {1, 4, 6, 7, 3, 4, 2};
        Arrays.fill(arr1, 3);//全部填充为3
        System.out.println(Arrays.toString(arr1));
//        Arrays.fill(arr1,0,3,2);//从索引0到索引3填充为2，左开右闭
//        System.out.println(Arrays.toString(arr1));
    }
}

结果：[3, 3, 3, 3, 3, 3, 3]

public class ArraysTest {
    @Test
    public void test1() {
        int[] arr1 = {1, 4, 6, 9, 3, 9, 2};
        int[] arr2 = {1, 4, 6, 9, 3, 9, 2};
        int[] arr3 = {1, 4, 6, 7, 3, 4, 2};
//        Arrays.fill(arr1, 3);//全部填充为3
//        System.out.println(Arrays.toString(arr1));
        Arrays.fill(arr1,0,3,2);//从索引0到索引3填充为2，左开右闭
        System.out.println(Arrays.toString(arr1));
    }
}

结果：[2, 2, 2, 9, 3, 9, 2]

• void sort(int[] a) 

public class ArraysTest {
    @Test
    public void test1() {
        int[] arr1 = {1, 4, 6, 9, 3, 9, 2};
        int[] arr2 = {1, 4, 6, 9, 3, 9, 2};
        int[] arr3 = {1, 4, 6, 7, 3, 4, 2};
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));
    }
}

结果：[1, 2, 3, 4, 6, 9, 9]

• int binarySearch(int[] a,int key)

public class ArraysTest {
    @Test
    public void test1() {
        int[] arr1 = {1, 4, 6, 9, 3, 9, 2};
        int[] arr2 = {1, 4, 6, 9, 3, 9, 2};
        int[] arr3 = {1, 4, 6, 7, 3, 4, 2};
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));
        int search = Arrays.binarySearch(arr1, 3);
        System.out.println(search);
    }
}

结果：

[1, 2, 3, 4, 6, 9, 9]
2