API_常用类

API

API：指的就是官方给开发人员提供的一个说明文档，对语言有哪些类，类中有什么方法进行说明

Object类

存放在java.lang.Object中存放，是java类体系中最顶层的类，每个类都使用Object作为超类（父类）。

Object可以表示java中任意的类。

toString()

Object类中定义有public String toString()方法，其返回值是 String 类型，描述当前对象的有关信息。

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

public class TestPerson {
    public static void main(String[] args) {
        Person person = new Person("张三",15);
        System.out.println(person);
    }

}

当输出一个对象时若类中没有重写toString()方法则会调用Object中的此方法进行输出

只有当你再重写你想要的输出格式的toString()方法后就会调用重写之后的输出格式

equals方法

此方法为判断两个对象是否相等

此方法的源码为

/*
==在用于基本类型比较时，比较的是变量的值是否相等，而在比较引用类型时，比较的则是对象的地址是否相等。
*/ 
public boolean equals(Object obj) {
        return (this == obj);
    }

如果只是这样的比较则可以使用"=="代替它，故在其它类中，一般都重写了equals()方法，把它改为比较对象的内容是否相等

如果类中没有重写equals方法则会在比较引用类型的对象时输出错误

public class Test1 {
    public static void main(String[] args) {
      Person person1 = new Person("张三",18);
      Person person2 = new Person("张三",18);
      System.out.println(person1.equals(person2));
    };
}

 若在Person类中没有重写equals方法则会显示false，所以必须在Person类中重写此方法才可以进行判断

@Override
    public boolean equals(Object obj) {
        if (obj instanceof Person){
            Person other = (Person) obj;
            return this.name.equals(other.name)&&this.age==other.age;
        }
        return false;
    }

通过这样重写则可以达到比较两个对象是否相等的要求

Arrays类

在与java.util.Arrays中存放。

toString()方法

返回指定数组的字符串表示形式

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

copyOf方法

数组复制,将指定数组中的元素复制到一个指定长度的新数组中,并返回新数组。

当自己定义的一个数组长度不够存放数据时可以使用此方法构造一个空间更大的数组

static int[] copyOf(int[] a, int newLength)//int[] a为原数组   newLength为新的数组长度

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

 

fill方法

将指定的int值分配给指定的int数组的每个元素。

fill(int[] a, int val) //a为原数组  val为替换的值

public class Test {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5}; //初始数组
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,0);//使用0替换数组a中的所有值
        System.out.println(Arrays.toString(a));

    }
}

 

sort方法

默认对数组进行升序排序

public static void sort(type[] a) //作用于数组的所有元素
public static void sort(type[] a, int fromIndex(包括), int
toIndex(不包括)) //将指定范围内的元素进行升序排序

public class Test {
    public static void main(String[] args) {
        int[] a = {22,21,65,41,32,12,10,69};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

 

如果对指定位置的元素进行排序则按照如下方法

public class Test {
    public static void main(String[] args) {
        int[] a = {22,21,65,41,32,12,10,69};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a,1,6);//包括位置1，不包括位置6
        System.out.println(Arrays.toString(a));
    }
}

如果是对一个类进行排序，那么这个类必须实现Comparable接口，指定一个排序的方法（这样所有的类就都可以进行排序了）

public class Student implements Comparable <Student>{
    private  String name;
    private  int id;

    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }

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

    @Override
    public int compareTo(Student o) {
        return this.id-o.id;  //使用id进行排序
        //return this.name.compareTo(o.name);这是使用姓名进行排序
    }
}

public class Test1 {
    public static void main(String[] args) {
        Student student1 =new Student("李四1",15);
        Student student2 =new Student("李四2",1);
        Student student3 =new Student("李四3",5);
        Student student4 =new Student("李四4",3);
        Student student5 =new Student("李四5",6);
        Student[] student = new Student[5];
        student[0] = student2;
        student[1] = student5;
        student[2] = student1;
        student[3] = student3;
        student[4] = student4;
        Arrays.sort(student);
        System.out.println(Arrays.toString(student));
    }
}

 

binarySearch()方法

使用二分搜索算法搜索指定数组，如果未找到则返回一个负数，如果找见则返回数组索引

使用二分法查找时需要先将数组升序排序，然后才可以使用二分法查找

publicstaticintbinarySearch(type[]a,typekey)
publicstaticintbinarySearch(long[]a,intfromIndex,int
toIndex,longkey)
/*
a-要搜索的数组。
key-要搜索的值。
fromIndex-要排序的第一个元素的索引（包括）。
toIndex-要排序的最后一个元素的索引（不包括）。
*/

public class Test {
    public static void main(String[] args) {
        int[] a = {22,21,65,41,32,12,10,69};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        int index = Arrays.binarySearch(a,12);
        System.out.println(index);
    }
}