字符串（String、String Buffer、StringBuilder）常用方法
原文链接：https://www.cnblogs.com/116970u/p/11495096.html
1.String
1 1.获取：
2 1）获取字符串str长度
3 int i = str.length();
4 2)根据位置（index)获取字符
5 char c = str.charAt(index);
6 3)获取字符在字符串中的位置
7 int i =str.indexOf(char ch); //获取的是第一次出现的位置
8 int i =str.indexOf(char ch ,int index); //从位置index后获取ch出现的第一次的位置
9 int i =str.indexOf(str1) ;// 获取str1 在str 第一次出现的位置
10 int i=str.indexOf(str1, index0);//获取从index位置后str第一次出现的位置
11 int i = str.lastIndexOf(ch或者 str1) //获取ch或者str1最后出现的位置
12
13 2.判断
14 1)判断是否以指定字符串str1开头、结尾
15 boolean b = str.startWith(str1) //开头
16 boolean b = str.endsWith(str1) //结尾
17 2)判断是否包含某一子串
18 boolean b = str.contains(str1)
19 3)判断字符串是否有内容
20 boolean b = str.isEmpty();
21 4)忽略大小写判断字符串是否相同
22 boolean b = str.equalsIgnoreCase(str1);
23
24 3.转换
25 1)将字符数组 -char[] ch- 转化成字符串
26 i. String str =new String(ch); //将整个数组变成字符串
27 ii. String str =new String(ch,offset,count)
28 //将字符数组中的offset位置之后的count个元素转换成字符串
29 1. String str =String.valueOf(ch);
30 2. String str =String.copyValueOf(ch,offset,count);
31 3. String str =String.copyValueOf(ch);
32 2)将字符串转化为字符数组
33 char[] ch = str.toCharAarray();
34 3)将字节数组转换为字符串
35 同上1) 传入类型变为Byte[];
36 4)将字符串转换为字节数组
37 Byte[] b = str.toByteArray();
38 5)将基本数据类型装换成字符串
39 String str = String.valueOf(基本数据类型数据)；
40 若是整形数据可以用 字符串连接符 + ""
41 eg : String str = 5+"";
42 得到字符串 “5”
43
44 4.替换 replace();
45 str.replace(oldchar,newchar)//将str里oldchar变为newchar
46 str.replace(str1,str2)//将str中str1，变为str2
47
48 5.切割 split();
49 String[] str1 = str.split(","); //将str用 ","分割成String数组
50
51 6.子串
52 String s = str.substring(begin);
53 // s 为 str 从begin位置到最后的字符串
54 String s = str.substring(begin,end)
55 //s 是 str 从begin 位置到end 位置的字符串
56
57 7.转换大小写：
58 String s1 = str. toUpperCase(); //将str变成大写字母
59 String s2 = str. toLowerCase(); //将str变成小写字母
60 除去空格：
61 String s =str.trim();
62 比较：
63 int i = str.compareTo(str1);
2.StringBuffer/StringBuilder
1 /***StringBuffer 是一个容器，长度可变，可以直接操作字符串，用toString方法变为字符串 **/ 2 1.存储 3 1)append(); //将指定数据加在容器末尾,返回值也是StringBuffer 4 eg: 5 StringBuffer sb = new StringBuffer(//可以加str); 6 StringBuffer sb1=ab.append(数据） //数据可以任何基本数据类型 7 注：此时sb == sb1他们是同一对象，意思是可以不用新建sb1直接 sb.append(数据) 使用时之后接使用sb 8 2)insert();// 插入 9 sb.insert(index ,数据); 10 2.删除 11 sb.delete(start ,end); //删除start到end的字符内容 12 //注意：这里的所有包含index的操作都是含头不含尾的 13 sb.deleteCharAt(index);//删除指定位置的字符 14 //清空StringBuffer缓冲区 15 sb=new StringBuffer(); 16 sb.delete(0,sb.length()); 17 3.获取 18 char c = sb.charAt(index);//获取index上的字符 19 int i = sb.indexOf(char)://获取char字符出现的第一次位置 20 //与 String 中的获取方法一致参考前面 21 22 4.修改 String类中无次操作方法 23 sb =sb.replace(start,end,string)//将从start开始到end的字符串替换为string； 24 sb.setCharAr(index ,char);//将index位置的字符变为新的char 25 26 5.反转 sb.reverse();//将sb倒序 27 6. getChars(int srcBegin,int srcEnd,char[] ch,int chBegin) 28 //将StringBuffer缓冲区中的指定数据存储到指定数组中
正则表达式语法大全
1 [正则表达式]文本框输入内容控制
2 整数或者小数：^[0-9]+\.{0,1}[0-9]{0,2}$
3 只能输入数字："^[0-9]*$"。
4 只能输入n位的数字："^\d{n}$"。
5 只能输入至少n位的数字："^\d{n,}$"。
6 只能输入m~n位的数字：。"^\d{m,n}$"
7 只能输入零和非零开头的数字："^(0|[1-9][0-9]*)$"。
8 只能输入有两位小数的正实数："^[0-9]+(.[0-9]{2})?$"。
9 只能输入有1~3位小数的正实数："^[0-9]+(.[0-9]{1,3})?$"。
10 只能输入非零的正整数："^\+?[1-9][0-9]*$"。
11 只能输入非零的负整数："^\-[1-9][]0-9"*$。
12 只能输入长度为3的字符："^.{3}$"。
13 只能输入由26个英文字母组成的字符串："^[A-Za-z]+$"。
14 只能输入由26个大写英文字母组成的字符串："^[A-Z]+$"。
15 只能输入由26个小写英文字母组成的字符串："^[a-z]+$"。
16 只能输入由数字和26个英文字母组成的字符串："^[A-Za-z0-9]+$"。
17 只能输入由数字、26个英文字母或者下划线组成的字符串："^\w+$"。
18 验证用户密码："^[a-zA-Z]\w{5,17}$"正确格式为：以字母开头，长度在6~18之间，只能包含字符、数字和下划线。
19 验证是否含有^%&',;=?$\"等字符："[^%&',;=?$\x22]+"。
20 只能输入汉字："^[\u4e00-\u9fa5]{0,}$"
21 验证Email地址："^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$"。
22 验证InternetURL："^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$"。
23 验证电话号码："^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$"正确格式为："XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX"。
24 验证身份证号（15位或18位数字）："^\d{15}|\d{18}$"。
25 验证一年的12个月："^(0?[1-9]|1[0-2])$"正确格式为："01"～"09"和"1"～"12"。
26 验证一个月的31天："^((0?[1-9])|((1|2)[0-9])|30|31)$"正确格式为；"01"～"09"和"1"～"31"。
27 匹配中文字符的正则表达式： [\u4e00-\u9fa5]
28 匹配双字节字符(包括汉字在内)：[^\x00-\xff]
29 应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
30 String.prototype.len=function(){return this.replace(/[^\x00-\xff]/g,"aa").length;}
31 匹配空行的正则表达式：\n[\s| ]*\r
32 匹配html标签的正则表达式：<(.*)>(.*)<\/(.*)>|<(.*)\/>
33 匹配首尾空格的正则表达式：(^\s*)|(\s*$)
34
184 JAVA正则表达式语法（转）
185 正则表达式语法
186
187 正则表达式是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为“元字符”）。模式描述在搜索文本时要匹配的一个或多个字符串。
188
189 正则表达式示例
190
191 表达式 匹配
192 /^\s*$/
193 匹配空行。
194
195 /\d{2}-\d{5}/
196 验证由两位数字、一个连字符再加 5 位数字组成的 ID 号。
197
198 /<\s*(\S+)(\s[^>]*)?>[\s\S]*<\s*\/\1\s*>/
199 匹配 HTML 标记。
200
201 下表包含了元字符的完整列表以及它们在正则表达式上下文中的行为：
202
203
204 字符 说明
205 \
206 将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如，“n”匹配字符“n”。“\n”匹配换行符。序列“\\”匹配“\”，“\(”匹配“(”。
207
208 ^
209 匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与“\n”或“\r”之后的位置匹配。
210
211 $
212 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与“\n”或“\r”之前的位置匹配。
213
214 *
215 零次或多次匹配前面的字符或子表达式。例如，zo* 匹配“z”和“zoo”。* 等效于 {0,}。
216
217 +
218 一次或多次匹配前面的字符或子表达式。例如，“zo+”与“zo”和“zoo”匹配，但与“z”不匹配。+ 等效于 {1,}。
219
220 ?
221 零次或一次匹配前面的字符或子表达式。例如，“do(es)?”匹配“do”或“does”中的“do”。? 等效于 {0,1}。
222
223 {n}
224 n 是非负整数。正好匹配 n 次。例如，“o{2}”与“Bob”中的“o”不匹配，但与“food”中的两个“o”匹配。
225
226 {n,}
227 n 是非负整数。至少匹配 n 次。例如，“o{2,}”不匹配“Bob”中的“o”，而匹配“foooood”中的所有 o。“o{1,}”等效于“o+”。“o{0,}”等效于“o*”。
228
229 {n,m}
230 M 和 n 是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次。例如，“o{1,3}”匹配“fooooood”中的头三个 o。'o{0,1}' 等效于 'o?'。注意：您不能将空格插入逗号和数字之间。
231
232 ?
233 当此字符紧随任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后时，匹配模式是“非贪心的”。“非贪心的”模式匹配搜索到的、尽可能短的字符串，而默认的“贪心的”模式匹配搜索到的、尽可能长的字符串。例如，在字符串“oooo”中，“o+?”只匹配单个“o”，而“o+”匹配所有“o”。
234
235 .
236 匹配除“\n”之外的任何单个字符。若要匹配包括“\n”在内的任意字符，请使用诸如“[\s\S]”之类的模式。
237
238 (pattern)
239 匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果“匹配”集合中检索捕获的匹配。若要匹配括号字符 ( )，请使用“\(”或者“\)”。
240
241 (?:pattern)
242 匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用“or”字符 (|) 组合模式部件的情况很有用。例如，'industr(?:y|ies) 是比 'industry|industries' 更经济的表达式。
243
244 (?=pattern)
245 执行正向预测先行搜索的子表达式，该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?=95|98|NT|2000)' 匹配“Windows 2000”中的“Windows”，但不匹配“Windows 3.1”中的“Windows”。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
246
247 (?!pattern)
248 执行反向预测先行搜索的子表达式，该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?!95|98|NT|2000)' 匹配“Windows 3.1”中的 “Windows”，但不匹配“Windows 2000”中的“Windows”。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
249
250 x|y
251 匹配 x 或 y。例如，'z|food' 匹配“z”或“food”。'(z|f)ood' 匹配“zood”或“food”。
252
253 [xyz]
254 字符集。匹配包含的任一字符。例如，“[abc]”匹配“plain”中的“a”。
255
256 [^xyz]
257 反向字符集。匹配未包含的任何字符。例如，“[^abc]”匹配“plain”中的“p”。
258
259 [a-z]
260 字符范围。匹配指定范围内的任何字符。例如，“[a-z]”匹配“a”到“z”范围内的任何小写字母。
261
262 [^a-z]
263 反向范围字符。匹配不在指定的范围内的任何字符。例如，“[^a-z]”匹配任何不在“a”到“z”范围内的任何字符。
264
265 \b
266 匹配一个字边界，即字与空格间的位置。例如，“er\b”匹配“never”中的“er”，但不匹配“verb”中的“er”。
267
268 \B
269 非字边界匹配。“er\B”匹配“verb”中的“er”，但不匹配“never”中的“er”。
270
271 \cx
272 匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样，则假定 c 就是“c”字符本身。
273
274 \d
275 数字字符匹配。等效于 [0-9]。
276
277 \D
278 非数字字符匹配。等效于 [^0-9]。
279
280 \f
281 换页符匹配。等效于 \x0c 和 \cL。
282
283 \n
284 换行符匹配。等效于 \x0a 和 \cJ。
285
286 \r
287 匹配一个回车符。等效于 \x0d 和 \cM。
288
289 \s
290 匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
291
292 \S
293 匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
294
295 \t
296 制表符匹配。与 \x09 和 \cI 等效。
297
298 \v
299 垂直制表符匹配。与 \x0b 和 \cK 等效。
300
301 \w
302 匹配任何字类字符，包括下划线。与“[A-Za-z0-9_]”等效。
303
304 \W
305 与任何非单词字符匹配。与“[^A-Za-z0-9_]”等效。
306
307 \xn
308 匹配 n，此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，“\x41”匹配“A”。“\x041”与“\x04”&“1”等效。允许在正则表达式中使用 ASCII 代码。
309
310 \num
311 匹配 num，此处的 num 是一个正整数。到捕获匹配的反向引用。例如，“(.)\1”匹配两个连续的相同字符。
312
313 \n
314 标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式，那么 n 是反向引用。否则，如果 n 是八进制数 (0-7)，那么 n 是八进制转义码。
315
316 \nm
317 标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式，那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获，则 n 是反向引用，后面跟有字符 m。如果两种前面的情况都不存在，则 \nm 匹配八进制值 nm，其中 n 和 m 是八进制数字 (0-7)。
318
319 \nml
320 当 n 是八进制数 (0-3)，m 和 l 是八进制数 (0-7) 时，匹配八进制转义码 nml。
321
322 \un
323 匹配 n，其中 n 是以四位十六进制数表示的 Unicode 字符。例如，\u00A9 匹配版权符号 (?)。
题1：请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
1 public class Solution {
2 public String replaceSpace(StringBuffer str) {
3 StringBuffer sb = new StringBuffer();
4 for(int i=0;i<str.length();i++){
5 if(str.charAt(i)==' '){
6 sb.append("%20");
7 }else{
8 sb.append(str.charAt(i));
9 }
10 }
11 return sb.toString();
12 }
13 }
题2:请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配。
分析：
match(char[] str, int i, char[] pattern, int j){} 结束条件：模式串和字符串同时遍历完成；j=pattern.length&&i=str.length
1.若当前字符存在下一个字符，判断下一个字符是‘*’，如果是：
①当前字符匹配
a.跳过str当前字符，判断下一个，例如aab a*b：
match(str,i+1,pattern,j) b.跳过pattern当前字符和后一个‘*’字符 ，例如abc a.*bc:
match(str,i,pattern,j+2) c.跳过str当前字符，pattern当前字符和后一个‘*’字符，例如abc a*bc：
match(str,i+1,pattern,j+2) ②当前字符不匹配
a.跳过pattern当前字符和后一个‘*’字符，例如abc v*abc：
match(str,i,pattern,j+2) 2.若不是‘*’，判断当前字符是否匹配或者是否是‘.’：
①如果成立，则str和pattern同时比较下一个字符，例如abc .bc：
match(str,i+1,pattern,j+1) 1 public class Solution {
2 public boolean match(char[] str, char[] pattern)
3 {
4 if(str==null||pattern==null){
5 return false;
6 }
7 return match(str,0,pattern,0);
8 }
9 public boolean match(char[] str, int i, char[] pattern, int j){
10 if(j==pattern.length){
11 return i==str.length;
12 }
13 if(j<pattern.length-1&&pattern[j+1]=='*'){
14 if(i!=str.length&&(str[i]==pattern[j]||pattern[j]=='.')){
15 return match(str,i+1,pattern,j)||match(str,i,pattern,j+2);
16 }else{
17 return match(str, i ,pattern, j+2);
18 }
19 }
20 if(i!=str.length&&(pattern[j]=='.'||str[i]==pattern[j])){
21 return match(str,i+1,pattern,j+1);
22 }
23 return false;
24 }
25 }
题3：请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。、
分析：表述数值的字符串遵循模式：A[.[B]][e|EC]，其中A和C可能是以+或者-开头的0~9数位串；B也是数位串，但是没有符号。例如123.45e+6；
正则表达式：[\\+\\-]?\\d*(\\.\\d+)?([eE][\\+\\-]?\\d+)?
[\\+\\-]? -> 正或负符号出现与否\\d* -> 整数部分是否出现，如-.34 或 +3.34均符合(\\.\\d+)? -> 如果出现小数点，那么小数点后面必须有数字；否则一起不出现([eE][\\+\\-]?\\d+)? -> 如果存在指数部分，那么e或E肯定出现，+或-可以不出现，紧接着必须跟着整数；或者整个部分都不出现
1 public class Solution {
2 public boolean isNumeric(char[] str) {
3 String string = String.valueOf(str);
4 return string.matches("[\\+\\-]?\\d*(\\.\\d+)?([eE][\\+\\-]?\\d+)?");
5 }
6 }
题四：请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。如果当前字符流没有存在出现一次的字符，返回#字符。
分析：使用HashMap保存字符和字符串出现的次数。使用一个ArrayList有序保存输入的字符。最后遍历ArrayList寻找第一个出现一次的字符。
1 import java.util.*;
2 public class Solution {
3 HashMap<Character,Integer> map = new HashMap();
4 List<Character> list = new ArrayList();
5 //Insert one char from stringstream
6 public void Insert(char ch)
7 {
8 if(map.get(ch)==null){
9 map.put(ch,1);
10 list.add(ch);
11 }else{
12 map.put(ch,map.get(ch)+1);
13 }
14 }
15 //return the first appearence once char in current stringstream
16 public char FirstAppearingOnce()
17 {
18 for(char ch:list){
19 if(map.get(ch)==1){
20 return ch;
21 }
22 }
23 return '#';
24 }
25 }