Java基礎(chǔ)09 —— 字符序列

字符串類型

字符與字符串

字符類型(char)是Java中的基本數(shù)據(jù)類型，占2個字節(jié)16位，默認值是 ‘\u0000’ 。字符是用單引號引住的單個符號.

// 字符
char c = 'A'; //單引號
char cA = 65; //數(shù)字
char c1 = '\u8888'; //Unicode碼
System.out.println(c); //A
System.out.println(cA); //A
System.out.println(c1);//袈

字符串(String)是用雙引號引住的任意個字符，是引用數(shù)據(jù)類型，默認值是null 。字符串其實就是字符組成的序列

字符串聲明

String 變量名 = "初始值";
String 變量名 = new String("初始值");

舉例：

String str = "張三"; // 字面量 比較常用
String str1 = new String("張三"); // 字符串對象

字符序列

多個字符按照一定的順序組成的列表就叫作字符序列，字符串 java.lang.String 可以用來表示多個字符,用 “” 引

起來。

JDK13 新增文本塊(預(yù)覽)，在 JDK15 正式在字符串支持文本塊，用 “”" 表示

// Text Block 文本塊聲明
String season = """
				winter""";


//H i , LF(換行) SP(空格) " B o b " LF(換行)
String salutation = """
                    Hi,
                    "Bob"
                    """;
                        
// 輸出為空
String empty = """
               """;

// 文本塊 “”“ 字符內(nèi)容 ”“”
   String text = """
                 序號    姓名
                 1      張三
                 "snadnlasmkl"
                 """;
   System.out.println(text);

String 字符串

StringBuffer 字符串緩沖區(qū)，是線程安全的

StringBuilder 字符串構(gòu)造器，非線程安全的

CharBuffer 字符緩沖區(qū)

以上都實現(xiàn)了 CharSequence 接口

String類

字符串具有不可變特性；

public final static String是用final修飾的類，在java中用final修飾的類不能被繼承，也就是說String沒有子類。

在java中，關(guān)鍵字final表示最終的。可以用來修飾類、方法、變量。

被final修飾的類，不能被繼承

被final修飾的方法，不能被重寫

被final修飾的變量，不能變，如果是基本數(shù)據(jù)類型不能被重新賦值，如果是引用數(shù)據(jù)類型不能改變引用。

字符串不可變原因

字符串的底層是一個數(shù)組，jdk1.8之前是char類型的數(shù)組，jdk1.9及之后的版本是byte類型的數(shù)組。,不管是 jdk 8 及以前還是 jdk 9 及以后版本， value 屬性都是 final 的。就說明，字符串一旦聲明就不可變。所以字符串擁有不可變性。

改變原因：主要是為了節(jié)約 String 占用的內(nèi)存，占用內(nèi)存少引發(fā)另外一個好處就是減少 GC 次數(shù)。

**解釋：**在java程序的堆里，String占用的空間最大，并且絕大多數(shù)String只有Latin-1字符，這些Latin-1字符只需要1字節(jié)就夠了。在jdk9之前,jvm使用char類型的數(shù)組存儲，char占用2個字節(jié)，即使字符串只需要1字節(jié)/字符，但依舊會按照2字節(jié)/字符進行存儲，浪費了一半的內(nèi)存空間。

jdk9的解決辦法就是，一個字符串出來的時候判斷，它是不是只有Latin-1字符，如果是，就按照1字節(jié)/每字符進行內(nèi)存分配，如果不是就按照2字節(jié)/每字符規(guī)格進行分配（UTF-16編碼）,提高了內(nèi)存使用率。

為什么用 UTF-16 而不用 UTF-8 呢

這就要從這兩個字符集的設(shè)計說起了。UTF-8 實際上是對空間利用效率最高的編碼集，它是不定長的，可以最大限度利用內(nèi)存和網(wǎng)絡(luò)。但是這種編碼集只能用于傳輸和存儲，并不適合拿來做 String 的底層實現(xiàn)。因為 String 有隨機訪問的方法，所謂隨機訪問，就是 charAt 、 subString 這種方法。如果字符串中的每個字符占用的內(nèi)存是不定長的，那么進行隨機訪問的時候，就需要從頭開始數(shù)每個字符的長度，才能找到你想要的字符。

使用 UTF-16 編碼將它們表示并存儲為每個字符2個字節(jié)。

對于 JDK9 和更高版本，默認情況下，如果 String 的行為已更改為對字符串使用緊湊表示形式。

String常用方法

1.構(gòu)造方法

2.實例方法

常用方法進行分類： 查找字符的位置， 截取字符串， 拼接字符串等

字符串只能做+操作，表示拼接。任何類型的元素和字符串做+操作都表示字符串的拼接

contains()方法表示是否包含子元素，例如contains("wor")為true。

