第五章 API（一）

Java API概述

●API(Application Programming Interface)应用程序编程接口

● 是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明

基本数据类型包装类

●Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类

●包装类（如：Integer，Double等）这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作方法

基本数据类型	包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

对于包装类来说，这些类的用途主要包含两种：

●作为和基本数据类型对应的类类型存在

●包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法

●包装类常用属性方法

●以下方法以java.lang.Integer为例

public static final int MAX_VALUE 最大的int型数（2^31-1）

public static final int MIN_VALUE 最小的int型数（2^31）

构造方法

Integer(int a);

Integer(String a);

比较方法

static int compareTo(Integer a);

boolean equals(Object);

int max(int a,int b);

int min(int a,int b);

转换方法

static toBinaryString(int i);

static String toHexString(int i);

static String toOctalString(int i);

int intValue();

static int parseInt(String s);

String toString();

static Integer valueOf(int i)

static Integer valueOf(String s)

●装箱和拆箱Auto-boxing/unboxing

●装箱

●自动将基本数据类型转换为包装器类型

●装箱的时候自动调用的是Integer的valueOf(int)方法

●拆箱

●自动将包装器类型转换为基本数据类型

●拆箱的时候自动调用的是Integer的intValue方法

//装箱
int a = 12;
Integer b = Integer.valueOf(a);

//拆箱

int c = b.intValue();
int a = 12;

//自动装箱

Integer b = a;

//自动拆箱

int c = b;

Object类

●Object类是所有Java类的祖先（根基类），每个类都使用 Object 作为超类（父类），所有对象（包括数组）都实现这个类的方法

●如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类

public class Person {...}

等价于：

public class Person extends Object {...}

toString方法

public class Person{
       Person p = new person();
        /*
          使用System.out.println(p);输出对象,此时会默认调用对象中的toString()
          当类中没有toString()时,默认调用父类toString()
           public String toString() {
                return getClass().getName() + "@" + Integer.toHexString(hashCode());
            }
​
            一般情况下可以重写Object类中toString()
        */
         System.out.println(p);
}

重写toString

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

equals方法

public static void main(String[] args) {
        int a = 10;
        int b = 10;
        System.out.println(a==b);//true
​
        Car car1 = new Car("宝马", 300000);
        Car car2 = new Car("宝马", 300000);
        Car car3 = car2;
​
        /*
          car1.equals(car2) 由于Car类中没有重写equlas(),那么调用Object类中的equals()
           public boolean equals(Object obj) {
                return (this == obj);
            }
            == 用于基本类型比较  比较的值是否相等
            == 用于引用类型比较  比较的是引用地址(对象地址)是否相等
         */
        System.out.println(car1.equals(car2));// flase
        System.out.println(car2.equals(car3));//true
​
        /*
          字符串类中重写了Object类中的equals()  实现是比较两个字符串中每一个字母是否相等
          所以一般默认为equals() 方比较的是对象中内容是否相等
         */
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.equals(s2));//true
​
​
    }

Arrays类

●java.util.Arrays类

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

equals 方法

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

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

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

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

    /*
       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 －排序

●作用于数组的所有元素

public static void sort(type[] a)

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

public static void sort(type[] a, int fromIndex(包括), int toIndex(不包括))将指定的类型（除

boolean以外的任意原生数据类型）数组所有元素（或指定范围内的元素）按数字升序进行排序。

object型数组，根据元素的自然顺序，对指定对象数组进行升序排序。

（fromIndex==toIndex，则排序范围为空）

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

自定义对象排序

自定义类实现Comparable接口

重写compareTo方法

//用来作比较，提供一个自定义排序规则的方法
@Override
    public int compareTo(User o) {
       //return this.id-o.id;
       return this.account.compareTo(o.account);
    }
    //compareTo()方法会在sort()的底层中调用


 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));
    }

binarySearch—二分搜索

●声明：

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

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

●描述：

使用二分搜索算法搜索指定的type型数组，以获得指定的值

●参数：

a - 要搜索的数组

key - 要搜索的值

fromIndex - 要排序的第一个元素的索引（包括）

toIndex - 要排序的最后一个元素的索引（不包括）

type -byte、double、float、object、long、int、short、char

●如果key在数组中，则返回搜索值的索引；否则返回-1或者”-“(插入点)

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);//无序数组先进行排序
        System.out.println(Arrays.binarySearch(a, 3));//返回负数表示没有找到
        System.out.println(Arrays.binarySearch(a, 0,6,3));
​
​
    }

copyOf - 数组复制

//数组复制
        int[] a = {1,2,3,4,5};
        //返回一个指定长度的新数组,并将原数组中的内容复制到新数组中
        int [] b = Arrays.copyOf(a, 10);
        System.out.println(Arrays.toString(b));
​