JAVA学习笔记

编程语言 JAVA

发布时间 : 2018-08-19 17:42

字数:6.4k 阅读 :

参考文献：**菜鸟教程**

简介

1.系统：Ubnuto18.04(桌面版)
2.环境：JDK10.0.2
3.有一定的C/C++编程基础

配置环境

从**官网**或者其他网站下载JDK
下载后解压到自己指定的目录
解压后在解压包所在的文件夹打开终端命令，输入sudo gedit ~/.bashrc,必须在当前用户下执行，不需要打开管理员权限，执行后会打开一个文件夹
打开文件后在文件最后加入以下文字

JAVA_HOME=jdk10.0.2
JRE_HOME=${JAVA_HOME}/jre
CLASSPATH=${JAVA_HOME}/lib: ${JRE_HOME}/lib
PATH=${JAVA_HOME}/bin: ${JRE_HOME}/bin:$PATH
export JAVA_HOME JRE_HOME CLASSPATH PATH

保存后退出，然后在终端上输入source .bashrc即可
在终端上输入java -version即可看到安装包信息

JAVA基础教程

Hello World!

1.创建一个文件（作者文件名字Test_001.java）,文件类型为.java
2.编辑文件，在文件内写入下列脚本

public class Test_001 {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

3.在脚本文件页面打开终端执如下图输入javac Test_001.java和java Test_001即可

枚举

脚本如下

public class Test_001 {
    enum MyEnum{One,Two,Three}
public static void main(String[] args) {
    System.out.println("Hello World");
    System.out.println(MyEnum.One);
    }
}

运行结果如下

类和对象

JAVA源文件规则

一个源文件中只能有一个public类

一个源文件可以有多个非public类

源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。

如果一个类定义在某个包中，那么package语句应该在源文件的首行。

如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。

import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

包和Import
包主要用来对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。
在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类。
import java.io.* 导入项目根目录下所有的包

Tset_002脚本

import java.io.*;
public class Test_002
{
    public static void main(String[] args)
    {
        People peo=new People(1615925241,"lianbai","man");
        peo.ShowPeople();
    }
}

People脚本

public class People
{
    int Id;
    String Name;
    String Sex;
    public People(int id,String name,String sex)
    {
        this.Id=id;
        this.Name=name;
        this.Sex=sex;
    }
    public void ShowPeople()
    {
        System.out.println("Id:"+Id);
        System.out.println("Name:"+Name);
        System.out.println("Sex:"+Sex);
    }
}

运行结果如下

数据类型

内置数据类型
Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte：
byte 数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
例子：byte a = 100，byte b = -50。
short：
short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
默认值是 0；
例子：short s = 1000，short r = -20000。
int：
int 数据类型是32位、有符号的以二进制补码表示的整数；
最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
一般地整型变量默认为 int 类型；
默认值是 0 ；
例子：int a = 100000, int b = -200000。
long：
long 数据类型是 64 位、有符号的以二进制补码表示的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
这种类型主要使用在需要比较大整数的系统上；
默认值是 0L；
例子： long a = 100000L，Long b = -200000L。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。
float：
float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
float 在储存大型浮点数组的时候可节省内存空间；
默认值是 0.0f；
浮点数不能用来表示精确的值，如货币；
例子：float f1 = 234.5f。
double：
double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
浮点数的默认类型为double类型；
double类型同样不能表示精确的值，如货币；
默认值是 0.0d；
例子：double d1 = 123.4。
boolean：
boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
默认值是 false；
例子：boolean one = true。
char：
char类型是一个单一的 16 位 Unicode 字符；
最小值是 \u0000（即为0）；
最大值是 \uffff（即为65,535）；
char 数据类型可以储存任何字符；
例子：char letter = 'A';。

脚本代码

public class Test
{
    public static void main(String[] args) 
    {  
        // byte  
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  
        System.out.println("包装类：java.lang.Byte");  
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);  
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);  
        System.out.println();  
      
        // short  
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);  
        System.out.println("包装类：java.lang.Short");  
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);  
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);  
        System.out.println();  
      
        // int  
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  
        System.out.println("包装类：java.lang.Integer");  
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);  
        System.out.println();  
      
        // long  
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);  
        System.out.println("包装类：java.lang.Long");  
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);  
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);  
        System.out.println();  
      
        // float  
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);  
        System.out.println("包装类：java.lang.Float");  
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);  
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);  
        System.out.println();  
      
        // double  
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  
        System.out.println("包装类：java.lang.Double");  
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);  
        System.out.println();  
      
        // char  
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  
        System.out.println("包装类：java.lang.Character");  
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台  
        System.out.println("最小值：Character.MIN_VALUE="  
                + (int) Character.MIN_VALUE);  
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台  
        System.out.println("最大值：Character.MAX_VALUE="  + (int) Character.MAX_VALUE);  
    }  
}

