Java常用工具之API——————JAVA学习第十天

Java常用工具之API

根据步骤查找API文档使用对应功能（有构造方法的类的使用）

1.查找类名

2.查看模块名

3.查看包名

4.查看构造方法

5.找到符合需要的方法

6.根据构造方法创建对象并使用

API(Application Programming Interface):应用程序接口，这里值的是API文档，通常叫“Java文档”，是java中提供的类的说明书。

Java中组件的层次结构:

模块（module）—>包（package）—>类或接口（class/interface）

模块（module）：自JAVA9起提供的一种新的Java基础组件，在包（package）的基础上又进行了一层封装，是包的容器。

JavaSE Modules:Java语言的核心类库，其下的模块名多以java开头

JDK Modules：java开发工具相关内容，其下的模块名多以jdk开头

Object类

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

java.base—>java.lang—>Object

构造方法

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

成员方法

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

Class<?> getClass():返回调用此方法对象的运行时类对象（调用者的字节码文件对象，一个类只有一个字节码文件对象：class java.lang.Object）

String toString():返回该对象的字符串表示

boolean equals():返回其他某个对象是否与此对象“相符”。默认情况下比较两个对象的引用（地址值），建议重写。默认打印的是地址值，但是不同对象的地址值肯定不同

地址值的组成：全类名+@+该对象的哈希码的无符号十六进制形式

代码：

package study5.demo;
//注意java.lang包下的类可以直接使用，不需要导包
public class Test {
    public static void main(String[] args) {
//        非静态方法的调用方式：通过 对象名. 的形式调用
//        1.创建Object类型的对象
        Object o = new Object();
        Object b = new Object();

//        2.测试Object类中的成员方法
//        int hashCode() :返回对象的哈希码值，不同对象的哈希码值一般不同，int表示返回int类型的数值
        int t1 = o.hashCode();
        int t2 = b.hashCode();
        System.out.println(t1);
        System.out.println(t2);
        System.out.println("——————————");

//Class<?> getClass()：返回调用者的字节码文件对象,一个类只有一个字节码文件对象 class java.lang.Object
        Class c1 = o.getClass();
        Class c2 = b.getClass();
        System.out.println(c1);
        System.out.println(c2);
        System.out.println("——————————");

//        String toString()：返回该对象的字符串表示形式,默认打印的是地址值，但是不同对象的地址值肯定不同
//        地址值的组成：全类名+@+该对象的哈希码的无符号十六进制形式
        String s1 = o.toString();
        String s2 = b.toString();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("——————————");

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

    }
}

//一般Person后面的extends Object是省略不写的
//Student类就是间接的继承Object类
//class Person extends Object {
//
//}
//class Student extends Person {
//
//}

JavaBean重写Object类的方法

需求：开发中通常需要将对象转成字符串形式进行传输，也需要对即将使用的对象进行相等判断。定义标准Javabean类，重写toString和equals方法。

注意：在实际开发中JavaBean一般都会重写Object类中的toString()和equals()方法

package study5.demo;

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(),用来比较两个对象是否相同的
//    自定义版本（理解即可），假设id属性值相同，两个对象就是一个对象
//
//    public boolean equals(Object obj) {     //s1.equals(s2)
//        /*
//            this:谁调用，this就表示谁 s1;obj=s1
//            obj=s2
//         */
//        //向下转型
//        Student t = (Student) obj;
//        return this.id == t.id;
//    }
    //通过快捷键的方式生成，步骤掌握，代码理解
//alt+insert—>

    @Override
    public boolean equals(Object o) {       //a.equals(t)
        //this=a;  o=t
        //比较两个对象的地址值是否相同，提高效率
        //如果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);
    }

}

package study5.demo;
/*
    注意：
    实际开发中，我们把两个对象的各个属性值都相同的情况下，才会认为两个对象是同一个对象
 */
public class Test2 {
    public static void main(String[] args) {
        //    测试toString()方法
//    创建学生类对象
        Student a = new Student(1,"小王",88);
//        输出语句直接打印对象，默认调用了该对象的toString()方法
        System.out.println(a);
        System.out.println(a.toString());
//    测试equals()方法
        Student t = new Student(1,"小张",99);
        boolean d = a.equals(t);        //比较a与t是否 相等
        System.out.println(d);
    }
}

