Java API 与帮助文档

API(Application Programming Interface,应用程序编程接口),可以简单理解为别人已经提供好的功能,我们不必每次都从头编写,学会调用就行。前面使用过的 String、Random 和 Scanner,都是熟悉的例子。

Java API 通常指 Java 平台提供的类、接口及其方法等。很多具体实现已经封装好了,我们在使用时更需要了解:这个类有什么用、怎样创建对象、有哪些方法、参数和返回值分别是什么。

API 帮助文档就是用来查询这些信息的。例如,可以通过 Oracle 官方 Java API 文档 查找类,也可以参考之前找到的 中文 JDK 帮助文档(其中部分内容对应较早的 JDK 版本)。

以 String 为例,在文档中找到 java.lang.String,就能查看它的构造方法和成员方法。java.lang 包中的类可以直接使用,不必像 Scanner 那样显式写 import。

试着用文档解决一个问题

之前我们用 Scanner 读取的都是整数。如果现在需要读取小数呢?

既然已经会用 nextInt(),就可以去 Scanner 的方法列表中找找有没有类似的方法。查阅文档后会发现,nextDouble() 可以读取 double 类型的数值。把原来的 nextInt() 换成它,就能试着读取小数了。

java
import java.util.Scanner;
public class Test1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double a=sc.nextDouble();
        System.out.println(a);
    }
}

以后遇到不熟悉的类或方法,也可以按这个思路先查文档,再结合一个小例子验证用法。

String:字符串

java.lang.String 用于表示字符串,例如 "abc"、"hello"。Java 代码中的字符串字面量,本身就对应 String 对象。

需要记住一个特点:String 的内容不可变。 创建字符串后,不能直接修改这个字符串对象的内容。我们平时写字符串拼接,看起来像是在原来的字符串后面追加内容,实际上得到的是另一个字符串。

创建 String 对象的两种方式

创建字符串主要有两种写法:

  1. 直接赋值,例如 String s = "helloworld";。
  2. 使用 new 和构造方法,例如 new String("helloworld")。

下面是几种常见的构造方法。把原来图片中的信息整理成表格后,查起来更方便。

构造方法作用
String()创建一个空字符串
String(String original)根据已有字符串的内容创建新字符串对象
String(char[] value)根据字符数组中的字符创建字符串
String(byte[] bytes)按默认字符集解码字节数组,得到字符串

我们用代码分别试一下:

java
public class Test1 {
    public static void main(String[] args) {
        //直接赋值获取一个字符串对象
        String s1 = "abcd";
        System.out.println(s1);//abcd
        //使用new关键字获取一个字符串对象
        //空参构造:可以获取一个空白的字符串对象
        String s2 = new String();
        System.out.println(s2);//空白
        //传递一个字符串,根据传递的内容创建一个新的字符串
        //完全没必要,直接赋值更方便。
        String s3 = new String("helloworld");
        System.out.println(s3);//helloworld
        //传递一个字符数组,根据字符数据的内容创建一个新的字符串
        char[] chs = { 'a', 'b', 'c' };
        String s4 = new String(chs);
        System.out.println(s4);//abc
        //传递一个字节数组,根据字节数组的内容创建一个新的字符串
        byte[] bytes = { 65, 66, 67 };
        String s5 = new String(bytes);//根据ASCII表,查找数字对应的字符然后拼接。
        System.out.println(s5);//ABC
    }
}

最后一个例子中,65、66、67 对应英文字母 A、B、C,因此在常见的兼容 ASCII 的字符集下会得到 "ABC"。不过,String(byte[]) 实际会使用默认字符集解码字节,不能简单理解为所有字节都直接按 ASCII 表转换。以后处理文件或网络数据时,最好明确指定字符集。

如果本来就有字符串字面量,平时直接赋值更简洁,没有必要特意写 new String("...")。

两种创建方式与字符串常量池

直接赋值和使用 new 的一个区别,在于字符串常量池(也常叫字符串池,StringTable)。

java
public class Test1 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
    }
}

当程序第一次使用字面量 "hello" 时,可以得到字符串池中与它对应的对象;再次使用相同的字符串字面量时,通常会直接复用这个对象,而不必为同样的字面量再创建一份新的 String 对象。

而 new String("hello") 会显式创建一个新的 String 对象。虽然它的内容也是 "hello",但不是刚才那个被复用的对象。

这里可以先把字符串池理解为帮助复用字符串对象的一种机制,不用急着研究它在不同 JDK 版本里的具体实现位置。

比较字符串:== 与 equals()

来看这段代码,两个变量里面都是 "hello",最终输出会是什么?

java
public class Test1 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = new String("hello");
        System.out.println(s1 == s2);
    }
}

