Java中String類的一些常見(jiàn)方法總結(jié)

更新時(shí)間：2024年11月19日 10:47:22 作者：愛(ài)編程的小新☆

這篇文章主要給大家介紹了關(guān)于Java中String類的一些常見(jiàn)方法,文中包括了Java中String類的基本概念、構(gòu)造方式、常用方法以及StringBuilder和StringBuffer的使用,涵蓋了字符串操作的各個(gè)方面,包括查找、轉(zhuǎn)換、比較、替換、拆分、截取等,需要的朋友可以參考下

一. String類的概念

在Java中 String類是用于表示和操作字符串的類，字符串是Java中常用的數(shù)據(jù)類型，用于存儲(chǔ)文本信息，并且String類中提供了許多方法用來(lái)執(zhí)各種字符串操作，那么我們隨著下文來(lái)學(xué)習(xí)一下常見(jiàn)的方法。

1.1 String類的特性

1. 不可變性：

String 對(duì)象是不可變的，一旦創(chuàng)建了 String 對(duì)象，其里面的內(nèi)容就不能被修改，對(duì) String的任何操作實(shí)際上都是創(chuàng)建了一個(gè)新的 String 對(duì)象。

注意：不能修改指的是：String對(duì)象的內(nèi)容不能修改，而指向String對(duì)象的引用是可以修改的

2. 常量池的概念

字符串常量池是Java中用于存儲(chǔ)字符串字面量的內(nèi)存區(qū)域，為了節(jié)省內(nèi)存，Java使用字符常量池來(lái)存儲(chǔ)字符串字面量，當(dāng)創(chuàng)建相同的字符串字面量時(shí)，它們會(huì)引用常量池中的同一個(gè)對(duì)象，從而降低程序內(nèi)存的開銷。

二. 字符串的構(gòu)造方式

1. 使用字符串字面量構(gòu)造

public class Test {
    public static void main(String[] args) {
        String s1 = "hello world"; //直接使用字符串字面量進(jìn)行構(gòu)造
        System.out.println(s1);
    }
}

2. 通過(guò)new關(guān)鍵字創(chuàng)建一個(gè)String對(duì)象

public class Test {
    public static void main(String[] args) {
        String s2 = new String("hello world");//通過(guò)new關(guān)鍵字創(chuàng)建對(duì)象
        System.out.println(s2);
    }
}

3.使用字符數(shù)組進(jìn)行構(gòu)造

public class Test {
    public static void main(String[] args) {
        char[] str = {'h','e','l','l','o','w','o','r','l','d'};
        String s3 = new String(str); //使用字符數(shù)組進(jìn)行構(gòu)造
        System.out.println(s3);
    }
}

以上就是最常見(jiàn)的最常見(jiàn)的字符串構(gòu)造方式。

三. 常用方法

3.1 字符串查找

（1）char charAt( int index)

public class Test {
    public static void main(String[] args) {
        String str="hello world";
        char ch=str.charAt(1);
        System.out.println(ch);//e
    }
}

如果輸入一個(gè)不合法的下標(biāo)位置，就會(huì)發(fā)生報(bào)錯(cuò)：

（2）int indexOf( int ch)

public class Test {
    public static void main(String[] args) {
        String str="hello world";
        int n=str.indexOf('l');
        System.out.println(n); //2
    }
}

（3）int indexOf(int ch, int fromIndex)

public class Test {
    public static void main(String[] args) {
        String str="hello world";
        int n=str.indexOf('o',6);
        //從下標(biāo)為6的位置(w)開始往后查找o的位置,7
        System.out.println(n);
    }
}

（4）int indexOf(String str)

public class Test {
    public static void main(String[] args) {
        String str="hello worldwor";
        int n=str.indexOf("wor");
        // 返回wor第一次出現(xiàn)的位置，沒(méi)有返回-1,所以返回值為6
        System.out.println(n);
    }
}

（5）int indexOf(String str, int fromIndex)

public class Test {
    public static void main(String[] args) {
        String str="hello worldwor";
        int n=str.indexOf("wor",8);
        //從下標(biāo)為8的位置開始找wor第一次出現(xiàn)的位置，沒(méi)有返回-1,所以這里返回值為11
        System.out.println(n);
    }
}

（6）int lastIndexOf(int ch)

public class Test {
    public static void main(String[] args) {
        String str="hello worldwor";
        int n=str.lastIndexOf('w');
        //從后往前找，返回w第一次出現(xiàn)的位置，沒(méi)有返回-1,所以返回值為11
        System.out.println(n);
    }
}

（7）int lastIndexOf(int ch, int fromIndex)

public class Test {
    public static void main(String[] args) {
        String str="hello worldwor";
        int n=str.lastIndexOf('w',10);
        //從下標(biāo)10的位置開始找，從后往前找w第一次出現(xiàn)的位置，沒(méi)有返回-1，所以返回值為6
        System.out.println(n);
    }
}

（8）int lastIndexOf(String str)

public class Test {
    public static void main(String[] args) {
        String str="hello worldwor";
        int n=str.lastIndexOf("wor");
        //從后往前找，返回wor第一次出現(xiàn)的位置，沒(méi)有返回-1,返回值為11
        System.out.println(n);
    }
}

（9）int lastIndexOf(String str, int fromIndex)

public class Test {
    public static void main(String[] args) {
        String str="hello worldwor";
        int n=str.lastIndexOf("wor",10);
        //從下標(biāo)為10的位置開始找，從后往前找wor第一次出現(xiàn)的位置，沒(méi)有則返回-1，這里返回值為6
        System.out.println(n);
    }
}

3.2 字符串轉(zhuǎn)換

（1）數(shù)值和字符串轉(zhuǎn)化

