String类

两种创建字符串的区别

• String str1="123";

创建时，先在常量池中找是否有“123”这个字符串，若有直接在栈中开辟内存并在该内存中存储常量池中存有该字符串的地址。若此时，String str2="123";则str1与str2指向的是常量池中的同一个地址，该地址存放了字符串“123”

• String str1=new String();

每实例化一个对象便在堆内存中开辟内存，栈中存储该堆内存首地址

---

• +操作与new操作

字符串的所有连接方式都是一个new操作。

 String str1="zh";//在常量池中
    String str2="ang";//常量池中
    String str3=str1+str2;//在堆中开辟了内存，存入了新的字符串
    System.out.println(str1);
    System.out.println(str2);
    System.out.println(str3);

---

• ~的方法

equal:如果给定对象表示的 String 与此 String 相等，则返回 true；否则返回 false。
 

 /**
   * 在objrct类中，eqial方法比较的是内存地址，但在一些其他类中，该方法会被重写。String类就是这样，它比较的是该字符串的内容
   *重写代码如下：
   public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }
    */
	//
  Protice pro1=new Protice();pro1.name="tom";//不同内存下，相同字符串的比较
  Protice pro2=new Protice();pro2.name="tom";
  System.out.println(pro1.name.equals(pro2.name));//true
  System.out.println(pro1);//demo.Protice@70dea4e
  System.out.println(pro2);//demo.Protice@5c647e05

==，双等号比较，则比较的是地址。

String s1 = new String(“tomcat”);//创建匿名对象
String s2 = new String(“tomcat”);
System.out.println (s1 == s2);  //false
System.out.println (s1.equals(s2)); //true 

compareto:

public int compareTo(String anotherString)，如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值。

比较时，

若两个字符串的元素有不同时，找出最小的对应位置k,该位置对应元素在unicod中对应的数字之差就是返回值

若两个字符串元素相同但长度不同，则返回长度之差。

String str="abd";
    	    String str1="acd";                                                          //1，字符串第二个字符不同，选择最小的位置即第二个，b、c,b=98、c=99,返回-1
    	    
    	    String str2="acb";
    	    String str3="abc";                                                          //1，字符串第二、时个字符不同，选择最小的位置即第二个，b、c,b=98、c=99,返回1
    	    
    	    String str4="aac";
    	    String str5="aa";                                                         //1，字符串对应字符相同，长度不同，长度之差为1
    	    
    	    String str6="aahh";
    	    String str7="aa";                                                            //2，字符串对应字符相同，长度不同，长度之差为2
    	    
    	    System.out.println(str.compareTo(str1));
    	    System.out.println(str2.compareTo(str3));
    	    System.out.println(str4.compareTo(str5));
    	    System.out.println(str6.compareTo(str7));

concat

public String concat(String str)

将指定字符串连接到此字符串的结尾。

如果参数字符串的长度为 0，则返回此 String 对象。否则，创建一个新的 String 对象，用来表示由此 String 对象表示的字符序列和参数字符串表示的字符序列连接而成的字符序列。

示例：

 "cares".concat("s") returns "caress"
 "to".concat("get").concat("her") returns "together"
 

 

参数：

str - 连接到此 String 结尾的 String。

返回：

一个字符串，它表示在此对象字符后连接字符串参数字符而成的字符。

replace

public String replace(char oldChar,
                      char newChar)

返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。

如果 oldChar 在此 String 对象表示的字符序列中没有出现，则返回对此 String 对象的引用。否则，创建一个新的 String 对象，它所表示的字符序列除了所有的 oldChar 都被替换为 newChar 之外，与此 String 对象表示的字符序列相同。

示例：

"mesquite in your cellar".replace('e', 'o')
         returns "mosquito in your collar"
 "the war of baronets".replace('r', 'y')
         returns "the way of bayonets"
 "sparring with a purple porpoise".replace('p', 't')
         returns "starring with a turtle tortoise"
 "JonL".replace('q', 'x') returns "JonL" (no change)
 

 

参数：

oldChar - 原字符。

newChar - 新字符。

返回：

一个从此字符串派生的字符串，它将此字符串中的所有 oldChar 替代为 newChar。

contains

public boolean contains(CharSequence s)

当且仅当此字符串包含指定的 char 值序列时，返回 true。

 

参数：

s - 要搜索的序列

返回：

如果此字符串包含 s，则返回 true，否则返回 false

抛出：

NullPointerException - 如果 s 为 null

split

public String[] split(String regex,
                      int limit)

根据匹配给定的 正则表达式来拆分此字符串。

此方法返回的数组包含此字符串的子字符串，每个子字符串都由另一个匹配给定表达式的子字符串终止，或者由此字符串末尾终止。数组中的子字符串按它们在此字符串中出现的顺序排列。如果表达式不匹配输入的任何部分，那么所得数组只具有一个元素，即此字符串。

limit 参数控制模式应用的次数，因此影响所得数组的长度。如果该限制 n 大于 0，则模式将被最多应用 n - 1 次，数组的长度将不会大于 n，而且数组的最后一项将包含所有超出最后匹配的定界符的输入。如果 n 为非正，那么模式将被应用尽可能多的次数，而且数组可以是任何长度。如果 n 为 0，那么模式将被应用尽可能多的次数，数组可以是任何长度，并且结尾空字符串将被丢弃。

例如，字符串 "boo:and:foo" 使用这些参数可生成以下结果：

Regex	Limit	结果
:	2	{ "boo", "and:foo" }
:	5	{ "boo", "and", "foo" }
:	-2	{ "boo", "and", "foo" }
o	5	{ "b", "", ":and:f", "", "" }
o	-2	{ "b", "", ":and:f", "", "" }
o	0	{ "b", "", ":and:f" }

调用此方法的 str.split(regex, n) 形式与以下表达式产生的结果完全相同：

Pattern. compile ( regex ). split ( str ,  n )

 

参数：

regex - 定界正则表达式

limit - 结果阈值，如上所述

返回：

字符串数组，它是根据给定正则表达式的匹配拆分此字符串确定的

抛出：

PatternSyntaxException - 如果正则表达式的语法无效

toLowerCase：public String toLowerCase(Locale locale)

要转换为小写的 String。

toUpperCase

public String toUpperCase(Locale locale)

返回：

要转换为大写的 String。

toCharArray

public char[] toCharArray()

将此字符串转换为一个新的字符数组。

 

返回：

一个新分配的字符数组，它的长度是此字符串的长度，它的内容被初始化为包含此字符串表示的字符序列。

trim

public String trim()

 

返回：

此字符串移除了前导和尾部空白的副本；如果没有前导和尾部空白，则返回此字符串。

---

valueOf：转换类型