數位與字串

1.裝箱拆箱

所有的基本型別都有對應的類型別，比如int對應的類是Integer
這種類就叫做封裝類

Number類
數位封裝類有
Byte,Short,Integer,Long,Float,Double
這些類都是抽象類Number的子類

public class TestNumber {
 
    public static void main(String[] args) {
        int i = 5;
 
        //基本型別轉換成封裝型別
        Integer it = new Integer(i);
         
        //封裝型別轉換成基本型別
        int i2 = it.intValue();
         
    }
}

自動裝箱
不需要構造方法，通過 = 符號自動把基本型別轉換爲類型別就叫裝箱

public class TestNumber {
 
    public static void main(String[] args) {
        int i = 5;
 
        //基本型別轉換成封裝型別
        Integer it = new Integer(i);
         
        //自動轉換就叫裝箱
        Integer it2 = i;
      
    }
}

自動拆箱
不需要呼叫Integer的intValue方法，通過=就自動轉換成int型別，就叫拆箱

public class TestNumber {
  
    public static void main(String[] args) {
        int i = 5;
  
        Integer it = new Integer(i);
          
        //封裝型別轉換成基本型別
        int i2 = it.intValue();
         
        //自動轉換就叫拆箱
        int i3 = it;
          
    }
}

2.字串轉化

數位轉字串
方法1：使用String類的靜態方法valueOf
方法2：先把基本型別裝箱爲物件，然後呼叫物件的toString

public class TestNumber {
  
    public static void main(String[] args) {
        int i = 5;
         
        //方法1
        String str = String.valueOf(i);
         
        //方法2
        Integer it = i;
        String str2 = it.toString();
         
    }
}

字串轉數位
呼叫Integer的靜態方法parseInt

public class TestNumber {
  
    public static void main(String[] args) {
 
        String str = "999";
         
        int i= Integer.parseInt(str);
         
        System.out.println(i);
         
    }
}

數學方法
Java.lang.Math

 float f1 = 5.4f;
        float f2 = 5.5f;
        //5.4四捨五入即5
        System.out.println(Math.round(f1));
        //5.5四捨五入即6
        System.out.println(Math.round(f2));
         
        //得到一個0-1之間的隨機浮點數（取不到1）
        System.out.println(Math.random());
         
        //得到一個0-10之間的隨機整數 （取不到10）
        System.out.println((int)( Math.random()*10));
        //開方
        System.out.println(Math.sqrt(9));
        //次方（2的4次方）
        System.out.println(Math.pow(2,4));
         
        //π
        System.out.println(Math.PI);
         
        //自然常數
        System.out.println(Math.E);

3.格式化輸出

如果不使用格式化輸出，就需要進行字串連線，如果變數比較多，拼接就會顯得繁瑣
使用格式化輸出，就可以簡潔明瞭

%s 表示字串
%d 表示數位
%n 表示換行

public class TestNumber {
  
    public static void main(String[] args) {
 
        String name ="蓋倫";
        int kill = 8;
        String title="超神";
         
        //直接使用+進行字串連線，編碼感覺會比較繁瑣，並且維護性差,易讀性差
        String sentence = name+ " 在進行了連續 " + kill + " 次擊殺後，獲得了 " + title +" 的稱號";
         
        System.out.println(sentence);
         
        //使用格式化輸出
        //%s表示字串，%d表示數位,%n表示換行
        String sentenceFormat ="%s 在進行了連續 %d 次擊殺後，獲得了 %s 的稱號%n";
        System.out.printf(sentenceFormat,name,kill,title);
         
    }
}

printf和format能夠達到一模一樣的效果

String sentenceFormat ="%s 在進行了連續 %d 次擊殺後，獲得了 %s 的稱號%n";
        //使用printf格式化輸出
        System.out.printf(sentenceFormat,name,kill,title);
        //使用format格式化輸出
        System.out.format(sentenceFormat,name,kill,title);

跨平臺使用
換行符就是另起一行 — ‘\n’ 換行（newline）
回車符就是回到一行的開頭 — ‘\r’ 回車（return）
在eclipse裡敲一個回車，實際上是回車換行符
Java是跨平臺的程式語言，同樣的程式碼，可以在不同的平臺使用，但在不同的操作系統，換行符是不一樣的
（1）在DOS和Windows中，每行結尾是「\r\n」；
（2）Linux系統裡，每行結尾只有「\n」；
（3）Mac系統裡，每行結尾是隻有「\r」。
爲了使得同一個java程式的換行符在所有的操作系統中都有一樣的表現，使用%n，就可以做到平臺無關的換行

