[趣學程式]java的常用類之String

upuptop發表於2019-08-12
Java

cmd2.gif

java基礎之常用類

String類

String表示字串,所謂字串,就是一連串的字元,是java中最常用的類之一。
String是不可變類，一旦String物件被建立，包含在物件中的字元序列(內容)是不可變的，直到物件被銷燬；
String物件儲存在JVM的常量池中，String類是用final來修飾的，是不可以被繼承的類。

常量池

常量池: JVM中一塊獨立的區域存放字串常量和基本型別常量（被public static final修飾的）。
String使用private final char value[]來實現字串的儲存,也就是說String物件建立之後
,就不能再修改此物件中儲存的字串內容,就是因為如此,才說String型別是不可變的.

String物件的建立方式

    String str = "HelloWorld";
    String str2 = new String("upuptop");
    String str3 = String.valueOf(1);
    String str4 = 123+"";

String物件比較:

單獨使用""引號建立的字串都是常量,編譯期就已經確定儲存到常量池中；
使用new String("")建立的物件會儲存到堆記憶體中,是執行期新建立的；
使用只包含常量的字串連線符如"aa" + "bb"建立的也是常量,編譯期就能確定,已經確定儲存到常量池中；
使用包含變數的字串連線符如"aa" + s1建立的物件是執行期才建立的,儲存在堆中；


public class StringDemo {
    public static void main(String[] args) {
        /*
         *  "" 其實表示的是  String的匿名物件
         */
        String s = "";
        /**
         * String()    初始化一個新建立的 String 物件，使其表示一個空字元序列。
         *  "",不是表示 null
         *  String(String original) 
         *  String s = new String("asd");// s 的值就是 asd
         */
        s = new String();//""
        String s1  = new String("11");
        String s2  = new String("11");
        System.out.println(s1 == s2);//false
        String s3 = "22";
        String s4 = "22";
        System.out.println(s3 == s4);//true
        System.out.println(s3 == s2);//false
        String  s5 = "2" + "2";//這句話其實在編譯器編譯後的class檔案中 已經變成  "22"
        //s5建立了幾個物件?//回答：最多一個，如果常量池裡面沒有就是建立一個，如果常量池裡本來就有就是建立零個！下面的str一樣的道理。
        String str = "A" +"B"+ "C" +"D" +"E";//String str = "ABCDE";
        System.out.println(s3 == s5);//true
        /**
         * String特點:    不可變的,  一個String物件的內容不能變,一旦內容變數該物件就變成一個新的String物件了
         *  String  str = "AAA";
         *  str = str+"12";
         */
        String str1 = "ABCDE";
        System.out.println(str == str1);//true
        String str2 = "ABC" + "DE";
        System.out.println(str == str2);//true
        String  ss = "AB";
        String str3 = ss + "CDE";//這裡的str3在執行期才能確定內容值
        System.out.println(str3 == str2);//false
        String str4 = getStr() +"CDE";//在執行期才能確定 str4的值
        System.out.println(str == str4);//false
        System.out.println(str3 == str4);//false
        /*
         *  String s = "cd";    //一個String物件
            s = s + "itcast";   //itcast也是String物件, 最後的s的值cditcast,也是一個String物件
            System.out.print(s);
         * */
    }
    public static String getStr(){
        return "AB";
    }
}

String常用方法

方法名 意義
String() 初始化一個新的 String 物件，使其表示一個空字元序列，並不是返回空(不等於 null)。
String(StringBuffer buffer) 根據StringBuffer物件來建立String物件；
String(StringBuilder builder) 同上
char charAt(int index) 取字串中指定位置的字元，index從0開始計算。
String concat(String str) 連線字串，等同於 “+”；
boolean contentEquals(StringBuffer buffer) 若二者包含的字元序列相同時就返回true;
boolean equals(Object obj) 將該字串與指定物件比較，若二者包含的字元序列相等返回true；
boolean equalsIgnoreCase(String anotherString) 將此 String 與另一個 String 比較，不考慮大小寫;
byte[] getBytes() 將該字串轉換成byte陣列；
int indexOf(String str) 找出str字串在該字串中第一次出現的位置；
int indexOf(String str, int fromIndex) 返回指定子字串在此字串中第一次出現處的索引，從指定的索引開始;
int lastIndexOf(String str) 返回指定子字串在此字串中最後一次出現處的索引;
int length() 返回當前字串長度；
String replace(char oldChar, char newChar) 返回一個新的字串，它是通過用 newChar 替換此字串中出現的所有 oldChar 得到的。
String replaceAll(String regex, String replacement) 使用給定的 字串replacement 替換此字串所有的regex字串;
boolean startsWith(String prefix) 測試此字串是否以指定的字首開始.
String[] split(String regex) 把字串按指定的字串分隔開。
String substring(int beginIndex) 返回一個新的字串，從beginIndex開始擷取，它是此字串的一個子字串;
String substring(int beginIndex, int endIndex) 返回一個新字串，它是此字串的一個子字串;[begin,end)
char[] toCharArray() 將此字串轉換為一個新的字元陣列。
String toLowerCase() 將此 String 中的所有字元都轉換為小寫;
String toUpperCase() 轉成大寫;
static String valueOf(基本型別 obj) 把基本型別值轉成字串;
String trim() 忽略字串前導空白和尾部空白。

String小練習

  1. 判斷字串是否由純數字組成：

package reviewDemo;

public class Demo20 {
    public static void main(String[] args) {
        String s1 = "123456789";
        String s2 = "12345  6789";
        System.out.print(isnum(s1));
        System.out.print(isnum(s2));
    }
    