數(shù)值轉(zhuǎn)換成字符串，用String.valueOf( )進(jìn)行轉(zhuǎn)換：

public class Test {
    public static void main(String[] args) {
        // 數(shù)字轉(zhuǎn)字符串
        String s1 = String.valueOf(123456);
        String s2 = String.valueOf(13.14521);
        System.out.println(s1);
        System.out.println(s2);
    }
}

數(shù)字字符串轉(zhuǎn)換成數(shù)字，用 Interger.valueOf( )進(jìn)行轉(zhuǎn)換：

public class Test {
    public static void main(String[] args) {
        // 字符串轉(zhuǎn)數(shù)字
        int n= Integer.valueOf("1234");
       double m= Double.valueOf("12.13");
        System.out.println(n);
        System.out.println(m);
    }
}

并且我們也可以傳數(shù)字字符串，所需要轉(zhuǎn)換的進(jìn)制數(shù)：

public class Test {
    public static void main(String[] args) {
        // 字符串轉(zhuǎn)數(shù)字
       int n=Integer.valueOf("1111",2);
       //后面的2表示，前面的數(shù)字字符串中的數(shù)字是2進(jìn)制的形式，我們轉(zhuǎn)換成10進(jìn)制形式
        //就是15
        System.out.println(n);
    }
}

（2）字母的大小寫轉(zhuǎn)換

字母大小寫轉(zhuǎn)換我們使用String.toUpperCase----小寫轉(zhuǎn)大寫和 String.toLowerCase----大寫轉(zhuǎn)小寫

public class Test {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO";
    // 小寫轉(zhuǎn)大寫
        System.out.println(s1.toUpperCase());//HELLO
    // 大寫轉(zhuǎn)小寫
        System.out.println(s2.toLowerCase());//hello
    }
}

（3）字符串轉(zhuǎn)數(shù)組

我們還可以將一個(gè)字符串轉(zhuǎn)換成一個(gè)數(shù)組，使用String.toCharArray( )方法進(jìn)行轉(zhuǎn)換：

public class Test {
    public static void main(String[] args) {
        String s = "hello";
        // 字符串轉(zhuǎn)數(shù)組
        char[] ch = s.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            System.out.print(ch[i]);
        }
    }
}

（4）格式化字符串

我們可以使用String.format( )方法進(jìn)行字符串的格式化：

public class Test {
    public static void main(String[] args) {
        String s = String.format("%d-%d-%d", 2024, 10,30);
        System.out.println(s);
        //打印2024-10-30
    }
}

3.3 字符串比較

當(dāng)我們比較基本數(shù)據(jù)類型的對(duì)象的時(shí)候，使用 == 可以進(jìn)行比較，但是對(duì)于我們的String類型（引用類型）來(lái)說(shuō)，使用 == 進(jìn)行比較，比較的是引用中的地址：

從上圖就可以發(fā)現(xiàn) str1和str2中存放的的字符串是一樣的，但是運(yùn)行結(jié)果顯示并不相等，那么當(dāng)我們需要進(jìn)行字符串比較的時(shí)候該怎么辦呢？

3.3.1 equals( )方法

equals( )方法的比較方式：按照字典序比較--->比較的是字符大小的順序

3.3.2 compare To( )方法

compare To( )方法的比較方法：按照字典序進(jìn)行比較 ----> compare To( )方法與equals( )方法的區(qū)別：equals( )方法的返回值是 boolean 類型的值，而 compare To( )方法返回的是 int 類型的值。

1. 先按照字典次序大小比較，如果出現(xiàn)不等的字符，直接返回這兩個(gè)字符的大小差值。

2. 如果前k個(gè)字符相等(k為兩個(gè)字符長(zhǎng)度最小值)，返回值兩個(gè)字符串長(zhǎng)度差值。

3.3.3 compare ToIgnoreCase( )方法

該方法與compare To( )方法沒(méi)有很大差別，但是compare ToIgnoreCase( )方法在進(jìn)行比較的時(shí)候能夠忽略字符的大小寫：

3.4 字符串替換

3.4.1 replace( )方法

replace( )方法能夠?qū)⒁粋€(gè)字符串中指定的字符替換成一個(gè)新指定的字符：

3.4.2 replaceFrist( )方法

replaceFrist( )方法能夠?qū)⒆址兄付ǖ牡谝粋€(gè)字符串替換成新指定的字符串：

3.4.3 replaceAll( )方法

replaceAll( )方法與 replaceFrist( )方法不同的是： replaceAll( )方法能將字符串中所有指定的字符串全部替換成一個(gè)新指定的字符串：

3.5 字符串拆分

3.5.1 String[] split(String regex)

String[] split( )方法能夠?qū)⒁粋€(gè)字符串按照指定的字符為分割線，分割成若干個(gè)子字符串：

3.5.2 String[] split(String regex, int limit)

String[] split(String regex, int limit)方法能夠?qū)⒆址凑罩付ǖ母袷剑指畛?strong> limit 個(gè)子字符串：

3.6 字符串截取

3.6.1 String substring(int beginIndex)

將字符串從下標(biāo)為 beginIndex 的位置開始截取到字符串結(jié)尾：

3.6.2 String substring(int beginIndex, int endIndex)

將字符串從下標(biāo)為 beginIndex 的位置開始截取到 endIndex 位置的前一個(gè)字符為止：

四.StringBuilder和StringBuffer

在開頭的String類的特征中，我們就說(shuō)明了String類的不可變性，對(duì) String 對(duì)象的任何修改操作都會(huì)創(chuàng)建一個(gè)新的對(duì)象，在程序運(yùn)行的過(guò)程中，效率是很低的，那么這個(gè)時(shí)候如果要對(duì)字符串進(jìn)行修改盡量使用StringBuffer或者StringBuilder。