常用的格式化方法

 int year = 2020;
    //總長度，左對齊，補0，千位分隔符，小數點位數，在地化表達
      
    //直接列印數位
    System.out.format("%d%n",year);
    //總長度是8,預設右對齊
    System.out.format("%8d%n",year);
    //總長度是8,左對齊
    System.out.format("%-8d%n",year);
    //總長度是8,不夠補0
    System.out.format("%08d%n",year);
    //千位分隔符
    System.out.format("%,8d%n",year*10000);
  
    //小數點位數
    System.out.format("%.2f%n",Math.PI);
      
    //不同國家的千位分隔符
    System.out.format(Locale.FRANCE,"%,.2f%n",Math.PI*10000);
    System.out.format(Locale.US,"%,.2f%n",Math.PI*10000);
    System.out.format(Locale.UK,"%,.2f%n",Math.PI*10000);

4.字元

char只能放一個字元
char對應的封裝類是Character

		char c1 = 'a';
        Character c = c1; //自動裝箱
        c1 = c;//自動拆箱

Character常見方法

System.out.println(Character.isLetter('a'));//判斷是否爲字母
System.out.println(Character.isDigit('a')); //判斷是否爲數位
System.out.println(Character.isWhitespace(' ')); //是否是空白
System.out.println(Character.isUpperCase('a')); //是否是大寫
System.out.println(Character.isLowerCase('a')); //是否是小寫
         
System.out.println(Character.toUpperCase('a')); //轉換爲大寫
System.out.println(Character.toLowerCase('A')); //轉換爲小寫
 
String a = 'a'; //不能夠直接把一個字元轉換成字串
String a2 = Character.toString('a'); //轉換爲字串

字串
字串不可改變，表現就像一個常數
字串即字元的組合，在Java中，字串是一個類，所以我們見到的字串都是物件
常見建立字串手段：

每當有一個字面值出現的時候，虛擬機器就會建立一個字串
呼叫String的構造方法建立一個字串物件
通過+加號進行字串拼接也會建立新的字串物件

  String garen ="蓋倫"; //字面值,虛擬機器碰到字面值就會建立一個字串物件
     
    String teemo = new String("提莫"); //建立了兩個字串物件
     
    char[] cs = new char[]{'崔','斯','特'};
     
    String hero = new String(cs);//  通過字元陣列建立一個字串物件
     
    String hero3 = garen + teemo;//  通過+加號進行字串拼接

操縱字串
獲取字元
charAt(int index)獲取指定位置的字元

public class TestString {
    
    public static void main(String[] args) {
   
        String sentence = "蓋倫,在進行了連續8次擊殺後,獲得了 超神 的稱號";
         
        char c = sentence.charAt(0);
         
        System.out.println(c);
           
    }
}

獲取對應的字元陣列
toCharArray()
public class TestString {

    public static void main(String[] args) {
   
        String sentence = "蓋倫,在進行了連續8次擊殺後,獲得了超神 的稱號";
 
        char[] cs = sentence.toCharArray(); //獲取對應的字元陣列
         
        System.out.println(sentence.length() == cs.length);
         
    }
}

擷取子字串
subString

public static void main(String[] args) {
   
        String sentence = "蓋倫,在進行了連續8次擊殺後,獲得了 超神 的稱號";
         
        //擷取從第3個開始的字串 （基0）
        String subString1 = sentence.substring(3);
         
        System.out.println(subString1);
         
        //擷取從第3個開始的字串 （基0）
        //到5-1的位置的字串
        //左閉右開
        String subString2 = sentence.substring(3,5);
         
        System.out.println(subString2);
         
    }
}

分隔
split

public class TestString {
    
    public static void main(String[] args) {
   
        String sentence = "蓋倫,在進行了連續8次擊殺後,獲得了 超神 的稱號";
         
        //根據,進行分割，得到3個子字串
        String subSentences[] = sentence.split(",");
        for (String sub : subSentences) {
            System.out.println(sub);
        }
           
    }
}

去掉首尾空格
trim

public class TestString {
    
    public static void main(String[] args) {
   
        String sentence = "        蓋倫,在進行了連續8次擊殺後,獲得了 超神 的稱號      ";
         
        System.out.println(sentence);
        //去掉首尾空格
        System.out.println(sentence.trim());
    }

大小寫
toLowerCase 全部變成小寫
toUpperCase 全部變成大寫

public class TestString {
    
