JAVA字符串操作总结与提升

创建一个字符串

1.直接创建：

String s="hello word";
//判断是否为空串: s=="";

2.使用new运算符创建：

String s=new String ("hello word");
//判断是否为空对象：s==null;

字符串的的拼接使用+，如：

String s1="hello";
String s2="word";
System.out.println(s1+s2);
//输出结果为 hello word

字符串的常用操作函数

1.length函数用于获取某一字符串的长度

	Scanner in =new Scanner(System.in);
		String s=in.nextLine();
		System.out.println(s.length());

2.equals函数用于比较两个字符串是否相等（非相同）

		String s="hello java";
		String s1="hello java";
		System.out.println(s1.equals(s));

3.startsWith函数用于判断某一字符串的前缀是否为另一字符串

String s="hello java";
String s2="hello";
System.out.println(s.startsWith(s2));

4.endsWith函数用于判断某一字符串后缀是否为另一字符串

String s="hello java";
String s4="java";
System.out.println(s.endsWith(s4));

5.compareTo函数，当前字符串与比较字符串相同，返回0，当前字符串大于比较字符串，返回正，当前字符串小于比较字符串，返回负。
比较原则：
依次取出两个字符串的字符，比较Unicode码，若s1长度小于s2，则s1<s2；

String s="hello java";
		String s1="hello java";
		String s2="hello";
		String s3="hello java,hello c";
		System.out.println(s1.compareTo(s2));
		System.out.println(s1.compareTo(s3));
		System.out.println(s1.compareTo(s));

6.indexOf函数：查找子串出现的位置，并返回首次出现的位置。

String s1="hello java";
System.out.println(s1.indexOf("va"));

7.subString函数用于获取子串：
subString（int Start，int end）注意：不包括end处的字符。

String s1="hello java";
String s5=s1.substring(2,8);
		System.out.println(s5);

8.tirm函数用于去掉字符串前后的空格：

String s7=" java";
		System.out.println(s7);
		String s6=s7.trim();
		System.out.println(s6);

9.split函数：以参数作为分隔符，获取分割后的字符串数组：

String s3="hello java,hello c";
String []s8=s3.split(",");
		System.out.println(s8[0]+""+s8[1]);

字符串与基本数据类型的相互转化

使用parse包裹方法：

Integer.parseInt("123");
Double.pareseDouble("5.15");

字符串与字符数组的相互转化

1.getChars函数实现：
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
srcBegin – 字符串中要复制的第一个字符的索引。
srcEnd – 字符串中要复制的最后一个字符之后的索引。
dst – 目标数组。
dstBegin – 目标数组中的起始偏移量。

String Str1 = new String("www.mazun132.com");
        char[] Str2 = new char[6];
        Str1.getChars(4, 10, Str2, 0);
            System.out.print("拷贝的字符串为：" );
            System.out.println(Str2 );

2.toString函数（将字符数组转化为字符串）:

char []a={'a','b','c'};
String s=a.toString();

3.toCharArray函数（将字符串转化为字符数组）:

String s="hello java";
char[]a=s.toCharArray();

正则表达式

正则表达式具有非常强大的功能，可以使用非常简单的代码实现复杂的匹配、替换等功能。
Java内嵌正则表达式引擎：Java.util.regex;
匹配规则：
（1）精确匹配：使用"“匹配双引号内的内容，如：“a&c"表示精确匹配"a&c”，注意在代码中应描述为"a\&c”，因为Java默认多一个\为转义符。非ASCII字符用\u###表示。
（2）特殊符号 . 可以匹配任意一个字符，如：“a.c"匹配"abc” ,“a&c”,但不匹配"ac"。
（3）符号\d可以匹配一个数字，如"00\d"匹配"007"
（4）符号\w可以匹配一个字母、数字或下划线，如"java\w"匹配"javac"
（5）符号\s可以匹配一个空白字符:如"A\sB"匹配"A B"
（6）符号\D可以匹配一个非数字，如"00\D"匹配:“00A”
（7）符号\W可以匹配一个非字母、数字或下划线:“java\W"匹配"java!”
（8）符号\S可以匹配一个非空白字符：“A\SB"匹配"ASB”
（9）修饰符 * 可以匹配任意个字符如"A\d *“匹配任意个数字字符"A21413”
（10）修饰符+可以匹配至少一个字符:“A\d+“匹配"A1”
（11）修饰符?可以匹配零个或一个字符:“A\d?“匹配"A1”,“A”
（12）修饰符{n}可以匹配n个字符:”\d{6}” “匹配"233432”(6个字符)
（13）修饰符{n,m}可以匹配n-m个字符:"\d{3,5}"+“匹配"132”,“4342”
（12）修饰符{n,}可以匹配至少n个字符:"\d{6,}" “匹配"233432”(6个字符)
程序实例：

public static boollean pipei(String s){
return s.maches("\\d{3,4}")
}

其他修饰符：

正则表达式	规则	可以匹配
^	开头	字符串开头
$	结尾	字符串结尾
【ABC】	【…】内任意一字符	A,B,C
[]a-f0-9xy	指定范围内的字符	a,f,1,2,c,x,y
[^A-F]	指定范围以外的其他字符	非A,B,C,D,E,F