输出结果

自动转换类型的层级由低到高为：

byte,short,char—> int —> long—> float —> double

修饰符

static

静态变量

static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据
对类变量和方法的访问可以直接使用 classname.variablename 和 classname.methodname 的方式访问。

final

变量

final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变，但是里面的值可以改变。
final 修饰符通常和 static 修饰符一起使用来创建类常量

方法

类中的 final 方法可以被子类继承，但是不能被子类修改。
声明 final 方法的主要目的是防止该方法的内容被修改。

类

final 类不能被继承，没有类能够继承 final 类的任何特性。

abstract

类
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。
方法
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
抽象方法的声明以分号结尾，例如：public abstract sample();
脚本如下

class Static
{
    static int a=99;
    static void Show()
    {
        System.out.println("This is Static");
    }
}
abstract class People
{
    protected String Name;
    public abstract void Show();
}
class Student extends People
{
    protected String Grade;
    public void SetInformation(String name,String grade)
    {
        this.Name=name;
        this.Grade=grade;
    }
    public void Show()
    {
        System.out.println("My name is "+Name);
        System.out.println("My grade is "+Grade);
    }
}
public class Test
{
    public static void main(String[] agr)
    {
        final int a=66;
        System.out.println(Static.a);
        Static.Show();
        //a=Static.a;		//最终会报错,final修饰的变量不可被修改
        Student stu=new Student();
        stu.SetInformation("LianBai","One");
        stu.Show();
    }
}

运行结果如下

synchronized

synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。

public synchronized 函数返回类型 函数名(参数)
{
    函数主题
}

transient

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

public transient 变量类型 变量名 = 变量值;   // 不会持久化
public 变量类型 变量名; // 持久化

volatile

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。

public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // 第一行
        {
            // 代码
        }
    }
    public void stop()
    {
        active = false; // 第二行
    }
}

通常情况下，在一个线程调用run()方法（在Runnable开启的线程，在另一个线程调用 stop() 方法。如果第一行中缓冲区的active值被使用，那么在第二行的active值为false时循环不会停止。
但是以上代码中我们使用了 volatile 修饰 active，所以该循环会停止

运算符

位运算符

A = 0011 1100
B = 0000 1101
-----------------
A&b = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

脚本如下

class Type{}
public class Test
{
    public static void main(String arg[])
    {
        int a=40;
        int b=30;
        int c=20;
        boolean T=true;
        boolean F=false;
        //算术运算符
        System.out.println(a+"+"+b+"="+(a+b));
        System.out.println(a+"-"+b+"="+(a-b));
        System.out.println(a+"*"+b+"="+(a*b));
        System.out.println(a+"/"+b+"="+(a/b));
        System.out.println(a+"%"+b+"="+(a%b));
        System.out.println(a+"%"+c+"="+(a%c));
        System.out.println(a+"++"+"="+(a++));
        System.out.println("++"+a+"="+(++a));
        //关系运算符
        System.out.println("a == b = " + (a == b) );
         	System.out.println("a != b = " + (a != b) );
         	System.out.println("a > b = " + (a > b) );
         	System.out.println("a < b = " + (a < b) );
         	System.out.println("b >= a = " + (b >= a) );
         	System.out.println("b <= a = " + (b <= a) );
        //逻辑运算符
        System.out.println("T && F = " + (T&&F));
         	System.out.println("T || F = " + (T||F) );
         	System.out.println("!(T && F) = " + !(T&&F));
        a = 5;//定义一个变量；
        boolean d = (a<4)&&(a++<10);
        System.out.println("使用短路逻辑运算符的结果为"+d);
        System.out.println("a的结果为"+a);
        //条件运算符
        a = 10;
          	b = (a == 1) ? 20 : 30;// 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
          	System.out.println( "Value of b is : " +  b );
          	b = (a == 10) ? 20 : 30;// 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
          	System.out.println( "Value of b is : " + b );
        //instanceof	该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
        Type t=new Type();
        boolean res=t instanceof Type;
        System.out.println(res);
    }
}

结果如下

循环

脚本如下