    public static void main(String[] args) {
   
        String sentence = "Garen";
         
        //全部變成小寫
        System.out.println(sentence.toLowerCase());
        //全部變成大寫
        System.out.println(sentence.toUpperCase());
         
    }

定位
indexOf 判斷字元或者子字串出現的位置
contains 是否包含子字串

public static void main(String[] args) {
    
        String sentence = "蓋倫,在進行了連續8次擊殺後,獲得了超神 的稱號";
  
        System.out.println(sentence.indexOf('8')); //字元第一次出現的位置
          
        System.out.println(sentence.indexOf("超神")); //字串第一次出現的位置
          
        System.out.println(sentence.lastIndexOf("了")); //字串最後出現的位置
          
        System.out.println(sentence.indexOf(',',5)); //從位置5開始，出現的第一次,的位置
          
        System.out.println(sentence.contains("擊殺")); //是否包含字串"擊殺"
          
    }

替換
replaceAll 替換所有的
replaceFirst 只替換第一個

public static void main(String[] args) {
   
        String sentence = "蓋倫,在進行了連續8次擊殺後,獲得了超神 的稱號";
 
        String temp = sentence.replaceAll("擊殺", "被擊殺"); //替換所有的
         
        temp = temp.replaceAll("超神", "超鬼");
         
        System.out.println(temp);
         
        temp = sentence.replaceFirst(",","");//只替換第一個
         
        System.out.println(temp);
         
    }

5.比較字串

是否是同一個物件
str1和str2的內容一定是一樣的！
但是，並不是同一個字串物件

public class TestString {
 
    public static void main(String[] args) {
 
        String str1 = "the light";
         
        String str2 = new String(str1);
         
        //==用於判斷是否是同一個字串物件
        System.out.println( str1  ==  str2);
         
    }

是否是同一個物件-特例

str1 = "the light";
str3 = "the light";

一般說來，編譯器每碰到一個字串的字面值，就會建立一個新的物件
所以在第6行會建立了一個新的字串"the light"
但是在第7行，編譯器發現已經存在現成的"the light"，那麼就直接拿來使用，而沒有進行重複建立

public class TestString {
 
    public static void main(String[] args) {
        String str1 = "the light";
        String str3 = "the light";
        System.out.println( str1  ==  str3);
    }
 
}

內容是否相同
使用equals進行字串內容的比較，必須大小寫一致
equalsIgnoreCase，忽略大小寫判斷內容是否一致

public class TestString {
  
    public static void main(String[] args) {
  
        String str1 = "the light";
          
        String str2 = new String(str1);
         
        String str3 = str1.toUpperCase();
 
        //==用於判斷是否是同一個字串物件
        System.out.println( str1  ==  str2);
         
        System.out.println(str1.equals(str2));//完全一樣返回true
         
        System.out.println(str1.equals(str3));//大小寫不一樣，返回false
        System.out.println(str1.equalsIgnoreCase(str3));//忽略大小寫的比較，返回true
         
    }
  
}

是否以子字串開始或者結束

startsWith //以…開始
endsWith //以…結束

public class TestString {
  
    public static void main(String[] args) {
        String str1 = "the light";
         
        String start = "the";
        String end = "Ight";
         
        System.out.println(str1.startsWith(start));//以...開始
        System.out.println(str1.endsWith(end));//以...結束
          
    }
  
}

6.StringBuffer是可變長的字串

**
append追加
delete 刪除
insert 插入
reverse 反轉

public class TestString {
  
    public static void main(String[] args) {
        String str1 = "let there ";
 
        StringBuffer sb = new StringBuffer(str1); //根據str1建立一個StringBuffer物件
        sb.append("be light"); //在最後追加
         
        System.out.println(sb);
         
        sb.delete(4, 10);//刪除4-10之間的字元
         
        System.out.println(sb);
         
        sb.insert(4, "there ");//在4這個位置插入 there
         
        System.out.println(sb);
         
        sb.reverse(); //反轉
         
        System.out.println(sb);
 
    }
  
}

長度容量
爲什麼StringBuffer可以變長？
和String內部是一個字元陣列一樣，StringBuffer也維護了一個字元陣列。但是，這個字元陣列，留有冗餘長度
比如說new StringBuffer(「the」)，其內部的字元陣列的長度，是19，而不是3，這樣呼叫插入和追加，在現成的陣列的基礎上就可以完成了。
如果追加的長度超過了19，就會分配一個新的陣列，長度比原來多一些，把原來的數據複製到新的陣列中，看上去陣列長度就變長了參考MyStringBuffer
length: 「the」的長度 3
capacity: 分配的總空間 19

public class TestString {
  
    public static void main(String[] args) {
        String str1 = "the";
 
        StringBuffer sb = new StringBuffer(str1);
         
        System.out.println(sb.length()); //內容長度
         
        System.out.println(sb.capacity());//總空間
  
    }
  
}

IStringBuffer介面

public interface IStringBuffer {
    public void append(String str); //追加字串
    public void append(char c);  //追加字元
    public void insert(int pos,char b); //指定位置插入字元
    public void insert(int pos,String b); //指定位置插入字串
    public void delete(int start); //從開始位置刪除剩下的
    public void delete(int start,int end); //從開始位置刪除結束位置-1
    public void reverse(); //反轉
    public int length(); //返回長度
}

value和capacity
value：用於存放字元陣列
capacity：容量
無參構造方法：根據容量初始化value

反轉 reverse

public void reverse() {
        for (int i = 0; i < length / 2; i++) {
            char temp = value[i];
            value[i] = value[length - i - 1];
            value[length - i - 1] = temp;
        }
    }