endsWith("內(nèi)容")表示是否以某字符結(jié)尾，startsWith("內(nèi)容")表示是否以某字符開頭。

indexOf("字符")表示某個子串在字符串第一次出現(xiàn)的下標(biāo)。-1表示未出現(xiàn)。

indexOf("字符"，3)表示某個字符從索引位開始第一次出現(xiàn)的位置

intern如果字符串在常量池中有，就返回常量池中的對象，如果沒有就將對象放入常量池中，并將這個對象返回。

自動裝箱操作是通過包裝類.valueOf()進行的，自動拆箱操作是通過包裝類對象.xxxValue()進行的。

//占位符 %s 字符串 %bboolean %cchar %dinteger %f 浮點數(shù)

字符串判斷相等：字符串（String）是引用數(shù)據(jù)類型，所以使用 equals 方法進行比較

// 字符串拼接 +
String str = "hello";
Str = str+" world";  //  hello world

//  分隔字符串 spilt()  用`-`做分隔符，然后通過`split()`方法轉(zhuǎn)換成逗號并輸出。
str = "1-2-3-4-5-6";
String[] strs = str.split("-");
System.out.println(Arrays.toString(strs));

//  重復(fù)
str = "666";
str = str.repeat(3);
System.out.println(str);

// 替換
str = "abcdabcd";
str = str.replace("a","A");// 會替換所有的a變成A
str = str.replaceFirst("a", "A");//只會替換第一次出現(xiàn)的a變成A
System.out.println(str);

// 格式化
str = "我是%s".formatted("張三");
System.out.println(str);   // 我是張三

// 判斷是否包含
boolean contains = str.contains("hello world");
System.out.println(contains);

// 是否以某個字符串結(jié)尾
String email = "xxxx@qq.com";
boolean end = email.endsWith(".com");
System.out.println(end);

// 是否以某個字符串開頭
boolean start = email.startsWith("xxx");
System.out.println(start);

// 子串在字符串中第一次出現(xiàn)的位置(下標(biāo)), -1 表示沒出現(xiàn)
int index = str.indexOf("e");
System.out.println(index);
int hello = str.indexOf("le");
System.out.println(hello); // -1

// 從 fromIndex開始第一次出現(xiàn)的下標(biāo)
index = str.indexOf("l", 3);
System.out.println(index);

// 最后一次出現(xiàn)的位置
index = str.lastIndexOf("l");
System.out.println(index); // 9

// 分隔字符串
str = "1-2-3-4-5-6";
String[] strs = str.split("-");
System.out.println(Arrays.toString(strs));

// 合并 static方法
str = String.join(".", "a", "b", "c", "d");
System.out.println(str);

isEmpty 和 isBlank 區(qū)別

isEmpty 當(dāng)且僅當(dāng)字符串長度為0時返回 true

isBlank 當(dāng)字符串長度為0或字符串中全是空白字符時都是 true

intern（）用法

intern 如果字符串在常量池中有就返回常量池中的對象，如果沒有就將對象放入常量池中,并將這個對象返回.

public class Demo07 {
	public static void main(String[] args) {
    /*
     intern 如果字符串在常量池中有就返回常量池中的對象，
            如果沒有就將對象放入常量池中,并將這個對象返回
     */
        //        String str = "你好啊";
//
//
//        System.out.println(str);
//        System.out.println(System.identityHashCode(str));
//
//        String s = new String("你好啊").intern();
//
//        System.out.println(System.identityHashCode(s));
            // 1.
//        String str = "abc";
//
//        String s = new String("abc");
//
//        String s1 = s.intern();
//
//        System.out.println(str == s); // false
//        System.out.println(str == s1); // true
//        System.out.println(s == s1); // false  
        
             // 2.
//        String s = new String("abc");
//
//        String s1 = s.intern();
//
//        String str = "abc";
//
//        System.out.println(str == s); // false
//        System.out.println(str == s1); // true
//        System.out.println(s == s1); // false   
        
            // 3.
//        String  a = "a";
//        String s = new String(a + "bc");
//
//        String s1 = s.intern();
//
//        String str = "abc";
//
//        System.out.println(str == s); //  true
//        System.out.println(str == s1); // true
//        System.out.println(s == s1); //   true 
        
        // 4.
        String  a = "a";
        String s = new String(a + "bc");

        String str = "abc";

        String s1 = s.intern();
        System.out.println(str == s); //  false
        System.out.println(str == s1); // true
        System.out.println(s == s1); //   false

	}
}

valueOf() 類方法

有很多重載方法。涵蓋了所有的數(shù)據(jù)類型轉(zhuǎn)換 字符串的方法；

字符串 <—> 基本數(shù)據(jù)類型文章來源地址http://www.zghlxwxcb.cn/news/detail-701837.html

