三 JAVA语言(学习笔记)

学习资料

http://www.w3cschool.cc/java/java-tutorial.html

-----------------------------------------------------------------------------------------------------------

Java语言

5.1 定义

类：类是一个模板，它描述一类对象的行为和状态。
局部变量：在方法/构造方法/语句块中定义的变量。在栈上分配。
for循环的初始化部分声明的变量，其作用范围在整个循环。因此可以在一个方法里，不同的非嵌套块中多次声明一个具有相同的名称局部变量.
成员变量：类中，方法体外定义的变量
类变量（静态变量）：类中，方法体外，但是必须为static类型。
定义变量：

类型变量名

类型变量名 = value

同时定义多个变量，用逗号隔开。 int d = 3, e, f = 5;

成员方法：类中定义的方法。
构造方法：使用new创建对象时，会调用构造方法初始化对象。构造方法名与类名相同。每个类有1到多个。
对象：对象是类的一个实例，有状态（属性）和行为（方法）。狗-----对象；状态：名字、品种、颜色-----属性；行为：叫、摇尾巴和跑-----方法
定义对象： 类名对象名 = new 构造方法（“参数“）

或者类名对象名 = new 构造方法（）； 没有构造方法，或者构造方法没有参数

实例变量：类中定义的变量。访问时通过已创建的对象访问成员变量，如：对象名.变量。
实例方法：对象名.方法，通过已创建的对象访问成员方法。

继承：在Java中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。
修饰符号：放在语句的最前端，用来定义类、方法或者变量。分为访问控制修饰符（默认，private，public，protected）和非访问控制修饰符（static， final）

父类中声明为private的方法，不能够被继承。

运算符：算数 / 关系 / 位 / 逻辑/ 赋值 / 条件（？：） / instanceOf
三元表达式: expression1?expression2:expression3

expression1是一个布尔表达式, 如果expression1为真，那么在问号和冒号之间的表达式被求值(expression2)被求值；否则，expression3被求值。

5.2 基本语法

大小写敏感
类名：首字母应该大写。例如 MyFirstJavaClass 。
方法名：以小写字母开头。
源文件名：必须和类名相同。使用类名作为文件名保存，后缀为.java。
主方法入口：由public static void main(String args[])方法开始执行。
Java 标识符：类名 / 变量名/方法名，以字母（A-Z或者a-z）,美元符（$）、或者下划线（_）开始。举例：age、$salary、_value、__1_value
修饰符：修饰类中方法和属性
Java变量：局部变量 / 类变量（静态变量）/ 成员变量（非静态变量）
注释: // 或者 /* */
一个源文件中只能有一个public类，文件名称应该和public类名相同
Java 包：对类和接口进行分类。
import java.io.* ：命令编译器载入java_installation/java/io路径下的所有类
System.out.println("Dot " + string1 + "Tod");

输出格式化数字可以使用printf()和format()方法，String类使用静态方法format()返回一个String对象

System.out.printf("The value of the float variable is " +

"%f, while the value of the integer " +

"variable is %d, and the string " +

"is %s", floatVar, intVar, stringVar);

你也可以这样写

String fs;

fs = String.format("The value of the float variable is " +

"%f, while the value of the integer " +

"variable is %d, and the string " +

"is %s", floatVar, intVar, stringVar);

System.out.println(fs);

方法

定义方法:

修饰符返回值类型方法名 (参数类型参数名){

方法体

返回值;

}

修饰符：可选，定义了该方法的访问类型。

返回值类型：方法可能会返回值。如果没有返回值,returnValueType是关键字void。

方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

方法体：方法体包含具体的语句，定义该方法的功能。

static float interest(float principal, int year){...}

调用方法：

当方法返回一个值的时候，方法调用通常被当做一个值。例如：

int larger = max(30, 40);

如果方法返回值是void，方法调用一定是一条语句

方法重载: 一个类的两个方法拥有相同的名字，但是有不同的参数列表。Java编译器根据方法的参数列表判断哪个方法应该被调用。

执行密切相关任务的方法应该使用相同的名字。

finalize() 方法: 用来清除回收对象,在对象被垃圾回收之前调用.

