Arrays类、常见算法（选择排序、二分查找）

一. Arrays类

1.1 Arrays类概述以及Arrays类常用API

Arrays类概述

• Arrays类是数组操作工具类，专门用于操作数组元素的。

package com.gch.d8_arrays;

import java.util.Arrays;

public class ArraysDemo1 {
    public static void main(String[] args) {
        // 目标:学会使用Arrays类的常用API,并理解其原理
        int[] arr = {10, 2, 55 ,23, 24, 100};
        System.out.println(arr); // [I@4554617c

        // 1.返回数组内容的 toString(arr)
//        String rs = Arrays.toString(arr);
//        System.out.println(rs);
        System.out.println(Arrays.toString(arr)); // [10, 2, 55, 23, 24, 100]

        // 2.排序的API(默认自动对数组元素进行升序排序)
        Arrays.sort(arr); // 快排机制
        System.out.println(Arrays.toString(arr)); // [2, 10, 23, 24, 55, 100]

        // 3.二分搜索技术(前提数组必须排好序才支持,否则出bug)
        // 非常优秀的一种数据搜索算法,可以极大的提高性能
        int index = Arrays.binarySearch(arr , 55);
        System.out.println(index); // 4

        // 返回不存在元素的规律: -(应该插入的位置索引 + 1)
        int index1 = Arrays.binarySearch(arr , 555);
        System.out.println(index1); // -7

        // 注意:数组如果没有拍好序,可能会找不到存在的元素,从而出现bug!!
        int[] arr2 = {12, 36, 34, 25, 13, 24, 234, 100};
        int index2 = Arrays.binarySearch(arr2 , 36);
        System.out.println(index2); // -7
    }
}

1.2 Arrays类对于Comparator比较器的支持

• 自定义Comparator比较器对象，只能支持引用数据类型的排序！！！

• Comparator是一个函数式接口

 

package com.gch.d8_arrays;

import java.util.Arrays;
import java.util.Comparator;

public class ArraysDemo2 {
    public static void main(String[] args) {
        // 目标:自定义数组的排序规则:Comparator比较器对象。
        // 1.Arrays的sort方法对于有值特性的数组是默认升序排序
        int[] ages = {34, 12, 42, 23};
        Arrays.sort(ages);
        System.out.println(Arrays.toString(ages)); // [12, 23, 34, 42]

        // 2.需求:降序排序!(自定义比较器对象,只能支持引用类型的排序！！)
        Integer[] ages1 = {34, 12, 42, 23};
        Arrays.sort(ages1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // 指定比较规则
//                if(o1 > o2){
//                    return 1;
//                }else if(o1 < o2){
//                    return -1;
//                }
//                return 0;

                // return o1 - o2; // 默认升序
                return o2 - o1; // 降序
            }
        });
        System.out.println(Arrays.toString(ages1)); // [42, 34, 23, 12]
        System.out.println("------------------------------------------------");
        Student[] students = new Student[3];
        students[0] = new Student("吴磊", 23, 175.5);
        students[1] = new Student("谢鑫", 18 ,185.5);
        students[2] = new Student("王亮", 20, 195.5);

        // 没有重写toString方法,默认打对象的地址
        System.out.println(Arrays.toString(students));

//        Arrays.sort(students); // 直接运行崩溃
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 自己制定比较规则   compare方法返回值类型为int
//                return o1.getAge() - o2.getAge(); // 按照年龄升序排序
//                return o2.getAge() - o1.getAge(); // 按照年龄降序排序
                // 浮点型排序不能这样写  173.3 - 173.0 = 0.3,转为int为0,认为这两个人身高相等,会出bug
//                return (int) (o1.getHeight() - o2.getHeight());
                // 按照身高升序排序   比较浮点型可以这样写,也必须这样写
//                return Double.compare(o1.getHeight() , o2.getHeight());
                // 按照身高降序排序
                return Double.compare(o2.getHeight() , o1.getHeight());
            }
        });
        System.out.println(Arrays.toString(students));
    }
}

package com.gch.d8_arrays;

public class Student {
    private String name;
    private int age;
    private double height;

    /*
       重写toString方法
     */
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }

    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }
}

 二、常见算法

2.1 选择排序

package com.gch.d9_sort_binarysearch;

import java.util.Arrays;

/**
   目标:学会使用选择排序的方法对数组进行排序
 */
public class Test1 {
    public static void main(String[] args) {
        // 1.定义数组
        int[] arr = {5, 1, 3, 2};
        //           0  1  2  3

        // 2.定义一个外部循环控制选择几轮:arr.length - 1
        for(int i = 0;i < arr.length;i++){
            // i = 0   j = 1 2 3
            // i = 1   j = 2 3
            // i = 2   j = 3
            // 3.定义内部循环,控制选择几次
            for(int j = i + 1;j < arr.length;j++){
                // 当前位:arr[i]
                // 如果有比当前位数据更小的(或者当前位比后面的值大),则交换
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr)); // [1, 2, 3, 5]
    }
}

2.2 二分查找

• 二分查找的思路：定义两个位置，一个在前，一个在后，这样才能折半，前面位置和后面位置，一半的位置作为中间索引。
• min和max表示查找的范围
•  二分查找相当于每次去掉一半儿的查找范围，检索速度非常快
• 二分查找一旦发现左边位置等于右边位置还没有确定值的话，那就说明找不到了

 

 

package com.gch.d9_sort_binarysearch;

import java.util.Arrays;

/**
   目标:理解二分搜索的原理并实现
 */
public class Test2 {
    public static void main(String[] args) {
        // 1.定义一个拍好序的数组
        int[] arr = {10, 14, 16, 25, 28, 30, 35, 88, 100};
        System.out.println(binarySearch(arr , 35));
    }

    /**
     * 二分查找算法的实现
     * @param arr 排好序的数组
     * @param data 要找的数据
     * @return 返回索引,如果元素不存在,直接返回-1
     */
    public static int binarySearch(int[] arr,int data){
        // 1.定义左边位置 和 右边位置
        int left = 0;
        int right = arr.length - 1;

        // 2.开始循环,折半查询。
        while(left <= right){
            // 取中间索引  折半的位置精确不精确没有关系
            int middleIndex = (left + right) / 2;
            // 3.判断当前中间位置的元素和要找的元素的大小情况
            if(data > arr[middleIndex]){
                // 往右边找,左位置更新为 = 中间索引 + 1
                left = middleIndex + 1;
            }else if(data < arr[middleIndex]){
                // 往左边找,右位置更新为 = 中间索引 - 1
                right = middleIndex - 1;
            }else {
                return middleIndex;
            }
        }
        return -1; // 查无此元素
    }

}