第十三章 字符串

2013年8月1日 星期四 21时05分59秒

第十三章 字符串
可以证明，字符串操作是计算机设计中最常见的行为

13.1 不可变String
String类中每一个看起来会修改String值的方法，实际上都是创建一个全新的String对象。

13.2 重载“+”与StringBuilder
可以用javap命令来反编译class文件，查看代码是如何工作。
例如：类Concatenation
package chapter13;
public class Concatenation {
public static void main(String[] args) {
String mango="mango";
String s="abc"+mango+"def"+47;
System.out.println(s);
}
}

通过javap -c Concatenation后，得到如下字节码：
D:\Program Files\Java\jdk1.6.0_13\bin>javap -c Concatenation
Compiled from "Concatenation.java"
public class chapter13.Concatenation extends java.lang.Object{
public chapter13.Concatenation();
Code:
0: aload_0
1: invokespecial #8; //Method java/lang/Object."<init>":()V
4: return

public static void main(java.lang.String[]);
Code:
0: ldc #16; //String mango
2: astore_1
3: new #18; //class java/lang/StringBuilder
6: dup
7: ldc #20; //String abc
9: invokespecial #22; //Method java/lang/StringBuilder."<init>":(Ljava/la
ng/String;)V
12: aload_1
13: invokevirtual #25; //Method java/lang/StringBuilder.append:(Ljava/lang
/String;)Ljava/lang/StringBuilder;
16: ldc #29; //String def
18: invokevirtual #25; //Method java/lang/StringBuilder.append:(Ljava/lang
/String;)Ljava/lang/StringBuilder;
21: bipush 47
23: invokevirtual #31; //Method java/lang/StringBuilder.append:(I)Ljava/la
ng/StringBuilder;
26: invokevirtual #34; //Method java/lang/StringBuilder.toString:()Ljava/l
ang/String;
29: astore_2
30: getstatic #38; //Field java/lang/System.out:Ljava/io/PrintStream;
33: aload_2
34: invokevirtual #44; //Method java/io/PrintStream.println:(Ljava/lang/St
ring;)V
37: return
}
由此可知，编译器创建了一个StringBuilder对象，用于构造最终的String。
注解：dup指令是复制之前分配的java/lang/StringBuilder空间的引用并压入栈顶，invokevirtual指令通过22这个常量池入口需找到了java/lang/ StringBuilder.append()方法，构造方法虽然找到了。但是必须还得知道是谁的构造方法，所以要将之前分配的空间的应用压入栈顶让 invokespecial命令应用才知道原来这个构造方法是刚才创建的那个引用的，调用完成之后将栈顶的值弹出。之后调用astore_1将此时的栈顶值弹出 存入局部变量中去。

13.3 无意识的递归
package chapter13;
import java.util.ArrayList;
import java.util.List;
/*@name InfiniteRecursion.java
* @describe 13.3 无意识的递归
* @since 2013-08-03 00:06
* @author 张彪
*/
public class InfiniteRecursion {
public String toString(){
return "InfiniteRecursion"+ this +"\n"; //this应该改为super.toString()
}
public static void main(String[] args) {
List<InfiniteRecursion> list=new ArrayList<InfiniteRecursion>();
for(int i=0;i<3;i++){
list.add(new InfiniteRecursion());
}
System.out.println(list.toString());
}
}
//报错
/*Exception in thread "main" java.lang.StackOverflowError
at java.lang.StringBuilder.append(StringBuilder.java:119)
at java.lang.StringBuilder.<init>(StringBuilder.java:93)*/

报错原因是由于编译器看到一个String对象之后跟一个“+”号，而后边的对象不是String类型，于是编译器试图将this转换成一个String。正式通过调用this上的 toString()方法，于是发生了递归调用。
如果你这的想打印对象的内存地址，应该用Object.toString()方法。这才是负责此任务的方法。

13.4 String上的操作
String对象的常用方法。
String类的方法都会返回一个新的String对象。同时，如果内容没发生改变，String()方法只是返回指向原对象的引用而已。

13.5 格式化输出
13.5.1 printf()
13.5.2 System.out.format()
J2SE5引入的format()方法。format()方法模仿于C的printf()方法。
package chapter13;
public class SimpleFormat {
public static void main(String[] args) {
int x=5;
float y=4.5f;
System.out.println(x+" "+y);
System.out.printf("%d,%f\n",x,y);
System.out.format("%d,%f",x,y );
}
}

13.5.3 Formatter类
13.5.4 格式化说明符
package chapter13;
import java.util.Formatter;
/*@name Receipt.java
* @describe 13.5.4 格式化说明符
* @since 2013-08-03 01:24
* @author 张彪
*/
//打印一个购物收据
public class Receipt {
private double total=0;
private Formatter f=new Formatter(System.out);
public void printTitle(){
f.format("%-15s %5s %10s\n","Item","Qty","Price");
f.format("%-15s %5s %10s\n","----","----","----");
}
public void print(String name ,int qty, double price){
f.format("%-15.15s %5d %10.2f\n", name,qty,price);
total+=price;
}
public void printTotal(){
f.format("%-15s %5s %10.2f\n","Tax","",total*0.06);
f.format("%-15s %5s %10s\n","","","----" );
f.format("%-15s %5s %10.2f\n","Total","",total*1.06 );
}

public static void main(String[] args) {
Receipt t=new Receipt();
t.printTitle();
t.print("Jack's Magic Bean", 4, 4.25);
t.print("Princess Peas", 3, 5.1);
t.printTotal();
}
}

