Java從菜鳥到精通（13）

*******************************
 
String類
*字串時一個特殊的對象。
*字串一旦初始化就不可以被改變。

*******面試題*******
*String str="abc";
*String str1=new String("abc");
str和str1有什麼區別？
    str在記憶體中有一個對象。
    str1在記憶體中有兩個對象。

String str="abc";//str是一個類類型變數，

“abc”是一個對象。
//字串最大的特點：一旦被初始化就不可以被改

變。
 

String類複寫了Object類中的equals方法，該方法

用於判斷字串是否相同。

String類適用於描述字串事物。那麼它就提供了

多個方法對字串進行操作。

常見的操作有哪些？
1、擷取；
    1.1 字串中的包含的字元數，也就是字

符串的長度。int length():擷取長度.數組也有

length，但是它是屬性不是方法，而String的

length是方法,必須帶括弧()。
    1.2 根據位置擷取位置上的某個字元。

char  charAt(int index)
    1.3 根據字元擷取該字元在字串中的位

置。int indexOf(int ch):返回的是ch在字串中

第一次出現的位置。int indexOf(int ch,int

formIndex):從fromIndex指定位置來時，擷取ch在

字元中出現的位置。
int indexOf(String str):返回的是str在字串

中第一次出現的位置。int indexOf(String

str,int formIndex):從fromIndex指定位置來時，

擷取str在字元中出現的位置。
int lastIndexOf():從後面向前查，第一次出現的

位置。
2、判斷；
    2.1 字串中是否包含某一個子串。
boolean contains(CharSequence

ch)//CharSequence是個介面。
特殊之處：indexOf(str)：可以索引str第一次出

現的位置，如果返回-1.表示該str不在字串中存

在。所以，也可以用於指定判斷是否包含。
if(str.indexOf("aa")!=-1)
而且該方法即可以判斷，又可以擷取出現的位置。
    2.2 字串是否有內容。boolean

isEmpty()//JDK1.6才出現的，原理就是判斷長度

是否為0.
    2.3 字元長是否是以指定內容開頭。

boolean startsWith(str);
    2.4 字串是否是以指定內容結尾。
boolean endsWith(str);
    2.5 判斷字串內容是否相同。複寫了

Object類中的equeals方法。boolean equals(str)
    2.6 判斷內容是否相同，並忽略大小寫。

boolean equalsIgnoreCase();

例子：
String str="ArrayDemo.java";
//判斷檔案名稱是否是Array單詞開頭
str.startsWith("Array");
//判斷檔案名稱是否是.java的檔案
str.endsWith(".java");
//判斷檔案名稱中是否包含Demo
str.contains("Demo");

3.轉換
    3.1 將字元數組轉成字串。
建構函式：String(char[])
      String(char[],offset,count):將字元

數組中的一部分轉成字串。
靜態方法：static String copyValueOf(char[])
      static String copyValueOf(char

[],offset,count)
      static String valueOf(char[]);    
    3.2 將字串轉成字元數組**
    char[] toCharArray()

    3.3 將位元組數組轉成字串
      String(byte[])
      String(byte[],offset,count):將位元組

數組中的一部分轉成字串。
    3.4 將字串轉成位元組數組
    byte[] getBytes()
    3.5 將基礎資料型別 (Elementary Data Type)轉換成字串
    static String ValueOf(int)
    static String ValueOf(double)

特殊：
字串和位元組數組在轉換過程中，是可以指定編碼

表的。

4.替換
    String replace(olechar,newchar);//如

果要替換的字元不存在，返回的還是原串。

字串一旦初始化，就不能再改變了。
 
    String replace(CharSequence

target,CharSequence replacement);

5.切割
    String[] split(regex);

6.子串,擷取字串中的一部分
    String subString(begin);//從指定位置

開始到結尾。如果角標不存在，會出現字串角標

越界異常。
    String subString(begin,end);//包含頭

，不包含尾。

7.轉換，去除空格，比較
    7.1 將字串轉換成大寫或小寫。
    String toUpperCase();
    String toLowerCase();
    7.2 將字串兩端的多個空格去除。
    String trim();
    7.3 對兩個字串進行自然順序的比較。
    int compareTo(String );

小例子：
1.類比一個trim方法，去除字串兩端的空格。
思路：
    1.判斷字串第一個位置是否是空格，如

