下载JDK,可以在官网Java Downloads | Oracle 中国下载,但是这里需要注册才能够下载。在Index of java-local/jdk (huaweicloud.com)也可以下载到,但是版本比较老,关系不大,直接下载,对应jdk-8u202-windows-x64.exe,这个是JDK8版本,它是一个长期维护版本。
下载后安装:
注意这里的JRE,它是Java程序执行的环境,会有额外安装:
因为已经包含在下载包中,所以也不需要额外下载。
安装成功之后需要增加Java相关的环境变量。
之后如果在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)
开发Java常用的IDE有Eclipse和IntelliJ IDEA,这里使用IntelliJ IDEA,它的Community版是免费的,界面如下:
创建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 |
还有三元运算符?:
也支持。
代码注释说明:
// 单行注释
/*
多行
注释
*/
/**
文档注释
注意上面有两个**
*/
一些编码规范:
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();
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() 判断字符串是否为空。 |