Java基礎—String類

String是一個特殊的對象,在計算機裏是很重要的角色,很多都是以String的形式存儲在計算機裏。
對字符串基本的操作有:
1、獲取:
 A、獲取長度:int length();
 B、根據角標獲取元素:char charAt(int index);
 C、根據元素獲取角標:
  int indexOf(char ch);
  int indexOf(char ch,int fromIndex);
  int lastIndexOf(char ch)
  int indexOf(String str);
  int indexOf(String str,int fromIndex);
2、判斷:
 A、字符串是否包含某一子串:boolean contains(CharSequence s);
 B、是否有內容:boolean isEmpty();
 C、是否以某字符串開頭:boolean startsWith(String str);
 D、是否以某字符串結尾:boolean endsWith(String str);
 E、判斷兩個字符串的內容是否相同:boolean equals(String str);
 F、忽略大小寫比較:hboolean equalsIgnoreCase(String str) ;
3、轉換:
 A、字符串轉換成字符數組:char[] toCharArray();
 B、字符數組轉換字符串:new String(char[] chs); static String copyValueOf(char[] chs); 可以只轉部分,需要提供角標和位數。
 C、字符串轉換字節數組:byte[] getBytes(Charset charset);
 D、字節數組轉字符串:new String(byte[] bts,Charset charset);
注:charset參數可以省略,省略是按照每人編碼表。
4、替換:
 String replace(char oldChar,char newChar) ,若要替換的字符不存在,則返回原串。
5、切割:
 String[] split(String regex); 如:string[] str = s.split(“,”);
6、獲取子串:
 String substring(int beginIndex);String substring(int beginIndex,int endIndex);
7、轉換、去除空格、比較:
 A、將字符串轉換成大寫或小寫:String toUpperCase();String toLowerCase();
 B、將字符串兩端的多個空格去除:String trim();
 C、將字符串進行自然順序的比較,不區分大小寫:int compareTo(String str);

StringBuffer:字符串緩衝區,是一個容器,長度可變,可直接操作多個數據類型(不支持byte和short),最終會通過toString的方法變成字符串。數組也是一個容器,長度固定的,操作的數據類型是在定義數組的時候就確定的。StringBuffer的基本操作(增、刪、改、查):
1、存儲:
 A、StringBuffer append(數據類型 變量);數據類型不能爲byte和short;
 B、StringBuffer insert(int offset,數據類型 變量);
2、刪除:
 StringBuffer delete(int start,int end)
3、修改:
 A、StringBuffer replace(int start,int end,String str)
 B、StringBuffer setCharAt(int index,char ch);將指定角標處的字符更改爲ch;
4、獲取:
 A、char charAt(int index):獲取指定角標處的字符;
 B、int indexOf(String str):獲取第一次出現指定字符串的位置;
    int lastIndexOf(String str):獲取最後一次出現指定字符的位置;
 C、int indexOf(String str,int fromIndex):從指定角標開始,返回第一次出現指定字符串的角標;
 D、int length():獲取StringBuffer的長度;
 E、String subString(int start,int end):獲取子串。
5、反轉:
 StringBuffer reverse();
6、將StringBuffer中指定的數據複製到字符數組中:
 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
Jdk1.5之後出現了StringBuilder,兩者的區別是StringBuffer是同步的,StringBuilder是不同步的。StringBuilder的效率高於StringBuffer,在多線程中StringBuilder的安全性低。
字符串的相應練習代碼:

/*
 1、去除字符串兩端的空格;
 2、將字符串進行反轉;
 3、獲取一個字符串在另一個字符串中出現的次數;"kk"
 4、獲取兩個字符串中最大相同子串。

 "  abkkcwkkerkkthellokkykkuiokkdefkkkk  "
  "cvhellobnm"
  "kk"

  分析:1、去除前端空格的方法:先判斷第一位是否爲空,若是,從第二位開始取子串,再判斷,
           再取子串,直至第一位不空爲止;去除後端空格的方法:先判斷最後一位是否爲空,
           如是,去子串:第一位到倒數第二位,再判斷,再取子串,直至倒數第一位不爲空
           爲止;
        2、StringBuffer有反轉輸出的功能,String沒有,當然也可以先把字符串存儲到StringBuffer
           中,再將其反轉輸出。這裏我用的方法是:通過char[] toCharArray()將字符串轉變爲
           字符數組,字符數組反轉之後,通過new String(char[] chs)方法將字符數組轉換爲字符串
           輸出。
        3、獲取一個字符串(s1)在另一個字符串(s2)出現的次數:先判斷s2中是否包含s1,如果包含,
           從s1在s2中出現的第一角標加上s1的長度的位置開始取子串,並且計數器加1,再判斷,再
           取子串,直至s2不包含s1爲止。
         4、獲取兩個字符串最大的相同子串。先判斷長的字符串是否包含短的字符串,如果不包含,
            將短的字符串去掉一位,再判斷長的字符串是否包含短的字符串,如果不包含,將短的
            字符串去掉兩位,再判斷,依次類推,如果短的字符串的長度爲0,還是長的字符串還是
            不包含短的字符串,那說明這兩個字符串沒有共同的元素。

*/
class StringTest 
{
    public static void main(String[] args) 
    {
        String s1 = "   abkkcwkkerkkthellokkykkuiokkdefkkkk   ";
        String s2 = "cvhellobnm";
        //去除字符串兩端空格的方法
        System.out.println("練習1:---------------------------------------------------------");
        String s = myTrim(s1);
        //將字符串反轉輸出
        System.out.println("練習2:---------------------------------------------------------");
        myReverse(s);
        //獲取一個字符串在另一個字符串中出現的次數
        System.out.println("練習3:---------------------------------------------------------");
        int count = myCount(s,"kk");
        System.out.println("字符串“kk”在字符串s中出現的次數爲:"+count);
        //獲取兩個字符串的最大相同子串
        System.out.println("練習4:---------------------------------------------------------");
        mySubstring(s,s2);
    }
    //去除字符串兩端空格
    public static String myTrim(String s)
    {
        System.out.println("原來的字符串:"+s);
        System.out.println("原來字符串長度:"+s.length());
        //去除前端空格
        for(int i=0;i<s.length();i++)
        {
            //如果字符串的第一位爲空格,則取子串,繼續循環判斷子串中的第一位是否爲空
            if(s.charAt(i) == ' ')
                s = s.substring(i+1,s.length());
            //如果第一位不爲空,則循環結束
            else
                break;
        }
        System.out.println("去除前端的空格後的字符串:"+s);
        System.out.println("去除字符串前端空格後的字符串長度:"+s.length());
        //去除後端空格
        for(int i=s.length()-1;i>0;i--)
        {
            //如果字符串的最後一位爲空,則取子串,繼續循環判斷字符串中的最後一位是否爲空
            if(s.charAt(i) == ' ')
                s = s.substring(0,i);
            //如果字符串的最後一位不爲空,則退出循環
            else
                break;
        }
        System.out.println("去除字符串後端空格的字符串:"+s);
        System.out.println("去除字符串後端空格的字符串長度:"+s.length());
        return s;
    }
    //將字符串反轉輸出
    public static void myReverse(String s)
    {
        System.out.println("原來的字符串:"+s);
        //定義一箇中間變量,便於交換字符位置
        char temp = ' ';
        //將字符串轉換成字符數組
        char[] chs = s.toCharArray();
        //將字符數組反轉
        for(int i=0;i<s.length()/2;i++)
        {
            temp = chs[i];
            chs[i] = chs[s.length()-1-i];
            chs[s.length()-1-i] = temp;
        }
        //將反轉後的字符數組轉換成字符串並打印
        System.out.println("反轉後的字符串:"+new String(chs));
    }
    //獲取一個字符串在另一個字符串中出現的次數
    public static int myCount(String s,String key)
    {
        //定義一個計數器
        int count = 0;
        while(true)
        {
            //如果字符串中包含字符串key,計數器加1,,取子串,繼續判斷
            if(s.contains(key))
            {
                count++;
                s = s.substring(s.indexOf(key)+key.length(),s.length());
            }
            //如果不包含,則計數結束,退出循環
            else
                break;
        }
        return count;
    }
    //獲取兩個字符串的最大相同子串
    public static void mySubstring(String s1,String s2)
    {
        //定義兩個變量分別存放大、小字符串
        String max = "";
        String min = "";
        //判斷兩個字符串的長短並賦值給相應的變量
        max = s1.length() > s2.length()?s1:s2;
        min = s1.length() < max.length()?s1:s2;
        //System.out.println(max+"::"+min);
        //定義一個變量來存儲兩個字符串的最大子串
        String submax = "";
        /*獲取最大子串:外循環控制最短字符串的最少子串數;內循環控制最短字符串的所有子串;
          取子串所需的角標跟外循環無關。
        */
        for(int i=0;i<min.length();i++)
        {
            for(int j=min.length()-i,k=0;j>k && j<min.length()+1;j++,k++)
            {
                String temp = min.substring(k,j);
                //System.out.println(temp);
                //如果長字符串包含短字符串的子串,則結束循環,並將該子串賦值爲submax
                if(max.contains(temp))
                {
                    submax = temp;
                    break;
                }
            }
            //如果submax不爲空,說明已找到最大相同子串,結束外循環
            if(!submax.isEmpty())
                break;
        }
        //根據submax是否爲空,來判斷是否找到最大相同子串
        if(!submax.isEmpty())
            System.out.println("這兩字符串的最大相同子串爲:"+submax);
        else
            System.out.println("這兩個字符串沒有相同的字符!");
    }
}
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章