结果是 false。原因就在于 == 比较的内容取决于操作数的类型:

  • 对于基本数据类型,== 比较的是数值是否相等。
  • 对于引用类型,== 比较的是两个引用是否指向同一个对象。

上面的 s1 引用字符串池中的对象,而 s2 引用 new 出来的新对象。即使内容相同,它们也不是同一个对象,所以 s1 == s2 为 false。

要比较字符串内容,通常使用下面两个方法:

方法作用
equals(String)比较内容是否一致,区分大小写
equalsIgnoreCase(String)比较内容是否一致,忽略大小写

比如校验两个字符串是否完全相同,可以用 equals();如果某个输入规则允许忽略大小写,就可以使用 equalsIgnoreCase()。

java
public class Test1 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = new String("hello");
        System.out.println(s1.equals(s2));//true
        String s3 = "Hello";
        System.out.println(s1.equals(s3));//false
        System.out.println(s1.equalsIgnoreCase(s3));//true
    }
}

这样就能理解:内容相同,不一定是同一个对象。 比较字符串内容时,优先想到 equals(),而不是 ==。

StringBuilder:可变的字符串内容

前面说过,String 对象的内容不可变。如果我们需要反复拼接字符串,每次都用 +,可能产生额外的中间字符串。这时就可以考虑 StringBuilder。

可以先把 StringBuilder 理解成一个内容可以不断追加、修改的容器。比如要依次拼接 "a"、"b"、"c",不必每增加一段内容都得到一个新的 String 对象,而是可以在同一个 StringBuilder 中调用 append()。

常见构造方法

构造方法作用
StringBuilder()创建空的 StringBuilder,初始容量为 16
StringBuilder(String str)根据已有字符串的内容创建 StringBuilder

常用方法

方法作用
append(内容)在末尾追加内容,并返回当前 StringBuilder 对象
reverse()将已有内容反转,并返回当前对象
length()获取当前内容的长度
toString()将当前内容转换成一个 String 对象

下面把这些方法放在一起使用:

java
public class Test1 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        // 直接打印为空,我们自己定义的类直接打印是地址值,String和StringBuilder做了一些特殊处理
        System.out.println(sb);
        // 添加多个元素然后打印
        sb.append("a");
        sb.append("b");
        sb.append("c");
        System.out.println(sb);
        // 反转
        sb.reverse();
        System.out.println(sb);
        // 获取长度
        int len = sb.length();
        System.out.println(len);
        // 变回字符串
        String s = sb.toString();
        System.out.println(s);
    }
}

直接打印空的 StringBuilder,会看到一个空行。添加 a、b、c 后打印,得到 abc;反转后是 cba,长度为 3,最后再通过 toString() 得到普通的字符串。

为什么它能直接打印出内容,而我们以前自定义的普通类直接打印常会出现 类名@... 这样的形式?因为打印对象时会使用对象的 toString() 方法,StringBuilder 已经实现了适合展示自身内容的 toString()。

那为什么还要手动调用 toString() 呢?因为我们最终可能需要把结果保存为 String,再交给只接收字符串的方法使用。StringBuilder 是用来构建、修改内容的工具,String 则适合表示构建完成后的字符串。

链式调用

有时,一个方法执行后会返回对象,我们就能在这个返回值上继续调用其他方法,这种写法称为链式调用。

例如,想取出 "hello,world" 中的 "world",并转换成大写,就可以这样写:

java
public class Test1 {
    public static void main(String[] args) {
        String s = "hello,world";
        System.out.println(s.substring(6).toUpperCase());
    }
}

先由 substring(6) 得到 "world",再在这个结果上调用 toUpperCase(),最终输出 WORLD。

StringBuilder 也支持这种写法,因为 append() 会返回当前对象,例如 sb.append("a").append("b").append("c")。

StringJoiner:按规则拼接字符串

如果要把多个元素用指定符号连接起来,有没有更省事的写法?有,StringJoiner 就适合这样的场景。

它和 StringBuilder 一样可以逐步添加内容,但更侧重于在各个元素之间自动加入分隔符,还可以指定整个结果的开头和结尾。StringJoiner 从 JDK 8 开始提供。

构造方法

构造方法作用
StringJoiner(CharSequence delimiter)指定元素之间的分隔符
StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix)指定分隔符,以及整体的前缀和后缀

常用方法

方法作用
add(CharSequence)添加一个元素,并返回当前 StringJoiner
length()获取目前拼接结果的长度
toString()得到拼接完成的字符串

比如只想把三个字符串用 --- 连起来,就用第一种构造方法;如果还希望整个结果包在 [ 和 ] 中,就使用第二种。