public class FinalizationDemo {

public static void main(String[] args) {

Cake c1 = new Cake(1);

Cake c2 = new Cake(2);

Cake c3 = new Cake(3);

c2 = c3 = null;

System.gc(); //调用Java垃圾收集器

}

class Cake extends Object {

private int id;

public Cake(int id) {

this.id = id;

System.out.println("Cake Object " + id + "is created");

}

protected void finalize() throws java.lang.Throwable {

super.finalize();

System.out.println("Cake Object " + id + "is disposed");

}

可变参数: 适用于参数个数不确定，类型确定的情况，java把可变参数当做数组处理。

只支持一个可变参数;

可变参数只能出现在参数列表的最后;

… 位于变量类型和变量名之间.

调用可变参数时,编译器为该可变参数隐含创建一个数组,在方法体中以数组的形式访问可变参数

public static int add(int x,int ...args){
int sum=x;
for(int i=0;i<args.length;i++){
sum+=args[i];
}

异常：

1. 捕获异常 try/catch：捕获异常并且自己要处理异常

try catch：考虑到try包含这段代码可能会遇到这种异常，直接用catch捕获处理，catch包含的代码为处理代码

try catch + [finally] ：finally语句为异常处理提供一个统一的出口，不论try代码块是否发生了异常事件，finally块中的语句都会被执行，通常运行清理类型等收尾善后性质的语句。

try{

// 程序代码---要实现的功能

}catch(异常类型1 异常的变量名1){

// 程序代码---发生异常时,如何处理

}catch(异常类型2 异常的变量名2){

// 程序代码

}catch(异常类型2 异常的变量名2){

// 程序代码

} finally {

// 程序代码

}

如果保护代码中发生异常，异常被抛给第一个catch块。

如果抛出异常的数据类型与异常类型匹配，它在这里就会被捕获。

如果不匹配，它会被传递给第二个catch块。

如此，直到异常被捕获或者通过所有的catch块。

最后，执行finally语句块。

异常类型,表明发生了哪种类型的异常

Java的非检查性异常。

异常	描述
ArithmeticException	当出现异常的运算条件时，抛出此异常。例如，一个整数"除以零"时，抛出此类的一个实例。
ArrayIndexOutOfBoundsException	用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。
ArrayStoreException	试图将错误类型的对象存储到一个对象数组时抛出的异常。
ClassCastException	当试图将对象强制转换为不是实例的子类时，抛出该异常。
IllegalArgumentException	抛出的异常表明向方法传递了一个不合法或不正确的参数。
IllegalMonitorStateException	抛出的异常表明某一线程已经试图等待对象的监视器，或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
IllegalStateException	在非法或不适当的时间调用方法时产生的信号。换句话说，即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。
IllegalThreadStateException	线程没有处于请求操作所要求的适当状态时抛出的异常。
IndexOutOfBoundsException	指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出。
NegativeArraySizeException	如果应用程序试图创建大小为负的数组，则抛出该异常。
NullPointerException	当应用程序试图在需要对象的地方使用 null 时，抛出该异常
NumberFormatException	当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
SecurityException	由安全管理器抛出的异常，指示存在安全侵犯。
StringIndexOutOfBoundsException	此异常由 String 方法抛出，指示索引或者为负，或者超出字符串的大小。
UnsupportedOperationException	当不支持请求的操作时，抛出该异常。

java.lang包中的检查性异常类。

异常	描述
ClassNotFoundException	应用程序试图加载类时，找不到相应的类，抛出该异常。
CloneNotSupportedException	当调用 Object 类中的 clone 方法克隆对象，但该对象的类无法实现 Cloneable 接口时，抛出该异常。
IllegalAccessException	拒绝访问一个类的时候，抛出该异常。
InstantiationException	当试图使用 Class 类中的 newInstance 方法创建一个类的实例，而指定的类对象因为是一个接口或是一个抽象类而无法实例化时，抛出该异常。
InterruptedException	一个线程被另一个线程中断，抛出该异常。
NoSuchFieldException	请求的变量不存在
NoSuchMethodException	请求的方法不存在

2. throws/throw关键字：把异常抛给调用它的程序处理

· throws：用在方法的参数列表后面,声明当主函数调用该方法时,可能会抛出什么异常.

格式是：方法声明 throws 异常类1,异常类2,...

protected void finalize() throws java.lang.Throwable {

这个声明告诉调用者，方法finalize()可能会抛出java.lang.Throwable异常。

但是throws对异常不处理，谁调用，谁需要去处理。

throws抛出的是类

· throw：用在方法体中，抛出一个具体的异常。程序在执行到throw语句时立即停止，它后面的语句都不执行。

public void withdraw(double amount) throws RemoteException,InsufficientFundsException{

// Method implementation

throw new RemoteException(); // throw抛出的是对象

}

3. 声明自定义异常类

class MyException extends Exception{

}

所有异常都必须是Throwable的子类。
如果希望写一个检查性异常类，则需要继承Exception类。
如果你想写一个运行时异常类，那么需要继承RuntimeException 类。

Java 流

1. 输入流：从一个源（键盘）读取数据 read() / readLine()，在Eclipse的result window中输入字符/字符串，就会输出结果

BufferReader对象来创建一个字符输入流，实现字符，数组和行的高效读取

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

read()方法: 从BufferedReader对象读取一个字符

readLine()方法: 从BufferedReader对象读取一个字符串

语法：

int read( ) throws IOException//当流结束时，返回-1，抛出IOException异常。

String readLine( ) throws IOException //

使用：

do {

c = (char) br.read();

str = br.readLine();

System.out.println(c);

System.out.println(str);

} while(c != 'q');

} while(!str.eaquals(“end”);

2. 输出流：向一个目标(如：屏幕)写数据。

接口：
Java关键字

关键字	描述
	不使用修饰符：对同一包内可见。（访问控制修饰符）
private	在同一类内可见。被声明为private的方法 / 变量 / 构造方法只能从类内部访问。
protected	对同一包内的类和所有子类可见。针对方法 / 变量 / 构造方法
public	对所有类可见，被声明为public的类 / 方法 / 构造方法 / 接口能够被任何其他类访问
abstract	抽象方法，抽象类的修饰符（非访问控制修饰符）、抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法的声明以分号结尾，例如：public abstract sample();
static	表示在类级别定义，所有实例共享的。用来创建类方法和类变量（独立于对象的静态变量/方法）对类变量和方法的访问可以直接使用classname.variablename和classname.methodname的方式访问。而不用先创建对象，再用对象调用。
final	修饰的变量为常量，是不可修改的修饰的方法不能被重写，----不能被继承类修改。声明final方法的主要目的是防止该方法的内容被修改。修饰得类不能有子类----修饰的类不能被继承。
synchronized	表示同一时间只能由一个线程访问的代码块
volatile	标记字段可能会被多个线程同时访问，而不做同步
transient	修饰不要序列化的字段
assert	断言条件是否满足
break	跳出循环或者label代码段
byte	8-bit 有符号数据类型，例子：byte a = 100，byte b = -50 （8种内置数据类型）
short	16位数字，例子：short s = 1000，short r = -20000
int	32位整型数，例子：int a = 100000, int b = -200000
long	64位整型数，例子： long a = 100000L，int b = -200000L
float	32-bit单精度浮点数，例子：float f1 = 234.5f
double	64-bit双精度浮点数，例子：double d1 = 123.4
boolean	布尔数据类型，例子：boolean one = true。
char	16-bit Unicode字符数据类型，如char letter = ‘A’。（8种内置数据类型）
void	标记方法不返回任何值
case	switch语句的一个条件
catch	和try搭配扑捉异常信息
class	定义类
const	未使用
continue	不执行循环体剩余部分
default	switch语句中的默认分支
do	循环语句，循环体至少会执行一次
else	if条件不成立时执行的分支
enum	枚举类型
extends	表示一个类是另一个类的子类
finally	为了完成执行的代码而设计的，主要是为了程序的健壮性和完整性，无论有没有异常发生都执行代码。
for	for循环语句
goto	未使用
if	条件语句
implements	表示一个类实现了接口
import	导入类
instanceof	测试一个对象是否是某个类的实例
interface	接口，一种抽象的类型，仅有方法和常量的定义
native	表示方法用非java代码实现
new	分配新的类实例
package	一系列相关类组成一个包
return	方法返回值
strictfp	浮点数比较使用严格的规则
super	表示基类
switch	选择语句
this	表示调用当前实例或者调用另一个构造函数
throw	抛出异常
throws	定义方法可能抛出的异常
try	表示代码块要做异常处理或者和finally配合表示是否抛出异常都执行finally中的代码
while	while循环

运算符

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B等于30
-	减法 - 左操作数减去右操作数	A – B等于-10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取模 - 右操作数除左操作数的余数	B%A等于0
+ +	自增 - 操作数的值增加1	B + + ：先+再等于 ++B ：先等于再+
-	自减 - 操作数的值减少1	B - -等于19

转义序列：前面有反斜杠（\）的字符代表转义字符

转义序列	描述
\t	在文中该处插入一个tab键
\b	在文中该处插入一个后退键
\n	在文中该处换行
\r	在文中该处插入回车
\f	在文中该处插入换页符
\'	在文中该处插入单引号
\"	在文中该处插入双引号
\\	在文中该处插入反斜杠

循环结构

while循环

while( 布尔表达式 ) {

//循环内容

}

do…while循环

do {

//代码语句

}while（布尔表达式）

for循环

for(初始化; 布尔表达式; 更新) {

//代码语句

}

最先执行初始化步骤。可以声明并初始化一个或多个循环控制变量，也可以是空语句。

用于数组的增强for循环

for(声明语句 : 表达式)

{

//代码句子

}

int [] numbers = {10, 20, 30, 40, 50};

for(int x : numbers ){

----声明语句中的变量类型必须与数组元素的类型匹配。变量的值与此时数组元素的值相等。

----表达式是要访问的数组名，或是返回值为数组的方法。

break 关键字----跳出循环
continue 关键字----让程序放弃本次迭代，立刻跳转到下一次循环的迭代
if 语句

分支结构

if(布尔表达式){

//如果布尔表达式的值为true

}else if(布尔表达式 3){

//如果布尔表达式 3的值为true执行代码 //else if可选

}else{

//如果布尔表达式的值为false

}

switch 语句

switch(expression){

case value :

//语句

break; //可选

case value :

//语句

break; //可选

//你可以有任意数量的case语句

default : //可选

//语句

5.3 数据类型

5.3.1 基本数据类型

byte	8-bit 有符号数据类型，例子：byte a = 100，byte b = -50 （8种内置数据类型）
short	16位数字，例子：short s = 1000，short r = -20000
int	32位整型数，例子：int a = 100000, int b = -200000
long	64位整型数，例子： long a = 100000L，int b = -200000L
float	32-bit单精度浮点数，例子：float f1 = 234.5f
double	64-bit双精度浮点数，例子：double d1 = 123.4
boolean	True / False布尔数据类型，例子：boolean one = true。
char	16-bit Unicode字符数据类型，如char letter = ‘A’。（8种内置数据类型）
boolean	布尔数据类型，例子：boolean one = true。
char	16-bit Unicode字符数据类型，如char letter = ‘A’。（8种内置数据类型）
char[]	char[] charArray ={ 'a', 'b', 'c', 'd', 'e' }; //字符数组
String	String greeting = "Hello world!"; //创建字符串

基本的数据类型由低级到高级分别为：byte/short/char –int---long—float—double

5.3.2 类型转换：

5.3.2.1 低级-------高级：自动转换成高级类型

5.3.2.2 高级-------低级：强制类型转换

l 基本类型----字符串

调用类的串转换方法: X.toString();
自动转换:X+“”;

System.out.println(“”+2+3))----输出23

使用String的方法:String.valueOf(X);

l 字符串---其它类型

先转换成类类型（new出一个新的类类型的变量），再调用子类的方法.xxValue()

.xxValue()----将number对象转换为xxx数据类型的值并返回

例子：

将一个字符串定义成一个Number类的子类

Double a = new Double("123.1");

调用子类的方法进行类型转换（只要子类和xxValue前边的类型符合转换条件就可以）

int b = a.intValue();

上面两step可以直接合并为：

new Double("123.1").intValue()

-------------实现了字符串到整型的转换-----------------------

parseXX方法：将字符串转换为int/double/…等等类型

Integer.parseInt("123");。

short t = Short.parseShort( “1” );

valueOf() ：返回一个Number对象指定的内置数据类型

Number子类.valueOf(“数据”).XXValue

----将字符串转化为一个Number子类对象，调用XXValue()方法返回其对应的XX类型的数值。

例如：

float f = Float.valueOf("123.123").floatValue();

double d = Double.valueOf(“123”).doubleValue

Character的getNumbericValue（char ch）

5.3.3 Java Number类

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类Number的子类。

实际用的时候，都是用子类以及子类的方法。

Number类其它成员方法

序号	方法与描述
1	xxxValue() ：将number对象转换为xxx数据类型的值并返回。
2	compareTo() ：将number对象与参数比较。
3	equals() ：判断number对象是否与参数相等。
4	valueOf() ：返回一个Integer对象指定的内置数据类型
5	toString() ：以字符串形式返回值。
6	parseInt() ：将字符串解析为int类型。
7	abs() ：返回参数的绝对值。
8	ceil() ：对整形变量向左取整，返回类型为double型。
9	floor() ：对整型变量向右取整。返回类型为double类型。
10	rint() ：返回与参数最接近的整数。返回类型为double。
11	round() ：返回一个最接近的int、long型值。
12	min() ：返回两个参数中的最小值。
13	max() ：返回两个参数中的最大值。
14	exp() ：返回自然数底数e的参数次方。
15	log() ：返回参数的自然数底数的对数值。
16	pow() ：返回第一个参数的第二个参数次方。
17	sqrt() ：求参数的算术平方根。
18	sin() ：求指定double类型参数的正弦值。
19	cos() ：求指定double类型参数的余弦值。
20	tan() ：求指定double类型参数的正切值。
21	asin() ：求指定double类型参数的反正弦值。
22	acos() ：求指定double类型参数的反余弦值。
23	atan() ：求指定double类型参数的反正切值。
24	atan2() ：将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
25	toDegrees() ：将参数转化为角度。
26	toRadians() ：将角度转换为弧度。
27	random() ：返回一个随机数。

5.3.4 Java Character类：Character类提供了一系列方法来操纵字符。

创建一个Character对象

Character ch = new Character('a');

序号	方法与描述
1	isLetter() ：是否是一个字母
2	isDigit() ：是否是一个数字字符
3	isWhitespace() ：是否一个空格
4	isUpperCase() ：是否是大写字母
5	isLowerCase() ：是否是小写字母
6	toUpperCase() ：指定字母的大写形式
7	toLowerCase() ：指定字母的小写形式
8	toString() ：返回字符的字符串形式，字符串的长度仅为1

5.3.5 Java String类：String类提供了一系列方法来操纵字符。

l 创建String对象： new String(字符数组);

char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.'};

String helloString = new String(helloArray);

System.out.println( helloString );

l String类是不可改变的，所以你一旦创建了String对象，那它的值就无法改变了。如果需要对字符串做很多修改，那么应该选择使用StringBuffer & StringBuilder 类。

l 方法

SN(序号)	方法描述
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)：将指定字符串连接到此字符串的结尾。 string1.concat(string2) “My name is”.concat(“Zara”) “My name is” + “Zara”
6	boolean contentEquals(StringBuffer sb) ：当且仅当字符串与指定的StringButter有相同顺序的字符时候返回真。
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() : 返回此字符串的长度。 String palindrome = "Dot saw I was Tod"; int len = palindrome.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参数的字符串表示形式。

5.3.6 Java StringBuffer和StringBuilder类

String类是不可改变的，所以你一旦创建了String对象，那它的值就无法改变了。当对字符串进行修改的时候，需要使用StringBuffer和StringBuilder类。

和String类不同的是，StringBuffer和StringBuilder类的对象能够被多次的修改，并且不产生新的未使用对象。

l 创建对象

StringBuffer sBuffer = new StringBuffer(" test");

sBuffer.append(" String Buffer");

System.ou.println(sBuffer);

l 方法

序号	方法描述
1	public StringBuffer append(String s) 将指定的字符串追加到此字符序列。
2	public StringBuffer reverse() 将此字符序列用其反转形式取代。
3	public delete(int start, int end) ：移除此序列的子字符串中的字符。
4	public insert(int offset, int i) ：将 int 参数的字符串表示形式插入此序列中。
5	replace(int start, int end, String str) ：使用给定 String 中的字符替换此序列的子字符串中的字符。

下面的列表里的方法和String类的方法类似：

序号	方法描述
1	int capacity() ：返回当前容量。
2	char charAt(int index) ：返回此序列中指定索引处的 char 值。
3	void ensureCapacity(int minimumCapacity) ：确保容量至少等于指定的最小值。
4	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 dst。
5	int indexOf(String str) ：返回第一次出现的指定子字符串在该字符串中的索引。
6	int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
7	int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。
8	int lastIndexOf(String str, int fromIndex) 返回最后一次出现的指定子字符串在此字符串中的索引。
9	int length() ：返回长度（字符数）。
10	void setCharAt(int index, char ch) ：将给定索引处的字符设置为 ch。
11	void setLength(int newLength) ：设置字符序列的长度。
12	CharSequence subSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。
13	String substring(int start) 返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
14	String substring(int start, int end) 返回一个新的 String，它包含此序列当前所包含的字符子序列。
15	String toString() 返回此序列中数据的字符串表示形式。

5.3.7 数组:

l 声明

dataType[] arrayRefVar; // 首选的方法

或

dataType arrayRefVar[]; // 效果相同，但不是首选方法

例子：

char[] myChar;

double[] mList

l 创建数组

arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事：

使用dataType[arraySize]创建了一个数组。

把新创建的数组的引用赋值给变量 arrayRefVar。

声明和创建合并为一条语句：

dataType[] arrayRefVar = new dataType[arraySize];

或

dataType[] arrayRefVar = {value0, value1, ..., valuek};

例如：double[] myList = new double[10];

l 数组处理

1.1 for 循环

for (int i=0; i < myList.length; i++){

System.out.println(myList[i] + "");

}

1.2 foreach循环：或者加强型循环，它能在不使用下标的情况下遍历数组。

double[] myList = {1.9, 2.9, 3.4, 3.5};

for (double element: myList) {

System.out.println(element);

}

l Arrays类：能方便地操作数组，它提供的所有方法都是静态的。

使用：

在文件最顶部加上import java.util.Arrays；可以直接调用Arrays的子类，例如：

int[] myArray = {1,2,3,4} ;

Arrays.sort(myArray);

方法：

给数组赋值：通过fill方法。

int[] myArray = new int[5] ;

int val =3;

Arrays.fill(myArray ,val);

对数组排序：通过sort方法,按升序。
比较数组：通过equals方法比较数组中元素值是否相等。
查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

序号	方法和说明
1	public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2	public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4	public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

5.3.8 日期时间

5.3.8.1 初始化Date对象

import java.util.Date;

……………

l Date date = new Date();//today被设置成创建时刻相对应的日期时间。

l Date date = new Date("Mon 6 Jan 1997 13:3:00"); //date 中时间为1997年1月6号星期一，13:3:00.

l public Date(int year,int month,int date[,int hrs,int min,int sec])

year的值为：需设定的年份-1900。例如需设定的年份是1997则year的值应为97，即1997-1900的结果。所以Date中可设定的年份最小为1900； month的值域为0～11，0代表1月，11表代表12月； date的值域在1～31之间；

hrs的值域在0～23之间。从午夜到次日凌晨1点间hrs=0，从中午到下午1点间hrs=12；min和sec的值域在0～59之间。

Date date = new Date(115,02,17); // 2015年3月17日

System.out.println(date.toString()); // Tue Mar 17 00:00:00 CST 2015

5.3.8.2日期比较

new Date(99, 2, 12).before(new Date (99, 2, 18))

Date date = new Date(99,2,29);

Date date2 = new Date(2010,1,10);

date.before(date2);

方法

序号	方法和描述
1	boolean after(Date date) 若当调用此方法的Date对象在指定日期之后返回true,否则返回false。例子：new Date (99,2,29).after(new Date (99,2,30))
2	boolean before(Date date) 若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
3	Object clone( ) 返回此对象的副本。
4	int compareTo(Date date) 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。例子：new Date (99,2,29).compareTo(new Date(2010,1,10))
5	int compareTo(Object obj) 若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
6	boolean equals(Object date) 当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
7	long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
8	int hashCode( ) 返回此对象的哈希码值。
9	void setTime(long time) 用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
10	String toString( ) ：转换Date对象为String表示形式，并返回该字符串。例子：System.out.println(date.toString()); -----获取当前时间

5.3.8.3 日期格式化

l 使用SimpleDateFormat格式化日期

Date dNow = new Date( );

SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz

");

System.out.println(ft.format(dNow));

l parse()，按照给定的SimpleDateFormat 对象的格式化存储来解析字符串。

SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");

ft.parse("2015-03-17"); // Tue Mar 17 00:00:00 CST 2015

l 让程序休眠一段时间

Thread.sleep(millis);// sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。

l 测量时间间隔

long start = System.currentTimeMillis( );

long end = System.currentTimeMillis( );

long diff = end - start;

l 简单的DateFormat格式化编码 : 时间模式字符串用来指定时间格式。定义如下：

字母	描述	示例
G	纪元标记	AD
y	四位年份	2001
M	月份	July or 07
d	一个月的日期	10
h	A.M./P.M. (1~12)格式小时	12
H	一天中的小时 (0~23)	22
m	分钟数	30
s	秒数	55
S	微妙数	234
E	星期几	Tuesday
D	一年中的日子	360
F	一个月中第几周的周几	2 (second Wed. in July)
w	一年中第几周	40
W	一个月中第几周	1
a	A.M./P.M. 标记	PM
k	一天中的小时(1~24)	24
K	A.M./P.M. (0~11)格式小时	10
z	时区	Eastern Standard Time
'	文字定界符	Delimiter
"	单引号	`

l 使用printf格式化日期

printf方法可以很轻松地格式化时间和日期。使用两个字母格式，它以t开头并且以下面表格中的一个字母结尾。

Date date = new Date();

// 使用toString()显示日期和时间

String str = String.format("Current Date/Time : %tc", date );

System.out.printf(str);

重复提供日期,可以利用一个格式化字符串指出要被格式化的参数的索引。

索引必须紧跟在%后面，而且必须以$结束。

System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date);

使用<标志。它表明先前被格式化的参数要被再次使用。

System.out.printf("%s %tB %<te, %<tY", "Due date:", date);

日期和时间转换字符

字符	描述	例子
c	完整的日期和时间	Mon May 04 09:51:52 CDT 2009
F	ISO 8601 格式日期	2004-02-09
D	U.S. 格式日期 (月/日/年)	02/09/2004
T	24小时时间	18:05:19
r	12小时时间	06:05:19 pm
R	24小时时间，不包含秒	18:05
Y	4位年份(包含前导0)	2004
y	年份后2位(包含前导0)	04
C	年份前2位(包含前导0)	20
B	月份全称	February
b	月份简称	Feb
n	2位月份(包含前导0)	02
d	2位日子(包含前导0)	03
e	2位日子(不包含前导0)	9
A	星期全称	Monday
a	星期简称	Mon
j	3位年份(包含前导0)	069
H	2位小时(包含前导0), 00 到 23	18
k	2位小时(不包含前导0), 0 到 23	18
I	2位小时(包含前导0), 01 到 12	06
l	2位小时(不包含前导0), 1 到 12	6
M	2位分钟(包含前导0)	05
S	2位秒数(包含前导0)	19
L	3位毫秒(包含前导0)	047
N	9位纳秒(包含前导0)	047000000
P	大写上下午标志	PM
p	小写上下午标志	pm
z	从GMT的RFC 822数字偏移	-0800
Z	时区	PST
s	自 1970-01-01 00:00:00 GMT的秒数	1078884319
Q	自 1970-01-01 00:00:00 GMT的毫妙	1078884319047

5.3.8.4 Calendar类

设置和获取日期数据的特定部分呢或者在日期的这些部分加上或者减去值

创建Calendar对象

Calendar c = Calendar.getInstance();//默认为当前日期

Calendar方法

u 赋值

public final void set(int year,int month,int date)

c1.set(2009,6-1,12);// 创建一个代表2009年6月12日的Calendar对象

public void set(int field,int value)// 只给某个字段赋值

c1.set(Calendar.YEAR,2008);

u 在日期的这些部分加上或者减去值

c1.add(Calendar.DATE, 10);

u 获取日期的某部分值

c1.get(Calendar.YEAR)

常量	描述
Calendar.YEAR	年份
Calendar.MONTH	月份
Calendar.DATE	日期
Calendar.DAY_OF_MONTH	日期，和上面的字段意义完全相同
Calendar.HOUR	12小时制的小时
Calendar.HOUR_OF_DAY	24小时制的小时
Calendar.MINUTE	分钟
Calendar.SECOND	秒
Calendar.DAY_OF_WEEK	星期几 // 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）

5.3.8.4 GregorianCalendar类

Calendar类实现了公历日历，GregorianCalendar是Calendar类的一个具体实现。Calendar 的getInstance（）方法返回一个默认用当前的语言环境和时区初始化的GregorianCalendar对象。

GregorianCalendar定义了两个字段：AD和BC。这些代表公历定义的两个时代。

GregorianCalendar gcalendar = new GregorianCalendar(); // 显示当前时间和日期的信息

gcalendar.get(Calendar.DATE)

l int get(int field) //获取指定字段的时间值

l void set(int year, int month, int date, int hour, int minute, int second)

设置年、月、日、小时、分钟、秒的值。

l boolean isLeapYear(int year) // 确定给定的年份是否为闰年。

这里是GregorianCalendar 类提供的一些有用的方法列表：

序号	方法和说明
1	void add(int field, int amount) 根据日历规则，将指定的（有符号的）时间量添加到给定的日历字段中。
2	protected void computeFields() 转换UTC毫秒值为时间域值
3	protected void computeTime() 覆盖Calendar ，转换时间域值为UTC毫秒值
4	boolean equals(Object obj) 比较此 GregorianCalendar 与指定的 Object。
5	int get(int field) 获取指定字段的时间值
6	int getActualMaximum(int field) 返回当前日期，给定字段的最大值
7	int getActualMinimum(int field) 返回当前日期，给定字段的最小值
8	int getGreatestMinimum(int field) 返回此 GregorianCalendar 实例给定日历字段的最高的最小值。
9	Date getGregorianChange() 获得格里高利历的更改日期。
10	int getLeastMaximum(int field) 返回此 GregorianCalendar 实例给定日历字段的最低的最大值
11	int getMaximum(int field) 返回此 GregorianCalendar 实例的给定日历字段的最大值。
12	Date getTime() 获取日历当前时间。
13	long getTimeInMillis() 获取用长整型表示的日历的当前时间
14	TimeZone getTimeZone() 获取时区。
15	int getMinimum(int field) 返回给定字段的最小值。
16	int hashCode() 重写hashCode.
17	boolean isLeapYear(int year) 确定给定的年份是否为闰年。
18	void roll(int field, boolean up) 在给定的时间字段上添加或减去（上/下）单个时间单元，不更改更大的字段。
19	void set(int field, int value) 用给定的值设置时间字段。
20	void set(int year, int month, int date) 设置年、月、日的值。
21	void set(int year, int month, int date, int hour, int minute) 设置年、月、日、小时、分钟的值。
22	void set(int year, int month, int date, int hour, int minute, int second) 设置年、月、日、小时、分钟、秒的值。
23	void setGregorianChange(Date date) 设置 GregorianCalendar 的更改日期。
24	void setTime(Date date) 用给定的日期设置Calendar的当前时间。
25	void setTimeInMillis(long millis) 用给定的long型毫秒数设置Calendar的当前时间。
26	void setTimeZone(TimeZone value) 用给定时区值设置当前时区。
27	String toString() 返回代表日历的字符串。

5.3.9 正则表达式: 通过java.util.regex包下的Pattern类与Matcher类实现

java.util.regex包主要包括以下三个类：

Pattern类：pattern对象是一个正则表达式的编译表示。----创建,编译一个正则表达式

String reg = "(.*)(\\d+)(.*)";

Pattern r = Pattern.compile(reg) ;

Pattern类没有公共构造方法。要创建一个Pattern对象，你必须首先调用其公共静态编译方法Pattern.compile，它返回一个Pattern对象。该方法接受一个正则表达式(pattern)作为它的第一个参数。

r.pattern() //返回reg,正则表达式的字符串形式.
Pattern r=Pattern.compile("\\d+");

String[] str=r.split("我的QQ是:456456我的电话是:0532214我的邮箱是:aaa@aaa.com"); // str[0]="我的QQ是:" str[1]="我的电话是:" str[2]="我的邮箱是:aaa@aaa.com"

r.split(源字符串): 通过正则表达式,分隔字符串,并返回一个String[],返回的字符串中不包含正则表达式匹配到的内容.

Pattern.matches ("\\d+", "a123b") // Pattern.matches 是一个静态方法,如果正则表达式能全部匹配后面的字符串,则返回true,不匹配或者是部分匹配返回false

Matcher类：Matcher对象是对输入字符串进行解释和匹配操作的引擎。Macther类提供了对正则表达式的分组支持.

String line = "This order was placed for QT3000! OK?";

Matcher m = r.matcher(line);

Matcher也没有公共构造方法。你需要调用Pattern对象的matcher方法来获得一个Matcher对象。

m.mactches() // 如果正则表达式能匹配整个字符串,那么返回true
m.lookingAt()//只对前面的字符串进行匹配,匹配到为true.
bollean m.find() ----能搜索到匹配结果,任何位置都行,返回为真,否则返回为假.

String REGEX = "\\bcat\\b";

String INPUT ="cat cat cat cattie cat";

Pattern p = Pattern.compile(REGEX);

Matcher m = p.matcher(INPUT); // 获取 matcher 对象

匹配到的字符串有四个cat, cattie没被匹配上.

m.start()----匹配到的子字符串在源字符串中的索引位置,从0开始
m.end()----匹配到的子字符串的最后一个字符在源字符串中的偏移量,从1开始.
m.group(index)-----返回匹配到的所有子字符串

Pattern p=Pattern.compile("\\d+");
Matcher m=p.matcher("我的QQ是:456456 我的电话是:0532214 我的邮箱是:aaa123@aaa.com");

//返回456456 ,0532214 ,123

m.group(index)-----匹配到的子字符串,index 从0开始

捕获组group可以通过从左到右计算其开括号来编号，编号是从1 开始的。例如，在表达式 ((A)(B(C)))中，存在四个这样的组：
1 ((A)(B(C)))
2 (A)
3 (B(C))
4 (C)
group(0)始终代表整个表达式。以 (?) 开头的组是纯的非捕获组，它不捕获文本，也不针对组合计进行计数。groupCount: 有多少个捕获组,结果为4

Group保存的是与正则表达式最后一个匹配的子序列.

String line = "1ABC249a78";

String pattern = "(\\D)(\\d)"; // group(1)针对的正则表达式是(\\D),匹配到的字符串从前往后有可能是A B C,最后一个匹配的是C,所以, group(1)对应C.针对group(2),C后面第一个匹配的是2,所以group(2)保存的就是2.如果(\\d)变成(\\d+),那么第一个匹配的是249,group(2)保存的就是249

String line = "This order was placed for QT3000! OK?";

String pattern = "(.*)(\\d+)(.*)";

这儿(.*)匹配任意字符串,所以就看第二组(\\d+),最后一个匹配的就是0,那么m.group(2)=0,以此为分界,m.group(1)就是0以前的所有字符串,group(3)就是0以后所有的字符串

String line = "aba";

String pattern = "(a(b)?)+";

这儿(a(b)?)匹配a 或者ab,第二组(b)?,匹配b或者0,那么m.group(2)=b,以此为分界,m.group(1)就是a

替换方法

m.replaceFirst(替换字符串):替换第一次匹配正则表达式的文本
private static String REGEX = "dog";
private static String INPUT = "The dog says meow. " +
"All dogs say meow.";
private static String REPLACE = "cat";
Pattern p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT);
INPUT = m.replaceAll(REPLACE);
System.out.println(INPUT);
- m.replaceAll(替换字符串): 替换所有匹配正则表达式的文本.
- m.appendReplacement(StringBuffer sb, String 替换字符串)

将当前匹配子串替换为指定字符串,并且将两次匹配成功之间的字符串一起放到StringBuffer对象里.

m.appendTail(sb): 最后一次匹配后剩余的字符串添加到StringBuffer对象

String REGEX = "[a-z]+";

String INPUT = "aaa123bbb456ccc789";

String replacemeng = "-";

while(m.find()) {

m.appendReplacement(sb, replacemeng);

System.out.println("result:"+sb.toString());

}

m.appendTail(sb);

System.out.println("finalresult:"+sb.toString());

结果

result:-

result:-123-

result:-123-456-

finalresult:-123-456-789

PatternSyntaxException：

PatternSyntaxException是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

表1.常用的元字符
代码	说明
.	匹配除换行符以外的任意字符
\w	匹配字母或数字或下划线或汉字
\s	匹配任意的空白符
\d	匹配数字
\b	匹配单词的开始或结束
^	匹配字符串的开始
$	匹配字符串的结束
-	不是元字符，只匹配它本身——连字符
\	转义字符 C:\\Windows匹配C:\Windows。

表2.常用的限定符
代码/语法	说明
*	重复零次或更多次
+	重复一次或更多次
?	重复零次或一次
{n}	重复n次
{n,}	重复n次或更多次
{n,m}	重复n到m次, {2,12} 则是重复的次数不能少于2次，不能多于12次
?	当此字符紧随任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后时，匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串，而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如，在字符串"oooo"中，"o+?"只匹配单个"o"，而"o+"匹配所有"o"。

表3.常用的代码及对应的反义代码
代码/语法	说明
\b	代表着单词的开头或结尾，也就是单词的分界处。它匹配一个位置
\B	匹配不是单词开头或结束的位置
\d	数字字符匹配。等效于 [0-9]。
\D	非数字字符匹配。等效于 [^0-9]。
\s	匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
\S	匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
\w	匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。匹配字母或数字或下划线或汉字等。
\W	匹配任意不是字母，数字，下划线，汉字的字符。与"[^A-Za-z0-9_]"等效。
[^xyz]	匹配除了xyz以外的任意字符
[xyz]	字符集。匹配包含的任一字符。例如，"[abc]"匹配"plain"中的"a"。
[a-z]	字符范围。匹配指定范围内的任何字符。例如，"[a-z]"匹配"a"到"z"范围内的任何小写字母。
[^a-z]	反向范围字符。匹配不在指定的范围内的任何字符。例如，"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符。

