概述：用于操作数组的工具类，里面定义了常见操作数组的静态方法。
1.Arrays类中的方法都是静态方法，都是通过类名调用
2.都是静态方法，也就是说明了Arrays中的方法没有一个是重写的方法
Arrays类位于java.util包中：
java.util包中都是一些工具类，这些工具类大多都是静态方法
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
}
}概述：将指定的类型（除boolean以外的任意基本数据类型）数组所有元素（或指定范围内的元素）按数字升序进行排序。
object型数组，根据元素的自然顺序，对指定对象数组进行升序排序(fromIndex==toIndex，则排序范围为空)
public static void sort(type[] a)
对指定类型的数组按数字升序进行排序
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));
}
}自定义类实现Comparable接口，重写compareTo方法
如果我们要对一个自定义对象类型的数组进行排序,我们直接调用Arrays.sort()方法在这个方法中传递这个数组名可以吗?
答案是不可以，而且会报出一个运行时异常(ClassCastException(类型转换异常)),这里会说明我们自定义的这个类型的对象无法转型为Comparable类型。
那么为什么不能转型呢?
我们知道，引用类型的转型需要满足的第一个条件是什么?
是转型对象和目标对象要存在继承关系，那么也就是说明我们这个自定义类和Comparable没有继承或者实现关系，所以我们就要去继承或者去实现这个Comparable<泛型>
其实，Comparable<泛型>是一个接口
那么我们要能够转型成功,也就是要用这个自定义类实现Comparable<泛型>接口，实现这个接口后就可以转型成功了
但是要注意，我们实现了这个接口，并且我们这个自定义类不是一个抽象类，那么也就是说明我们必须要实现这个接口中的所有的抽象方法
那么我们要如何去实现这个接口中的抽象方法呢？
这里，这个抽象方法是: compareTo(<泛型> o); 这个方法的返回值是int型，返回值无非就是<0,=0,>0,通过这三种状态来判断我们比较的值哪个大哪个小，我们实现的接口中的<泛型>是什么类型的, 那么这个重写方法的<泛型>就是什么类型
而我们在重写这个方法时,我们要在这个方法体中来完成什么事情呢?
我们知道compareTo()方法就是判断前后两个数的大小，所以我们要做的就是返回对象的属性之间的一个差值，也就是做一个减法，但是做减法只有基本数据类型中的一部分数据类型可以做减法，像字符串就做不了减法，那么这个时候我们可以直接调用字符串中的compareTo()方法
为什么字符串有compareTo()方法呢?
因为String类已经实现了Comparable接口了，这里由于已经是确定了要比较字符串类型的值，那么这里的泛型就应该是<String 0>，并且肯定也已经实现了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<User>{
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);
}
}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的位置,所以就是左闭右开区间。
这种功能也叫做扩容
这个方法的返回值是一个数组类型
该方法需要传入两个参数,第一个是传入原数组名,第二个是传入新数组长度
案例：
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));
}
}描述：将指定数组内容以字符串形式返回
1.声明：public static String toString(type[] a)
该方法的返回值为字符串类型
该方法没有参数，所以就不需要传递参数
2.基本数组，字符串表示形式由数组的元素列表组成，括在[]，相邻元素用“, ”(逗号加空格)分隔。
3.功能:toString()方法返回的是对象的字符串表示(返回的字符串为:包名.类名@哈希码值的十六进制形式)
如果想要返回一些更有意义的数据，就需要我们去重写toSting()方法
例如：
public String toString(){
return "dog[color="+getColor+",name="+getName+"]"
}以后我们就可以使用toSting()方法来代替show()方法来打印信息，其实也就是通过在类中重写toSting()方法来代替了show()方法。
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()方法,那么就会输出对象的字符串表示(也就是包名.类名@对象哈希码值(哈希码值也就是对象的内存地址编码,但不是内存地址))