Arrays类及该类中的方法[java]

⛳️基本概念

概述：用于操作数组的工具类，里面定义了常见操作数组的静态方法。

1.Arrays类中的方法都是静态方法，都是通过类名调用

2.都是静态方法，也就是说明了Arrays中的方法没有一个是重写的方法

Arrays类位于java.util包中：

java.util包中都是一些工具类，这些工具类大多都是静态方法

⛳️equals 方法

Arrays类中的equals(A a1,A a2 )方法中一次要传递两个参数(a1和a2)来进行比较

因为Arrays类中的所有方法都是静态的(包括equals()方法)，所以我们是通过类名进行调用的，因此就要传递两个参数进行比较，而Object类中(父类中)是通过对象名进行调用的equals方法(),也就是Object类中的equals方法是非静态的,所以我们就通过对象名调用,这个时候我们就只需要再找一个对象来和调用这个方法的对象比较

声明：public static boolean equals(type[]a,type[]a2)

● 参数的类型可以是基本数据类型和引用类型的任意一种类型。

● 返回：如果两个相等，则返回true，否则返回false

案例：

import java.util.Arrays;
public class EqualsDemo {
    /*
       Arrays类中包含了许多关于数组操作的静态方法
     */
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5};
        int[] b = {1,2,3,4,5};
        /*
            Arrays.equals(a, b) 比较数组中的内容是否相等
         */
        System.out.println(Arrays.equals(a, b));//true
    }
}

⛳️sort方法--排序

概述：将指定的类型（除boolean以外的任意基本数据类型）数组所有元素（或指定范围内的元素）按数字升序进行排序。

• object型数组，根据元素的自然顺序，对指定对象数组进行升序排序(fromIndex==toIndex，则排序范围为空)

1.作用于数组的所有元素

public static void sort(type[] a)

对指定类型的数组按数字升序进行排序

2.作用于数组指定范围内的元素

public static void sort(type[] a, int fromIndex(包括), int toIndex(不包括))

• (数组,开始排序的位置(fromIndex),结束排序的位置(toIndex)) 这里的开始排序的位置到结束排序的位置，是以左闭右开区间来排序

• 这里的方法其实在底层调用的方法相同,只是如果我们只传了一个数组名的话,就会将fromIndex默认为0,将toIndex默认为length-1;

案例：

import java.util.Arrays;
public class SortDemo1 {
    public static void main(String[] args) {
        int [] a = {5,3,4,2,1};
        Arrays.sort(a);//0, length-1  底层使用的是快速排序
        //将a数组对[0,3)这个区间进行排序
        Arrays.sort(a,0,3);//对某个区间排序 开始位置(包含),结束位置(不包含)
        System.out.println(Arrays.toString(a));
    }
}

3.自定义对象排序

自定义类实现Comparable接口，重写compareTo方法

如果我们要对一个自定义对象类型的数组进行排序,我们直接调用Arrays.sort()方法在这个方法中传递这个数组名可以吗?

答案是不可以，而且会报出一个运行时异常(ClassCastException(类型转换异常)),这里会说明我们自定义的这个类型的对象无法转型为Comparable类型。

那么为什么不能转型呢?

我们知道，引用类型的转型需要满足的第一个条件是什么?

是转型对象和目标对象要存在继承关系，那么也就是说明我们这个自定义类和Comparable没有继承或者实现关系，所以我们就要去继承或者去实现这个Comparable<泛型>

• 其实，Comparable<泛型>是一个接口

那么我们要能够转型成功,也就是要用这个自定义类实现Comparable<泛型>接口，实现这个接口后就可以转型成功了

但是要注意，我们实现了这个接口，并且我们这个自定义类不是一个抽象类，那么也就是说明我们必须要实现这个接口中的所有的抽象方法

那么我们要如何去实现这个接口中的抽象方法呢？

这里，这个抽象方法是: compareTo(<泛型> o); 这个方法的返回值是int型，返回值无非就是<0,=0,>0,通过这三种状态来判断我们比较的值哪个大哪个小，我们实现的接口中的<泛型>是什么类型的, 那么这个重写方法的<泛型>就是什么类型

而我们在重写这个方法时,我们要在这个方法体中来完成什么事情呢?

我们知道compareTo()方法就是判断前后两个数的大小，所以我们要做的就是返回对象的属性之间的一个差值，也就是做一个减法，但是做减法只有基本数据类型中的一部分数据类型可以做减法，像字符串就做不了减法，那么这个时候我们可以直接调用字符串中的compareTo()方法

为什么字符串有compareTo()方法呢?

因为String类已经实现了Comparable接口了，这里由于已经是确定了要比较字符串类型的值，那么这里的泛型就应该是，并且肯定也已经实现了compareTO()方法

案例：

import java.util.Arrays;
public class SortDemo2 {
    public static void main(String[] args) {
         /*
          数组
          */
         User user1 = new User(1,"123456","111111");
         User user2 = new User(2,"123457","111111");
         User user3 = new User(3,"123458","111111");
         User user4 = new User(4,"123454","111111");
         User user5 = new User(5,"123459","111111");
        /*
         创建User类型数组
         */
        User[]  users = new User[]{user1,user5,user4,user2,user3};
        Arrays.sort(users);
        System.out.println(Arrays.toString(users));
​
        String [] strings = {"b","a","c","d"};
        Arrays.sort(strings);
        System.out.println(Arrays.toString(strings));
    }
}