AB|CD 匹配AB或CD 举例： AB,CD
AB|CD|EF匹配 AB或CD或EF 举例： AB,CD,EF
正则表达式应用举例：提取电话号码###-########

String s="^ \\d{3,4} \\- \\d{6,8}$";

1.我们若想提取匹配字符串的某一部分，可以在正则表达式中用小括号将其括起来。在之前的代码中，我们使用String的maches类进行匹配，而在小括号分组匹配时，我们使用Pattern类和matcher类。另外，如果需要多次匹配某一字符串，推荐使用Pattern对象方法。

import Java.util.regex;
public static void main(){
  Tel  parse(String s){//parse函数返回一个Tel类型的对象，传入一个字符串变量
Pattern p= Pattern.complie("^(0\\d{2,3})\\-([1,9]\\d[5,7])$");//用Pattern.compare获得一个Pattern对象
Macher m = p.macher(s);//获得一个macher对象
if(m.matches()){//如果matches方法返回为true
String s1=m.group(0);//提取所有内容
String s2=m.group(1);//提取第一个括号内的内容
return new Tel(s1,s2);//返回一个新的Tel对象
}
return null;
}
}

2.贪婪匹配和非贪婪匹配问题：由于Java的正则表达式默认使用贪婪匹配，例如，当使用+时，Java默认尽可能的多向后匹配字符。如果我们想提取某一串数字最后的0的个数,我们使用("^(\d+)\-(0*)$")是不可取的，因为无论输入多少数字，+都会将所有数字归到第一个括号内，第二个括号只能匹配到 “” （空）。解决方案：使用?实现非贪婪匹配。

Pattern p=Pattern.compare("^(\\d+?)\\-(0*)$");
Matcher m=p.macher("123000");
if(m.matches())
{
m.group(1);//"123"
m.group(2);"000"
}

注意：\d?? 第一个？表示匹配0或1个字符，第二个?表示非贪婪匹配。
3.使用正则表达式分割字符串：

"a,b;; c".split("[\\, \\; \\s]+");//{"a","b","c"}

4.使用正则表达式的Matcher.find()方法搜索字符串：

String s="the quick brown fox jump over the lazy dog."
Pattern p =Pattern.compile("the",Pattern.CASE_INSENSITIVE);
Maher m=p.machier;
while(m.find())
{
String sub=s.subString(m.start(),m.end());
System.out.println(sub+",start=" + m.start() + ",end=" + m.end());
}
//Pattern.CASE_INSENSITIVE表示此搜索大小写不敏感

5.使用正则表达式的replaceAll方法替换字符串：

String s="the         quick    brown  fox jump over the lazy dog."
String r=s.relpaceAll("\\s+"," ");
//得到the quick brown fox jump over the lazy dog.

6.反向引用：

 String r2 =  r1.replaceAll("(\\w+)","<b>$1<b>");
//使用$1反向引用r1中每一个单词，为其加粗)。

StringTokenizer 类

StringTokenizer 类能够从一个字符串中根据指定的分隔符，拆分出若干单词，注意使用时需要import。其功能比spilt更为强大，因其允许指定若干个分隔符。
常用函数：
String nextToken()//逐个获取字符串中的单词
boolean hasMoreTokens()//判断是否还有未取得的单词
int countTokens()//统计剩余的单词树
程序运行实例：

while(st.hasMoreTokens()){
System.out.println(st.nextToken()+"/");
}

使用Scanner的useDelimiter方法分隔文件

Scanner sc = new Scanner(s);
sc.useDelimiter("[^1332423];");
double sun=sc.nextDouble();

useDelimiter(","); //以’,'为分隔符
useDelimiter("\n"); //“\n”换行符（回车）作为输入的分隔符。

StringBuffer类

Sting对象是不可修改的，执行String的tirm，replaceAll等方法时，实际上是创建了一个新的实体，然后改变String对象的引用。如果一个字符串经常发上改变，显然会浪费大量的内存空间。
StringBuffer类是可修改的字符串序列，适合存放一个可变的字符序列。
1.StringBuffer类的构造方法：
（1）StringBuffer();//默认16字符
（2）StringBuffer(int size);//指定容量
（3）StringBuffer(String s);//容量为s的长度外加16字符

StringBuffer sb = newStringBuffer("hello");
sb.append("word!");

常用方法:
append()：追加字符串
char charAt(int n)：获取指定位置字符
void setCharAt(int n,char c)：替换指定字符
StringBuffer insert(int n,String s)：插入字符串
StringBuffer reverse()：翻转字符串
StringBuffer delete(int start,int end)：删除指定位置范围的字符，从start到end-1
StringBuffer replace(int start,int end ,String s)：替换指定位置范围的字符，从start到end-1

StringBuffer  buffer=new StringBuffer(“hello world”);
Char c=buffer.charAt(4);   //   ‘o’
buffer.setChartAt(5,’_’) ;  // hello_world
buffer.insert(0,”upc ”);  //upc hello_world