String

<b>string</b><b>的比較問題：</b>

       · string是一個系統提供好的類，但是string可以像基本資料類型那樣，直接指派

       · string還可以通過new關鍵字指派

public class oodemo12{

         public static void main(string args[]){

                   string str1 = "abc" ;

                   string str2 = new string("abc") ;

                   string str3 = str2 ;

         }

};

那麼該如何去比較兩個字元串是否相等呢？

· 按照“==”的方式進行比較

                   system.out.println(str1==str2) ;    // false

                   system.out.println(str1==str3) ;    // false

                   system.out.println(str3==str2) ;    // true

       比較之後發現，雖然str1和str2的内容是一樣，但是通過==比較之後，結果均為“false”，而str2和str3的比較結果均為“true”。

       如果使用了“==”，則最終的比較結果是比較的兩個位址。

· 最終應該比較的是兩個字元串的内容，是以此時，就必須使用string類中提供好的一個方法：

       public boolean equals(string str)

public class oodemo13{

                   system.out.println(str1.equals(str2)) ;    // true

                   system.out.println(str1.equals(str3)) ;    // true

                   system.out.println(str3.equals(str2)) ;    // true

使用equals方法比較的是兩個字元串的内容。

<b>注意點1</b><b>：</b>

       實際上一個字元串就是string類的匿名對象。

       每一個字元串都會在堆記憶體中開辟空間。

              string str1 = "abc" ;

       · 首先要在堆記憶體中開辟一個空間，此空間存放的是“abc”的字元串，之後把此字元串的位址使用給了str1：system.out.println("abc".equals(str2)) ;<b></b>

<b>注意點2</b><b>：</b>

       string有兩種執行個體化方式

       · 直接指派

       · 使用new關鍵字開辟

       以上兩種方式使用那種更好呢？

       · 直接指派：它本身隻會産生一個執行個體化對象

public class oodemo14{

       · 使用new關鍵字開辟，會産生兩個執行個體化對象

                   string str1 = new string("abc") ;

使用直接指派的方式比較節約空間，是以絕對不要使用new關鍵字執行個體化對象。

<b>注意點3</b><b>：</b>

       · string中的内容一旦聲明則不可改變

       string的内容是固定的，如果要改變其内容，修改的是其記憶體的指向。

                   str1 += "bcd" ;

                   system.out.println(str1) ;

<b>注意點4</b><b>：</b>

       對于一個字元串而言，在java中屬于共享設計模式的應用，即：如果一個字元串已經被另外一個字元串所引用，則以後如果聲明的字元串内容相同，則不會再重新聲明。

public class oodemo15{

                   string str2 = "abc" ;

                   system.out.println(str1==str2) ;

<b>注意點5</b><b>：</b>

       以下的程式代碼絕對不要出現，出現之後會影響系統的性能。

public class oodemo28{

                   string str1 = "a" ;

                   for(int i=0;i&lt;100;i++){

                            str1 += i ;

                   }

       如果按以上的形式編寫代碼，則string的記憶體指向（斷開和重新連接配接）需要進行100次，性能肯定低。是以此種語句在開發中絕對不允許出現。

實際上string類還存在着大量的系統提供好的方法

1、  取得字元串長度的方法

       public int length()   à 取出字元串的長度

public class oodemo16{

                   string str1 = "abcfdafdsadafsdfdssdfa" ;

                   system.out.println(str1.length()) ;

2、  将字元串變為一個字元數組

public class oodemo17{

                   char c[] = str1.tochararray() ;

                   for(int i=0;i&lt;c.length;i++){

                            system.out.print(c[i]+"\t") ;

3、  将一個字元數組變為字元串

       public <b>string</b>(char[] value)

public class oodemo18{

                   char c[] = {'a','b','c','d','e'} ;

                   system.out.print(new string(c)) ;

4、  判斷在一個字元串中是否包含一個一個指定的字元串

       public int indexof(string str) ;如果查到了則傳回位置，否則傳回-1。

public class oodemo19{

                   string str = "abcdefg" ;

                   system.out.println(str.indexof("abc")) ;

                   if(str.indexof("abc")!=-1){

                            system.out.println("查到了指定内容。") ;

                   }else{

                            system.out.println("沒有查到指定内容。") ;

5、  按照位置截取一定長度的字元串

       public string substring(int beging,int end)

public class oodemo20{

                   system.out.println(str.substring(0,3)) ;

6、  如以下的字元串：“a:b:c”，按照“:”進行字元串拆分

       public string[] split(string str) ;

public class oodemo21{

                   string str = "a:b:c" ;

                   string s[] = str.split(":") ;

                   for(int i=0;i&lt;s.length;i++){

                            system.out.println(s[i]) ;

7、  将“hello world!!!”字元串中的“o”替換成“x”

       public string replace(string str)

public class oodemo22{

                   string str = "hello world!!!" ;

                   system.out.println(str.replace("o","x")) ;

8、  判斷一個字元串是否是以“**”開頭或結尾。

       以指定的字元串開頭：public boolean startswith(string str)

       以指定的字元串結尾：public boolean endswith(string str)

public class oodemo23{

                   string str = "**hello**" ;

                   system.out.println(str.startswith("**")) ;

                   system.out.println(str.endswith("**")) ;

9、  給定以下字元串：“mike:70|jones:80|tom:75”

       要求拆分成以下格式：

              · mike       à    70

              · jones     à    80

              · tom        à   75

public class oodemo24{

                   string str = "mike:70|jones:80|tom:75" ;

                   system.out.println("\"\'\\") ;

                   // 拆分兩次

                   string s1[] = str.split("\\|") ;

                   for(int i=0;i&lt;s1.length;i++){

                            string s2[] = s1[i].split(":") ;

                            system.out.println(s2[0]+" --&gt; "+s2[1]) ;

10、取出字元串“hello world”中的第三個字元

       public char charat(int

ind

) ;

public class oodemo25{

                   string str = "helwo" ;

                   system.out.println(str.charat(2)) ;

11、一個指定的字元數組，将其中指定位置的字元變為字元串

public <b>string</b>(char[] value, int offset, int count)

public class oodemo26{

                   char c[] = {'h','e','l','w','o'} ;

                   system.out.println(new string(c,1,3)) ;

12、如何可以進行不區分大小寫的比較？

       public boolean equalsignorecase(string str)

public class oodemo27{

                   system.out.println(str1.equalsignorecase(str2)) ;

<b>繼續探讨對象的引用傳遞</b>

       現在觀察以下三道題目，分析其記憶體空間的指向，并說出結果。

class demo{

         int x ;

public class demo29{

                   demo d1 = new demo() ;

                   d1.x = 30 ;

                   fun(d1) ;

                   system.out.println(d1.x) ;

         public static void fun(demo d2){

                   d2.x = 50 ;

public class demo30{

                   string str = "abc" ;

                   fun(str) ;

                   system.out.println(str) ;

         public static void fun(string s){

                   s = "bcd" ;

         string name ;

public class demo31{

                   demo d = new demo() ;

                   d.name = "abc" ;

                   fun(d) ;

                   system.out.println(d.name) ;

         public static void fun(demo x){

                   x.name = "bcd" ;