果是繼續向下判斷，直到不是空格為止。結尾處判

斷空格也是如此。
    2.當開始和結尾都判斷到不是空格時，就

是要擷取的字串。

class StringTest
{
  public static void main(String[] args)
{
    String s="     ds　fds　　"；
    sop(s);//原字串
    s=myTrim(s);
    sop(s);//去除空格的
}

public stataic void sop(String str){
    syso(str);
}

public static String myTrim(String str)
{
    int star=0,end=str.length()-1;
    while(start<=end && str.charAt

(start)==" "){
    start++;
}
    while(start<=end && str.charAt(end)

==" ")
{
         end--；
}

    return str.substring(start,end+1);
}

}

2.將一個字串進行反轉，將字串中指定部分進

行反轉，“abcdefg”;abfedcg
思路：
    1.對數組的元素進行反轉。
    2.將字串變成數組，對數組反轉。
    3.將反轉後的數組變成字串。
    4.只要將或反轉的部分的開始和結束位置

作為參數傳遞即可。

class StringTest
{
  public static void sop(String str)
{
    syso(str);
}
public static void main(String [] args)
{
    String s="abcdefg";
    sop(s);//原的字串
    sop(reverseString(s));

}
/*
1.將字串變成數組
2.對數組反轉。
3.將數組變成字串。
*/
public static String reverseString(String

s,int start,int end)
{
    //字串變數組。
    char[] chs=s.toCharArray();

    //反轉數組
    reverse(chs,start,end);

    //將數組變成字串。
    return new String(chs);    
}
public static String reverseString(String s)
{
    
  return reverseString(s,0,s.length());
}

 private static void reverse(char[] arr,int

x,int y)
{
for(int start=x,end=y-

1;start<end;start++,end--)
{
   swap(arr,start,end);
}
}

private static void swap(char[] arr,int

x,int y)
{
  char temp=arr[x];
 arr[x]=arr[y];
 arr[y]=temp;

}

}

3.擷取一個字串在另一個字串中出現的次數。
"abkkcdkkefkkskk"
思路：
    1.定義一個計數器。
    2.擷取kk第一次出現的位置
    3.從第一次出現位置後剩餘的字串中繼

續擷取kk出現的位置。每擷取一次就計數一次。
    4.當擷取不到時，計數完成。
方法一：
public static int geSubCount(String

str,String key)
{ int count=0;
  int index =0;
while((index=tr.indexOf(key))!=-1)
{
  str=  str.substring(index+key.length());
count++;

}
 return count;
}
class StringTest
{
  public static void sop(String str)
{
    syso(str);
}
public static void main(String [] args)
{
    String str="abkkcdkkefkkskk";
    sop(getSubCoun(str,"kk"));
}

}

方法二：

public static int geSubCount(String

str,String key)
{ int count=0;
  int index =0;
while((index=str.indexOf(key,index))!=-1)
{
  index =index+key.length();
count++;

}
 return count;
}
class StringTest
{
  public static void sop(String str)
{
    syso(str);
}
public static void main(String [] args)
{
    String str="abkkcdkkefkkskk";
    sop(getSubCoun(str,"kk"));
}

}
4.擷取兩個字串中最大相同子串，第一個動作：

將短的那個串進行長度一次遞減的子串列印。
"abcwerthelloyuiodef"
"cvhellobnm"
思路：
    1.將短的那個子串按照長度遞減的方式獲

取到。
    2.將沒擷取到的子串去長串中判斷是否包

含，如果包含，已經找到！

class StringTest
{
  public static void sop(String str)
{
    syso(str);
}
public static void main(String [] args)
{
     String s1="abcwerthelloyuiodef";
    String s2="cvhellobnm";
sop(getMaxSubString(s1,s2));
}

public static String getMaxSubString(String

s1,String s2)
{
  for(int i=0;i<s2.length();i++){
    for(int j=0,x=s2.length()-x;x!

=s2.length()+1;j++,x++)
    }

    String temp=s2.substring(j,x);
    if(s1.contains(temp)){
    return temp;
    }
}
    return "";
}

StringBuffer
*字串的組成原理就是通過該類實現的。
*StringBuffer可以對字串內容進行增刪。
*StringBuffer是一個容器。
*很多方法與String相同。
*StringBuffer是可邊長度的。

