Java-Arrays类

基本介绍

Arrays类里面包含了一系列静态方法，用于管理或操作数组

Arrays类常见方法

1)toString()方法，返回数组的字符串形式

    Arrays.toString(arr);

2)sort()方法，排序（自然排序和定制排序）

    Integer arr[] = {1,-1,7,0,89};

package com.pero.arrays_;

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

/**
 * @author Pero
 * @version 1.0
 */
public class ArraysMethod {
    public static void main(String[] args) {
        //1.使用Arrays.toString方法,显示数组
        Integer[] array = {1,2,3,4,5,6};
        System.out.println(Arrays.toString(array));

        //2.使用Array.sort()方法（默认为从小到大排序），进行数组排序
        //  因为数组是引用类型，所以通过sort()方法排序后，会直接影响到实参
        //  sort()方法是重载的方法，也可以通过传入一个接口Comparator实现定制排序
        //  调用定制排序时，传入了两个参数①排序数组；
        //  ②实现了Comparator接口的匿名内部类，要求实现compare()方法
        //  源码分析：
        //  （1）Arrays.sort(arr, new Comparator()
        //  （2）最终到TimSort类的private static <T> void binarySort(T[] a, int lo, int hi, int start,
        //                                       Comparator<? super T> c)
        //  （3）执行到binarySort()方法的代码，会根据动态绑定机制 c.compare()执行传入的匿名内部类的compare()方法
        //  while (left < right) {
        //                int mid = (left + right) >>> 1;
        //                if (c.compare(pivot, a[mid]) < 0)
        //                    right = mid;
        //                else
        //                    left = mid + 1;
        //            }
        //  （4）new Comparator() {
        //            @Override
        //            public int compare(Object o1, Object o2) {
        //                Integer i1 = (Integer) o1;
        //                Integer i2 = (Integer) o2;
        //                return i1 - i2;
        //            }
        //        });
        //  （5）public int compare(Object o1, Object o2) 返回的值是大于0，还是小于0，会影响整个排序结果
        //      非常灵活，冲锋体现了接口编程+动态绑定+匿名内部类的综合使用，在底层框架和源码的使用方式非常常见
        Integer[] arr = {5,4,2,3,1,8,9};
//        Arrays.sort(arr);
        Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                return i1 - i2;
            }
        });
        System.out.println(Arrays.toString(arr));
    }
}

★自写定制排序 

package com.pero.arrays_;

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

/**
 * @author Pero
 * @version 1.0
 */
public class ArraysSortCustom {
    public static void main(String[] args) {

        int[] arr = {2,5,1,-3,8,7};
        //bubble01(arr);
        bubble02(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //向下转型才能体现动态绑定
                int i1 = (Integer) o1;  //拆箱
                int i2 = (Integer) o2;
                return i2 - i1;  //i1 - i2;
            }
        });
        System.out.println(Arrays.toString(arr));

    }

    //使用冒泡排序
    public static void bubble01(int[] a){
        for (int i = 0; i < a.length -1; i++) {
            for (int j = 0; j < a.length -1 -i; j++) {
                if(a[j] > a[j+1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
    }

    //结合冒泡排序+定制模式
    public static void bubble02(int[] a, Comparator comparator){
        for (int i = 0; i < a.length -1; i++) {
            for (int j = 0; j < a.length -1 -i; j++) {
                if(comparator.compare(a[j],a[j+1])>0){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
    }
}

3)binarySearch()方法，通过二分搜索法进行查找，要求必须排好顺序

   int index = Arrays.binarySearch(arr,3);

4)copyOf()方法，数组元素的复制

   Integer[] newArr = Arrays.copyOf(arr,arr.length);

5)fill()方法，数组元素的填充

   integer[] num = new Integer[]{9,3,2};

   Arrays.fill(num,99);

6)equals()方法，比较两个数组元素内容是否完全一致

   boolean equals = Arrays.equals(arr1,arr2)

7)asList()方法，将一组值转换成list

   List<Integer> asList = Array.asList(2,3,4,5,6,7);

   System.out.println("asList="+asList);

package com.pero.arrays_;


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

/**
 * @author Pero
 * @version 1.0
 */
public class ArraysMethod02 {
    public static void main(String[] args) {

        Integer[] arr = {8,-5,-3,5,6,1,7};

        Arrays.sort(arr,new Comparator(){
            public int compare(Object o1,Object o2){
                int i1 = (Integer) o1;
                int i2 = (Integer) o2;
                return i1 -i2;
            }
        });

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

        //binarySearch 通过二分搜索法进行查找，要求必须排好顺序
        //如果是无序的那么就无法使用binarySearch方法
        //如果找不到该数字则返回return -(low + 1);
        // low是指如果该元素存在，其所在数组中的位置的索引
        int index = Arrays.binarySearch(arr,9);
        System.out.println(index);

        //copyOf()方法，数组元素的复制
        //1.从arr数组中，拷贝arr.length个元素到newArr数组中
        //2.如果拷贝的长度大于被拷贝的数组的长度，则后续用null填充后续空间
        //3.如果拷贝长度小于0则抛出异常NegativeArraySizeException
        Integer[] newArr = Arrays.copyOf(arr,arr.length);
        System.out.println(Arrays.toString(newArr));

        //fill()方法，数组元素的填充
        //1.用指定的数字填充被填充的数组（替换原数组中的所有元素）
        Integer[] num = new Integer[]{9,3,2};
        Arrays.fill(num,10);
        System.out.println(Arrays.toString(num));

        //equals()方法，比较两个数组是否完全相同
        Integer[] arr1 = new Integer[]{1,2,3};
        Integer[] arr2 = new Integer[]{1,2,3};
        boolean equals = Arrays.equals(arr1,arr2);
        System.out.println(equals);

        //asList()方法，将一组值转换成list
        //asList()，会将(1,2,3,4,5,6)数据转成一个List集合
        //2.返回asList 编译类型 List(接口)
        //3.asList 运行类型 java.util.Arrays#ArrayList (Arrays类中的ArrayList静态内部类)
        List<Integer> asList = Arrays.asList(1,2,3,4,5,6);
        System.out.println("asList=" + asList);
        System.out.println("asList的运行类型："+asList.getClass());
    }
}