JavaSE第五章

JavaSE第五章(上)

API常用类

JavaAPI概述

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

是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供

给开发人员进行使用帮助说明

本章会是java提供的一些基础常用类，后面的章节以具体模块化学习为主

基本数据类型包装类

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面

向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设

计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和

基本数据类型对应的类统称为包装类.

包装类（如：Integer，Double等）这些类封装了一个相应的基本数据

类型数值，并为其提供了一系列操作方法。

基本数据类型封装类

对于包装类来说，这些类的用途主要包含两种：
作为和基本数据类型对应的类类型存在。
包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操 作方法。

包装类常用属性方法

以下方法以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(); //类型转换

package Day_5;

public class Apidemo {

    public static void main(String[] args) {
        int m=10;
        Integer n = new Integer("15");//Integer是引用类型
        System.out.println(n.compareTo(m));//m与n比较大小，若m>n则返回1；m<n返回-1；m=n返回0；
        System.out.println(n.equals(m));//判断n与m是否相等，相等返回true,不相等返回false
        System.out.println(Integer.max(9,7));//返回最大值
        System.out.println(Integer.MAX_VALUE);//int类型的最大值
        System.out.println(Integer.MIN_VALUE);//int类型的最小值
        System.out.println(Integer.SIZE);//32
        System.out.println(Integer.BYTES);//4
        System.out.println(n.doubleValue());//类型转换，先取出对象中包含的int值，再将这个值value转换为double类型
        System.out.println(n.intValue());//将引用类型转换为整型，取出对象中包含的int值
        System.out.println(n.getClass());//获取类
        System.out.println(Integer.toBinaryString(4));//100,将整数转换成二进制整数
        System.out.println(Integer.toHexString(18));//转十六进制
        System.out.println(Integer.toOctalString(20));//转八进制


        Integer x=100;
        Integer y=100;
        System.out.println(x==y);//true
    }
}

static int parseInt(String s);

String toString();

static String toString(int i)

package Day_5;

public class Apidemo1 {
    public static void main(String[] args) {

        String x = "100";

        int y = Integer.parseInt(x);//将String类型的x转换成十进制的int整型
        System.out.println(y);
        Integer n = new Integer("10");
        String s1 = n.toString();//将整数转换成string类型
        System.out.println(s1);
    }
}

static Integer valueOf(int i)

static Integer valueOf(String s)

package Day_5;

public class Apidemo2 {
    public static void main(String[] args) {

        //类型转换
        System.out.println(Integer.valueOf(5));//5
        System.out.println(Integer.valueOf("9"));//9


        /*
        *自动装箱是使用的valueof方法
        */
        //基本类型判断是否相等是判断值的是否相等，引用类型判断是否相等是判断地址是否相等
        //在自动装箱过程中 integer的判断范围是-128 到127 在这个范围中返回true，超过这个范围将会自动创建新的对象产生新的地址 既是返回false
        Integer x=127;
        Integer y = Integer.valueOf(127);//显示的表示
        System.out.println(x==y);//true

        int l=8,i=8;
        System.out.println(l==i);//true

        Integer m = new Integer(100);
        Integer n = new Integer(100);
        System.out.println(m==n);//false
    }
}

● 装箱和拆箱Auto-boxing/unboxing

● 装箱

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

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

● 拆箱

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

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

Object类

● Object类是所有Java类的祖先（根基类）。每个类都使用 Object 作为

超类（父类）。所有对象（包括数组）都实现这个类的方法。

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

Object类

public class Person { …

}

● 等价于：

public class Person extends Object {

…

}

● toString方法

● Object类中定义有public String toString()方法，其返回值是 String

类型，描述当前对象的有关信息。

● 在进行String与其它类型数据的连接操作时（如：