public class Demo08 {
	public static void main(String[] args) {
    /*
           valueOf() 類方法，有很多重載方法。涵蓋了所有的數(shù)據(jù)類型轉(zhuǎn)換 字符串的方法；

           字符串 <---> 基本數(shù)據(jù)類型
     */
    // 任意類型轉(zhuǎn)換為字符串
    byte b = 1;
    String str = String.valueOf(b);
    String.valueOf(true);
    String.valueOf(1.1);

    // int <---> String

    // 字符串 --> int  包裝類.valueOf
    Integer a = Integer.valueOf("11");
    Integer.parseInt("11");
    System.out.println(a);
    // int  --> 字符串  String.valueOf()
    String s = String.valueOf(a);
	}
}

StringBuffer和StringBuilder

二者都是繼承自抽象類AbstractStringBuilder

StringBuffer 中很多方法和 String 中的方法類似在此不再贅述

StringBuffer 是線程安全的類，StringBuilder是非線程安全的; String 不可變，所以是線程安全

StringBuilder執(zhí)行效率相對較高.

StringBuffer 從jdk1.0開始就提供了，而StringBuilder 是jdk1.5才提供的

兩個類大部分實現(xiàn)都一樣，不同點在于StringBuffer 中大部分方法都有 synchronized 修飾。synchronized 表示同步，修飾的方法表示同步方法。是多線程中一種線程安全的實現(xiàn)方法。

StringBuffer常用方法

StringBuffer sb = new StringBuffer();
sb.append("a").append("b");

StringBuilder

一個可變的字符序列。 此類提供與 StringBuffer 相同的API，但不保證同步

在可能的情況下，建議使用 StringBuilder ，因為它在大多數(shù)實現(xiàn)中將更快

在使用 String 實例拼接(’ + ')時，編譯器會使用 StringBuilder 來拼接字符串

class StringBuilderDemo {
        public static void main(String[] args) {

            // 16個長度的字符構(gòu)建器
            StringBuilder sb = new StringBuilder();
            // 創(chuàng)建指定長度的 StringBuilder 對象
            sb = new StringBuilder(3);
            // 創(chuàng)建指定內(nèi)容的 StringBuilder 對象
            //        sb = new StringBuilder("hello");
            System.out.println(sb.capacity());

            // 修改 StringBuilder 內(nèi)容
            sb.append("a");
            sb.append("b");

            // 鏈?zhǔn)秸{(diào)用
            sb.append("c").append("d").append("e");

            // 刪除某個位置
            //        sb.deleteCharAt(0);
            // 刪除某個范圍
//        sb.delete(0, 2);
            sb.insert(3, "A");

            // 數(shù)組長度 arr.length 字符串 str.length()
            //        System.out.println(sb.length());
            // StringBuilder --> String
            String str = sb.toString();
            System.out.println(str);
            System.out.println(sb.capacity());

            sb.reverse();
            System.out.println(sb.toString());
        }
    }

valueOf() 類方法

有很多重載方法。涵蓋了所有的數(shù)據(jù)類型轉(zhuǎn)換 字符串的方法；

字符串 <—> 基本數(shù)據(jù)類型

public class Demo08 {
	public static void main(String[] args) {
    /*
           valueOf() 類方法，有很多重載方法。涵蓋了所有的數(shù)據(jù)類型轉(zhuǎn)換 字符串的方法；

           字符串 <---> 基本數(shù)據(jù)類型
     */
    // 任意類型轉(zhuǎn)換為字符串
    byte b = 1;
    String str = String.valueOf(b);
    String.valueOf(true);
    String.valueOf(1.1);

    // int <---> String

    // 字符串 --> int  包裝類.valueOf
    Integer a = Integer.valueOf("11");
    Integer.parseInt("11");
    System.out.println(a);
    // int  --> 字符串  String.valueOf()
    String s = String.valueOf(a);
	}
}

包裝類

public class Demo09 {
	public static void main(String[] args) {
    /*
        包裝類
            自動裝箱操作是通過 包裝類.valueOf 進行的
            自動拆箱操作是通過 包裝類對象.xxxValue() 進行
        包裝類結(jié)構(gòu)
     */

    Integer a = 1;
    int b = a;
// 	Integer n = Integer.valueOf(1);
//  Integer num = new Integer(1);
//  Integer num1 = new Integer("12");
    Integer num = 100;//  Integer.valueOf(100)
    Integer num1 = 100; // Integer.valueOf(100)

    System.out.println(num == num1);

    num = 200; // new Integer()
    num1 = 200; // new Integer();
    System.out.println(num == num1);

    // Byte  Short Character(0~127)  Integer Long 都有緩存對象數(shù)組
    Character c = '(';

    System.out.println(Character.isMirrored('['));
    }
}

到了這里，關(guān)于Java基礎(chǔ)09 —— 字符序列--String、StringBuilder、StringBuffer區(qū)別及其方法介紹的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！