		表4.其它代码
		代码/语法		说明
	x\|y		匹配 x 或 y。例如，'z\|food' 匹配"z"或"food"。'(z\|f)ood' 匹配"zood"或"food"。
	\cx		匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样，则假定 c 就是"c"字符本身。
	\f		换页符匹配。等效于 \x0c 和 \cL。
	\n		换行符匹配。等效于 \x0a 和 \cJ。
	\r		匹配一个回车符。等效于 \x0d 和 \cM。
	\t		制表符匹配。与 \x09 和 \cI 等效。
	\v		垂直制表符匹配。与 \x0b 和 \cK 等效。
	\xn		匹配 n，此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，"\x41"匹配"A"。"\x041"与"\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。
	\num		匹配 num，此处的 num 是一个正整数。到捕获匹配的反向引用。例如，"(.)\1"匹配两个连续的相同字符。
	\n		标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式，那么 n 是反向引用。否则，如果 n 是八进制数 (0-7)，那么 n 是八进制转义码。
	\nm		标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式，那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获，则 n 是反向引用，后面跟有字符 m。如果两种前面的情况都不存在，则 \nm 匹配八进制值 nm，其中 n 和 m 是八进制数字 (0-7)。
	\nml		当 n 是八进制数 (0-3)，m 和 l 是八进制数 (0-7) 时，匹配八进制转义码 nml。
	\un		匹配 n，其中 n 是以四位十六进制数表示的 Unicode 字符。例如，\u00A9 匹配版权符号 (©)。
(pattern)			匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( )，请使用"$"或者"$"。
(?:pattern)			匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用"or"字符 (\|) 组合模式部件的情况很有用。例如，'industr(?:y\|ies) 是比 'industry\|industries' 更经济的表达式。
(?=pattern)			执行正向预测先行搜索的子表达式，该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?=95\|98\|NT\|2000)' 匹配"Windows 2000"中的"Windows"，但不匹配"Windows 3.1"中的"Windows"。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
(?!pattern)			执行反向预测先行搜索的子表达式，该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?!95\|98\|NT\|2000)' 匹配"Windows 3.1"中的 "Windows"，但不匹配"Windows 2000"中的"Windows"。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。

5.3.10 正则表达式:

posted on 2015-05-08 14:17 小虾皮儿阅读(390) 评论(0) 收藏举报

刷新页面返回顶部