class Loop
{
    public void ForLoop()
    {
        for(int i=1;i<10;i++)
        {
            for(int j=1;j<i+1;j++)
                System.out.print(i+"*"+j+"="+i*j+"\t");
            System.out.println();
        }
    }
    public void StrengthenForLoop()
    {
        int[] number={1,2,3,4,5};
        String[] name={"One","Two","Three"};
        for(String c:name)
        {
            for(int i:number)
            {				
                if(i==3)
                    break;
                System.out.print(i+"\t");
            }
            System.out.println(c);
        }
        System.out.println("--------------------------------");
        for(String c:name)
        {
            for(int i:number)
            {				
                if(i==3)
                    continue;
                System.out.print(i+"\t");
            }
            System.out.println(c);
        }
    }
    public void WhileLoop()
    {
        int i=1;
        while(i<10)
        {
            int j=1;
            while(j<i+1)
            {
                System.out.print(i+"*"+j+"="+i*j+"\t");
                j++;
            }
            System.out.println();
            i++;
        }
    }
    public void DoWhileLoop()
    {
        int i=1;
        do
        {
            int j=1;
            do
            {
                System.out.print(i+"*"+j+"="+i*j+"\t");
                j++;
            }while(j<i+1);
            System.out.println();
            i++;
        }while(i<10);
    }
}
public class Test
{
    public static void main(String[] arg)
    {
        Loop l=new Loop();
        l.ForLoop();
        l.WhileLoop();
        l.DoWhileLoop();
        l.StrengthenForLoop();
    }
}

运行结果如下

分支语句（if,switch）

脚本如下

class Branch
{
    public void IfFrame(int achieve)
    {
        if(achieve==100)
        {
            System.out.println("You got full marks");
        }
        else if(achieve>=90&&achieve<100)
        {
            System.out.println("You got excellent");
        }
        else if(achieve>=80&&achieve<90)
            System.out.println("You got good");
        else if(achieve>=60&&achieve<80)
            System.out.println("You got pass");
        else
            System.out.println("You got file");
    }
    public void SwitchFrame(String achieve)
    {
        switch(achieve)
        {
            case "a":;
            case "A":System.out.println("You got full marks");break;
            case "b":;
            case "B":System.out.println("You got excellent");;break;
            case "c":;
            case "C":System.out.println("You got good");break;
            default:System.out.println("You got file");break;
        }
    }
}
public class Test
{
    public static void main(String[] arg)
    {
        Branch bran=new Branch();
        bran.IfFrame(95);
        bran.IfFrame(85);
        bran.IfFrame(75);
        bran.IfFrame(55);
        bran.SwitchFrame("a");
        bran.SwitchFrame("A");
        bran.SwitchFrame("b");
        bran.SwitchFrame("B");
        bran.SwitchFrame("C");
        bran.SwitchFrame("D");
    }
}

运行结果如下

Switch规则

switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串类型了，同时 case 标签必须为字符串常量或字面量。
switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直>到出现 break 语句。
switch 语句可以包含一个 default 分支，该分支必须是 switch 语句的最后一个分支。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

Number&&Math

Number
在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。

Number&&Math方法

名字	作用
xxxValue()	将 Number 对象转换为xxx数据类型的值并返回。
compareTo()	将number对象与参数比较。
equals()	判断number对象是否与参数相等。
valueOf()	返回一个 Number 对象指定的内置数据类型
toString()	以字符串形式返回值
parseInt()	将字符串解析为int类型。
abs()	返回参数的绝对值。
ceil()	返回大于等于( >= )给定参数的的最小整数。
floor()	返回小于等于（<=）给定参数的最大整数。
rint()	返回与参数最接近的整数。返回类型为double。
round()	它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
min()	返回两个参数中的最小值
max()	返回两个参数中的最大值
exp()	返回自然数底数e的参数次方。
log()	返回参数的自然数底数的对数值。
pow()	返回第一个参数的第二个参数次方。
sqrt()	求参数的算术平方根
sin()	求指定double类型参数的正弦值。
cos()	求指定double类型参数的余弦值。
tan()	求指定double类型参数的正切值。
asin()	求指定double类型参数的反正弦值。
acos()	求指定double类型参数的反余弦值。
atan()	求指定double类型参数的反正切值。
atan2()	将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
toDegrees()	将参数转化为角度。
toRadians()	将角度转换为弧度。
random()	返回一个随机数。

脚本如下

class NumberValue
{
    public void TestNumber()
    {
    }
    public void TestMath()
    {
        System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));  
        System.out.println("0度的余弦值：" + Math.cos(0));  
        System.out.println("60度的正切值：" + Math.tan(Math.PI/3));  
        System.out.println("1的反正切值： " + Math.atan(1));  
        System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));  
        System.out.println(Math.PI);
    }
    public void TestMath(double num)
    {
        System.out.println("Math.floor(" + num + ")=" + Math.floor(num));   
            System.out.println("Math.round(" + num + ")=" + Math.round(num));   
            System.out.println("Math.ceil(" + num + ")=" + Math.ceil(num)); 
    }
}
public class Test
{
    public static void main(String[] args)
    {
        NumberValue num=new NumberValue();
        num.TestMath();
        double[] nums = { 1.4, 1.5, 1.6, -1.4, -1.5, -1.6 };   
    		for (double i : nums)
        {   
      			num.TestMath(i);
    		} 
    }
}

