第五章.常用类.java.API概述——object类(toString方法，equals方法)；Arrays类（equals方法，sort方法，binarysearch方法，copeof方法）

1.java.API概述

直译为应用程序编程接口

API——java语言中实际提供的类与接口

API文档——对java中提供的类和接口中的功能进行说明的文档

2.object类

2.1toString（）方法

以此为案例

public static void main(String[] args) {
        Car car=new Car("迈巴赫",880000);
        System.out.println(car);
    }

输出一个对象时，如果类中无toString（）方法，默认调用object类中toString（）方法，输出为这个对象的地址。

如果想要让对象以字符串的形式输出，那么需要重写toString（）

 @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

输出结果为：

 2.2equals（）方法

使用形式：对象1.equals(对象2）

判断对象1是否等于对象2，如果是的话，返回true，如果不是，返回false

object类中的equals（）等同于"=="

用于基本数据类型时：判断值是否相等

用于引用类型时：判断地址是否相等

此处为引用类型

 public static void main(String[] args) {
        Car car1=new Car("玛莎拉蒂",400000);
        Car car2=new Car("玛莎拉蒂",400000);
        System.out.println(car1.equals(car2));
        System.out.println(car1==car2);
}


输出结果：false
         false

如果是对字符串进行操作，即String类；

    public static void main(String[] args) {  
        String s1=new String();
        String s2=new String();
        System.out.println(s1.equals(s2));
       
}

输出结果为：true

String类中已经对equals方法进行了重写，此时的equals（）方法的作用是判断字符串中每一个字符是否相等，是返回true，不是则返回false

重写的equals（）方法为：

public boolean equals(Object anObject) {
            if (this == anObject) {
                return true;
            }
            if (anObject instanceof String) {
                String aString = (String)anObject;
                if (coder() == aString.coder()) {
                    return isLatin1() ? StringLatin1.equals(value, aString.value)
                            : StringUTF16.equals(value, aString.value);
                }
            }
            return false;
        }

3.Arrays类

包含操作数组的各种方法

3.1equals方法

比较数组中的内容是否相同：

代码实现：

import java.util.Arrays;

public class EqualsDoem1 {
    public static void main(String[] args) {
        int []a={1,2,3,4,5};
        int []b={1,2,3,4,5};
        System.out.println(Arrays.equals(a,b));
    }

}


输出结果：true

相同则返回true，不同则返回false；

3.2sort方法

1）对基本类型数组进行排序

代码实现：

import java.util.Arrays;

public class SortDome2 {
    public static void main(String[] args) {
        int[]a={2,4,5,3,1};
        System.out.println(a);
        //输出的是一串地址
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

    }
}


输出结果：[I@b4c966a
         1,2,3,4,5

2）分段排序

sort方法中还有一种形如此类的方法 Arrays.sort(a,0,4);

0为开始排序的下标（包括下标为0元素），4为结束排序的下标（不包括下标为4的元素），即就是只对下标前4位元素排序；

代码实现：

import java.util.Arrays;

public class SortDome2 {
    public static void main(String[] args) {
        int[]a={2,4,5,3,1};
        Arrays.sort(a,0,4);
        //分段排序
        System.out.println(Arrays.toString(a));
        //通过调用toString方法输出数组的内容
      

    }
}


输出结果：2,3,4,5,1

3）对引用类型数组进行排序

对引用类型数组来说，需要重写toString方法，且常规的toString方法会报错。

则必须通过实现接口 Comparable<>来实现，还需要重写public int compareTo(SortDome1 o){}方法，才能调用sort方法对数组进行排序。

代码实现：

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

public class SortDome1 implements Comparable<SortDome1> {
    private  int id;
    private int count;
    private String mima;
    public SortDome1(int id,int count,String mima){
        this.count=count;
        this.id=id;
        this.mima=mima;
    }

    public static void main(String[] args) {
        SortDome1 users1=new SortDome1(1,4568,"6782");
        SortDome1 users2=new SortDome1(5,6456,"6783");
        SortDome1 users5=new SortDome1(4,4565,"6781");
        SortDome1 users3=new SortDome1(3,4756,"6784");
        SortDome1 users4=new SortDome1(2,4586,"6785");
        SortDome1[]users={users5,users1,users3,users2,users4};
//创建一个名为users的引用类型数组
        System.out.println(Arrays.toString(users));
        Arrays.sort(users);
//输出排序之后的数组
        System.out.println(Arrays.toString(users));
    }

    @Override
    public int compareTo(SortDome1 o) {
        return this.id-o.id;
//按id顺序排列
    }
}


输出结果为：
[SortDome1{id=4, count=4565, mima='6781'}, SortDome1{id=1, count=4568, mima='6782'}, SortDome1{id=3, count=4756, mima='6784'}, SortDome1{id=5, count=6456, mima='6783'}, SortDome1{id=2, count=4586, mima='6785'}]
[SortDome1{id=1, count=4568, mima='6782'}, SortDome1{id=2, count=4586, mima='6785'}, SortDome1{id=3, count=4756, mima='6784'}, SortDome1{id=4, count=4565, mima='6781'}, SortDome1{id=5, count=6456, mima='6783'}]

 3.3binarysearch方法

binarysearch（）即就是二分查找法（折半查找）

使用格式为：

Arrays.binarySearch(a,5)

 a为数组名，5为需要查找的元素

前提是数组必须是一个有序的数组

如果不是有序数组可先通过Arrays.sort()方法完成排序，再进行查找

代码实现：

import java.util.Arrays;
//二分查找法——Arrays.binarySearch(数组名，需要查找的数）；
public class BinarysearchDome {
    public static void main(String[] args) {
        int []a={4,5,2,3,2,1,8,6};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        System.out.println( Arrays.binarySearch(a,5));
    }
}

3.4copeof方法

copeof可以被称作数组复制法；

使用格式为：a为被复制的数组名

int []a={1,4,5,2,4,8,6};
int[]b= Arrays.copyOf(a,15);

返回一个新数组，并将原来的数组复制到新数组，可用于扩展数组

代码实现：

import java.util.Arrays;

public class CopeofDome {
    public static void main(String[] args) {
        int []a={1,4,5,2,4,8,6};
        //普通的扩容方式
        //int []b=new int[10];
        int[]b= Arrays.copyOf(a,15);
        System.out.println(Arrays.toString(b));
    }
}