13字符串-Java编程思想

有意思的地方：在idea中，输入sout,再按tab就可以出现输出打印的一行代码。

psvm,再按tab即可出现public static void main

运行时候按键control，shift，r。

当运行的代码需要额外的输入args的时候，在run/edit configurations/program arguments中编辑即可。

字符串操作是程序中最常见的行为。

String对象是不可变的，看起来在修改对象的实际上都是创建了一个全新的对象。对象具有可读性。

重载操作符：操作符在用于特定的类的时候，被赋予特殊的意思。String的+，+=是java中仅有的重载操作符，java不允许程序员重载操作符。

关于String，StringBuffer，StringBuilder

String是定长的，是不可变对象，每次对String对象进行改变长度的操作实际都是生成了新的对象。对StringBuilder与StringBuffer对象的操作都是针对其自身，在字符串对象会经常改变的情况下使用这两个比较好。StringBuffer是线程安全的，而StringBuilder是非线程安全的，所以StringBuilder要快一些。StringBuilder是javaSE5引入的。

●对于“+”，se5以前是对于String创建三个对象，se5以后jvm进行了优化，编译器调用了StringBuilder。

代码段：

public static void main(String[] args){

String mango="mango";

String s="abc"+mango+""def"+47;

}

如果是为一个类编写toString()，字符串操作比较简单就可以依赖编译器。如果在toString()方法中使用了循环，那么最好自己创建StringBuilder对象来构造最终的结果。

public class StringBuilderTest {
public static Random random=new Random(47);
@Override
public String toString() {
StringBuilder result=new StringBuilder("[");
for(int i=0;i<25;i++  ){
result.append(random.nextInt(100));
result.append(", ");
}
result.delete(result.length() -2, result.length());
result.append("]");
return result.toString();
}
public static void main(String[] args) {
StringBuilderTest stringBuilderTest=new StringBuilderTest();
System.out.println(stringBuilderTest);
}
}

//结果：[58, 55, 93, 61, 61, 29, 68, 0, 22, 7, 88, 28, 51, 89, 9, 78, 98, 61, 20, 58, 16, 40, 11, 22, 4]

容器类都有覆写toString()方法，例如ArrayList().toString()方法遍历ArrayList所有对象，调用每个元素的toString()方法。

String上的操作：length（）字符个数，charAt(Int)取得该索引位置上的char，toCharArray()把String字符生成char[]，equals(String)比较两个String是否相同，compareTo(String)按字典顺序比较String内容（比较结果为负数0或正数，大小写不同），contains(String)如果String中包括参数的内容就返回true，startsWith()、endsWith()判断是否是以某参数为开头或结尾的，indexOf（）判断String是否包含该参数，没有就返回-1。

当需要改变字符串内容的时候，String方法会返回一个新的Stirng对象。如果内容没有发生改变，String方法知识返回原对象的引用而已。

格式化输出

对输出格式和排练提供更大的控制能力。

printf("Row 1: [%d %f]\n",x,y);不仅仅说明了插入数据的位置，还说明了变量类型。%d表示x是一个整数，%f表示y是浮点数。

javaSE5引入的format方法实际等价于printf方法。format方法作用于PrintStream,PrintWrite方法,其中包括System.out方法。

//Old way
System.out.print("Row 1: ["+i+" x "+j+" ]\n");
//printf way
System.out.printf("Row 1: [%d x %f]\n",i,j);
//format way
System.out.format("Row 1: [%d x %f]\n",i,j);
//Row 1: [10 x 1.000000]

java中所有格式化的功能由java.util.Formatter类处理，Formatter一个翻译器，把格式化字符串和数据翻译。创建Formatter对象的时候，向构造器传递一些信息，告诉最终结果输出到哪里。最常用的是PrintStream(),OutputStream,File。这个地方需要领悟的是，更高级的格式化输出查看Formatter部分。对于更加精细的控制，例如控制对齐方式，尺寸大小等参考Java编程思想原书。

String.format()是一个static方法，它接受Formatter.format()方法一样的参数，返回String方法，实际上这种方式非常方便。

String s="wan";

int a=1,b=2;

System.out.println(String.format("(t%d,q%d) %s",a,b,s));

正则表达式

强大而灵活的文本处理工具。用编程的方式构造复杂的文本模式，并对输入的字符串进行搜索，一旦搜索到匹配到的部分，就可以随心所欲的进行处理。正则表达式提供了完全通用的方式，能解决各类字符串处理相关的问题：匹配，选择，编辑，验证。