System.out.println(“info”+person）），将自动调用该对象类的

toString()方法

● 可以根据需要在用户自定义类型中重写toString()方法。

package Day_6;

public class ObjectToString {
    public static void main(String[] args) {
        Person t = new Person();
        t.setName("李四");
        t.setAge(17);

        System.out.println(t.toString());//在使用sout方法时，输出对象，此时会默认调用对象中的toString（）方法，当类中没有时会默认调用父类中的toString（）方法
        /* public String toString() {
                return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }*/
    }
}

● equals方法

● Object类中定义有：

● public boolean equals(Object obj)方法

● 提供定义对象是否“相等”的逻辑。

● Object 的 equals 方法 定义为：x.equals ( y ) ，当 x 和 y是同一

个对象的引用时返回 true 否则返回 false

● JDK提供的一些类，如String，Date等，重写了Object的equals方

法，调用这些类的equals方法， x.equals (y) ,当x和y所引用的对象

是同一类对象且属性内容相等时（并不一定是相同对象），返回

true 否则返回 false。

package Day_6;

public class ObjectEquals {
    public static void main(String[] args) {
        Person t1 = new Person();
        t1.setName("李四");
        t1.setAge(17);


        Person t2 = new Person();
        t2.setName("李四");
        t2.setAge(17);

        System.out.println(t1==t2);
        System.out.println(t1.equals(t2));


        Integer x=128;//超出了integer的最大值范围，所以系统new Person(128);
        Integer y=128;
        System.out.println(x==y);//这里比的是地址，地址不同所以返回false
        System.out.println(x.equals(y));//几乎API中所有类都重写了object类中的equals（）方法，equals（）方法比较的是对象中的内容是否相等
    }
}

Arrays类

● java.util.Arrays类

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

equals 方法

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

组是否它本身。

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

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

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

package Day_6;

import java.util.Arrays;

public class ArraysEquals {
    public static void main(String[] args) {
        int[] b = {1,2,3,4,5};
        int[] c = {1,2,3,4,5};


        System.out.println(b==c);//false  ==比的是对象的地址
        System.out.println(Arrays.equals(b,c));//比较对象中的内容
    }
}

● sort －排序

● 作用于数组的所有元素

public static void sort(type[] a)

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

public static void sort(type[] a, int fromIndex(包括), int toIndex(不包括))

将指定的类型（除boolean以外的任意原生数据类型）数组所有元素（或指定范

围内的元素）按数字升序进行排序。

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

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

• 自定义对象排序

自定义类实现Comparable接口

重写compareTo方法

package Day_6;

import java.util.Arrays;

public class ArraysSort {
    public static void main(String[] args) {
        int [] a = {5,4,3,2,1};
        Arrays.sort(a);//默认从0到length-1，对整个数组进行排序
        System.out.println(Arrays.toString(a));//{1,2,3,4,5}
        int[]  b = {5,4,3,2,1};
        Arrays.sort(b,0,3);//对指定区间进行排序
        System.out.println(Arrays.toString(b));//{3,4,5,2,1}

    }
}

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或者”-“(插入点)

package Day_6;

import java.util.Arrays;

public class ArraysBinarySearch {
    public static void main(String[] args) {
        //二分搜索法
        //前提：数组要有序
        int [] a = {3,2,4,6,1,5};
        Arrays.sort(a);//1,2,3,4,5,6
        System.out.println(Arrays.binarySearch(a,4));//查找指定数值在数组中的位置，对整个区间进行查找
        System.out.println(Arrays.binarySearch(a,0,4,4));//对指定区间进行查找
        //用自己的程序写一个构造方法进行调用
        System.out.println(mybinarysearch(a,4));
        System.out.println(mybinarysearch(a,8));

    }
    public static int mybinarysearch(int[] a,int key){
        int low = 0;
        int high = a.length-1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -1;  // key not found.
    }

}

toString() 方法

● 声明：public static String toString(type[] a)

● 描述：返回指定数组内容的字符串表示形式。

● 基本数组，字符串表示形式由数组的元素列表组成，括在[]，相邻元素

用“, ”(逗号加空格)分隔。

package Day_6;

import java.util.Arrays;

public class ArraysToString {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5};
        System.out.println(a.toString());//默认调用的是toString方法中对象a的地址
        /*public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
        
    }*/

        System.out.println(Arrays.toString(a));

    }
}