java
import java.util.StringJoiner;
public class Test1 {
    public static void main(String[] args) {
        StringJoiner sj1 = new StringJoiner("---");
        sj1.add("aaa").add("bbb").add("ccc");
        System.out.println(1);//aaa---bbb---ccc
        StringJoiner sj2 = new StringJoiner(",", "[", "]");
        sj2.add("1").add("2").add("3");
        System.out.println(sj2);//[1,2,3]
        System.out.println(sj2.toString());//[1,2,3]
    }
}

把 String、StringBuilder 和 StringJoiner 放在一起看,区别就比较清楚了:

类型适合做什么
String表示字符串,内容不可变,提供各种字符串操作方法
StringBuilder反复追加、修改、反转字符串内容
StringJoiner将多个元素按照指定的分隔符、前后缀拼接起来

字符串的几个底层原理

上面主要学的是怎么用。这一部分再结合前面的例子,整理几个有助于理解字符串行为的底层知识点。

字符串池为什么能复用对象?

直接使用相同的字符串字面量时,程序通常会复用字符串池里的对象;而 new String("hello") 会创建新的 String 对象。这就是为什么两个变量的内容相同,使用 == 却可能得到不同结果。

这里记住字面量可以复用对象,new 会创建新对象这条基本规律就够了,暂时不必继续深入字符串池的内部结构。

字符串拼接什么时候会产生新对象?

先看第一种情况:参与拼接的都是字符串常量。

java
public class Test1 {
    public static void main(String[] args) {
        String s = "a" + "b" + "c";
        System.out.println(s);//abc
    }
}

这里的 "a" + "b" + "c" 在编译时就可以确定结果,因此编译器可以直接把它处理成 "abc",不需要运行时再逐个拼接。

再看含有变量的情况:

java
public class Test1 {
    public static void main(String[] args) {
        String s1 = "a";
        String s2 = s1 + "b";
        String s3 = s2 + "c";
        System.out.println(s3);//abc
    }
}

这次拼接过程涉及变量,通常需要在运行时完成。不同 JDK 版本使用的优化方式也不一样:

  • JDK 8 及更早的常见编译实现:通常把这类字符串拼接转换成类似 StringBuilder.append(...).toString() 的操作。
  • JDK 9 起:引入了基于 invokedynamic 的字符串拼接机制,具体怎样创建和组合字符串,由运行时的实现策略决定。

所以,不能简单认为只要写了 +,就一定会按固定方式创建两个对象;也不是从 JDK 8 开始才使用新的拼接机制。

实际写代码时,可以先记住一个实用的原则:少量的字符串拼接直接用 + 很自然;如果要在循环中反复追加大量内容,可以考虑 StringBuilder;如果主要是添加分隔符,StringJoiner 更直接。

StringBuilder 为什么适合连续拼接?

StringBuilder 会维护一块可以增长的内部缓冲区。只要新追加的内容还放得下,就可以继续使用已有的容量,而不是每次追加都重新构造一个完整的 String 对象。

例如:

java
StringBuilder sb = new StringBuilder();
sb.append("abc");

一个空参创建的 StringBuilder,初始容量是 16;追加 "abc" 后,当前长度为 3,容量仍是 16。

**长度与容量不是一回事:**长度表示现在有多少字符,容量表示在再次扩容之前,最多能容纳多少字符。

StringBuilder 的容量如何增长?

可以把下面这张表看成原来容量示意图的文字版(使用空参构造方法,并分别从一个新对象开始观察):

操作当前内容或长度容量
new StringBuilder()长度 016
append("abc")长度 316
在新的空对象中一次追加 "abcdefghijklmnopqrstuvwxyz"长度 2634
在新的空对象中一次追加长度为 43 的字符串长度 4343

以常见的扩容规则为例,当需要的容量超出原有容量时,会先按下面的方式计算:

纯文本
新容量 = max(原容量 × 2 + 2, 实际所需的最小容量)

所以从容量 16 出发,如果一次追加 26 个字符,16 × 2 + 2 = 34,可以放下,于是容量增长到 34。如果一次追加 43 个字符,34 仍然不够,就至少扩到 43。

这里画的是容量与长度的简化示意,不是说 JVM 内部一定使用 16 个 0 或 ASCII 数值直接保存字符。不同 JDK 版本的内部字符存储方式也可能不同,我们现阶段理解它会自动扩容、减少反复分配就可以了。

理解这点后,StringBuilder 适合在循环中不断追加内容的原因也就更清楚了:它可以复用缓冲区,必要时再扩容,避免每一步都重新构造完整的不可变字符串。

谢谢你读到这里。 ✧

聊两句

评论审核后显示

有疑问、补充,或者想交流一下,都可以写在这里。

评论区将在滚动到这里时加载。