JavaString类的总结

Posted 2020-07-13 siwluxuefeng

因为需要在这里把String类涉及的各个方面总结一下，另给出了一下SCJP题目。如有不足的地方，请在评论中指教，谢谢。
 
一、不变模式：
一个字符串对象创建后它的值不能改变。
String str1="hello";//创建一个对象hello，不会变；
System.out.println(str1);
str1+=" world!";//两个字符串对象粘粘，系统其实创建了一个新的对象，把Str1的指向改了，指向新的对象；hello就                     //变成了垃圾；
System.out.println(str1);
//如果一直这样创建会影响系统的效率；要频繁的改变字符串对象的值就用StringBuffer来描述；
StringBuffer sb=new StringBuffer("[");
sb.append("hehe");
sb.append("]");//append();不会制造垃圾，真正在改sb的值；
System.out.println(sb);
append方法如下：
public AbstractStringBuilder append(String str) {
        if (str == null) str = "null";
        int len = str.length();
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;


二、对象池
 
首先要明白，Object obj = new Object();
obj是对象的引用，它位于栈中， new Object() 才是对象，它位于堆中。
可以这样理解obj是拴在氢气球上的绳子，new Object() 是氢气球，我们通过对象的引用访问对象，就像我们那着绳子氢气球才不会跑掉。
 
 
创建一个Stirng对象，主要就有以下两种方式：
java 代码
String str1 = new String("abc");    
Stirng str2 = "abc";  
     虽然两个语句都是返回一个String对象的引用，但是jvm对两者的处理方式是不一样的。对于第一种，jvm会马上在heap中创建一个String对象，然后将该对象的引用返回给用户。对于第二种，jvm首先会在内部维护的strings pool中通过String的 equels 方法查找是对象池中是否存放有该String对象，如果有，则返回已有的String对象给用户，而不会在heap中重新创建一个新的String对象；如果对象池中没有该String对象，jvm则在heap中创建新的String对象，将其引用返回给用户，同时将该引用添加至strings pool中。注意：使用第一种方法创建对象时，jvm是不会主动把该对象放到strings pool里面的，除非程序调用 String的intern方法。看下面的例子：
java 代码
String str1 = new String("abc"); //jvm 在堆上创建一个String对象   
  
 //jvm 在strings pool中找不到值为“abc”的字符串，因此   
 //在堆上创建一个String对象，并将该对象的引用加入至strings pool中   
 //此时堆上有两个String对象   
Stirng str2 = "abc";   //在堆区创建了对象，并将对象的引用放入了String Pool
  
 if(str1 == str2){   
         System.out.println("str1 == str2");   
 }else{   
         System.out.println("str1 != str2");   
 }   
  //打印结果是 str1 != str2,因为它们是堆上两个不同的对象   
  
  String str3 = "abc";   
 //此时，jvm发现strings pool中已有“abc”对象了，因为“abc”equels “abc”   
 //因此直接返回str2指向的对象给str3，也就是说str2和str3是指向同一个对象的引用   
  if(str2 == str3){   
         System.out.println("str2 == str3");   
  }else{   
         System.out.println("str2 != str3");   
  }   
 //打印结果为 str2 == str3  
三、String / StringBuffer / StringBuilder 
 
    String类是字符串常量，是不可更改的常量。而StringBuffer是字符串变量，它的对象是可以扩充和修改的。
 
   StringBuffer sb=new StringBuffer("[");//创建StringBuffer对象
   sb.append("hehe");//把hehe加入字符串，变成 "[hehe"
   sb.append("]");//append();不会制造垃圾，真正在改sb的值；
   System.out.println(sb);
   String str = sb.toString();//把"[hehe]"，赋值给一个字符串对象str
    StringBuilder,一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
 
StringBuilder sb=new StringBuilder("[");//创建StringBuilder对象
sb.append("hehe");//把hehe加入字符串，变成 "[hehe"
sb.append("]");//append();不会制造垃圾，真正在改sb的值；
System.out.println(sb);
String str = sb.toString();//把"[hehe]"，赋值给一个字符串对象str
 
 
四、String类中常用的方法
 
String 类包括的方法可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写。不用去记，用到的时候查API，用的多了自然就熟悉了。
 
 
  java.lang.String
 char charAt (int index)
 返回index所指定的字符
 String concat(String str)
 将两字符串连接
 boolean endsWith(String str)
 测试字符串是否以str结尾
 boolean equals(Object obj)
 比较两对象
 char[] getBytes
 将字符串转换成字符数组返回
 char[] getBytes(String str)
 将指定的字符串转成字符数组返回
 boolean startsWith(String str)
 测试字符串是否以str开始
 int length()
 返回字符串的长度
 String replace(char old ,char new)
 将old用new替代
 char[] toCharArray
 将字符串转换成字符数组
 String toLowerCase()
 将字符串内的字符改写成小写
 String toUpperCase()
 将字符串内的字符改写成大写
 String valueOf(Boolean b)
 将布尔方法b的内容用字符串表示
 String valueOf(char ch)
 将字符ch的内容用字符串表示
 String valueOf(int index)
 将数字index的内容用字符串表示
 String valueOf(long l)
 将长整数字l的内容用字符串表示
 String substring(int1,int2)
 取出字符串内第int1位置到int2的字符串


 
view plaincopy to clipboardprint?
import java.util.Collections;   
import java.util.Comparator;   
import java.util.LinkedList;   
import java.util.List;   
public class StringUsage {   
 // 几个欧不太用的方法。   
 public static void main(String[] args) {   
  // 判断字符串首/尾。   
  String contentS = "test String again. test ";   
  System.out.println(contentS);   
  System.out.println("contentS.startsWith(\"test\")\t"  
    + contentS.startsWith("test"));   
  System.out.println("contentS.endsWith(\"test\")\t"  
    + contentS.endsWith("test"));   
  // 忽略大小写的字符串比较方法。   
  System.out   
    .println("contentS.compareToIgnoreCase(contentS.toUpperCase()))\t"  
      + contentS.compareToIgnoreCase(contentS.toUpperCase()));   
  // 不区分大小写的字符串比较。   
  Comparator cmprStr = String.CASE_INSENSITIVE_ORDER;   
  List lstStr = new LinkedList();   
  // 准备数据。   
  lstStr.add("test");   
  lstStr.add("Test");   
  lstStr.add("tEst");   
  lstStr.add("rest");   
  lstStr.add("sest");   
     
  // 不区分大小写的排序。   
  Collections.sort(lstStr, cmprStr);   
  System.out.println(lstStr);   
  // 区分大小写的排序。   
  Collections.sort(lstStr);   
  System.out.println(lstStr);   
  System.out.println("\ntest String.valueOf()");   
     
  // 用 valueOf 处理 null 对象的字符串转换。   
  try {   
   String ss = null;   
   System.out.println(ss);   
   System.out.println(String.valueOf(null)); // 比较奇怪的地方   
  } catch (RuntimeException e1) {   
      e1.printStackTrace();   
  }   
     
  BigDecimal db = null;   
  try {   
   System.out.println(((BigDecimal)db).toString());   
  } catch (Exception e) {   
   e.printStackTrace();   
  }   
  try {   
   System.out.println(String.valueOf(db));   
  } catch (Exception e) {   
   e.printStackTrace();   
  }   
  db = new BigDecimal("100.00");   
  try {   
   System.out.println(((BigDecimal)db).toString());   
  } catch (Exception e) {   
   e.printStackTrace();   
  }   
 }   
}  
 
五、SCJP题目
 
String a="Hello World!";
String b="Hello World!";
a=b?  a和b是否相等？ 为什么？


String a=new String("Hello World!");
String b="Hello World!";
a=b?  a和b是否相等 ？ 为什么？
 
解释：
1. 首先String不属于8种基本数据类型，String是一个对象。
因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。  


2. new String()和new String(“”)都是申明一个新的空字符串，是空串不是null；


3. String str="kvill";
    String str=new String (“kvill”);的区别：  
在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。  
常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的
一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。  
看例1：  
String s0="kvill";  
String s1="kvill";  
String s2="kv" + "ill";  
System.out.println( s0==s1 );  
System.out.println( s0==s2 );  
结果为：  
true  
true  
首先，我们要知道Java会确保一个字符串常量只有一个拷贝。  
因为例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以
s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字符串由多个字符串常量连
接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中”kvill”的一个引用。所以我们得出s0==s1==s2;  


用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 
创建的字符串不放入常量池中，它们有自己的地址空间。  


看例2：  
String s0="kvill";  
String s1=new String("kvill");  
String s2="kv"+ new String("ill");  
System.out.println( s0==s1 );  
System.out.println( s0==s2 );  
System.out.println( s1==s2 );  
结果为：  
false  
false  
false  
例2中s0还是常量池中”kvill”的应用，s1因为无法在编译期确定，所以是运行时创
建的新对象”kvill”的引用，s2因为有后半部分new String(“ill”)所以也无法在编译
期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。  


4. String.intern()：  
再补充介绍一点：存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看例3就清楚了。  


例3：  
String s0= "kvill";  
String s1=new String("kvill");  
String s2=new String("kvill");  
System.out.println( s0==s1 );  
System.out.println( “**********” );  
s1.intern(); 
s2=s2.intern(); //把常量池中"kvill"的引用赋给s2  
System.out.println( s0==s1);  
System.out.println( s0==s1.intern() );  
System.out.println( s0==s2 );  
结果为：  
false  
**********  
false //虽然执行了s1.intern(),但它的返回值没有赋给s1  
true //说明s1.intern()返回的是常量池中”kvill”的引用  
true 
 
最后我再破除一个错误的理解：  
有人说，“使用String.intern()方法则可以将一个String类的保存到一个全局Strin
g表中，如果具有相同值的Unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中“如果我把他说的这个全局的String表理解为常量池的话，他的最后一句话，“如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：  


看例4：  
String s1=new String("kvill");  
String s2=s1.intern();  
System.out.println( s1==s1.intern() );  
System.out.println( s1+" "+s2 );  
System.out.println( s2==s1.intern() );  
结果：  
false  
kvill kvill  
true  
在这个类中我们没有声名一个"kvill"常量，所以s1.intern()同new String("kvill")是不同的，当我们调用s1.intern()后就在常量池中新添加了一个"kvill"常量，原来的不在常量池中的"kvill"仍然存在，也就不是“将自己的地址注册到常量池中”了。  
s1==s1.intern()为false说明原来的“kvill”仍然存在；  
s2现在为常量池中“kvill”的地址，所以有s2==s1.intern()为true。  


5. 关于equals()和==:  


这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。  


6. 关于String是不可变的  


这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：
String str=”kv”+”ill”+” “+”ans”;  
就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” “ 生成 ”kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为String的“不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原因了，因为StringBuffer是可改变的










构造方法： 
String() 
          初始化一个新创建的 String 对象，它表示一个空字符序列。 
String(byte[] bytes) 
          构造一个新的 String，方法是使用平台的默认字符集解码字节的指定数组。 
String(byte[] bytes, int offset, int length) 
          构造一个新的 String，方法是使用指定的字符集解码字节的指定子数组。 
String(byte[] bytes, int offset, int length, String charsetName) 
          构造一个新的 String，方法是使用指定的字符集解码字节的指定子数组。 
String(byte[] bytes, String charsetName) 
          构造一个新的 String，方法是使用指定的字符集解码指定的字节数组。 
String(char[] value) 
          分配一个新的 String，它表示当前字符数组参数中包含的字符序列。 
String(char[] value, int offset, int count) 
          分配一个新的 String，它包含来自该字符数组参数的一个子数组的字符。 
String(int[] codePoints, int offset, int count) 
          分配一个新的 String，它包含该 Unicode 代码点数组参数的一个子数组的字符。 
String(String original) 
          初始化一个新创建的 String 对象，表示一个与该参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的一个副本。 
String(StringBuffer buffer) 
          分配一个新的字符串，它包含当前包含在字符串缓冲区参数中的字符序列。 
String(StringBuilder builder) 
          分配一个新的字符串，它包含当前包含在字符串生成器参数中的字符序列 
方法总结： 
char charAt(int index) 
          返回指定索引处的 char 值。 
int codePointAt(int index) 
          返回指定索引处的字符（Unicode 代码点）。 
int codePointBefore(int index) 
          返回指定索引之前的字符（Unicode 代码点）。 
int codePointCount(int beginIndex, int endIndex) 
          返回此 String 的指定文本范围中的 Unicode 代码点数。 
int compareTo(String anotherString) 
          按字典顺序比较两个字符串。 
int compareToIgnoreCase(String str) 
          不考虑大小写，按字典顺序比较两个字符串。 
String concat(String str) 
          将指定字符串联到此字符串的结尾。 
boolean contains(CharSequence s) 
          当且仅当此字符串包含 char 值的指定序列时，才返回 true。 
boolean contentEquals(CharSequence cs) 
          当且仅当此 String 表示与指定序列相同的 char 值时，才返回 true。 
boolean contentEquals(StringBuffer sb) 
          当且仅当此 String 表示与指定的 StringBuffer 相同的字符序列时，才返回 true。 
static String copyValueOf(char[] data) 
          返回指定数组中表示该字符序列的字符串。 
static String copyValueOf(char[] data, int offset, int count) 
          返回指定数组中表示该字符序列的字符串。 
boolean endsWith(String suffix) 
          测试此字符串是否以指定的后缀结束。 
boolean equals(Object anObject) 
          比较此字符串与指定的对象。 
boolean equalsIgnoreCase(String anotherString) 
          将此 String 与另一个 String 进行比较，不考虑大小写。 
static String format(Locale l, String format, Object... args) 
          使用指定的语言环境、格式字符串和参数返回一个格式化字符串。 
static String format(String format, Object... args) 
          使用指定的格式字符串和参数返回一个格式化字符串。 
byte[] getBytes() 
          使用平台默认的字符集将此 String 解码为字节序列，并将结果存储到一个新的字节数组中。  
byte[] getBytes(String charsetName) 
          使用指定的字符集将此 String 解码为字节序列，并将结果存储到一个新的字节数组中。 
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 
          将字符从此字符串复制到目标字符数组。 
int hashCode() 
          返回此字符串的哈希码。 
int indexOf(int ch) 
          返回指定字符在此字符串中第一次出现处的索引。 
int indexOf(int ch, int fromIndex) 
          从指定的索引开始搜索，返回在此字符串中第一次出现指定字符处的索引。 
int indexOf(String str) 
          返回第一次出现的指定子字符串在此字符串中的索引。 
int indexOf(String str, int fromIndex) 
          从指定的索引处开始，返回第一次出现的指定子字符串在此字符串中的索引。 
String intern() 
          返回字符串对象的规范化表示形式。 
int lastIndexOf(int ch) 
          返回最后一次出现的指定字符在此字符串中的索引。 
int lastIndexOf(int ch, int fromIndex) 
          从指定的索引处开始进行后向搜索，返回最后一次出现的指定字符在此字符串中的索引。 
int lastIndexOf(String str) 
          返回在此字符串中最右边出现的指定子字符串的索引。 
int lastIndexOf(String str, int fromIndex) 
          从指定的索引处开始向后搜索，返回在此字符串中最后一次出现的指定子字符串的索引。 
int length() 
          返回此字符串的长度。 
boolean matches(String regex) 
          通知此字符串是否匹配给定的正则表达式。 
int offsetByCodePoints(int index, int codePointOffset) 
          返回此 String 中从给定的 index 处偏移 codePointOffset 个代码点的索引。 
boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 
          测试两个字符串区域是否相等。 
boolean regionMatches(int toffset, String other, int ooffset, int len) 
          测试两个字符串区域是否相等。 
String replace(char oldChar, char newChar) 
          返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 而生成的。 
String replace(CharSequence target, CharSequence replacement) 
          使用指定的字面值替换序列替换此字符串匹配字面值目标序列的每个子字符串。 
String replaceAll(String regex, String replacement) 
          使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的每个子字符串。 
String replaceFirst(String regex, String replacement) 
          使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的第一个子字符串。 
String[] split(String regex) 
          根据给定的正则表达式的匹配来拆分此字符串。 
String[] split(String regex, int limit) 
          根据匹配给定的正则表达式来拆分此字符串。 
boolean startsWith(String PRefix) 
          测试此字符串是否以指定的前缀开始。 
boolean startsWith(String prefix, int toffset) 
          测试此字符串是否以指定前缀开始，该前缀以指定索引开始。 
CharSequence subSequence(int beginIndex, int endIndex) 
          返回一个新的字符序列，它是此序列的一个子序列。 
String substring(int beginIndex) 
          返回一个新的字符串，它是此字符串的一个子字符串。 
String substring(int beginIndex, int endIndex) 
          返回一个新字符串，它是此字符串的一个子字符串。 
char[] toCharArray() 
          将此字符串转换为一个新的字符数组。 
String toLowerCase() 
          使用默认语言环境的规则将此 String 中的所有字符都转换为小写。 
String toLowerCase(Locale locale) 
          使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。 
String toString() 
          返回此对象本身（它已经是一个字符串！）。 
String toUpperCase() 
          使用默认语言环境的规则将此 String 中的所有字符都转换为大写。 
String toUpperCase(Locale locale) 
          使用给定的 Locale 规则将此 String 中的所有字符都转换为大写。 
String trim() 
          返回字符串的副本，忽略前导空白和尾部空白。 
static String valueOf(boolean b) 
          返回 boolean 参数的字符串表示形式。 
static String valueOf(char c) 
          返回 char 参数的字符串表示形式。 
static String valueOf(char[] data) 
          返回 char 数组参数的字符串表示形式。 
static String valueOf(char[] data, int offset, int count) 
          返回 char 数组参数的特定子数组的字符串表示形式。 
static String valueOf(double d) 
          返回 double 参数的字符串表示形式。 
static String valueOf(float f) 
          返回 float 参数的字符串表示形式。 
static String valueOf(int i) 
          返回 int 参数的字符串表示形式。 
static String valueOf(long l) 
          返回 long 参数的字符串表示形式。 
static String valueOf(Object obj) 
          返回 Object 参数的字符串表示形式。