Arrays中sort方法升序,降序,和引用数组类型的排序, binarySearch等方法的分析

toString(数组)

public static String toString 将(任意类型的)数组元素拼接为带有格式的字符串

举例

 		int[] arr1 = {1,4,5,6,7};
        System.out.println(Arrays.toString(arr1));  //[1, 4, 5, 6, 7]

equals(数组a, 数组b)

public static boolean equals(类型[ ] a, 类型[ ] b)比较俩个数组是否相同,
如果两个数组引用都为 null，则认为它们是相等的
如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的
细节:俩个数组类型要相同

举例

		int[] arr1 = {1,4,5,6,7};
        int[] arr2 = {1,4,5,6,8};
        System.out.println(Arrays.equals(arr1,arr2));//false

		int[] arr1 = {1,4,5,6,7};
        int[] arr2 = {1,4,5,6,7};
        System.out.println(Arrays.equals(arr1,arr2));//true

binarySearch(数组,查找的元素)

使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过 sort(int[]) 方法）。
如果没有对数组进行排序，则结果是不确定的。
如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
参数 : a - 要搜索的数组 key - 要搜索的值
返回: 如果它包含在数组中，则返回搜索键的索引；
否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即第一个大于此键的元素索引，如果数组中的所有元素都小于指定的键，则为 a.length。
注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
注: 前提,数组是有序的

举例

数组是有序:
		int[] arr1 = {1,4,5,6,7};
        int[] arr2 = {1,4,5,6,8};
        System.out.println(Arrays.binarySearch(arr1,7));  //4
        System.out.println(Arrays.binarySearch(arr1,3));  //-2   (-(插入点-1)-1)-->插入点为1-->在1和4之间

数组是无序:  int[] arr1 = {1,3,2,6,5}; 
        System.out.println(Arrays.binarySearch(arr1,5));  //-4  错误索引

idea原码:
  private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            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.
    }

sort(类型[] a)

public static void sort(Object[] a)—>对数组进行默认升序排序(快速排序)

举例

		int[] arr1 = {1,3,2,6,5};
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));//[1, 2, 3, 5, 6]
        

sort(数组,Comparator<? super T> c(规则))

public static void sort(T[] a,Comparator<? super T> c)
利用插入排序+二分查找的方式进行排序的
参数1–>要排序的数组, 参数2–>排序规则 //Comparator<? super T> c: 比较器
细节: 只能给引用数组类型的数组进行排序
如果数组是基本数据类型的,需要变成其对应的包装类
eg.int–>Integer

o1–>表示在无序序列中,遍历得到的每一个元素
o2–>有序序列中的元素
如果 o1 大于 o2 ，比较器返回1。这意味着在排序后的数组中,o1 应该位于 o2 之后。
如果 o1 小于 o2 ，比较器返回-1。这意味着在排序后的数组中, o1 应该位于 o2 之前
如果 o1 等于 o2， 比较器返0。 这意味着 o1 和 o2 的顺序并不重要，它们可以以任何顺序出现
分析(o1-o2):
返回值为正数 : 表示当前要插入的元素是大的,放在后面
返回值为负数 : 表示当前要插入的元素是小的,放在前面
返回值为0 : 表示当前要插入的元素跟现在的元素比是一样的,也会也会放在后面

举例

降序:
		Integer[] arr1 = {1,3,2,6,5};
        Arrays.sort(arr1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        System.out.println(Arrays.toString(arr1));//[6, 5, 3, 2, 1]
升序:
		Integer[] arr1 = {1,3,2,6,5};
        Arrays.sort(arr1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        System.out.println(Arrays.toString(arr1));//[1, 2, 3, 5, 6]
        
lambda表达式的升序:
		Integer[] arr1 = {1, 3, 2, 6, 5};
        Arrays.sort(arr1, (Integer o1, Integer o2) -> {
                    return o1 - o2;
                }
        );
        System.out.println(Arrays.toString(arr1));//[1, 2, 3, 5, 6]

copyOf(原数组,新数组的长度)

public static boolean[] copyOf(原数组,新数组的长度)—>拷贝数组
返回一个新的数组
细节:方法的底层会根据第二个参数来创建数组
如果新数组的长度是小于老数组的长度,会部分拷贝
如果新数组的长度是等于老数组的长度,会完全拷贝
如果新数组的长度是大于老数组的长度,会补上默认初始值

举例

		int[] arr1 = {1,3,2,6,5};
        int[] a = Arrays.copyOf(arr1, 3);
        int[] b = Arrays.copyOf(arr1, 5);
        int[] c = Arrays.copyOf(arr1, 10);
        System.out.println(Arrays.toString(a));//[1, 3, 2]
        System.out.println(Arrays.toString(b));//[1, 3, 2, 6, 5]
        System.out.println(Arrays.toString(c));//[1, 3, 2, 6, 5, 0, 0, 0, 0, 0]

copyOfRange(原数组,起始索引,结束索引)

public static T[] copyOfRange(原数组,起始索引,结束索引)–>拷贝数组(指定范围)
细节:包头不包尾,包左不包右–>具体看举例

举例

		int[] arr1 = {1,3,2,6,5};
        int[] a = Arrays.copyOfRange(arr1, 0, 3);
        System.out.println(Arrays.toString(a));   //[1, 3, 2] ---> (范围为[0,2]|| [0,3))

fill(数组,元素)

public static void fill(数组,元素) -->填充数组 会覆盖先前的元素

举例:

		int[] arr1 = {1,3,2,6,5};
        Arrays.fill(arr1,4);
        System.out.println(Arrays.toString(arr1));//[4, 4, 4, 4, 4]

引用数据类型使用sort方法

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

    public GirlFriend() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return height
     */
    public double getHeight() {
        return height;
    }

    /**
     * 设置
     * @param height
     */
    public void setHeight(double height) {
        this.height = height;
    }

    public String toString() {
        return "GirlFriend{name = " + name + ", age = " + age + ", height = " + height + "}";
    }
}

import java.util.Arrays;

public class SortText1 {
    public static void main(String[] args) {
        GirlFriend gf1 = new GirlFriend("小a", 18, 1.68);
        GirlFriend gf2 = new GirlFriend("小b", 19, 1.72);
        GirlFriend gf3 = new GirlFriend("小c", 19, 1.65);

        GirlFriend[] arr = {gf1, gf2, gf3};

        Arrays.sort(arr, (GirlFriend o1, GirlFriend o2) -> {
            double temp = o1.getAge() - o2.getAge();
            temp = temp == 0 ? o1.getHeight() - o2.getHeight() : temp;
            temp = temp == 0 ? o1.getName().compareTo(o2.getName()) : temp;
            if (temp > 0) {
                return 1;
            } else if (temp < 0) {
                return -1;
            } else {
                return 0;
            }
        });

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

	1.年龄: GirFriend 对象按年龄升序排序
	2.身高:如果两个 GirlFriend 对象的年龄相同，那么按身高排序。
	3.名字: 如果两个 GirlFriend 对象的年龄和身高都相同，那么按名字的字母顺序排序(ASCII)