运行结果如下

Character

在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情况。为了解决这个问题，Java语言为内置数据类型char提供了包装类Character类。
脚本如下

public class Test
{
    public static void main(String[] args)
    {
        Character ch='a';
        char c='x';
        System.out.println(ch);
        System.out.println(c);
    }
}

运行结果如下

Character方法

函数名称	函数功能
isLetter()	是否是一个字母
isDigit()	是否是一个数字字符
isWhitespace()	是否是一个空格
isUpperCase()	是否是大写字母
isLowerCase()	是否是小写字母
toUpperCase()	指定字母的大写形式
toLowerCase()	指定字母的小写形式
toString()	返回字符的字符串形式，字符串的长度仅为1

String

代码如下

public class Test
{
    public static void main(String[] args)
    {
        int a=10;
        double b=3.14;
        String str1="My name is ";
        String str2="LianBai";
        a=str2.length();
        System.out.println(str1.length());
        String str=str1.concat(str2);
        System.out.println(str);
        System.out.println(str1+str2);
        System.out.printf("整型类a的值为%d"+
                   "浮点型b的值为%lf"+
                   "字符串的值为%s",a,b,str1+str2);
        str=String.format("整型类a的值为%d"+"浮点型b的值为%lf"+
                   "字符串的值为%s",a,b,str1+str2);
    }
}

运行结果如下

String方法

返回类型	函数名	作用
char	charAt(int index)	返回指定索引处的 char 值。
int	compareTo(Object o)	把这个字符串和另一个对象比较。
int	compareTo(String anotherString)	按字典顺序比较两个字符串。
int	compareToIgnoreCase(String str)	按字典顺序比较两个字符串，不考虑大小写。
String	concat(String str)	将指定字符串连接到此字符串的结尾。
boolean	contentEquals(StringBuffer sb)	当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。
static String	copyValueOf(char[] data)	返回指定数组中表示该字符序列的 String。
static String	copyValueOf(char[] data, int offset, int count)	返回指定数组中表示该字符序列的 String。
boolean	endsWith(String suffix)	测试此字符串是否以指定的后缀结束。
boolean	equals(Object anObject)	将此字符串与指定的对象比较。
boolean	equalsIgnoreCase(String anotherString)	将此 String 与另一个 String 比较，不考虑大小写。
byte[]	getBytes()	使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
byte[]	getBytes(String charsetName)	使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
void	getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)	将字符从此字符串复制到目标字符数组。
int	hashCode()	返回此字符串的哈希码。
int	indexOf(int ch)	返回指定字符在此字符串中第一次出现处的索引。
int	indexOf(int ch, int fromIndex)	返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
int	indexOf(String str)	返回指定子字符串在此字符串中第一次出现处的索引。
int	indexOf(String str, int fromIndex)	返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
String	intern()	返回字符串对象的规范化表示形式。
int	lastIndexOf(int ch)	返回指定字符在此字符串中最后一次出现处的索引。
int	lastIndexOf(int ch, int fromIndex)	返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
int	lastIndexOf(String str)	返回指定子字符串在此字符串中最右边出现处的索引。
int	lastIndexOf(String str, int fromIndex)	返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
int	length()	返回此字符串的长度。
boolean	matches(String regex)	告知此字符串是否匹配给定的正则表达式。
boolean	regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)	测试两个字符串区域是否相等。
boolean	regionMatches(int toffset, String other, int ooffset, int len)	测试两个字符串区域是否相等。
String	replace(char oldChar, char newChar)	返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String	replaceAll(String regex, String replacement)	使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String	replaceFirst(String regex, String replacement)	使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
String[]	split(String regex)	根据给定正则表达式的匹配拆分此字符串。
String[]	split(String regex, int limit)	根据匹配给定的正则表达式来拆分此字符串。
boolean	startsWith(String prefix)	测试此字符串是否以指定的前缀开始。
boolean	startsWith(String prefix, int toffset)	测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
CharSequence	subSequence(int beginIndex, int endIndex)	返回一个新的字符序列，它是此序列的一个子序列。
String	substring(int beginIndex)	返回一个新的字符串，它是此字符串的一个子字符串。
String	substring(int beginIndex, int endIndex)	返回一个新字符串，它是此字符串的一个子字符串。
char[]	toCharArray()将此字符串转换为一个新的字符数组。
String	toLowerCase()	使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
String	toLowerCase(Locale locale)	使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
String	toString()	返回此对象本身（它已经是一个字符串！）。
String	toUpperCase()	使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
String	toUpperCase(Locale locale)	使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
String	trim()	返回字符串的副本，忽略前导空白和尾部空白。
static String	valueOf(primitive data type x)	返回给定data type类型x参数的字符串表示形式。

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 841774407@qq.com