java -的字符串hei
字符串的不可变
String 对象是不可变的。查看 JDK 文档你就会发现，String 类中每一个看起来会修改 String 值的方法，实际上都是创建了一个全新的 String 对象，以包含修改后的字符串内容。而最初的 String 对象则丝毫未动。
其实程序当中所有的双引号字符串都是String 类的对象，即使没有new
特点：
字符串的那日容勇不可变
正是因为字符串不可改变，所以字符是可以共享使用的。
字符串效果是相当于char字符数组，
public class sevenseven { public static void main(String[] args) { String x = "abcd"; // 每当把 String 对象作为方法的参数时，都会复制一份引用， // 而该引用所指向的对象其实一直待在单一的物理位置上，从未动过。 String X = x.toUpperCase(); System.out.println(x); System.out.println(X); } } /* abcd ABCD */
public class DemoString { public static void main(String[] args) { String str1 = new String(); System.out.println(str1); // 单引号括起来才是字符，双引号括起来是字符串 char[] chararray = { 'A' , 'B'}; String str2 = new String(chararray); System.out.println(str2); byte[] bytearray = { 99,49,49}; String str3 = new String(bytearray); System.out.println(str3); // 直接创建 String str5 = "qqqq"; System.out.println(str5); } } 结果： AB c11 qqqq
字符串的存储
public class DemoString { public static void main(String[] args) { String str1 ="abc"; String str2 ="abc"; char[] charArray = {'a','b','c'}; String str3 = new String(charArray); System.out.println(str1 == str2); System.out.println(str1 == str3); System.out.println(str3 == str2); } } //结果: // true // false // false
StringBuilder
用于创建最终的String,可以使用append等方法修改字符串
如果使用String的重载方法+ 的话，每次加都需要建立新的String对象，性能不高
使用 StringBuilder 类的场景：在频繁进行字符串运算（如拼接、替换、和删除等），
并且运行在单线程的环境中，则可以考虑使用 StringBuilder，如 SQL 语句的拼装、JSON 封装等。
StringBuilder 提供了丰富而全面的方法，包括 insert()、replace()、substring()，甚至还有reverse()，但是最常用的还是 append() 和 toString()。还有 delete()
public class sevenseven { public static void main(String[] args) { StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append("how "); stringBuilder.append("to "); stringBuilder.append("say"); System.out.println(stringBuilder); stringBuilder.delete(0,1);//按字符算 System.out.println(stringBuilder); stringBuilder.deleteCharAt(1);//按字符位置索引 System.out.println(stringBuilder); System.out.println(stringBuilder.reverse());//字符反向 } }
字符处理操作：
| 方法 | 参数，重载版本 | 作用 |
|---|---|---|
| 构造方法 | 默认版本，String，StringBuilder，StringBuffer，char数组，byte数组 |
创建String对象 |
length() |
String中字符的个数 |
|
charAt() |
int索引 |
获取String中索引位置上的char |
getChars()，getBytes() |
待复制部分的开始和结束索引，复制的目标数组，目标数组的开始索引 | 复制char或byte到一个目标数组中 |
toCharArray() |
生成一个char[]，包含String中的所有字符 |
|
equals()，equalsIgnoreCase() |
与之进行比较的String |
比较两个String的内容是否相同。如果相同，结果为true |
compareTo()，compareToIgnoreCase() |
与之进行比较的String |
按词典顺序比较String的内容，比较结果为负数、零或正数。注意，大小写不等价 |
contains() |
要搜索的CharSequence |
如果该String对象包含参数的内容，则返回true |
contentEquals() |
与之进行比较的CharSequence或StringBuffer |
如果该String对象与参数的内容完全一致，则返回true |
isEmpty() |
返回boolean结果，以表明String对象的长度是否为0 |
|
regionMatches() |
该String的索引偏移量，另一个String及其索引偏移量，要比较的长度。重载版本增加了“忽略大小写”功能 |
返回boolean结果，以表明所比较区域是否相等 |
startsWith() |
可能的起始String。重载版本在参数中增加了偏移量 |
返回boolean结果，以表明该String是否以传入参数开始 |
endsWith() |
该String可能的后缀String |
返回boolean结果，以表明此参数是否是该字符串的后缀 |
indexOf()，lastIndexOf() |
重载版本包括：char，char与起始索引，String，String与起始索引 |
如果该String并不包含此参数，就返回-1；否则返回此参数在String中的起始索引。lastIndexOf()是从后往前搜索 |
matches() |
一个正则表达式 | 返回boolean结果，以表明该String和给出的正则表达式是否匹配 |
split() |
一个正则表达式。可选参数为需要拆分的最大数量 | 按照正则表达式拆分String，返回一个结果数组 |
join()（Java8引入的） |
分隔符，待拼字符序列。用分隔符将字符序列拼接成一个新的String |
用分隔符拼接字符片段，产生一个新的String |
substring()（即subSequence()） |
重载版本：起始索引；起始索引+终止索引 | 返回一个新的String对象，以包含参数指定的子串 |
concat() |
要连接的String |
返回一个新的String对象，内容为原始String连接上参数String |
replace() |
要替换的字符，用来进行替换的新字符。也可以用一个CharSequence替换另一个CharSequence |
返回替换字符后的新String对象。如果没有替换发生，则返回原始的String对象 |
replaceFirst() |
要替换的正则表达式，用来进行替换的String |
返回替换首个目标字符串后的String对象 |
replaceAll() |
要替换的正则表达式，用来进行替换的String |
返回替换所有目标字符串后的String对象 |
toLowerCase()，toUpperCase() |
将字符的大小写改变后，返回一个新的String对象。如果没有任何改变，则返回原始的String对象 |
|
trim() |
将String两端的空白符删除后，返回一个新的String对象。如果没有任何改变，则返回原始的String对象 |
|
valueOf()（static） |
重载版本：Object；char[]；char[]，偏移量，与字符个数；boolean；char；int；long；float；double |
返回一个表示参数内容的String |
intern() |
为每个唯一的字符序列生成一个且仅生成一个String引用 |
|
format() |
要格式化的字符串，要替换到格式化字符串的参数 | 返回格式化结果String |
当需要改变字符串的内容时，String 类的方法都会返回一个新的 String 对象。同时，如果内容不改变，String 方法只是返回原始对象的一个引用而已。这可以节约存储空间以及避免额外的开销。
字符串格式化输出
System.out.format()
/* 首先将 name 的值插入到 %s 的位置，然后将 age 的值插入到 %d的位置。这些占位符叫做格式修饰符， 它们不仅指明了插入数据的位置，同时还指明了将会插入什么类型的变量，以及如何格式化。 */
public class FormatOutput { public static void main(String[] args) { String name = "quan"; int age = 23; // 最老的方式 System.out.println(name + age); // 新方式 System.out.format("how to say %s -- %d \n",name,age); System.out.printf("how to say %s -- %d",name,age); } } /* quan23 how to say quan -- 23 how to say quan -- 23 */
格式化修饰符
ForMatter
/* 下面通过ForMatter格式话的字符串都存在内部的StringBuffer中 必须通过formatter.toString()进行统一输出 格式： %[argument_index$][flags][width][.precision]conversion argument_index$：指定对应的内容参数位置，默认按照顺序依次对应。 flags：格式控制。 width：区域宽度。 .precision：对于浮点型数据，表示显示的小数位数；对于字符串数据，表示显示的字符数量。 conversion：类型转换字符。 */
格式控制
/* 默认右对齐 有负号 - 左对齐 + 正数前显示正号，负数前显示负好 空格 正数前希纳是控制，负号前显示负好 0 使用0填充剩余位置 逗号 每三位数字添加一个逗号 */
public class ForMatterT2 { private double sum = 0; //创建ForMatter 对象f private Formatter f = new Formatter(new StringBuilder()); public ForMatterT2(){ f.format("%-15s %5s %10s%n","item","num","Price"); f.format("%-15s %5s %10s%n","++++++","++++++","++++++"); } public void add(String name,int q,double p){ f.format("%-15.15s %5d %10.2f%n",name,q,p); sum += p*q; } //最后的结账，得出总价格 public String build(){ f.format("%-15s %5s %10s%n","++++++","++++++","++++++"); f.format("%-15.15s %5s %10.2f%n","sum","",sum); // 最后结算统一输出ForMatter 对象里面的所有的格式化字符串 f.format("%-15.15s %5s %,10.2f%n","sum","乘上12038",sum*12038);//逗号 每三位数字添加一个逗号 return f.toString(); } public static void main(String[] args) { ForMatterT2 f2 = new ForMatterT2(); // 加入商品价格字符串 f2.add("bag",1,45); f2.add("big",1,30); //一定要使用toString 才能将f里面的格式进行输出 System.out.println(f2.build()); } } /* item num Price ++++++ ++++++ ++++++ bag 1 45.00 big 1 30.00 ++++++ ++++++ ++++++ sum 75.00 sum 902,850.00 */
conversion：类型转换字符。
d |
整型（十进制） |
c |
Unicode字符 |
b |
Boolean值 |
s |
String |
f |
浮点数（十进制） |
e |
浮点数（科学计数） |
x |
整型（十六进制） |
h |
散列码（十六进制） |
% |
字面值“%” |
意，程序中的每个变量都用到了 b 转换。虽然它对各种类型都是合法的，但其行为却不一定与你想
象的一致。对于 boolean 基本类型或 Boolean 对象，其转换结果是对应的 true 或 false。
但是，对其他类型的参数，只要该参数不为 null，其转换结果永远都是 true。即使是数字 0，
转换结果依然为 true，而这在其他语言中（包括C），往往转换为 false。
String.format()
/* String.format() 是一个 static 方法，它接受与 Formatter.format() 方法一样的参数
，但返回一个 String 对象。 当你只需使用一次 format() 方法的时候，String.format() 用起来很方便。 */
public class OneFormatException extends Exception{ public OneFormatException(String name,String how){ super(String.format("warn %s %s",name,how)); } public static void main(String[] args) { try{ throw new OneFormatException("quan","testsomethings"); }catch (OneFormatException e){ System.out.println(e); } } } /* bytes.OneFormatException: warn quan testsomethings */
正则表达式：
/* 在java中 \\:我要插入一个正则表达式的反斜线，后面的字符具有特殊意义 eg: 想表达一位数字 \\d eg:普通的反斜线： \\\ 一个或多个之前的表达式”，应该使用 + ? 可能存在， \\W，它的意思是一个非单词字符 （如果 W 小写，\\w，则表示一个单词字符 注意：换行符和制表符致谢的只需要单反斜杠\n \t */
public class StringMatch{ public static void main(String[] args) { System.out.println("-23232".matches("-?\\d+")); //(-|\+)?\d+ 可能以加号或者减号开头的数字 System.out.println("+23232".matches("(-|\\+)?\\d+")); System.out.println("-23232".matches("(-|\\+)?\\d+")); System.out.println("23232".matches("(-|\\+)?\\d+")); } }// all true
public class StringMatch{ private static String something = "blic static String format(String format, Object... args)" + " {return new Formatter().format(format, args).toString()}"; public static void splitA(String regex){ System.out.println(Arrays.toString(something.split(regex))); } public static void main(String[] args) { splitA(" ");//以空格分割 splitA("}"); splitA("\\W+");//\\W，它的意思是一个非单词字符 splitA("\\W");//\\W，它的意思是一个非单词字符 } } /* [blic, static, String, format(String, format,, Object..., args), {return, new, Formatter().format(format,, args).toString()}] [blic static String format(String format, Object... args) {return new Formatter().format(format, args).toString()] [blic, static, String, format, String, format, Object, args, return, new, Formatter, format, format, args, toString] [blic, static, String, format, String, format, , Object, , , , args, , , return, new, Formatter, , , format, format, , args, , toString] */
查找并替换：
public static void main(String[] args) { String someth = "{return new Formatter().{format(format"; System.out.println(someth.replaceFirst("\\{","lalala ")); System.out.println(someth.replaceAll("format|Format"," rerere ")); } /* lalala return new Formatter().{format(format {return new rerere ter().{ rerere ( rerere */
Pattern 和Matcher
用 static Pattern.compile() 方法来编译你的正则表达式即可。它会根据你的 String 类型的正则表达式生成一个 Pattern 对象
把你想要检索的字符串传入 Pattern 对象的 matcher() 方法。matcher() 方法会生成一个 Matcher 对象
public class TestRegularExpression { public static void main(String[] args) { String[] argss ={"abcabcdaefafeabc", "abc+","(abc+)"}; if (argss.length < 2) { System.out.println( "Usage:\njava TestRegularExpression " + "characterSequence regularExpression+"); System.exit(0); } System.out.println("Input: \"" + argss[0] + "\""); for (String arg : argss) { System.out.println( "Regular expression: \"" + arg + "\""); Pattern p = Pattern.compile(arg);//创建匹配模式p Matcher m = p.matcher(argss[0]); //通过匹配模式对象的方法matcher创建匹配器m while (m.find()) {//find是否可以匹配得到，返回布尔值 System.out.println( "Match \"" + m.group() + "\" at positions " + m.start() + "-" + (m.end() - 1)); } } } }
Pattern 对象表示编译后的正则表达式 已编译的 Pattern 对象上的 matcher() 方法，加上一个输入字符串，从而共同构造了一个 Matcher 对象 static boolean matches(String regex, CharSequence input)
matcher对象中的方法：
boolean find() 尝试找到匹配模式的输入序列的下一个子序列。 boolean lookingAt() 尝试将输入序列从区域开头开始与模式相匹配。 boolean matches() 尝试将整个区域与模式进行匹配 String group() 返回与上一个匹配匹配的输入子序列。
正则表达式的组：
（A（B）C）:
0 组：ABCD
1 组：BC
2组：C
public class MatcherTest { public static void main(String[] args) { String string="BCCDIJFOIWJoefjlwfeDBCCjwoiCCfj"; String strP = "(B(CC))"; Pattern p = Pattern.compile(strP); Matcher m = p.matcher(string); while (m.find()){ System.out.println(m.group());//返回前一次匹配操作第0组 System.out.println(m.groupCount());//返回该匹配器的模式中的分组数目 System.out.println(m.group(2));//返回前一次匹配操作期间指定的组号 System.out.println(m.start(1));//返回在前一次匹配操作中寻找到的组的起始索引 //返回在前一次匹配操作中寻找到的组的最后一个字符索引加一的值。 System.out.println(m.end(1));// System.out.println(m.matches());//全员匹配 } } } /* BCC 2 CC 0 3 false BCC 2 CC 20 23 false */
替换操作
reset()
通过 reset() 方法，可以将现有的 Matcher 对象应用于一个新的字符序列：
正则表达式与 Java I/O
浙公网安备 33010602011771号