JAVA 一篇文章让你学会Arrays方法

一、常用方法

Arrays里面包含了一系列静态方法，用于管理或操作数组(比如排序和搜索)

1）toString 返回数组的字符串形式

Arrays.toString(arr)

2）sort 排序(自然排序和定制排序)

Integer arrl= {1,-1,7,0,89};

Arrays.sort()的使用方法以及原理

1.基本数据类型

(1)数字类型:

    int[] a = {1, 3, 4, 67, 78, 9, 90, 6, 3, 2};
    Arrays.sort(a);//对数组进行排序
    System.out.println(Arrays.toString(a));//遍历并输出整个数组

数字类型很简单了,就是从小到大排序(浮点类型与整形同理),

输出结果如下:

[1, 2, 3, 3, 4, 6, 9, 67, 78, 90]

(2)字符串类型:

    String[] strArray = new String[]{"hello","Hello", "Hello kity", "hello kity","D","w","A","z"};
    Arrays.sort(strArray);
    System.out.println(Arrays.toString(strArray));

运行结果如下:

[A, D, Hello, Hello kity, hello, hello kity, w, z]

对于字符串类型的数组,sort()则是将字符串的开头字母进行排序,排列顺序为:

大写在小写前,从A~Z依次往下排,若第一位相同则比较第二位,规则相同,若第三位也相同,依次往下比较.

还有一种按照字母表排序,忽略大小写的方式

    String[] strArray = new String[]{"hello","Hello", "Hello kity", "hello kity","D","w","A","z"};
    Arrays.sort(strArray ,String.CASE_INSENSITIVE_ORDER);
    System.out.println(Arrays.toString(strArray));

运行结果如下:

[A, D, hello, Hello, Hello kity, hello kity, w, z]

2.对象数组

对象怎么进行排序呢?这时候就需要我们自己制定排序规则了(比如说,给student对象排序,是将学号id进行排序),但是如果是每个不同的类型的对象,我们都需要去分析数据,自己手动敲规则的话,过于麻烦.所以我们用到Comparable或者Comparator接口.

拿Comparator为例,里面有个方法

int compare(T o1,T o2);

用法举例说明:

public class Student  {
    private int id;
    private int age;
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", age=" + age +
                '}';
    }
    public Student(int id, int age){
        this.id = id;
        this.age = age;
    }
//通过id排序
    public static class SortById implements Comparator<Student>{
        @Override
        public int compare(Student o1, Student o2) {
            return o1.id - o2.id;
        }
    }
//通过age排序
    public static class SortByAge implements Comparator<Student>{
        @Override
        public int compare(Student o1, Student o2) {
            return o1.age - o2.age;
        }
    }
    public static void main(String[] args) {
        Student s1 = new Student(11110,13);
        Student s2 = new Student(11112,12);
        Student[] ss = {s1, s2};
        Arrays.sort(ss,new SortById());
        for (Student s : ss) {
            System.out.print(s);
        }
        System.out.println();
        Arrays.sort(ss,new SortByAge());
        for (Student s : ss) {
            System.out.print(s);
        }
    }
}

运行结果如下:

Student {id=11110, age=13}Student{id=11112, age=12}
Student {id=11112, age=12}Student{id=11110, age=13}

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

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

import java.util.Arrays;
import java.util.Comparator;
​
public class Main {
    public static void main(String[] args) {
        Integer[] integers = {1, 90, 30, 20};
​
        //直接使用Arrays.toString()方法
        System.out.println(Arrays.toString(integers));
​
        //默认排序
        //因为数组是引用类型，所以通过sort排序后，会直接影响到实参arr
        //sort是重载的，也可以通过再传入一个接口
        Arrays.sort(integers);
        System.out.println(Arrays.toString(integers));
​
        //定制排序
        //传入两个参数
        //（1）排序的数组 integers
        //（2）实现 Compare 方法 接口编程的方式
        //源码分析
        //(1)Arrays.sort(arr, new Comparator()
        //(2)最终到 TimSort类的 private static <T> void binarySort(T[] a, int lo1Comparator<? 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(){
        //@0verride
        //        public int compare(0bject o1，0bject o2)
        //        Integer i1=(Integer)o1;
        //        Integer i2=(Integer)o2;
        //        return i2-i1;
        //(5)public int compare(Object o1,Object o2) 返回的值>0还是<0 会影响整个排序结果

        Arrays.sort(integers, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                Integer i1 = (Integer) o1;//o1是传入数组里面的数
                Integer i2 = (Integer) o2;//o2是 -1
                return i2 - i1;//< 0从大到小排序 > 0从小到大排序
            }
        });
        System.out.println(Arrays.toString(integers));//这样会使从大到小排序
