数组排序,Arrays数组工具类专题(Arrays工具类)

本文链接：https://blog.youkuaiyun.com/Java_OracleSun/article/details/54672500

数组排序,Arrays数组工具类专题(Arrays工具类)

1. 冒泡排序

2. 选择排序

3. 二分查找法

最后是Arrays工具类的三个方法:

Arrays.toString()方法,将数组转换成字符串
Arrays.sort()方法,将字符串进行排序
Arrays.binarySearch()方法,通过值查找对应索引.注意(排序问题!).

package com.heima.array;

/*
 * A:画图演示
        需求：
            数组元素：{24, 69, 80, 57, 13}
            请对数组元素进行排序。
            冒泡排序
            相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
 * B:案例演示
            数组高级冒泡排序代码
---------------------------------------------
 * A:画图演示
    * 需求：
        * 数组元素：{24, 69, 80, 57, 13}
        * 请对数组元素进行排序。
        * 选择排序
            * 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
  * B:案例演示
        * 数组高级选择排序代码
 */

public class Demo1_Array {
    public static void main(String[] args) {
         int[] arr = {24, 69, 80, 57, 13};
         bubbleSort(arr);
//       selectSort(arr);
         print(arr);
    }
    /*
     * 冒泡排序 1,返回值类型,void 2,参数列表,int[] arr
     * 
     * 第一次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4]比较4次
     * 第二次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3]比较3次
     * 第三次:arr[0]与arr[1],arr[1]与arr[2]比较2次 
     * 第四次:arr[0]与arr[1]比较1次
     */
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {                  //外层循环  
            for (int j = 0; j < arr.length -1-i; j++) {
                if(arr[j] > arr[j+1]) {
                    /*int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;*/
                    swap(arr,j,j+1);

                }
            }
        }
    }

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

    /*
     * 选择排序
     * 1,返回值类型void
     * 2,参数列表int[] arr
     * 
     * 第一次:arr[0]分别与arr[1-4]比较,比较4次
        第二次:arr[1]分别与arr[2-4]比较,比较3次
        第三次:arr[2]分别与arr[3-4]比较,比较2次
        第四次:arr[3]与arr[4]比较,比较1次
     */

    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    /*int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;*/
                    swap(arr,i,j);
                }
            }
        }
    }

    /*
     *换位操作
     *1,返回值哦类型,void
     *2,参数列表int[] arr , int i , int j
     *
     *如果某个方法,只针对本类使用,不想让其他类使用就可以定义成私有的
     */
    public static void swap(int[] arr, int i ,int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

package com.heima.array;

/*
 *A:案例演示
    * 数组高级二分查找代码
* B:注意事项
    * 如果数组无序，就不能使用二分查找。
        * 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。
 */
public class Demo2_Array {

    public static void main(String[] args) {
        int[] arr = { 11, 22, 33, 44, 55, 66, 77 };
        System.out.println(getIndex(arr, 22)); // 1 //返回的是对应的索引值
        System.out.println(getIndex(arr, 66)); // 5

        System.out.println(getIndex(arr, 88)); // -1 在源代码中返回的值是 -插入值 - 1;
        System.out.println(getIndex(arr, 10)); // -1
        System.out.println(getIndex(arr, 20)); // -1

    }

    // 二分查找法,获得索引值
    // 1,返回值类型,int
    // 2,参数列表,int[] arr , int value

    public static int getIndex(int[] arr, int value) {
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max) >> 1;

        while (arr[mid] != value) {
            if (arr[mid] > value) {
                max = mid - 1;
            } else if (arr[mid] < value) {
                min = mid + 1;
            }
            mid = (min + max) >> 1;

            if (min > max) {
                return -1;
            }
        }
        return mid;
    }
}

package com.heima.array;

import java.util.Arrays;

/*
 * * A:Arrays类概述
    * 针对数组进行操作的工具类。
    * 提供了排序，查找等功能。
* B:成员方法          
    * 
    * public static String toString(int[] a)         //使用toString方法,将数组转换成字符串
    * public static void sort(int[] a)                 //使用sort方法,将数组进行排序
    * public static int binarySearch(int[] a,int key)//使用binarySearch方法查找值的索引!
 */
public class Demo3_Array {
    public static void main(String[] args) {

        int[] arr = { 33, 22, 11, 12, 44, 55, 66 };
        System.out.println(Arrays.toString(arr)); // [33, 22, 11, 12, 44, 55,
                                                    // 66]

        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr)); // [11, 12, 22, 33, 44, 55,
                                                    // 66]

        // 使用二分法的前提数组必须是有序的!!!如果排序后才使用,那索引值是排序后的数组索引!!!
        int[] arr2 = { 11, 22, 33, 44, 55, 66, 77 };
        System.out.println(Arrays.binarySearch(arr2, 22)); // 1
        System.out.println(Arrays.binarySearch(arr2, 66)); // 5
        // 当值不包含数组中,返回(-插入点-1).
        System.out.println(Arrays.binarySearch(arr2, 10)); // -1 因为10应该放在数组0索引
                                                            // -0-1 为-1
        System.out.println(Arrays.binarySearch(arr2, 100)); // -8
                                                            // 因为100应该放在数组7索引位置
                                                            // -7-1 -8

    }

    // Arrays工具类中的toString源码
    public static String toString(int[] a) {
        if (a == null) // 如果传入的数组是null
            return "null"; // 返回null
        int iMax = a.length - 1; // iMax是最大索引
        if (iMax == -1) // 如果数组中没有元素,则上一行为(0-1)=-1.
            return "[]"; // 返回[] 代表数组元素为空

        StringBuilder b = new StringBuilder(); // 为什么选StringBuilder?线程不安全,但效率高
        b.append('['); // 将[添加到字符串缓冲区中
        for (int i = 0;; i++) { // 遍历数组,判断语句没写默认是true
            b.append(a[i]); // 把第一个元素添加进字符串缓冲区
            if (i == iMax) // 如果索引等于最大索引
                return b.append(']').toString(); // 将]添加子字符串缓冲区,在转换成字符串并返回
            b.append(", "); // 如果不等于最大索引就继续将,添加到缓冲区
        }
    }

    // Arrays工具类中的binarySearch0源码
    private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) {
        int low = fromIndex; // 0,最小索引
        int high = toIndex - 1; // a.length - 1;最大索引

        while (low <= high) { // 最小索引小鱼等于最大索引可以循环判断
            int mid = (low + high) >>> 1; // 向右移1位,相当于除以2,求出中间索引值,(最小+最大)/2
            int midVal = a[mid]; // 通过中间索引获取中间值

            if (midVal < key) // 中间索引对应的值小于查找的值
                low = mid + 1; // 最小索引变化
            else if (midVal > key) // 中间索引对应的值大于查找的值
                high = mid - 1; // 最大索引变化
            else
                return mid; // key found //找到了
        }
        return -(low + 1); // key not found. //没找到,返回 -插入点-1
    }

}