public class User implements Comparable{
        private int id;
        private String account;
        private String password;
    public User(int id, String account, String password) {
        this.id = id;
        this.account = account;
        this.password = password;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getAccount() {
        return account;
    }
    public void setAccount(String account) {
        this.account = account;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", account='" + account + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
    /*
       为我们的引用类型提供一个自定义排序规则,
       方法会在Arrays类中的sort()方法底层调用
       结果是用来判断大小  小于0  等于0  大于0
     */
    @Override
    public int compareTo(User o) {
       //return this.id-o.id;  按id排序
       return this.account.compareTo(o.account);
    }
}

⛳️binarySearch -使用二分搜索算法搜索指定数组

1.描述：使用二分搜索算法搜索指定的type型数组，以获得指定的值。

• 在调用这个方法前，我们一定要先为数组排好序

• 该方法的返回值为int类型

  • 如果查询到了(返回一个非负数),那么就会返回这个查询值在数组中的索引

  • 如果查询不到(返回一个负数),那么就会返回这个查询值应该在这个数组的位置(也就是返回 -(low+1))

2.声明：

public static int binarySearch(type[] a, type key)
public static int binarySearch(long[] a,int fromIndex,int toIndex,long key)

参数：

• a - 要搜索的数组。 key - 要搜索的值。 fromIndex - 要排序的第一个元素的索引(包括）。 toIndex - 要排序的最后一个元素的索引(不包括）。

• 类型：byte、double、float、object、long、int、short、char

案例：

import java.util.Arrays;
public class BinarySearchDemo {
     public static void main(String[] args) {
        int [] a = {8,2,7,4,5,6,3,1,9};
        /*
          二分查找法(折半查找)  前提: 有序的
           1,2,3,4,5,6,7,8,9
         */
        Arrays.sort(a);//先用sort方法进行排序
        //在整个数组搜索(这里a是该数组，3是我们想要查找的值)
        System.out.println(Arrays.binarySearch(a, 3));//返回负数表示没有找到
        //在指定区间搜索(在[0,6)这个区间中查找3)
        System.out.println(Arrays.binarySearch(a,0,6,3));
    }
}

为什么总是左闭右开区间?

因为我们默认遍历总是从0遍历到length-1,而这些重载方法在基层可能是以同一种方式来解决问题的,所以一般传进来toIndex也是遍历到toIndex-1的位置,所以就是左闭右开区间。

⛳️copyOf()

功能：返回一个新的数组，并将原数组复制到新数组中

• 这种功能也叫做扩容

• 这个方法的返回值是一个数组类型

• 该方法需要传入两个参数,第一个是传入原数组名,第二个是传入新数组长度

案例：

import java.lang.reflect.Array;
import java.util.Arrays;
​
public class CopyOfDemo {
    public static void main(String[] args) {
        int[] a={1,2,3,4,5};
        /*
          数组赋值，传入原数组，新数组长度
          返回一个新数组 并将原数组值复制到新数组中
         */
        int [] b = Arrays.copyOf(a,10);
        System.out.println(Arrays.toString(b));
    }
}

⛳️toString() 方法

描述：将指定数组内容以字符串形式返回

1.声明：public static String toString(type[] a)

• 该方法的返回值为字符串类型

• 该方法没有参数，所以就不需要传递参数

2.基本数组，字符串表示形式由数组的元素列表组成，括在[]，相邻元素用“, ”(逗号加空格)分隔。

3.功能:toString()方法返回的是对象的字符串表示(返回的字符串为:包名.类名@哈希码值的十六进制形式)

• 如果想要返回一些更有意义的数据，就需要我们去重写toSting()方法

例如：

public String toString(){
   return "dog[color="+getColor+",name="+getName+"]"
}

以后我们就可以使用toSting()方法来代替show()方法来打印信息，其实也就是通过在类中重写toSting()方法来代替了show()方法。

toString()方法在使用中的两个特例:

1.当System.out.println()中使用了字符串内容与引用相连接时,这个引用会自动调用toString()方法

例如：

System.out.println("s1="+s1);//这里的s1是一个对象,也就是一个引用(这个引用指向了一个实例化对象)
//那么这里会自动通过s1对象调用toString()方法来得到结果
//如果没有进行重写那么这里就会输出 这个包名.类名@这个对象(也就是s1)的哈希码值
//哈希码值:就是这个对象储存地址的编码,而不是这个对象的存储地址

2.当调用println()方法或者print()方法打印引用时,这个引用会自动调用toString()方法

例如：

System.out.println(s1);//这里会输出s1的字符串表示,也就是所在包名.类名@s1对象的哈希码值

这两个特征可以归结为一句话:

java在使用System.out.println()打印对象时，或者打印对象连接字符串时，都会默认调用toString()方法，如果没有重写toString()方法,那么就会输出对象的字符串表示(也就是包名.类名@对象哈希码值(哈希码值也就是对象的内存地址编码,但不是内存地址))