Scanner类

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

java.base—>java.util—>Scanner

构造方法

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

成员方法

两类

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

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

两个（都是接收String类型的数据）

String nextLine():获取下一行数据，以换行符作为分隔符

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

注意：在实际开发中应用到的最多的方法是：
nextInt()：接收整数
nextLine()：接收字符串

package study5.demo;

import java.util.Scanner;

/*

    **hasNextXxx()**:判断是否还有下一个输入项，其中Xxx可能是任意基本数据类型，返回结果为布尔类型
    **NextXxx()**：获取下一个输入项，其中Xxx可能是任意基本数据类型，返回对应类型的数据
    **String nextLine()**:获取下一行数据，以换行符作为分隔符
    **String next()**:获取下一个输入项，以空白字符作为分隔符，空白字符：空格，tab，回车等
    
    注意：在实际开发中应用到的最多的方法是：
        nextInt()：接收整数
        nextLine()：接收字符串
 */
public class Test3 {
    public static void main(String[] args) {
        //创建Scanner类型的对象（注意要导包）
        //System.in:标准的输入流，默认指向键盘
        Scanner sc = new Scanner(System.in);
        //接收整数
//        System.out.println("请输入一个整数");
        为了避免（解决）InputMismatchException异常，可以加入一个判断
//        if (sc.hasNextInt()) {          //判断下一个录入的是否是整数，如果是结果就是ture
//            int num = sc.nextInt();
//            System.out.println("num："+num);
//        }
        //接受字符串类型的数据
        System.out.println("请录入一个字符串");
//        String s = sc.nextLine();     //结束标记是换行符
//        System.out.println("s:"+s);
        String s2 = sc.next();      //结束标记是换行符(空白字符后的字符无效)
        System.out.println("s2:"+s2);
    }
}

String类

简介：字符串，每一个字符串对象都是常量。

java.base—>java.lang—>String

构造方法

String(byte[]):构造一个String对象，将指定字节数组中的数据转化成字符串

String(char[]):构造一个String对象，将指定字符数组中的数据转化成字符串

成员方法

判断

boolean equals(String)：判断当前字符串与给定的字符串是否相同，区分大小写

boolean equalslgnoreCase(String)：判断当前字符串与给定的字符串是否相同，不区分大小写

boolean startsWith(String):判断是否以给定字符串开头

boolean isEmpty:判断字符是否为空

package study5.demo;
/*
 **构造方法**
 **String(byte[])**:构造一个String对象，将指定字节数组中的数据转化成字符串
 **String(char[])**:构造一个String对象，将指定字符数组中的数据转化成字符串

 **成员方法**
 **boolean equals(String)**：判断当前字符串与给定的字符串是否相同，区分大小写
 **boolean equalslgnoreCase(String)**：判断当前字符串与给定的字符串是否相同，不区分大小写
 **boolean startsWith(String)**:判断是否以给定字符串开头
boolean isEmpty:判断字符是否为空

 */
public class Test4 {
    public static void main(String[] args) {
//        测试：构造方法
//        1.将指定的字节数组转成字符串
//        a的ASCII为97
        byte[] s = {97,98,99};
        String t = new String(s);
        System.out.println("t:"+t);
        //        1.将指定的字符数组转成字符串
        char[] c = {'a','b','c','d','e'};
        String d = new String(c);
        System.out.println("d:"+d);
//        在实际开发中，String类非常常用，每次都new很麻烦，于是针对于String的语法做了优化，省去了new的动作
        String k = "aaa";       //免new
//        String k =new String("aaa");
        System.out.println("————————————");
//        测试成员方法
        String as = "abc";
        String az = "ABC";
        boolean v1 = as.equals(az);
        System.out.println("v1:"+v1);
        boolean v2 = as.equalsIgnoreCase(az);
        System.out.println("v2:"+v2);
//        判断as是否以a开头
        boolean v3 = as.startsWith("a");
        System.out.println(v3);
        boolean v4 = as.isEmpty();
        System.out.println(v4);
        String aw = "";
        boolean v5 = aw.isEmpty();
        System.out.println(v5);
    }
}

