Java_String&StringBuilder&StringBuffer类

目录

• 一、String类
• 二、"==" 和 “equals”的区别
• 三、StringBuffer和StringBuilder

一、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()+ "个");
 }