Java API

Application Programming Interface，应用程序编程接口，这里指的是API文档，通常叫“Java文档”，是Java中提供的类的使用说明书。Java中的类和方法几乎全部都添加了文档注释（/** 文档注释内容 */），这些文档注释就被Java 的命令（javadoc.exe，在JDK安装的bin目录下）编译成了 Java文档，即API。

为什么学习API文档？

发挥面向对象思想，找到Java提供的对象来实现功能，学习API文档就是学习Java中的类的使用方法。开发Java程序的过程中，想要使用Java提供的类的功能，就需要通过API文档来查找并使用。API是程序员和Java语言之间沟通的桥梁。

API文档的使用方法

学习API其实就是学习如何使用JDK提供的类。API文档的学习并不要求你把所有的类和方法都记住，也不关心这些类的具体实现，而是学习如何使用它们。随着你对编程的理解越来越深入，使用JDK中的类越来越多，翻阅API文档的次数和时间也会越来越多。你不需要记住Java提供的所有的类，但你一定要学会通过API文档熟练的查找并使用这些类。

使用步骤

1. 搜索类

在搜索框里按类名模糊查询，或者通过文档顶部提供的层级结构查找。

2. 查看类的包名

很多类在使用之前需要导包，所以要知道该类所属的包。

每一个类都默认导入 java.lang 包，所以如果你使用的是该包下的类，则无须手动导包。

3. 查看类的注释

使用一个类前，要知道该类的大致功能和它的定位，要知道一个类的能力边界，以便快速确定该类是不是你真正需要的。

4. 查看构造方法（如有）

使用类之前要创建类的对象。如果是静态类或者一些工具类如 java.lang.Math 类，则不需要这么做。

5. 查找需要的方法并使用

根据标识符的命名规则，可以快速定位方法的位置。仔细阅读方法的注释，注意区分重载方法的使用有何不同。如果找不到想要的方法，可能该方法在父类，或者更高的父类中。

Object类

简介

类层次结构最顶层的基类，所有类都直接或间接的继承自Object类，所以，所有的类都是一个Object（对象）。

构造方法

Object()：

构造一个对象。所有子类对象初始化时都会优先调用该方法

成员方法

int hashCode()：

返回对象的哈希码值，该方法通过对象的地址值进行计算，不同对象的返回值一般不同

Class<?> getClass()：

返回调用此方法对象的运行时类对象（调用者的字节码文件对象）

String toString()：

返回该对象的字符串表示

boolean equals()

返回其它某个对象是否与此对象“相等”。默认情况下比较两个对象的引用（地址值），建议重写

package com.itcast.demo8;

public class Test {
    public static void main(String[] args) {
        //创建Object类型对象
        Object ob1 = new Object();
        Object ob2 = new Object();

        //测试Object类中的成员方法
        //int hashCode();       返回对象的哈希码值，不同对象的哈希码值一般不同
        int code1 = ob1.hashCode();
        int code2 = ob2.hashCode();
        System.out.println(code1);
        System.out.println(code2);

        //Class<?> getClass();返回该调用对象的字节码文件对象，一个类只有一个字节码对象
        Class class1 = ob1.getClass();
        Class class2 = ob2.getClass();
        System.out.println(class1);
        System.out.println(class2);

        //String toString();返回该对象的字符串形式,默认打印的是地址值
        String s1 = ob1.toString();
        String s2 = ob2.toString();
        System.out.println(s1);
        System.out.println(s2);

        //boolean equals();比较两个对象是否相等,默认比较的是地址值，无意义，子类一般会重写
        boolean b1 = ob1.equals(ob2);
        System.out.println(b1);
    }
}

JavaBean重写Object类的方法

package com.itcast.demo8;

public class StudentTest {
    public static void main(String[] args) {
        //测试toString()方法
        //创建学生类的对象
        Student s1 = new Student(1, "张三", 98);
        System.out.println(s1);
        System.out.println(s1.toString());

        //测试equals()方法
        Student s2 = new Student(1, "张三", 79);
        boolean b1 = s1.equals(s2);
        System.out.println(b1);
    }
}



package com.itcast.demo8;

import java.util.Objects;

public class Student {
    //成员变量
    private int id;
    private String name;
    private int score;

    //构造方法

    public Student() {
    }

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

    //成员方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    //toString(),将原来的对象转换成其对应的字符串形式

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

    //equals()方法，用来比较两个对象是否相同
//    public boolean equals(Object obj){
//        //
//        Student s2 = (Student) obj;
//        return this.id == s2.id;
//    }

    @Override
    public boolean equals(Object o) {
        //this：s1  o：s2
        //比较两个对象的地址值是否相同，提高效率
        //如果if语句控制的语句体只有一行代码，那么{}可以省略不写
        if (this == o)
            return true;
        //判断要比较的两个对象是否是同一类型的对象，提高程序的健壮性
        if (o == null || getClass() != o.getClass())//字节码
            return false;
        //向下转型
        Student student = (Student) o;
        return id == student.id && score == student.score && name.equals(student.name);
    }


}

Scanner类

简介

扫描器。能够解析字符串（String）和基本数据类型的数据