​
    }
}

二、Arrays模拟排序 详解

import java.util.Arrays;
import java.util.Comparator;
​
public class Main {
    public static void main(String[] args) {
        int[] arr = {1, -1, 8, 0, 20};
        //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;// return i2 - i1;
            }
        });
​
        System.out.println("==定制排序后的情况==");
        System.out.println(Arrays.toString(arr));
    }
​
    //使用冒泡完成排序
    public static void bubble01(int[] arr) {
        int temp = 0;
        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]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
​
    //结合冒泡 + 定制
    public static void bubble02(int[] arr, Comparator c) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //数组排序由 c.compare(arr[j], arr[j + 1])返回的值决定
                if (c.compare(arr[j], arr[j + 1]) > 0) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

三、Arrays其他方法

1.copyOf 数组元素的复制

2.fill 数组元素的填充

3.equals 比较两个数组元素内容是否完全一致

4.asList 将一组值，转换成 list

import java.util.Arrays;
import java.util.List;
​
public class ArraysMethod02 {
    public static void main(String[] args) {
        Integer[] arr = {1, 2, 90, 123, 567};
        // binarySearch 通过二分搜索法进行查找，要求必须排好
        // 解读
        // 1. 使用 binarySearch 二叉查找
        // 2. 要求该数组是有序的. 如果该数组是无序的，不能使用 binarySearch
        // 3. 如果数组中不存在该元素，就返回 return -(low + 1); 
        // key not found. 
        int index = Arrays.binarySearch(arr, 93);//low=4 - 1
        System.out.println("index=" + index);
​
        //copyOf 数组元素的复制
        // 解读
        // 1. 从 arr 数组中，拷贝 arr.length 个元素到 newArr 数组中
        // 2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
        // 3. 如果拷贝长度 < 0 就抛出异常 NegativeArraySizeException
        // 4. 该方法的底层使用的是 System.arraycopy()
        Integer[] newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("==拷贝执行完毕后==");
        System.out.println(Arrays.toString(newArr));
        
        //fill 数组元素的填充
        Integer[] num = new Integer[]{9, 3, 2};
        //解读
        // 1. 使用 99 去填充 num 数组，可以理解成是替换原理的元素
        Arrays.fill(num, 99);
        System.out.println("==num 数组填充后==");
        System.out.println(Arrays.toString(num));
        
        //equals 比较两个数组元素内容是否完全一致
        Integer[] arr2 = {1, 2, 90, 123};
        //解读
        // 1. 如果 arr 和 arr2 数组的元素一样，则方法 true;
        // 2. 如果不是完全一样，就返回 false
        boolean equals = Arrays.equals(arr, arr2);
        System.out.println("equals=" + equals);
        
        //asList 将一组值，转换成 list
        // 解读
        // 1. asList 方法，会将 (2,3,4,5,6,1)数据转成一个 List 集合
        // 2. 返回的 asList 编译类型 List(接口)
        // 3. asList 运行类型 java.util.Arrays#ArrayList, 是 Arrays 类的
        // 静态内部类 private static class ArrayList<E> extends AbstractList<E>
        // implements RandomAccess, java.io.Serializable
        List asList = Arrays.asList(2, 3, 4, 5, 6, 1);
        System.out.println("asList=" + asList);
        System.out.println("asList 的运行类型" + asList.getClass());
    }
}

5.toCharArray()的用法:是将字符串对象中的字符转换为一个字符数组;

public class Demo{
    public static void main(String[] args) {
        String str = "Hello, world!";
        char[] charArray = str.toCharArray();
​
        // 输出字符数组中的每个字符
        for (char c : charArray) {
            System.out.println(c);
        }
    }
}

结果如下：