StringBuffer是字串緩衝區。
是一個容器。
*****特點：
1.而且長度是可變化的。
2.可以位元組操作多個資料類型。
3.最終會通過toString方法變成字串。
c: create
u: update
r: read
d: delete

1.儲存。
    StringBuffer append():將指定資料作為

參數添加到自己有資料結尾處。
    StringBuffer insert(index,資料)：可

以將資料插入到指定Index位置。

2.刪除。
    StringBuffer delete（int start，int

end）//刪除緩衝區中的資料。包含頭，不包含尾
    StringBuffer deleteCharAt(index):刪

除指定位置的字元。

3.擷取。
    char charAt(int index);
    int indexOf(String str);
    int lastIndexOf(String str);
    int length();
    String substring(int start,int end);
    
4.修改。
    StringBuffer replace(int start,int

end,String str);//替換字串裡面的一部分字元
    setCharAt(int index,char ch);//替換

裡面的一個字元、

5.反轉
    Stringbuffer reverse()//反轉。
6.void getChars(int srcBegin,int

srcEnd,char[] dst,int dstBegin):將緩衝區中指

定資料存放區到指定字元數組中。

例子：
StringBuffer sb=new StringBuffer("2dsfsdf");
char[] chs=new char[4];
sb.getChars(1,4,chs,1);//包含頭，不包含尾
for(int x=0;x<chs.length;x++)
{
    syso("chs["+x+"]"+chs[x]+";");
}

StringBuilder類

在JDK1.5版本之後出現了Stringbuilder類
******StringBuffer和StringBuilder的區別？
StringBuffer是線程同步的安全的。
StringBuilder是線程不同步的不安全的。

以後開發，建議使用StringBuilder

升級三個因素：
1、提高效率。
2、簡化書寫。
3、提高安全性。

基礎資料型別 (Elementary Data Type)對象封裝類。
byte是基礎資料型別 (Elementary Data Type) 它有對應的引用資料類型

Byte
short是基礎資料型別 (Elementary Data Type) 它有對應的引用資料類型

Short
int是基礎資料型別 (Elementary Data Type) 它有對應的引用資料類型

Integer
long是基礎資料型別 (Elementary Data Type) 它有對應的引用資料類型

Long
boolean是基礎資料型別 (Elementary Data Type) 它有對應的引用資料類型

Boolean
float是基礎資料型別 (Elementary Data Type) 它有對應的引用資料類型

Float
double是基礎資料型別 (Elementary Data Type) 它有對應的引用資料類型

Double
char是基礎資料型別 (Elementary Data Type) 它有對應的引用資料類型

Character

基礎資料型別 (Elementary Data Type)對象封裝類的最常見作用：
就是用於基礎資料型別 (Elementary Data Type)和字串類型之間做轉換。

*基礎資料型別 (Elementary Data Type)轉成字串。

基礎資料型別 (Elementary Data Type).toString(基礎資料型別 (Elementary Data Type)值)；
如：Integer.toString(34);//將34整數變成“34

”

*字串轉成基礎資料型別 (Elementary Data Type)。

//靜態轉換
    xxx a= xxx.parseXXX(String);
    
    int a=Integer.parseInt("123");

    double b=Double.parsDouble("12.3");
    
    boolean b=Boolean.parseBoolean

("true");

    
//非靜態，對象調用方式

    Integer i=new Integer("123");
    int num=i.intValue();

//將一個字串轉成整數：
int num=Integer.parseInt("123");

//整數類型的最大值
syso(Integer.MAX_VALUE);

十進位轉成其他進位。
    toBinaryString();
    toHexString();
    toOctalString();
其他進位轉成十進位。
    parseInt(String s,進位)；

********JDK1.5版本以後出現的新特性。
//要進行判斷，如果不判斷，Integer 會為null
Integer x=4;//自動裝箱。等同於new Integer(4)
x=x/*x.intValue()*/+2;  //x=2:x 進行自動拆箱

。變成了int類型，和2進行加法運算，再將和進行

裝箱，賦給X。

Integer m=128;
Integer n=128;
syso(m==n)  //false
Integer a=127;
integer b=127;
syso(a==b); // true.因為a和b指向了同一個

Integer對象，因為當數值在byte範圍內容，對於

新特性，如果該數值，已經存在，則不會在開闢新

的空間。

compareTo():數字可以進行排序