Java基礎 String StringBuffer StringBuilder

String

實現String.trim()和 翻轉字符串順序。

class StringTest
{
    public static void main(String[] args)//throws Exception
    {
        MyString str=new MyString("1234567890");
        //System.out.println(str.trim());
        System.out.println(str.reverse(1,5));
    }
}
class MyString
{
    private String str="";
    MyString(String str)
    {
        this.str=str;
    }

    public String trim()//去除字符串開頭和末尾的空白
    {
        int start=0,end=str.length()-1;
        while(start<end)
        {
            if(str.charAt(start)==' ')
                start++;
            if(str.charAt(end)==' ')
                end--;
            if(str.charAt(start)!=' '&&str.charAt(end)!=' ')
                break;
        }
        return str.substring(start,end+1);
    }

    public String reverse()//throws Exception//倒序排列字符串
    {

        return reverse(0,str.length()-1);

    }
    public String reverse(int start,int end) //throws Exception//倒序排列字符串
    {
        char[] carr=str.toCharArray();
        reverseArr(carr,start,end);
        return String.valueOf(carr);
    }
    private void reverseArr(char[] carr,int s,int e)/* throws Exception *///倒序排列字符數組
    {
/*      if(s<0||s>=carr.length-1)
            throw new Exception("start超出字符串邊界!");
        if(e<=0||e>(carr.length-1))
            throw new Exception("end超出字符串邊界!"); */
        for(int start=s,end=e;start<end;start++,end--)
        {
            swap(carr,start,end);
        }
    }
    private void swap(char[] carr,int start,int end)//交換數組元素
    {
        char tmp=carr[start];
        carr[start]=carr[end];
        carr[end]=tmp;
    }
}

---

獲取字符串1和字符串2中相同的最大字符串。在教程的基礎上進行了優化。

• 原視頻,x,y,z分別改爲 wide,start,end.更加好理解.
• 原視頻教程當發現第一個相同的最大字符串時使用return結束搜索.
• 優化後，把return改爲wide=0.可以繼續在當前搜索寬度繼續搜索.
  而不繼續向更窄範圍搜索.

class StringTest2
{
    private static String str1="okhelloko";
    private static String str2="ok,ko";

    public static void getMaxSubString(String s1,String s2)//獲取字符串1和字符串2中相同的最大字符串,如果有相同字數的相同字符串,也找出.
    {
        String max="",min="";
        max=(s1.length()>s2.length())?s1:s2;
        min=(max==s1)?s2:s1;
        for(int wide=min.length();wide>0;wide--)//字符串寬度,逐漸縮小,wide代表搜索的字符串寬度//每循環一次搜索區變小一個字符.代表搜索的字符串寬度變小
        {
            for(int start=0,end=wide;end!=min.length()+1;start++,end++)//start代表搜索區起點,end代表搜索區終點.終點不超過字符串長度
            {                                                       //將起點,終點向字符串末尾移動.代表搜索區從左向右進行移動.
                String temp=min.substring(start,end);//temp是當前搜索區內的字符串
                if(max.contains(temp))//如果max長字符串包含 當前在min短字符串內 搜索區的temp字符串，就找到了最長的相同字符串.
                {
                    System.out.println(temp);
                    wide=0;//這裏使用wide=0結束外循環,而不用return結束循環,因爲要把當前寬度的搜索區繼續搜索到最後.否則,發現第一個時會忽略掉之後的.
                    //當內循環結束,到外循環時,由於wide==0，就不繼續進行更小範圍的搜索了。
                }

            }
        }
    }
    public static void main(String[] args)
    {
        getMaxSubString(str2,str1);
    }
}
/*輸出結果:
ok
ko
*/

---

StringBuffer

構造方法摘要
StringBuffer()
構造一個其中不帶字符的字符串緩衝區，初始容量爲 16 個字符。

StringBuffer(CharSequence seq)
public java.lang.StringBuilder(CharSequence seq) 構造一個字符串緩衝區，它包含與指定的 CharSequence 相同的字符。

StringBuffer(int capacity)
構造一個不帶字符，但具有指定初始容量的字符串緩衝區。

StringBuffer(String str)
構造一個字符串緩衝區，並將其內容初始化爲指定的字符串內容。

線程安全的可變字符序列。一個類似於 String 的字符串緩衝區，但不能修改。雖然在任意時間點上它都包含某種特定的字符序列，但通過某些方法調用可以改變該序列的長度和內容。

常用方法:
追加文本
StringBuffer append(data)
刪除指定範圍的文本
StringBuffer delete(int start,int end)
刪除指定標號的字符
StringBuffer deleteCharAt(int index)
根據標號獲取字符
char charAt(int index)
根據指定範圍 獲取字符列表,存到dst字符列表的dstBegin位置
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
獲取字符串的位子
int indexOf(String str)
插入字符串
StringBuffer insert(int offset, data)
獲取字符串長度
int length()
替換字符串
StringBuffer replace(int start, int end, String str)
翻轉字符串
StringBuffer reverse()
替換指定位置的字符
void setCharAt(int index, char ch)
獲取子文本
String substring(int start)
String substring(int start, int end)
返回文本類型
String toString()

---

StringBuilder

一個可變的字符序列。此類提供一個與 StringBuffer 兼容的 API，但不保證同步。該類被設計用作 StringBuffer 的一個簡易替換，用在字符串緩衝區被單個線程使用的時候（這種情況很普遍）。如果可能，建議優先採用該類，因爲在大多數實現中，它比 StringBuffer 要快。

將 StringBuilder 的實例用於多個線程是不安全的。如果需要這樣的同步，則建議使用 StringBuffer。

構造方法摘要
StringBuilder()
構造一個其中不帶字符的字符串生成器，初始容量爲 16 個字符。
StringBuilder(CharSequence seq)
構造一個字符串生成器，包含與指定的 CharSequence 相同的字符。
StringBuilder(int capacity)
構造一個其中不帶字符的字符串生成器，初始容量由 capacity 參數指定。
StringBuilder(String str)
構造一個字符串生成器，並初始化爲指定的字符串內容。

Integer

static int parseInt(String s, int radix)
使用第二個參數指定的基數，將字符串參數解析爲有符號的整數。
Integer.parseInt(“1010”,2)
將字符串”1010”中的數字按照2進制轉換爲10進制數.
第一個參數指定被轉換的數，第二個參數指定進制.
Integer.parseInt(“f”,16)

Integer.parseInt(“11”,17)按照17進制轉換”11”
得到17+1=18

Integer m=128;
Integer n=128;
boolean b=(m==n);

b==false

Integer a=127;
Integer b=127;
boolean b=(a==b);

b==true

因爲Integer定義變量時先判斷值的大小，值在byte範圍內就使用內存中的byte數據,所以a和b指向同一個數據
而m,n的值大於byte的範圍，所以在內存中開闢了新的空間給兩個變量。所以不相等。