构造方法

Scanner(InputStream)：

构造一个扫描器对象，从指定输入流中获取数据参数System.in，对应键盘录入

成员方法

hasNextXxx()：

判断是否还有下一个输入项，其中Xxx可能是任意基本数据类型，返回结果为布尔类型

nextXxx()：

获取下一个输入项，其中Xxx可能是任意基本数据类型，返回对应类型的数据

String nextLine()：

获取下一行数据。以换行符作为分隔符。

String next()

获取下一个输入项，以空白字符作为分隔符空白字符：空格、tab、回车等

package com.itcast.demo9;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //System.in标准的输入流，默认指向键盘
        Scanner sc = new Scanner(System.in);

        //接收整数
        System.out.println("请输入一个整数：");
        if (sc.hasNext()) {  //判断下一个录入的是否是整数，如果是，结果就是true
            int num = sc.nextInt();
            System.out.println("num:" + num);
        }

        //接收字符串
        System.out.println("请输入一个字符串：");
        String str1 = sc.nextLine();    //结束标记是换行符
        System.out.println("str1" + str1);

        String str2 = sc.next();    //结束标记是空白字符（空格，tab，换行符）
        System.out.println("str2" + str2);
    }
}

String类

简介

字符串。每一个字符串对象都是常量。

构造方法

String(byte[])：

构造一个String对象，将指定字节数组中的数据转化成字符串

String(char[])：

构造一个String对象，将指定字符数组中的数据转化成字符串

成员方法

判断功能

boolean equals(String)：

判断当前字符串与给定字符串是否相同，区分大小写

boolean equalsIgnoreCase(String)：

判断当前字符串与给定字符串是否相同，不区分大小写

boolean startWith(String)：

判断是否以给定字符串开头

boolean isEmpty():

判断字符串是否为空

package com.itcast.demo9;

public class Test1 {
    public static void main(String[] args) {
        //将指定的字节数组转成字符串
        byte[] bys = {97, 98, 99};
        String s1 = new String(bys);
        System.out.println("s1:" + s1);

        //将指定的字符数组转成字符串
        char[] chs = {'h', 'e', 'l', 'l', '0'};
        String s2 = new String(chs);
        System.out.println("s2:" + s2);

        //在实际开发中，省去了new
        String s3 = "abc";
        //String s3 = new String("abc");

        String str1 = "abc";
        String str2 = "ABC";
        //boolean equals(String)：
        //判断当前字符串与给定字符串是否相同，区分大小写
        boolean b1 = str1.equals(str2);
        System.out.println("equals():" + b1);
        //boolean equalsIgnoreCase(String)：
        //判断当前字符串与给定字符串是否相同，不区分大小写
        boolean b2 = str1.equalsIgnoreCase(str2);
        System.out.println("equalsIgnoreCase():" + b2);
        //boolean startWith(String)：
        //判断是否以给定字符串开头
        boolean b3 = str1.startsWith("a");
        System.out.println("startsWith():" + b3);
        //boolean isEmpty(); 判断字符串是否为空
        String str3 = "hello";
        boolean b4 = str3.isEmpty();
        System.out.println("isEmpty():" + b4);
    }
}

获取功能

int length()：

获取当前字符串的长度

char charAt(int index)：

获取指定索引位置的字符

int indexOf(String)：

获取指定字符（串）第一次出现的索引

int lastIndexOf(String)：

获取指定字符（串）最后一次次出现的索引

String substring(int)：

获取指定索引位置（含）之后的字符串

String substring(int, int)：

获取从索引start位置（含）起至索引end位置（不含）的字符串

String str = "java 一门语言 java";
        //int length()：
        //获取当前字符串的长度
        System.out.println("str.length()");
        //char charAt(int index)：
        //获取指定索引位置的字符
        char ch = str.charAt(2);
        System.out.println(ch);
        //int indexOf(String)：
        //获取指定字符（串）第一次出现的索引
        int index1=str.indexOf("a");
        System.out.println(index1);
        //int lastIndexOf(String)：
        //获取指定字符（串）最后一次次出现的索引
        int index2=str.lastIndexOf('a');
        System.out.println(index2);
        //String substring(int)：
        //获取指定索引位置（含）之后的字符串
        String s1 = str.substring(5);
        System.out.println(s1);
        //String substring(int, int)：
        //获取从索引start位置（含）起至索引end位置（不含）的字符串
        String s2 = str.substring(5,9);
        System.out.println(s2);

转换功能

byte[] getBytes()：

将字符串转换成字节数组

char[] toCharArray()：

将字符串转换成字符数组

static String valueOf(..) ：

将指定类型数据转换成字符串

String replace(old, new)：

将指定字符（串）替换成新的字符（串）

String[] split(String)：

切割字符串，返回切割后的字符串数据，原字符串不变

String trim()：

去掉字符串两端的空白字符