    public static boolean isnum(String s){
        //將字串引數轉為字元陣列
        char []ch = s.toCharArray();
        //迴圈字元陣列，判斷每一個元素是否在數字對應的字元區間內
        for (char c : ch) {
            //判斷字元是否在[0-9]這個區間內部
            if(!(c > '0' && c <= '9')){
                return false;
            }
        }
        return true;
    }
}

輸出：

true
false
  1. 判斷字串是否為空：
分析：
字串的空有兩種情況：1、null；2、"";

package reviewDemo;

public class Demo21 {
    public static void main(String[] args) {
        
        String s1 = "";
        System.out.println(isimpty(s1));
        
    }
    
    public static String isimpty(String s){

        if(s != null && !"".equals(s)){
            return "不為空";
        }
        return "為空！";
    }
}

StringBuffer 與 StringBuilder

String是不可變類，一旦String物件被建立，包含在物件中的字元序列是不可變的，直到物件被銷燬；
StringBuffer 與 StringBuilder物件則是可變的！

由於String建立的物件是一個不變化的物件，為了方便在我們使用過程中修改字串的內容，java為我們提供了StringBUffer和StringBuilder兩個類
StringBuffer是執行緒安全的類，StringBuilder是執行緒不安全的類。在多執行緒環境下使用StringBuffer。


在平時的程式設計中，我們為了方便，總是使用字串之間相互加減進行操作修改字串的內容。
比如：
    String a  = "h";
    String b = "e";
    String c = "c";
    String result = a + b +c +"result" ;
    
如上方式是不高效的，推薦修改為StringBuilder或StringBuffer。下列程式驗證了程式的高效性。


package reviewDemo;

public class Demo22 {
    public static void main(String[] args) {
        
        String s = "";
        long begintime = System.currentTimeMillis();
        for(int i = 1;i <= 100000;i++){
            s += i;
        }
        
        
        long endtime = System.currentTimeMillis();
        long time = endtime - begintime;
        System.out.println("執行時間為："+time);
        
        StringBuffer s1 = new StringBuffer();
        s = "";
        begintime = System.currentTimeMillis();
        for(int i = 1;i <= 100000;i++){
            s = ""+i;
            s1 = new StringBuffer(s);
        }
        
        endtime = System.currentTimeMillis();
        time = endtime - begintime;
        System.out.println("執行時間為："+time);
        
    }
}

輸出：
執行時間為：82922
執行時間為：15
可以看得出：StringBuffer這兩個效率相當高！

StringBuffer 與 StringBuilder

  • StringBuffer： 是執行緒安全的；
  • StringBuilder： 是執行緒不安全的，效能高點，推薦使StringBuilder；(jdk1.5出現)
  • StringBuffer的字元序列是可變的(通過append等方法操作)
  • StringBuffer 和 String之間的轉換；
  • String toString() 返回此序列中資料的字串表示形式。
  • StringBuffer(String str):以指定的字串建立StringBuffer物件。

StringBuffer方法

方法名 意義
public StringBuilder() 構造一個不帶任何字元的StringBuilder物件。
StringBuffer(String str) 構造一個字串緩衝區，並將其內容初始化為指定的字串內容。
StringBuffer append(Object o) 將指定的任意型別物件追加到此StringBuffer 物件。
StringBuffer insert(int offset, Object o) 將任意型別引數的字串表示形式插入此序列中。
StringBuffer delete(int start, int end) 移除此序列的子字串中的字元。
StringBuffer deleteCharAt(int index) 移除此序列指定位置的 char。

練習

  1. 需求：用StringBuilder 或StringBuffer: 把字串“ABCDE”; 轉變成字串“A,B,C,D”


public class Demo23 {
    public static void main(String[] args) {
        //第一種方法：往裡面插入；
        StringBuilder sb = new StringBuilder("ABCDE");
        sb.deleteCharAt(sb.length()-1);
        System.out.println(sb);
        for (int i = 0; i < sb.length(); i+=2) {
            sb.insert(i, ",");
        }
        sb.deleteCharAt(0);
        
        System.out.println(sb);
        
        
        //第二種方法：往裡面追加，要追加必須遍歷，必須換為陣列！
        sb = new StringBuilder("ABCDE");
        sb.deleteCharAt(sb.length()-1);
        System.out.println(sb);
        char []cs = sb.toString().toCharArray();
        StringBuilder sb1 = new StringBuilder();
        for (char c : cs) {
            sb1.append(c).append(",");
        }
        sb1.deleteCharAt(sb1.length()-1);
        System.out.println(sb1);
    } 
}
  1. 編寫一個程式，這個程式把一個整數陣列中的每個元素用逗號連線成一個字串，例如，根據內容為{1，2，3}的陣列形成內容為"1,2,3"的字串。

package reviewDemo;
/**
 * 編寫一個程式，
 * 這個程式把一個整數陣列中的每個元素用逗號連線成一個字串，
 * 例如，根據內容為{1，2，3}的陣列形成內容為"1,2,3"的字串。
 */

public class Demo24 {
    public static void main(String[] args) {
        int []i = {1,2,3,4,5};
        StringBuilder sb = new StringBuilder();
        for (int j : i) {
            sb.append(j).append(",");
        }
        sb.deleteCharAt(sb.length()-1);
        System.out.println(sb);
    }
}

注意:

字串是任何程式語言的最常用、處理操作最多的。即使在大資料領域也是以處理文字資料為主。

推薦朋友關注【趣學程式】公眾號，公眾號內所有資源免費獲取。

相關文章