获取

索引是从0开始的

int length():获取当前字符串的长度

char charAt(int index):获取指定索引位置的字符

int indexOf(String):获取指定字符（串）第一次出现的索引

int lastIndexOf(String):获取指定字符（串）最后一次出现的索引

String substring(int):获取指定索引位置（含）之后的字符串

String substring(int,int):获取从索引start位置（含）起至索引end位置（不含）的字符串

package study5.demo;
/*
 **int length()**:获取当前字符串的长度
 **char charAt(int index)**:获取指定索引位置的字符
 **int indexOf(String)**:获取指定字符（串）第一次出现的索引
 **int lastIndexOf(String)**:获取指定字符（串）最后一次出现的索引
 **String substring(int)**:获取指定索引位置（含）之后的字符串
 **String substring(int,int)**:获取从索引start位置（含）起至索引end位置（不含）的字符串
 */
public class Test6 {
    public static void main(String[] args) {
//        定义一个字符串
        String s = "java 黑马程序员 java";
//        获取当前字符串的长度(包含空格)
//        int l = s.length();
//        System.out.println("s的长度为："+l);
        System.out.println("s的长度为："+s.length());

        char c = s.charAt(6);
        System.out.println(c);
//        需求字符a第一次出现的位置
        int index = s.indexOf('a');
        int index2 = s.lastIndexOf('a');
        System.out.println("a第一次出现的位置"+index);
        System.out.println("a最后一次出现的位置"+index2);
//        需求截取从索引5开始的所有元素
        String r = s.substring(5);
        System.out.println("从索引5开始的所有元素:"+r);
        //        需求截取从索引5开始到索引10结束的所有元素
        String i = s.substring(5,10);
        System.out.println("索引5开始到索引10结束的所有元素:"+i);
    }
}

转换

**byte[] getByte()😗*将字符串转换成字节数组

char[] toCharArray():将字符串转换成字符数组

**static String valueOf(……)😗*将指定类型数据转换成字符串

**String replace(old,new)😗*将指定字符（串）替换成新的字符（串）

**String[] split(String)😗*切割字符串，返回切割后的字符串数据，原字符串不变

String trim():去掉字符串两端的空白字符

package study5.demo;

public class Test5 {
    public static void main(String[] args) {
//        定义一个字符串
        String s = "abcd";
//byte[] getByte():将字符串转换成字节数组
        byte[] b = s.getBytes();        //97,98,99，100      ASCII码
        for (int i = 0; i < s.length();i ++) {
            System.out.println(b[i]);
        }
        System.out.println("——————————");
//char[] toCharArray():将字符串转换成字符数组
        char[] c = s.toCharArray();     //a,b,c,d
        for (int i = 0; i < s.length();i ++) {
            System.out.println(c[i]);
        }
        System.out.println("——————————");
//static String valueOf(……):将指定类型数据转换成字符串
        String t = String.valueOf(123);
        System.out.println(t+4);            //1234
//        在实际开发中，上述的方式基本会用下边的这行代码替代
        String r = "" + 123;
        System.out.println(r + 4);      //1234
        System.out.println("——————————");
// String replace(old,new):将指定字符（串）替换成新的字符（串）
        String n = "efgh efgh efgh";
//        用字符d来替换g
        String g = n.replace('g','d');          //要用单引号括起来
        System.out.println("替换后的n为："+g);
        System.out.println("——————————");
//String[] split(String):切割字符串，返回切割后的字符串数据，原字符串不变
//        将字符串n,按照空格进行切割"efgh“ ”efgh“ ”efgh"
        String[] arr = n.split(" ");
        for (int i = 0; i < arr.length;i ++) {
            System.out.println(arr[i]);
        }
        System.out.println("——————————");
//String trim():去掉字符串两端的空白字符
        String s1 = " a b c d ";
        String s2 = s1.trim();
        System.out.println("s1:"+s1);
        System.out.println("s2:"+s2);
//在实际开发中，当用户输入密码或者账号，一般会调用.trim()方法来执行
    }
}