Formatter提供了对空格与对其的强大功能。

13.5.5 Formatter转换
13.5.6 String.format()

13.6 正则表达式
正则表达式是一种强大而灵活的文本处理工具。
13.6.1 基础
\d 表示一位数字
在 Java中，"\\"的意思是我要插入一个正则表达式的反斜线。
-?\\d+ 表示可能有一个负数，后面有多个数字

13.6.2 创建正则表达式
13.6.3 量词
量词描述一个模式吸收输入文本的方式
贪婪型：
勉强型：用?号来指定,
占有型：

charSequence 接口。

package chapter13;
import java.util.Arrays;

/*@name IntegerMatch.java
* @describe 13.6 正则表达式
* @since 2013-08-03 10:24
* @author 张彪
*/
public class IntegerMatch {
public void match1(){
System.out.println("-123".matches("-?\\d+")); //true
System.out.println("-a3".matches("-?\\d+")); //false
//"+"在正则表达式有特殊的意义，所以这个地方要用转义
System.out.println("+56".matches("(-|\\+)?\\d+")); //true
}
public void splitMethod(){
String knights="Tree in the fores... wih ....a herring!";
String regex1="\\w+";
System.out.println(Arrays.toString(knights.split(" "))); //以" "进行分割
System.out.println(Arrays.toString(knights.split("\\W"))); // "\W"意思是非单词字符 ,"\w"表示一个单词字符
System.out.println(Arrays.toString(knights.split("n\\W+"))); //表示字母n后面跟着一个或多个非单词字符
//split(regex, limit) 重载方法， 第二个参数为限制分割的次数
}
public void replaceMethod(){
System.out.println("abc".replaceFirst("a|b|c","uu")); //uubc
}
//创建正则表达式
public void createRegex(){
for(String patter:new String[]{"Rudolph","[rR]udolph","[rR][aeiou][a-z]ol.*","R.*"}){
System.out.println("Rudolph".matches(patter));
}
}
public static void main(String[] args) {
new IntegerMatch().createRegex();
}
}

13.6.4 Patter和Matcer
Matcher.find()方法可以在CharSequence中查找多个匹配。
package chapter13.string;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Finding {
public void findMethod(){
//模式 "\\w+" 将字符串划分为单词
Matcher m=Pattern.compile("\\w+").matcher("Evening is full of the linet's wings");
while(m.find()){
System.out.print(m.group()+"-");
}
System.out.println();
int i=0;
while(m.find(i)){
System.out.print(m.group()+"-");
i++;
}
}
public static void main(String[] args) {
new Finding().findMethod();
}
}

组（Groups）
组是用括号划分的正则表达式，可以根据组的编号来引用某个组。组号为0表示整个表达式。

start（）和end（）
Pattern标记
package chapter13.string;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ReFlags {
public static void main(String[] args) {
Pattern p=Pattern.compile("^java", Pattern.CASE_INSENSITIVE|Pattern.MULTILINE);
Matcher m=p.matcher("java has regex\nJava has regex\n" +
"JAVA has regex\n" +
"Regular exression are in Java");
while(m.find()){
System.out.println(m.group()+"-");
}
}
}
/*java-
Java-
JAVA-*/
该例子中的模式将匹配以"java,Java,JAVA"等开头的行。注意group()方法只返回已匹配的部分。

13.6.5 split()方法
split()方法将输入字符串断开成字符串对象数组，断开边界由下列正则表达式确定。
package chapter13.string;
import java.util.Arrays;
import java.util.regex.Pattern;
public class SplitDemo {
public static void main(String[] args) {
String input="This!!unusal use!!of exclamation!!points";
System.out.println(Arrays.toString(Pattern.compile("!!").split(input))); //[This, unusal use, of exclamation, points]
//第二个参数可以限制分割成字符串的数量
System.out.println(Arrays.toString(Pattern.compile("!!").split(input,3))); //[This, unusal use, of exclamation!!points]
}
}

13.6.6 替换操作
replaceFirst(),replaceALl(),appendReplacement()..........
13.6.7 reset()
13.6.8 正则表达式与Java I/O

13.7 扫描输入
Scanner类
Scanner类在 Java SE5中新增的类。
package chapter13.string;
import java.io.BufferedReader;
import java.io.StringReader;
import java.util.Scanner;
public class BetterRead {
public static void main(String[] args) {
Scanner scanner=new Scanner(new BufferedReader(new StringReader("Sir Robin of Camelot\n22 1.61803")));
System.out.println(scanner.nextLine()); //Sir Robin of Camelot
System.out.println(scanner.nextInt()); //22
}
}

13.7.1 Scanner定界符
Scanner默认情况下根据空白字符对输入进行分词。但是你也可以根据正则表达式进行指定自己所需要的定界符
package chapter13.string;
import java.util.Scanner;
public class ScannerDelmiter {
public static void main(String[] args) {
Scanner scanner=new Scanner("12,34,56,78");
scanner.useDelimiter("\\s*,\\s*");
while(scanner.hasNext()){
System.out.println(scanner.nextInt());
}

}
}

13.7.2 用正则表达式扫描

13.8 StringTokenizer
有了正则表达式和Scanner之后，StringTokenizer基本上可以废弃不用了。

13.9 总结

个人总结： 通过这章的学习，对正则表达式有了新的认识。。。。。。。。。。




2013-08-06 0:47 记 @jinrongdajie31.xichengqu.beijing