API常用类之Arrays类

java.util.Arrays类

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

equals 方法

比较两个非同一数组是否相等，而数组本身的equals判断另一个数组是否它本身。

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

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

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

public class ArraysDemo1 {

    public static void main(String[] args) {
        int []a={1,5,3,4,2,8};
        int []b={2,4,1,6,7,8,4};
        int []a1={1,3,5,4,2,8};
        //比较数组中的内容
        System.out.println(Arrays.equals(a,b));
        //数组中的元素进行排序
        Arrays.sort(a,0,3);
        //重写
        System.out.println(Arrays.toString(a));



    }
}

当我们创建一个对象（new Object）时，就会调用对象的构造函数来开辟空间，将对象数据存储到堆内存中，然后再在栈内存中生成相对应的引用，在后面使用创建的对象名进行函数的调用时用的都是栈内存中引用的对象。还需注意的一点，基本数据类型是存储在栈内存中。基础数据类型使用==进行比较

equals与==的区别

==是判断两个变量或实例是不是指向同一个内存空间，equals是判断两个变量或实例所指向的内存空间的值是不是相同

==是指对内存地址进行比较 ， equals()是对字符串的内容进行比较（重写过后的equals，没重写前的equals方法返回的依然是地址比较（==））

==指引用是否相同（地址是否相同）， equals()指的是值是否相同

有两种数据类型：基本数据类型和引用数据类型，基本数据类型在栈中数据存放在栈内存中，引用数据类型数据存放在堆内存中。

public class Week1 {
    public static void main(String[] args) {
        int a=10;
        int b=10;
        //int类型为基础数据类型，因此直接在栈内存中调用，a和b指向的都是同一地址。
        System.out.println(a==b);

        Cat c1=new Cat("小黑",3);
        Cat c2=new Cat("小黑",3);
        Cat c3=c2;
        //Cat类中还未重写equals（），那么调用Cat类继承的Object类
        //在Object类中默认equals方法返回的是“c1==c2”所以返回的是false
        //虽然类中的内容相同，但仍然返回false
        /*
        public boolean equals(Object obj){
            return (this==obj);
        }
         */
        System.out.println(c1.equals(c2));
        //指向的地址相同
        System.out.println(c2.equals(c3));
        /*
        字符串类中重写了Object类的equals() 实现是比较两个字符串中每一个字母是否相等
        所以一般默认为equals（）方法比较的是对象中内容是否相等
         */
        String s1 =new String("abc");
        String s2 =new String("abc");
        System.out.println(s1.equals(s2));

    }
}

compareTo()方法

1.返回参与比较的前后两个字符串的asc码的差值，若这两个字符串的首字母的asc码值不同，那么此方法返回的就是首字母的asc码的差值。

2.如果两个字符串不一样长，可参与比较的字符又完全一样，则返回两个字符串的长度差值

3.如果参与比较的两个字符串首字符相同，就会比较下一个字符，直到有不同的为止，返回此不同的字符的asc码的差值。

4.返回值为正数表示a1>a2,返回为负数表示a1<a2，返回值为0表示相等（因此可以通过compareTo()方法和sort()方法进行排序）

5.数字类型不需要使用comparaTo,int与int的比较不能用compareTo方法，直接用大于（>）,小于（>）或者等于和不等于来比较即可。（在自定义的类中重写comparaTo方法，若传入参数为int类型，也可以进行排序）

public class test {
    public static voidmain(String[] args) {
        Bank bank1=new Bank("123",4,"xie");
        Bank bank2=new Bank("234",7,"xie");
        System.out.println(bank1.compareTo(bank2));//若直接进行对象的比较直接调用实现过的方法
        System.out.println(bank1.getName().compareTo(bank2.getName()));//直接使用compareTo方法进行比较
    }
}

Comparable接口的实现与使用

Comparable接口的用法在Arrays类中，就一个，Arrays.sort()方法（进行对象数组的排序）

在自定义的类中实现了Comparable接口。

重写comparaTo()方法时，如果比较的元素类型是int类型，那么就直接相减就可以了，其他的类型可以使用comparaTo()方法来应用。

//泛化，实现比较的接口
public class Bank implements Comparable<Bank> {
   private String count;
    private int id;
    private String name;
    public Bank(String count,int id,String name){
        this.count=count;
        this.id=id;
        this.name=name;
    }
     /*
       为我们的引用类型提供一个自定义排序规则,
       方法会在Arrays类中的sort()方法底层调用
       结果是用来判断大小  小于0  等于0  大于0
     */
     @Override
    public int compareTo(Bank o) {
        return this.count.compareTo(o.count);
      }
   }

public class ArraysDemo2 {
    public static void main(String[] args) {
        Bank b1=new Bank("12345",1,"xie");
        Bank b2=new Bank("23456",2,"wen");
        Bank b3=new Bank("34567",3,"xuan");
        Bank b4=new Bank("56789",4,"xiewen");
        Bank [] banks=new Bank[]{b1,b3,b2,b4};
        Arrays.sort(banks);//在原数组上进行比较，也可以b1.compareTo(b2)进行比较
        System.out.println(Arrays.toString(banks));

    }

}

sort()方法

对数组中的元素进行排序

public class ArraysDemo1 {

    public static void main(String[] args) {
        int []a={1,5,3,4,2,8};
        int []b={2,4,1,6,7,8,4};
        int []a1={1,3,5,4,2,8};

        //数组中的元素进行排序
        Arrays.sort(a,0,3);
        //重写
        System.out.println(Arrays.toString(a));
    }
}

toString()方法

toString()方法返回反映这个对象的字符串

调用时使用Arrays.toString()方法，常用方法为将数组转化为字符串

public class Demo{  public static void main(String[] args){        
        String[] arrs=new String[]{"a","b","c","d","e"}; //若直接输出数组       
       System.out.println(arrs);//输出的为数组的首地址       
       System.out.println(Arrays.toString(arrs));//输出的是字符串  
      }
 }

当然也可以通过重写tostring()方法来输出链表等结构的内容（由字符串形式）

copyOf()方法

copyOf()方法向方法传入一个数组为原数组，将原数组的值赋给新数组，可以赋给新数组一个新的长度，返回的为一个新数组。

public class Demo{
   public static void mian(String[] args){
       int[] a={1,2,3,4,5};
       
       int[] b=Arrays.copyOf(a,10);
       System.out.println(Arrays.toString(b));
   }
}

binarySearch()方法

二分查找法（折半查找） 前提：有序的

public class Demo{  
public static void mian(String[] args){        
    //有序数组        
    int[] a={1,2,3,4,5,6,7};        
    //无序数组       
    int[] b={2,1,4,5,3,5,6};        
    //无序数组需要先排序后，再使用binarySearch()方法，若不使用sort()方法，无序使用binarySearch()方法，可能会返回负数        
    Arrays.sort(b);//进行元素排序，不需要重写compareTo()方法         
    System.out.println(Arrays.binarySearch(b,3));//返回值为2         
    System.out.println(Arrays.binarySearch(a,3));//返回值为2         
    System.out.println(Arrays.binarySearch(a,0,4,3));//返回值为2        
//若找到返回元素位置，若未找到，return -(low + 1);   
     }
 }