代码收藏家 Java基础知识详解
环境准备
安装JDK和JRE
下载JDK，可以在官网Java Downloads | Oracle 中国下载，但是这里需要注册才能够下载。在Index of java-local/jdk (huaweicloud.com)也可以下载到，但是版本比较老，关系不大，直接下载，对应jdk-8u202-windows-x64.exe，这个是JDK8版本，它是一个长期维护版本。
下载后安装：
注意这里的JRE，它是Java程序执行的环境，会有额外安装：
因为已经包含在下载包中，所以也不需要额外下载。
设置环境变量
安装成功之后需要增加Java相关的环境变量。
- 首先是新建一个环境变量JAVA_HOME：
- 再将JDK和JRE的bin目录添加到PATH变量中：
之后如果在PowerShell下可以使用java，就表示安装成功了，比如：
C:\Users\jiang>java
用法: java [-options] class [args...]
(执行类)
或 java [-options] -jar jarfile [args...]
(执行 jar 文件)
其中选项包括:
-d32 使用 32 位数据模型 (如果可用)
-d64 使用 64 位数据模型 (如果可用)
-server 选择 "server" VM
默认 VM 是 server.
-cp <目录和 zip/jar 文件的类搜索路径>
-classpath <目录和 zip/jar 文件的类搜索路径>
用 ; 分隔的目录, JAR 档案
和 ZIP 档案列表, 用于搜索类文件。
-D<名称>=<值>
设置系统属性
-verbose:[class|gc|jni]
启用详细输出
-version 输出产品版本并退出
-version:<值>
警告: 此功能已过时, 将在
未来发行版中删除。
需要指定的版本才能运行
-showversion 输出产品版本并继续
-jre-restrict-search | -no-jre-restrict-search
警告: 此功能已过时, 将在
未来发行版中删除。
在版本搜索中包括/排除用户专用 JRE
-? -help 输出此帮助消息
-X 输出非标准选项的帮助
-ea[:<packagename>...|:<classname>]
-enableassertions[:<packagename>...|:<classname>]
按指定的粒度启用断言
-da[:<packagename>...|:<classname>]
-disableassertions[:<packagename>...|:<classname>]
禁用具有指定粒度的断言
-esa | -enablesystemassertions
启用系统断言
-dsa | -disablesystemassertions
禁用系统断言
-agentlib:<libname>[=<选项>]
加载本机代理库 <libname>, 例如 -agentlib:hprof
另请参阅 -agentlib:jdwp=help 和 -agentlib:hprof=help
-agentpath:<pathname>[=<选项>]
按完整路径名加载本机代理库
-javaagent:<jarpath>[=<选项>]
加载 Java 编程语言代理, 请参阅 java.lang.instrument
-splash:<imagepath>
使用指定的图像显示启动屏幕
有关详细信息, 请参阅 http://www.oracle.com/technetwork/java/javase/documentation/index.html。
C:\Users\jiang>java -version
java version "1.8.0_202"
Java(TM) SE Runtime Environment (build 1.8.0_202-b08)
Java HotSpot(TM) 64-Bit Server VM (build 25.202-b08, mixed mode)
安装IDE
开发Java常用的IDE有Eclipse和IntelliJ IDEA，这里使用IntelliJ IDEA，它的Community版是免费的，界面如下：
创建Java项目：
示例代码：
到这里Java的基本环境已经安装完毕。
Java基础
Java主类结构
Java程序的基本组成单元是类。
每一个应用程序都必须要包含一个main()方法，含有main()方法的类称为主类。
一个Java程序有若干个类组成。
通过package关键字声明类所在的包，通过import关键字引入该包包含的类。
下面的代码声明了一个包，该包中包含一个类：
package LearnJava;
public class BasicDataType {
public void test() {
System.out.print(new BasicDataType());
}
}
下面的代码包含并使用了上述类：
import LearnJava.BasicDataType;
public class Main {
public static void main(String[] args) {
// 基本数据类型测试
BasicDataType myBasicDataType = new BasicDataType();
myBasicDataType.test();
}
}
public、static、void分别是权限修饰符、静态修饰符和返回值修饰符。
基本数据类型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ymhpetO7-1693156098722)(Java.assets/基本数据类型.svg)]
Java没有区分正负的数值型，它们本身包含正负。
下面是一个示例：
package LearnJava;
public class BasicDataType {
public byte byteValue = 0;
public short shortValue = -1;
public int intValue = 2;
public long longValue = 3;
public char charValue = 'a';
public float floatValue = 1.1F; // 不加F会告警
public double doubleValue = -1.2;
public boolean booleanValue = true;
public void test() {
System.out.println(new BasicDataType());
System.out.println(byteValue);
System.out.println(shortValue);
System.out.println(intValue);
System.out.println(longValue);
System.out.println(charValue);
System.out.println(floatValue);
System.out.println(doubleValue);
System.out.println(booleanValue);
}
}
变量和常量
Java语言严格区分大小写。
Java语言规定标识符有任意顺序的字母、下划线（_）、美元符号（$）和数字组成，并且第一个字符不能是数字。
Java关键字：
| 关键字 | 描述 |
|---|---|
abstract |
非访问修饰符。用于类和方法：抽象类不能用于创建对象（要访问它，必须从另一个类继承）。抽象方法只能在抽象类中使用，并且它没有主体。主体由子类（继承自）提供。 |
assert |
用于调试。 |
boolean |
只能存储真值和假值的数据类型。 |
break |
从循环或switch块中断开。 |
byte |
可以存储-128和127之间的整数的数据类型。 |
case |
在switch语句中标记代码块。 |
catch |
捕获由try语句生成的异常。 |
char |
用于存储单个字符的数据类型。 |
class |
定义一个类。 |
continue |
继续到循环的下一个迭代。 |
const |
定义一个常量。不再使用，改用final。 |
default |
指定switch语句中的默认代码块。 |
do |
与while一起使用以创建do-while循环。 |
double |
可以存储1.7e−308 到 1.7e+308。 |
else |
用于条件语句中。 |
enum |
声明枚举（不可更改）类型。 |
exports |
导出包含模块的包。Java9中的新特性。 |
extends |
扩展类（表示一个类是从另一个类继承的）。 |
final |
用于类、属性和方法的非访问修饰符，使它们不可更改（无法继承或重写）。 |
finally |
与异常一起使用，无论是否存在异常都将执行的代码块。 |
float |
可以存储3.4e−038 到 3.4e+038。 |
for |
创建for循环。 |
goto |
不在使用中，没有任何功能。 |
if |
一个条件语句。 |
implements |
实现一个接口。 |
import |
用于导入包、类或接口。 |
instanceof |
检查对象是特定类的实例还是接口的实例。 |
int |
可以存储从-2147483648到2147483647的整数的数据类型。 |
interface |
用于声明仅包含抽象方法的特殊类型的类。 |
long |
可以存储从-9223372036854775808到9223372036854775808的整数的数据类型。 |
module |
声明一个模块。Java9中的新特性。 |
native |
指定方法不是在同一Java源文件中实现的（而是在另一种语言中实现的）。 |
new |
创建新对象。 |
package |
声明一个包。 |
private |
用于属性、方法和构造函数的访问修饰符，使它们只能在声明的类中访问。 |
protected |
用于属性、方法和构造函数的访问修饰符，使它们可以在同一个包和子类中访问。 |
public |
用于类、属性、方法和构造函数的访问修饰符，使它们可以被任何其他类访问。 |
requires |
指定模块内所需的库。Java9中的新特性。 |
return |
已完成方法的执行，并可用于从方法返回值。 |
short |
可以存储从-32768到32767的整数的数据类型。 |
static |
用于方法和属性的非访问修饰符。无需创建类的对象即可访问静态方法/属性。 |
strictfp |
限制浮点计算的精度和舍入。 |
super |
指超类（父）对象。 |
switch |
选择要执行的多个代码块之一。 |
synchronized |
非访问修饰符，指定一次只能由一个线程访问方法。 |
this |
指方法或构造函数中的当前对象。 |
throw |
创建自定义错误。 |
throws |
指示方法可能引发的异常。 |
transient |
非访问修饰符，指定属性不是对象持久状态的一部分。 |
try |
创建try…catch语句。 |
var |
声明一个变量。Java10中的新特性。 |
void |
指定方法不应具有返回值。 |
volatile |
指示属性不是本地缓存的线程，并且总是从“主内存”中读取。 |
while |
创建while循环。 |
常量也被称为“final变量”，再整个程序中只能被赋值一次。
在Java语言中声明一个常量，除了要指定数据类型，还需要通过final关键字进行限定。
常量名通常使用大写字母，但这并不是必须的。
final double PI = 3.1425926;
在为所有的对象共享值时，常量是非常有用的。
根据变量的有效返回，变量可以分为：
运算符
算数运算符：
| 运算符 | 名称 | 描述 | 实例 |
|---|---|---|---|
+ |
加法 | 将两个值相加。 | x + y |
- |
减法 | 从一个值减去另一个值。 | x – y |
* |
乘法 | 将两个值相乘。 | x * y |
/ |
除法 | 分子除以分母。 | x / y |
% |
取模 | 取模运算符，整除后的余数。 | x % y |
++ |
自增 | 自增运算符，整数值增加 1。 | ++x |
-- |
自减 | 自减运算符，整数值减少 1。 | –x |
赋值运算法：
| 运算符 | 实例 | 等同于 |
|---|---|---|
= |
x = 5 | x = 5 |
+= |
x += 3 | x = x + 3 |
-= |
x -= 3 | x = x – 3 |
*= |
x *= 3 | x = x * 3 |
/= |
x /= 3 | x = x / 3 |
%= |
x %= 3 | x = x % 3 |
&= |
x &= 3 | x = x & 3 |
|= |
x |= 3 | x = x | 3 |
^= |
x ^= 3 | x = x ^ 3 |
>>= |
x >>= 3 | x = x >> 3 |
<<= |
x <<= 3 | x = x << 3 |
关系运算符：
| 运算符 | 名称 | 实例 |
|---|---|---|
== |
等于 | x == y |
!= |
不等于 | x != y |
> |
大于 | x > y |
< |
小于 | x < y |
>= |
大于或等于 | x >= y |
<= |
小于或等于 | x <= y |
逻辑运算符：
| 运算符 | 名称 | 描述 | 实例 |
|---|---|---|---|
&& |
逻辑与 | 如果两个语句都为true，则返回true。 |
x < 5 && x < 10 |
|| |
逻辑或 | 如果其中一条语句为true，则返回true。 |
x < 5 || x < 4 |
! |
逻辑非 | 反转结果，如果结果为真则返回false。 |
!(x < 5 && x < 10) |
位运算符：
| 运算符 | 描述 | 例子 | 等同于 | 结果 | 十进制 |
|---|---|---|---|---|---|
& |
AND – 如果两个位都为1，则将每个位设置为1。 | 5 & 1 | 0101 & 0001 | 0001 | 1 |
| |
OR – 如果两个位中的任何一个为1，则将每个位设置为1。 | 5 | 1 | 0101 | 0001 | 0101 | 5 |
~ |
NOT – 反转所有位。 | ~ 5 | ~0101 | 1010 | 10 |
^ |
XOR – 如果两个位中只有一个为1，则将每个位设置为1。 | 5 ^ 1 | 0101 ^ 0001 | 0100 | 4 |
<< |
Zero-fill left shift – 通过从右侧推入零并让最左边的位脱落来向左移动。 | 9 << 1 | 1001 << 1 | 0010 | 2 |
>> |
Signed right shift – 通过从左侧推入最左侧位的副本并让最右侧位脱落来右移。 | 9 >> 1 | 1001 >> 1 | 1100 | 12 |
>>> |
Zero-fill right shift – 通过从左边推入零并让最右边的位脱落来右移。 | 9 >>> 1 | 1001 >>> 1 | 0100 | 4 |
还有三元运算符?:也支持。
代码注释和编码规范
代码注释说明：
// 单行注释
/*
多行
注释
*/
/**
文档注释
注意上面有两个**
*/
一些编码规范：
- package语句要写在类文件的第一行。如果类不在任何包中，可以不写package语句。
- import语句写在类的上方，package语句下方。
流程控制
if语句：
if () {
} else if {} {
} else {
}
switch语句：
switch () {
case x:
break;
case y:
break;
default:
break;
}
循环语句：
while () {
}
do {
} while ();
for (x; y; z) {
}
for (i : a) {
}
控制语句：
break;
continue;
数组
int[] arr1;
// int arr2[];
第二种会在IDE中报告警：
Local variable 'arr2' has C-style array type declaration
所以还是建议使用数据类型[]的方式。
public void testArray() {
int[] arr1;
arr1 = new int[5];
for (int j : arr1) {
System.out.println(j);
}
}
int[] arr1 = new int[5];
int[] arr1 = new int[] {1, 2, 3, 4, 5};
int[] arr2 = {10, 20, 30};
int[][] arr3 = new int[2][4];
2是行数，4是列数：
int[][] arr4 = new int[][] {{1, 2, 3, 4}, {5, 6, 7, 8}};
arr3和arr4是等价的，但是不能直接写new int[2][4]，会报错。
这样写更能看出行列关系：
int[][] arr3 = new int[][] {
{1, 2, 3, 4},
{5, 6, 7, 8}
};
数组的基本操作
int[][] arr3 = new int[][] {
{1, 2, 3, 4},
{5, 6, 7, 8}
};
for (int[] j : arr3) {
for (int i : j) {
System.out.println(i);
}
}
foreach的方式很好用。
int[] arr2 = new int[3];
Arrays.fill(arr2, 1);
for (int i : arr2) {
System.out.println(i);
}
为了使用fill()，需要导入对应的类：
import java.util.Arrays;
这里通过fill()为数组填充了同一个值。
还可以指定范围填充：
Arrays.fill(arr2, 0, 1, 10);
0表示起始位置，1表示结束位置（但该位置不在填充范围内），10表示需要填充的值。
int[] arr1 = new int[] {10, 2, 1, 4, 5};
Arrays.sort(arr1);
for (int i : arr1) {
System.out.println(i);
}
int[] arr1 = new int[] {10, 2, 1, 4, 5};
int[] arr2 = Arrays.copyOf(arr1, 10);
for (int i : arr2) {
System.out.println(i);
}
如果复制的值超过了原有的数组，则用0填充。
也有一个范围的版本：
int[] arr1 = new int[] {10, 2, 1, 4, 5};
int[] arr2 = Arrays.copyOfRange(arr1, 1, 2);
for (int i : arr2) {
System.out.println(i);
}
通用结束的索引没有包含在内，所以上例中只复制一个值。
int[] arr1 = new int[] {10, 2, 1, 4, 5};
System.out.println(Arrays.binarySearch(arr1, 1));
System.out.println(Arrays.binarySearch(arr1, 0, arr1.length, 1));
返回的是索引值，同样可以指定范围。上例的返回值是2。
类和对象
面向对象的特性：
类示例：
package LearnJava;
public class Book {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
修饰符权限：
| private | protected | public | |
|---|---|---|---|
| 本类 | 可见 | 可见 | 可见 |
| 同包其它类或子类 | 不可见 | 可见 | 可见 |
| 其它包的类或子类 | 不可见 | 不可见 | 可见 |
如果没有显式指定权限修饰符，则预设为包存取范围，即只有一个包中的类可以访问。
this关键字用于表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类。this关键字只能在本类中使用。
构造函数：
public Book() {
this.name = "Unspecific";
}
public Book(String name) {
this.name = name;
}
如果类中没有定义构造方法，则会自动创建一个无参数的构造方法；如果已经有构造函数了，且都是带参数的，则不会有无参数的构造方法。
这里定义了两个构造函数，实际是中方法重载，即方法名相同，但是参数不同。
static定义类的静态变量或静态方法，它们在所有的实例中共享。静态成员同样有修饰符约束。
静态成员在类中可以不用this：
package LearnJava;
public class Book {
private String name;
public static int count = 0;
public Book() {
this.name = "Unspecific";
count++;
}
public Book(String name) {
this.name = name;
count++;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void showBook() {
System.out.format("Total count: %d\n", count);
System.out.println(this.name);
}
}
类的使用：
Book book1 = new Book();
Book book2 = new Book("Learning Java");
book1.showBook();
book2.showBook();
Object类
| ID | 方法描述 |
|---|---|
| 1 | protected Object clone();创建并返回一个对象的拷贝。 |
| 2 | boolean equals(Object obj);比较两个对象是否相等。 |
| 3 | protected void finalize();当 GC (垃圾回收器)确定不存在对该对象的有更多引用时，由对象的垃圾回收器调用此方法。 |
| 4 | Class getClass();获取对象的运行时对象的类。 |
| 5 | int hashCode();获取对象的hash值。 |
| 6 | void notify();唤醒在该对象上等待的某个线程。 |
| 7 | void notifyAll();唤醒在该对象上等待的所有线程。 |
| 8 | String toString(); 返回对象的字符串表示形式。 |
| 9 | void wait();让当前线程进入等待状态。直到其他线程调用此对象的notify()方法或notifyAll()方法。 |
| 10 | void wait(long timeout);让当前线程处于等待(阻塞)状态，直到其他线程调用此对象的notify()方法或notifyAll()方法，或者超过参数设置的 timeout超时时间。 |
| 11 | void wait(long timeout, int nanos);与 wait(long timeout)方法类似，多了一个nanos参数，这个参数表示额外时间（以纳秒为单位，范围是 0-999999），所以超时的时间还需要加上 nanos纳秒。 |
继承和多态
继承：
package LearnJava;
public class FictionBook extends Book {
public FictionBook(String name) {
super(name);
System.out.println("FictionBook(String)"); // 这句要在上句下面，否则会报错
}
}
super指向父类，这里是父类的构造函数。
使用：
Book book = new FictionBook("The Three-Body Problem");
book.showBook();
这里有一个向上转型，即子类对象转换成父类对象。
子类可以直接使用父类的函数。
多态是通过父类可以对它以及其子类都可以进行通用操作（其中也包含了向上转型）：
public static void checkBook(Book book) {
if (book instanceof FictionBook) {
System.out.println("This is a fiction book");
} else if (book instanceof ReferenceBook) {
System.out.println("This is a reference book");
} else {
System.out.println("This is a normal book");
}
}
Book book1 = new FictionBook("The Three-Body Problem");
Book book2 = new ReferenceBook("XinHua Dictionary");
checkBook(book1);
checkBook(book2);
这里使用了instanceof关键字，可以用来判断对象的类型。
前面介绍过final变量，还有：
Java只支持单继承。
抽象类与接口
抽象类使用abstract关键字定义。
抽象类不可实例化。
通过abstract关键字还可以定义抽象方法，该方法没有方法体，本身没有任何意义，必须要被重写（可以被它的直接子类重写，也可以被其子类的子类重写）。当然抽象类中也可以有正常的方法。
接口是纯粹的抽象类，所有方法都没有方法体。
使用interface关键字定义接口。
接口中方法必须要是public或abstract形式的，否则没有意义。
接口中定义的任何字段都默认是static和final的。
内部类
在一个类中使用内部类，可以在内部类中直接存起其所在类的私有成员变量。
package LearnJava;
public class OuterClass {
private int x = 1;
public class InnerClass {
private int x = 11;
public void show() {
System.out.format("Inner int: %d\n", this.x); // 只用内部类（就是它自己）的成员变量
System.out.format("Outer int: %d\n", OuterClass.this.x); // 使用外部类的成员变量
}
}
public void show() {
InnerClass inner = new InnerClass();
inner.show();
}
}
内部类的使用：
OuterClass out = new OuterClass();
OuterClass.InnerClass inner = out.new InnerClass(); // 内部类依赖于外部类的方法，所以必须要用out.new
out.show();
inner.show();
匿名类是只在创建对象时才会编写类体的一种方法。
匿名类的特点是“现用现写”。比如有一个抽象类：
package LearnJava;
public abstract class AnimalClass {
String name;
public abstract void sound();
}
这里临时使用：
AnimalClass dog = new AnimalClass() {
@Override
public void sound() {
System.out.println("Wang ~ Wang ~");
}
};
dog.sound();
异常
try-catch-finally语句块用于捕捉异常：
try {
int a = 10 / 0;
}
catch (Exception e) {
e.printStackTrace();
}
finally {
System.out.println("Always be here"); // 无论是否异常都会执行
}
字符串
| ID | 方法描述 |
|---|---|
| 1 | char charAt(int index)返回指定索引处的 char 值。 |
| 2 | int compareTo(Object o)把这个字符串和另一个对象比较。 |
| 3 | int compareTo(String anotherString)按字典顺序比较两个字符串。 |
| 4 | int compareToIgnoreCase(String str)按字典顺序比较两个字符串，不考虑大小写。 |
| 5 | String concat(String str)将指定字符串连接到此字符串的结尾。 |
| 6 | boolean contentEquals(StringBuffer sb)当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。 |
| 7 | static String copyValueOf(char[] data)返回指定数组中表示该字符序列的String。 |
| 8 | static String copyValueOf(char[] data, int offset, int count)返回指定数组中表示该字符序列的String。 |
| 9 | boolean endsWith(String suffix)测试此字符串是否以指定的后缀结束。 |
| 10 | boolean equals(Object anObject)将此字符串与指定的对象比较。 |
| 11 | boolean equalsIgnoreCase(String anotherString)将此String与另一个String比较，不考虑大小写。 |
| 12 | byte[] getBytes()使用平台的默认字符集将此String编码为byte序列，并将结果存储到一个新的byte数组中。 |
| 13 | byte[] getBytes(String charsetName)使用指定的字符集将此String编码为byte序列，并将结果存储到一个新的byte数组中。 |
| 14 | void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)将字符从此字符串复制到目标字符数组。 |
| 15 | int hashCode()返回此字符串的哈希码。 |
| 16 | int indexOf(int ch)返回指定字符在此字符串中第一次出现处的索引。 |
| 17 | int indexOf(int ch, int fromIndex)返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。 |
| 18 | int indexOf(String str)返回指定子字符串在此字符串中第一次出现处的索引。 |
| 19 | int indexOf(String str, int fromIndex)返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。 |
| 20 | String intern()返回字符串对象的规范化表示形式。 |
| 21 | int lastIndexOf(int ch)返回指定字符在此字符串中最后一次出现处的索引。 |
| 22 | int lastIndexOf(int ch, int fromIndex)返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。 |
| 23 | int lastIndexOf(String str)返回指定子字符串在此字符串中最右边出现处的索引。 |
| 24 | int lastIndexOf(String str, int fromIndex)返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。 |
| 25 | int length()返回此字符串的长度。 |
| 26 | boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。 |
| 27 | boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)测试两个字符串区域是否相等。 |
| 28 | boolean regionMatches(int toffset, String other, int ooffset, int len)测试两个字符串区域是否相等。 |
| 29 | String replace(char oldChar, char newChar)返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。 |
| 30 | String replaceAll(String regex, String replacement)使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串。 |
| 31 | String replaceFirst(String regex, String replacement)使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串。 |
| 32 | String[] split(String regex)根据给定正则表达式的匹配拆分此字符串。 |
| 33 | String[] split(String regex, int limit)根据匹配给定的正则表达式来拆分此字符串。 |
| 34 | boolean startsWith(String prefix)测试此字符串是否以指定的前缀开始。 |
| 35 | boolean startsWith(String prefix, int toffset)测试此字符串从指定索引开始的子字符串是否以指定前缀开始。 |
| 36 | CharSequence subSequence(int beginIndex, int endIndex)返回一个新的字符序列，它是此序列的一个子序列。 |
| 37 | String substring(int beginIndex)返回一个新的字符串，它是此字符串的一个子字符串。 |
| 38 | String substring(int beginIndex, int endIndex)返回一个新字符串，它是此字符串的一个子字符串。 |
| 39 | char[] toCharArray()将此字符串转换为一个新的字符数组。 |
| 40 | String toLowerCase()使用默认语言环境的规则将此String中的所有字符都转换为小写。 |
| 41 | String toLowerCase(Locale locale)使用给定Locale的规则将此String中的所有字符都转换为小写。 |
| 42 | String toString()返回此对象本身（它已经是一个字符串）。 |
| 43 | String toUpperCase()使用默认语言环境的规则将此String中的所有字符都转换为大写。 |
| 44 | String toUpperCase(Locale locale)使用给定Locale的规则将此String中的所有字符都转换为大写。 |
| 45 | String trim()返回字符串的副本，忽略前导空白和尾部空白。 |
| 46 | static String valueOf(primitive data type x)返回给定data type类型x参数的字符串表示形式。 |
| 47 | contains(CharSequence chars)判断是否包含指定的字符系列。 |
| 48 | isEmpty()判断字符串是否为空。 |
