一、String类
String为引用数据类型，final的，不可被继承。不可变的Unicode字符序列。本质上为char 字符数组
- 字符串方法
| 方法 | 含义 |
|---|---|
| int length() | 获取字符串的长度 |
| int indexOf(int ch) | 返回指定字符在此字符串中第一次出现处的索引 |
| int indexOf(String str) | 返回指定子字符串在此字符串中第一次出现处的索引 |
| int lastIndexOf(int ch) | 返回指定字符在此字符串中最后一次出现处的索引 |
| int compareTo(Object o) | 把这个字符串和另一个对象比较 |
| String intern() | 返回字符串对象的规范化表示形式 |
| String trim() | 去除字符串前后空格 |
| String toLowerCase() | 将字符串全部转换为小写 |
| String toUpperCase() | 将字符串全部转换为大写 |
| String substring(int index) | 按索引截取字符串 |
| String substring(int begin, int end) | 指定索引范围截取字符串 |
| String replace(char old, char new) | 将新字符替换旧的字符 |
| String[] split(String regex) | 给定正则表达式的匹配拆分此字符串 |
| boolean matches(String regex) | 符串是否匹配给定的正则表达式 |
| boolean isEmpty() | 判断字符串的长度是否等于0 |
| boolean equals(Object obj) | 字符串与指定的对象比较 |
| boolean equalsIgnoreCase(String str) | 判断两字符串比较(忽略大小写) |
| boolean startsWith(String prefix) | 字符串是否以指定的前缀开始 |
| boolean endsWith(String suffix) | 字符串是否以指定的后缀结束 |
| char[] toCharArray() | 字符串转换为一个新的字符数组 |
| static String valueOf(type x) | 将指定类型的参数转换为字符串类型 |
-
字符串连接
String str="You and ".concat("Me");
String str="You and " + "Me" + 'I';
// 可连接字符串或者数字及其他基本类型数据； concat只接受字符串
还可以使用StringBuffer或StringBuilder进行连接 -
格式化输出字符串
printf() 和 format()
浮点型为 %f ;整型为 %d ; 字符串为 %s
例子：String str=String.format("%f %d %s", 1.1, 5, "aa") ;
字符串替换实例：
// 字符串替换的方法
String s = "one dog and two dogs ";
System.out.println(s.replaceFirst("dog","cat"));//第一次匹配的字符替换为指定字符串
System.out.println(s.replaceAll("one|two","three"));// 所有匹配替换为指定字符串
System.out.println(s.replace("do","pi"));// 将目标字符串替换为指定字符串
System.out.println(s.replace('a','A'));// 将旧字符 a 替换为新字符 A
二、"==" 和 “equals”的区别
首先 == 是用来比较两个变量所指向的内存地址是否相同，可以用来两个基本类型的数据或两个引用变量是否相等。
在Object类中： equals方法的实现是 return this==obj , 也就是说equals与 == 是一样的，比较的都是两个对象所指向的内存地址是否相同。但是在String类中重写了父类Obejct中的equls方法，比较的是两个对象的内容是否相同。例子：
// final String s = "ab";
String s = "ab"; // 栈中存放变量 s , String池中存放常量"ab", 变量s指定常量 "ab";
String a = "abc"; // 在栈中开辟空间存放变量 a,String池中开辟空间存放"abc"，变量a指向String中的常量"abc";
String b = "ab" + "c"; // 栈中存放变量 b, 通过编译器优化合并后的常量为 "abc";
String c = "ab".concat("c"); // 如果传入的参数长度为大于0， 则返回一个new String(buf, true)对象,存放在堆中;
String d = s + "c";// 栈中存放变量d , String池中存放常量"c", 运行后才能确定变量d的值(对象),存放在堆中。
// （通过StringBuilder的toString方法返回一个新的对象"adc"）, 变量d 指向这个新的对象。
System.out.println(a==b); // true
System.out.println(a==c); // false
System.out.println(a==d); // false 如果变量s 被定义为final对象，则 a==d 结果为 true
System.out.println(b==c); // false
System.out.println(b==d); // false 如果变量s 被定义为final对象，则 b==d 结果为 true
System.out.println(c==d); // false
// a,b,c d 三个变量，也就是对象的内容都是"abc",所以都返回true
System.out.println(a.equals(b)); // true
System.out.println(a.equals(c)); // true
System.out.println(a.equals(d)); // true
System.out.println(b.equals(c)); // true
三、StringBuffer和StringBuilder
StringBuffer和StringBuilder：每个字符串缓冲区都有一定的容量(初始容量为 16 个字符)。只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区数组。如果内部缓冲区溢出，则此容量自动增大。
从源码来看StringBuffer和StringBuilder都是继承抽象类AbstractStringBuilder，调用了父类的方法。StringBuffer调用的父类方法都有修饰符synchronized。
StringBuffer 允许并发操作，线程安全
StringBuilder 不支持并发操作，非线程安全；但速度更优
StringBuffer 类的常用方法：
| 方法 | 含义 |
|---|---|
| append(String s) | 追加指定的字符串 |
| reverse() | 反转字符串 |
| delete(int start, int end) | 删除指定index范围的字符，不包含end |
| insert(int offset, String str) | 从指定位置插入字符串 |
| replace(int start, int end, String str) | 替换指定范围的字符串 |
| int capacity() | 返回容量大小 |
| int length() | 返回长度（字符数） |
| void setLength(int newLen) | 设置字符序列的长度 |
| indexOf()/ substring() | 与String类一致 |
实例：
字符串翻转
- 方法一
// 使用StringBuffer中自带的reverse方法(调用父类的reverse)
String s = "1234";
StringBuffer sb = new StringBuffer(s);
System.out.println(sb.reverse()); // "4321"
- 方法二
// 使用for循环字符追加的方式
String s = "1234",t="";
for(int i=s.length()-1; i>=0 ;i--){
t += s.charAt(i);
}
System.out.println(t); // "4321"
统计字符串中每个字符的个数
- 方法一
// 使用StringBuilder去重，for遍历统计
String s = "hello word test is";
StringBuilder sb = new StringBuilder();
for(int i=0;i<s.length();i++){
String ss = String.valueOf(s.charAt(i));
if (sb.indexOf(ss)== -1) { //去重
sb.append(ss);
int t=0;
for(int j=0; j<s.length();j++){
if(s.charAt(j)==ss.charAt(0)){
t++;
}
}
System.out.println(ss+":"+t+"个");
}
}
- 方法二
// 对字符串重新排序，利用索引位置差进行统计
String s = "hello word test is";
char [] chars = s.toCharArray();
Arrays.sort(chars);
String ns = new String(chars); // 排序后的新字符串 deehilloorssttw
for(int i=0;i<s.length();){
String ss = String.valueOf(ns.charAt(i));
int index = ns.lastIndexOf(ss); // 字符最后的索引位置
System.out.println(ss+": "+(index+1-i)+"个");
i=index+1; //下一个字符的索引位置
}
- 方法三
// 将重复的字符去除，利用字符串的长度统计
String s = "hello word test is";
while(s.length()>0){
String ss = String.valueOf(s.charAt(0));
String ns = s.replaceAll(ss,"");
int t = s.length() - ns.length();
s = ns;
System.out.println(ss + ": " + t + "个");
}
- 方法四
// 利用Map的key不能重复，进行统计
String s = "hello word test is";
Map<Character, Integer> hm = new HashMap<Character, Integer>();
for(int i=0; i<s.length();i++){
char c = s.charAt(i);
if(hm.containsKey(c)){
hm.put(c,hm.get(c)+1);
}else{
hm.put(c,1);
}
}
for(Entry<Character, Integer> e: hm.entrySet()){
System.out.println(e.getKey()+": "+e.getValue()+ "个");
}