JavaSE从零学起12. 数组的应用：Arrays类，冒泡排序

数组的应用：Arrays类，冒泡排序

Arrays类

• 数组的工具类java.util.Arrays，使用前要先导入java.util.Arrays;

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

• 查看JDK帮助文档Java8 API帮助文档

• Arrays类中的方法都是static修饰的静态方法。在使用的时候可以直接使用类名进行调用而不能适用对象来调用。

• Arrays类主要有以下常用功能：

  1. 给数组赋值：通过fill方法：

     Arrays.fill(待处理数组名,要填充的值) :将数组的所有位置填充为指定的。

     Arrays.fill(待处理数组名, 要用指定值填充的第一个元素的索引, 要用指定值填充的最后一个元素的索引,要填充的值) :将数组的指定位置填充为指定的值。

  2. 对数组排序：通过sort方法，升序

     Arrays.sort(数组名)：将指定数组的数组元素按升序排列。

     Arrays.sort(数组名,要排序的第一个元素的索引,要排序的最后一个元素的索引):将数组的指定位置处的数组元素按升序排列。

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

     Arrays.equals(待比较数组1, 待比较数组2) ：比较数组中元素值是否相等，两数组同一索引处的值完全相同两个数组才相等。返回值是true或false

  4. 查找数组元素：通过binarySearch方法堆排序好的数组进行二分查找法操作。

     使用binarySearch方法前须先用Sort方法对待查找数组进行排序。

     Arrays.binarySearch(待查找数组,要查找的值)：查找指定的值在数组中的位置。返回值是查找到的第一个指定值的索引。

     Arrays.binarySearch(待查找数组,要搜索的第一个元素的索引,要搜索的最后一个元素的索引,要查找的值) :查找指定的值在数组中指定范围内的位置。返回值是查找到的第一个指定值的索引。

以下是对上述四种方法的演示示例：

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


        //equals
        int[] a = {1, 2, 3, 4, 5};
        int[] b = {1, 2, 3, 4, 5};
        System.out.println(Arrays.equals(a, b));
        //fill one:Arrays.fill(待处理数组名,开始填充位置的索引,结束填充位置的索引,要填充的值);
        int[] c = {1,2,3,4,5};
        Arrays.fill(c,1,4,0);
        System.out.println(Arrays.toString(c));
        //fill two：(待处理数组名,要填充的值);
        int[] d = {1,2,3,3,3,4,5};
        Arrays.fill(d,0);
        System.out.println(Arrays.toString(d));
        //sort one
        int[] nums= {15,3,3,1,5,13};
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));
        //sort two
        int[] e = {13,2,2,42,4,4,24,5};
        Arrays.sort(e,0,4);
        System.out.println(Arrays.toString(e));
        //binarySearch one
        int[] f = {1,5,4,6,8,2,7,3};
        Arrays.sort(f);
        int key = Arrays.binarySearch(f,8);
        System.out.println(key);//返回的是key的索引
        //binarySearch two
        System.out.println(Arrays.binarySearch(f,0,4,8));
        //返回的是key的索引

    }

    }

输出结果：
true
[1, 0, 0, 0, 5]
[0, 0, 0, 0, 0, 0, 0]
[1, 3, 3, 5, 13, 15]
[2, 2, 13, 42, 4, 4, 24, 5]
7
-5

冒泡排序

• 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算。它重复地走访过要排序的元素列，依次比较两个相邻的元素,如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
  这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中的气泡最终会上浮到顶端一样，故名“冒泡排序”。百度百科—冒泡排序
• 八大排序中，冒泡排序无疑是最出名的排序算法之一。
• 两层循环，外层冒泡轮数，内层依次比较。
• 该算法的时间复杂度为O（n^2）

下面来看冒泡排序的两种写法：
写法一：（用flag标识进行优化）

    public static void sort(int []array){
        boolean flag;//优化遍历次数
        for (int i = 0; i < array.length-1; i++) {//i+1<array.length so i<array.length-1
            //外层进行完一轮循环后就会排出最大的数放在最后一个，所以j可以少做一轮比较。
            //外层进行i轮，内层就可以少进行i轮。
            flag=true;
            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 =false;
                }
        }
            if (flag){
                break;
            }
            System.out.println(Arrays.toString(array));
    }
}

写法二：

public static void sort2(int []array){

           for (int i = 0; i < array.length; i++) {
               for (int j = 0; j < i; j++) {
                   //若前项大于后项，交换
                   if (array[i]<array[j]){
                       temp = array[j];
                       array[j] =array[i];
                       array[i] = temp;//交换

                   }
               }

               System.out.println(Arrays.toString(array));
           }
       }