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() 换成它,就能试着读取小数了。
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 对象的两种方式
创建字符串主要有两种写法:
- 直接赋值,例如
String s = "helloworld";。 - 使用
new和构造方法,例如new String("helloworld")。
下面是几种常见的构造方法。把原来图片中的信息整理成表格后,查起来更方便。
| 构造方法 | 作用 |
|---|---|
String() | 创建一个空字符串 |
String(String original) | 根据已有字符串的内容创建新字符串对象 |
String(char[] value) | 根据字符数组中的字符创建字符串 |
String(byte[] bytes) | 按默认字符集解码字节数组,得到字符串 |
我们用代码分别试一下:
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)。
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",最终输出会是什么?
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()。
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 对象 |
下面把这些方法放在一起使用:
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",并转换成大写,就可以这样写:
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() | 得到拼接完成的字符串 |
比如只想把三个字符串用 --- 连起来,就用第一种构造方法;如果还希望整个结果包在 [ 和 ] 中,就使用第二种。
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 会创建新对象这条基本规律就够了,暂时不必继续深入字符串池的内部结构。
字符串拼接什么时候会产生新对象?
先看第一种情况:参与拼接的都是字符串常量。
public class Test1 {
public static void main(String[] args) {
String s = "a" + "b" + "c";
System.out.println(s);//abc
}
}这里的 "a" + "b" + "c" 在编译时就可以确定结果,因此编译器可以直接把它处理成 "abc",不需要运行时再逐个拼接。
再看含有变量的情况:
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 对象。
例如:
StringBuilder sb = new StringBuilder();
sb.append("abc");一个空参创建的 StringBuilder,初始容量是 16;追加 "abc" 后,当前长度为 3,容量仍是 16。
**长度与容量不是一回事:**长度表示现在有多少字符,容量表示在再次扩容之前,最多能容纳多少字符。
StringBuilder 的容量如何增长?
可以把下面这张表看成原来容量示意图的文字版(使用空参构造方法,并分别从一个新对象开始观察):
| 操作 | 当前内容或长度 | 容量 |
|---|---|---|
new StringBuilder() | 长度 0 | 16 |
append("abc") | 长度 3 | 16 |
在新的空对象中一次追加 "abcdefghijklmnopqrstuvwxyz" | 长度 26 | 34 |
在新的空对象中一次追加长度为 43 的字符串 | 长度 43 | 43 |
以常见的扩容规则为例,当需要的容量超出原有容量时,会先按下面的方式计算:
新容量 = max(原容量 × 2 + 2, 实际所需的最小容量)所以从容量 16 出发,如果一次追加 26 个字符,16 × 2 + 2 = 34,可以放下,于是容量增长到 34。如果一次追加 43 个字符,34 仍然不够,就至少扩到 43。
这里画的是容量与长度的简化示意,不是说 JVM 内部一定使用 16 个 0 或 ASCII 数值直接保存字符。不同 JDK 版本的内部字符存储方式也可能不同,我们现阶段理解它会自动扩容、减少反复分配就可以了。
理解这点后,StringBuilder 适合在循环中不断追加内容的原因也就更清楚了:它可以复用缓冲区,必要时再扩容,避免每一步都重新构造完整的不可变字符串。
聊两句
评论审核后显示有疑问、补充,或者想交流一下,都可以写在这里。
评论区将在滚动到这里时加载。