public class StringMatch1Test {
//正则表达式,简单的String.matches方法
public static void main(String args[]){
System.out.println("-1234".matches("-?\\d+"));
System.out.println("5678".matches("-?\\d+"));
System.out.println("+911".matches("-?\\d+"));
System.out.println("+911".matches("(-?|\\+)\\d+"));
//true true false true
}
}

public class StringMatch2Test {
//正则表达式,split方法
public static String s="helln, i am here learning javn,i love java so much,and i enjoy play with datn.";
public static void spilt(String regex){
System.out.println(Arrays.toString(s.split(regex)));
}
public static void main(String args[]){
spilt(" ");//以空格为划分
spilt("\\W+");//以非单词字符划分
spilt("n\\W+");//
spilt("i");
//下面的方法是为了证明说split后的形式
String[] strings="i want to study java.".split(" ");
for (String s:strings
) {
System.out.println(s);
}

}
}
[helln,, i, am, here, learning, javn,i, love, java, so, much,and, i, enjoy, play, with, datn.]
[helln, i, am, here, learning, javn, i, love, java, so, much, and, i, enjoy, play, with, datn]
[hell, i am here learning jav, i love java so much,and i enjoy play with dat]
[helln, ,  am here learn, ng javn,,  love java so much,and ,  enjoy play w, th datn.]

i
want
to
study
java.

关于替代：

public class StringReplace {
//替代
private static String s="i love java , and i love being a pm , i enjoy my life";
public static void main(String args[]){
System.out.println(s.replaceFirst("o\\w+","oo"));
//i loo java , and i love being a pm , i enjoy my life
System.out.println(s.replaceAll("i|my","wanpro"));
//wanpro love java , and wanpro love bewanprong a pm , wanpro enjoy wanpro lwanprofe
System.out.println(s.replaceAll("i\\W+","wanpro "));
//wanpro love java , and wanpro love being a pm , wanpro enjoy my life
}
}

public class StringMatch3Test {
public static void main(String args[]){
String[] strings={"Rudolph","[rR]udolph","[rR][aeiou][a-z]ol.*","R.*"};
for (String s:strings
) {
System.out.println("Rudolph".matches(s));
}
}
}
//true true true true

Pattern和Matcher

先生存一个Pattern对象，然后把需要检索的内容传入matcher方法创建出Matcher的对象。

该程序在300页.在测试自己写的正则表达式是否具有匹配功能时候有用

pattern对象表示编译后的正则表达式，我们用已经编译的pattern对象的matcher方法加上一个字符串，共同创建了一个Matcher对象。

public class StringRegularExpression {
public static void main(String args[]){
if (args.length<2){
System.out.print("Usage:\njava TestRegularExpression");
System.exit(0);
}
//下面用到了转义符
System.out.println("Input: \""+args[0]+"\"");
for (String arg:args
) {
System.out.println("Regular Expression : \""+arg+" \"");
Pattern p=Pattern.compile(arg);<span style="font-family: Menlo; font-size: 9pt;">//**********************************
</span>            Matcher m=p.matcher(args[0]);<span style="font-family: Menlo; font-size: 9pt;">//**********************************</span>
while(m.find()){
System.out.println("Match \""+m.group()+"\" at positons "+m.start()+"-"+(m.end()-1));
}
}
}
}Input: "abcabcabcabcdefabc"
Regular Expression : "abcabcabcabcdefabc "
Match "abcabcabcabcdefabc" at positons 0-17
Regular Expression : "abc+ "
Match "abc" at positons 0-2
Match "abc" at positons 3-5
Match "abc" at positons 6-8
Match "abc" at positons 9-11
Match "abc" at positons 15-17
Regular Expression : "(abc)+ "
Match "abcabcabcabc" at positons 0-11
Match "abc" at positons 15-17
Regular Expression : "(abc){2,} "
Match "abcabcabcabc" at positons 0-11

public class StringRegular2Expression {
public static void main(String[] args) {
Matcher m= Pattern.compile("\\w+").matcher("wanpro want data");
while(m.find()){
System.out.print(m.group()+" ");
}
int i=0;
System.out.println();
while(m.find(i)){
System.out.print(m.group()+" ");
i++;
}
}
}
//wanpro want data
//wanpro anpro npro pro ro o want want ant nt t data data ata ta a前面的\\w+将字符串划分为单词，find()像迭代器一样遍历输入的字符串。第二个find能指定接收整数作为参数，该整数作为字符串中字符的位置，作为搜索的起点。