String s1 = "abc";
        //byte[] getBytes()：
        //将字符串转换成字节数组
        byte[] b1 = s1.getBytes();
        for (int i = 0; i < b1.length; i++) {
            System.out.println(b1[i]);
        }
        //char[] toCharArray()：
        //将字符串转换成字符数组
        char[] chs = s1.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            System.out.println(chs[i]);
        }
        //static String valueOf(..) ：
        //将指定类型数据转换成字符串
        String s2 = String.valueOf(123);
        System.out.println(s2 + 4);
        //两种
        String s3 = "" + 123;
        System.out.println(s3 + 4);
        //String replace(old, new)：
        //将指定字符（串）替换成新的字符（串）
        String s4 ="abc abc abc";
        String s5 = s4.replace('b','d');
        System.out.println(s5);
        //String[] split(String)：
        //切割字符串，返回切割后的字符串数据，原字符串不变
        String[] arr = s4.split(" ");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        //String trim()：
        //去掉字符串两端的空白字符
        String s6  ="   a    b    d   ";
        String s7 = s6.trim();
        System.out.println(s6);
        System.out.println(s7);

StringBuilder和StringBuffer类

简介

可变字符序列，用于构造字符串对象。内部使用自动扩容的数组操作字符串数据。StringBuilder和StringBuffer使用相同的API。

构造方法

StringBuilder()：

构造一个空的StringBuilder容器

StringBuilder(String)：

构造一个StringBuilder容器，并添加指定字符串

成员方法

StringBuilder append(…)：

将任意数据添加到StringBuilder容器中，返回自身。

String toString()：

将当前StringBuilder容器转成字符串

package com.itcast.demo9;

public class Test3 {
    public static void main(String[] args) {
        //测试空参构造
        StringBuilder sb = new StringBuilder();
        StringBuilder sb2 = sb.append("asd");
        System.out.println(sb);
        System.out.println(sb2);

        StringBuilder sb3 = new StringBuilder("abc");
        System.out.println(sb3);

        //测试成员方法
        //StringBuilder append(…)：
        //将任意数据添加到StringBuilder容器中,返回自身
        StringBuilder sb4 = new StringBuilder();
        sb4.append("小明");
        sb4.append("找");
        sb4.append("小红");
        System.out.println(sb4);
        //String toString()：
        //将当前StringBuilder容器转成字符串
        String s = sb4.toString();
        System.out.println(sb4);
    }
}

Date和Calendar类

简介

日期和日历类，用于操作日期相关信息。

构造方法

Date()：

构造一个日期对象，当前系统时间，精确到毫秒

Date(long)：

构造一个日期对象，时间为自“1970年1月1日00:00:00 GMT”起，至指定参数的毫秒数

成员方法

long getTime()：

将日期对象转换成对应时间的毫秒值

static Calendar getInstance()：

根据当前系统时区和语言环境获取日历对象

int get(int field)：

返回给定日历字段的值

void set(int field, int value)：

将给定的日历字段设置为指定的值

package com.itcast.demo9;

import java.util.Calendar;
import java.util.Date;

public class Test2 {
    public static void main(String[] args) {
        //测试Data类
        //空参构造
        Date date1 = new Date();
        System.out.println(date1);
        //获取当前操作系统时间毫秒值
        long time = date1.getTime();
        System.out.println(time);
        //Mon Aug 02 19:06:26 CST 2021-->1627902386381
        Date data2 = new Date(1627902386381L);
        System.out.println(data2);

        //Calendar类 抽象类，不能new
        Calendar c = Calendar.getInstance();
        System.out.println(c);

        //获取年月日的信息
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);
        int day = c.get(Calendar.DATE);
        System.out.println(year+"年"+(month+1)+"月"+day+"日");
        //设置指定时间
        c.set(Calendar.YEAR,2022);
        int year2 = c.get(Calendar.YEAR);
        System.out.println(year2+"年"+(month+1)+"月"+day+"日");

        c.set(2022,7,2);
        //重新获取
        int year1 = c.get(Calendar.YEAR);
        int month1 = c.get(Calendar.MONTH);
        int day1 = c.get(Calendar.DATE);
        System.out.println(year1+"年"+(month1+1)+"月"+day1+"日");


    }
}

基本类型的包装类

简介

基本数据类型不是对象，所以Java针对基本类型提供了对应的包装类，以对象的形式来使用。

装箱

基本类型转包装类型（对象类型）

拆箱

包装类型（对象类型）转基本类型

成员方法

基本类型 parseXxx(String)：

将字符串类型的数据转换成对应的基本类型

package com.itcast.demo9;

//static int parseInt(String)
public class Testimony {
    public static void main(String[] args) {

        //基本类型不能用 对象名. 的形式调用
        int a = 10;
        //装箱
        Integer i1 = new Integer(20);
        //拆箱
        int b = i1.intValue();
        System.out.println(i1);
        System.out.println(b);

        //JDK5新特性，自动拆装箱
        Integer i2 = 30;    //装箱
        int c = i2;         //拆箱

        //字符串转换成int类型
        String s = "10";
        int num = Integer.parseInt(s);
        System.out.println(num);
        System.out.println(num + 100);    //110

    }
}

除了Character类以外，其他七种包装类都有parseXxx(String)方法

如果字符串想转换成char类型的数据，可以通过：String类中的方法toCharArray()，charAt()；