欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Java中字符串String常用方法詳解

 更新時間：2024年01月26日 10:11:23   作者：tao滔不絕  
這篇文章主要給大家介紹了關于Java中字符串String常用方法的相關資料,String表示字符串類型,是引用數(shù)據(jù)類型不是基本數(shù)據(jù)類型,String是類且是最終類,不能有子類,文中將用法介紹的非常詳細,需要的朋友可以參考下

一、常用方法

1、字符串構造

三種構造方法

（1）、直接賦值

String s1 = "hello world";
System.out.println(s1);

（2）、創(chuàng)建出新的對象

String s2 = new String("hello");
System.out.println(s2);

（3）、使用字符數(shù)組進行構造

char[] ch = {'h','e','l','l','o'};
String s3 = new String(ch);
System.out.println(s3);

三個輸出效果如下：

2、String對象的比較

對于基本變量，可以直接用 “==， <，  >，  <=， >= ”來進行比較，但對于引用類型變量，不可以直接使用上面的表達式來比較，如圖：

代碼：

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);

s1和s2的內容都是一樣的，為啥下面輸出false呢？

原因是s1和s2是引用類型，使用上述表達式進行比較，比較的是兩個對象的地址，兩個對象是不同的，地址自然也是不同的。

那么怎么可以比較引用對象的內容呢？有以下方法：

（1）、equals方法

按照字典序比較，字典序：字符大小。

Object的equals默認是按 “==” 進行比較的，如圖：

所以類都默認繼承Object類，String繼承Object類，重寫了equals方法，如圖：

方法的使用：

代碼：

        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1.equals(s2));

        String s3 = new String("Hello");
        System.out.println(s1.equals(s3));

執(zhí)行效果：

（2）、compareTo方法

按照字典序比較，和equals方法不同的是：equals返回的是boolean類型，而compareTo返回的是int類型，具體比較方式：

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

        2、如果前k個字符相同，返回兩個字符串長度差值。

方法內部：

public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

方法使用：

代碼：

        String s1 = new String("ab");
        String s2 = new String("ac");
        String s3 = new String("ab");
        String s4 = new String("abcdef");
        System.out.println(s1.compareTo(s2)); // 不同輸出字符差值-1
        System.out.println(s1.compareTo(s3)); // 相同輸出 0
        System.out.println(s1.compareTo(s4)); // 前k個字符完全相同，輸出長度差值 -3

執(zhí)行效果：

（3）、compareToIgnoreCase方法（忽略大小寫進行比較）

與compareTo方法一樣，不過忽略大小寫

方法內部：

public static final Comparator<String> CASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();
    private static class CaseInsensitiveComparator
            implements Comparator<String>, java.io.Serializable {
        // use serialVersionUID from JDK 1.2.2 for interoperability
        private static final long serialVersionUID = 8575799808933029326L;

        public int compare(String s1, String s2) {
            int n1 = s1.length();
            int n2 = s2.length();
            int min = Math.min(n1, n2);
            for (int i = 0; i < min; i++) {
                char c1 = s1.charAt(i);
                char c2 = s2.charAt(i);
                if (c1 != c2) {
                    c1 = Character.toUpperCase(c1);
                    c2 = Character.toUpperCase(c2);
                    if (c1 != c2) {
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
                            // No overflow because of numeric promotion
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }

方法的使用：

代碼：

String s1 = new String("hello");
        String s2 = new String("Hello");
        System.out.println(s1.compareToIgnoreCase(s2));

執(zhí)行效果：

3、字符串查找

方法功能
char charAt(int index)返回index位置上字符，如果index為負數(shù)或者越界，拋出
IndexOutOfBoundsException異常
int indexOf(int ch)返回ch第一次出現(xiàn)的位置，沒有返回-1
int indexOf(int ch, int
fromIndex)		從fromIndex位置開始找ch第一次出現(xiàn)的位置，沒有返回-1
int indexOf(String str)返回str第一次出現(xiàn)的位置，沒有返回-1
int indexOf(String str, int
fromIndex)		從fromIndex位置開始找str第一次出現(xiàn)的位置，沒有返回-1
int lastIndexOf(int ch)從后往前找，返回ch第一次出現(xiàn)的位置，沒有返回-1
int lastIndexOf(int ch, int
fromIndex)		從fromIndex位置開始找，從后往前找ch第一次出現(xiàn)的位置，沒有返
回-1
int lastIndexOf(String str)從后往前找，返回str第一次出現(xiàn)的位置，沒有返回-1
int lastIndexOf(String str, int
fromIndex)		從fromIndex位置開始找，從后往前找str第一次出現(xiàn)的位置，沒有返
回-1

4、轉化

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

數(shù)值轉字符串：

        String s1 = String.valueOf(1234);
        String s2 = String.valueOf(12.34);
        System.out.println(s1);
        System.out.println(s2);

        System.out.println("==============");

        String s3 = String.valueOf(true);
        String s4 = String.valueOf(new Student("Hanmeimei", 18));
        System.out.println(s3);
        System.out.println(s4);

整型轉換為字符串型的內部代碼：

    public static String valueOf(int i) {
        return Integer.toString(i);
    }

double類型轉換為字符串型代碼：

    public static String valueOf(double d) {
        return Double.toString(d);
    }

boolean轉換為字符串的內部代碼：

    public static String valueOf(boolean b) {
        return b ? "true" : "false";
    }

引用類型轉換為字符串型的內部代碼：

    public static String valueOf(Object obj) {
        return (obj == null) ? "null" : obj.toString();
    }

字符串轉換為整型 / double類型：

代碼：

int data1 = Integer.parseInt("1234");
Double data2 = Double.parseDouble("12.34");

如圖，執(zhí)行效果：

（2）大小寫轉換

代碼:

        String s1 = "hello";
        String s2 = "HELLO";
        //小寫轉大寫
        System.out.println(s1.toUpperCase());
        //大寫轉小寫
        System.out.println(s2.toLowerCase());

執(zhí)行效果：

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

代碼：

//字符串轉數(shù)組
char[] ch = s1.toCharArray();
//數(shù)組轉字符串
String s2 = new String(ch);

執(zhí)行效果

（4）格式化

代碼：

String s = String.format("%d-%d-%d", 2023, 11, 21);

執(zhí)行效果：

5、字符串替換

使用一個新的字符串替換舊的字符串，方法如下：

方法功能
String replaceAll(String regex, String replacement)替換所有的指定內容
String replaceFirst(String regex, String replacement)替換首個內容

代碼：

String str = "hello world";
System.out.println(str.replaceAll("l", "-"));
System.out.println(str.replaceFirst("l", "-"));

執(zhí)行效果：

6、字符串拆分

可以將一個完整的字符串按照指定的分隔符劃分成若干個字符子串

方法功能
String[] split(String regex)將字符串全部拆分
String[] split(String regex, int limit)將字符串以指定的格式，拆分為limit組

代碼：

        String s1 = "hello world hello bit";
        String[] result = s1.split(" ");
        for(String x : result) {
            System.out.println(x);
        }

執(zhí)行效果：

字符串的部分拆分代碼： 

        String s1 = "hello world hello bit";
        String[] result = s1.split(" ", 2);
        for(String x : result) {
            System.out.println(x);
        }

拆分IP地址： 

        String s1 = "192.168.1.1";
        String[] result = s1.split("\\.");
        for(String x : result) {
            System.out.println(x);
        }

執(zhí)行效果：

注意：要寫劃分ip地址，在字符串里寫進轉義字符，在字符串里，兩個 “ \\ ” 代表一個 “ \ ” 

1. 字符"|","*","+"都得加上轉義字符，前面加上 "\\" .

2. 而如果是 "\" ，那么就得寫成 "\\\\" .

3. 如果一個字符串中有多個分隔符，可以用"|"作為連字符.

如下：

        String s1 = "192.16-8.1.1";
        String[] result = s1.split("\\.|-");
        for(String x : result) {
            System.out.println(x);
        }

代碼示例: 多次拆分

String str = "name=zhangsan&age=18" ;
String[] result = str.split("&") ;
for (int i = 0; i < result.length; i++) {
String[] temp = result[i].split("=") ;
System.out.println(temp[0]+" = "+temp[1]);
}

7、字符串截取

從一個完整的字符串截取出部分內容，方法如下：

方法功能
String substring(int beginIndex)從指定索引截取到結尾
String substring(int beginIndex, int endIndex)截取部分內容

代碼：

        String s = "helloworld";
        System.out.println(s.substring(5));
        System.out.println(s.substring(0, 5));

執(zhí)行效果：

注意：區(qū)間是是前閉后開的規(guī)則，上面的第二個substring語句，是 [0,5）。所以不包含5下標。

8、其他操作方法

方法功能
String trim()去掉字符串中的左右空格,保留中間空格
String toUpperCase()字符串轉大寫
String toLowerCase()字符串轉小寫

trim 會去掉字符串開頭和結尾的空白字符(空格, 換行, 制表符等).

后面兩個函數(shù)只轉換字母

二、String的不可變性

String是一種不可變對象. 字符串中的內容是不可改變。字符串不可被修改，是因為：

1. String類在設計時就是不可改變的，String類實現(xiàn)描述中已經說明了

String類中的字符實際保存在內部維護的value字符數(shù)組中，該圖還可以看出：

1. String類被final修飾，表明該類不能被繼承。

2. value被修飾被final修飾，表明value自身的值不能改變，即不能引用其它字符數(shù)組，但是其引用空間中的內容可以修改。

2. 所有涉及到可能修改字符串內容的操作都是創(chuàng)建一個新對象，改變的是新對象比如 replace 方法：

原因不是final，

final修飾類表明該類不想被繼承，final修飾引用類型表明該引用變量不能引用其他對象，但是其引用對象中的內容是可以修改的代碼驗證如下：

final int array[] = {1,2,3,4,5};
array[0] = 100;
System.out.println(Arrays.toString(array));
//array = new int[]{4,5,6}; //java: 無法為最終變量array分配值

執(zhí)行效果：

注意：盡量避免直接對String類型對象進行修改，因為String類是不能修改的，所有的修改都會創(chuàng)建新對象，效率非常低下，盡量避免對String的直接修改，如果要修改建議盡量使用StringBuffer或者StringBuilder。

三、StringBuffer和StingBuilder

1、方法：

方法說明
StringBuff append(String
str)		在尾部追加，相當于String的+=，可以追加：boolean、char、char[]、
double、float、int、long、Object、String、StringBuff的變量
char charAt(int index)獲取index位置的字符
int length()獲取字符串的長度
int capacity()獲取底層保存字符串空間總的大小
void ensureCapacity(int
mininmumCapacity)		擴容
void setCharAt(int index,
char ch)		將index位置的字符設置為ch
int indexOf(String str)返回str第一次出現(xiàn)的位置
int indexOf(String str, int
fromIndex)		從fromIndex位置開始查找str第一次出現(xiàn)的位置
int lastIndexOf(String str)返回最后一次出現(xiàn)str的位置
int lastIndexOf(String str,
int fromIndex)		從fromIndex位置開始找str最后一次出現(xiàn)的位置
StringBuff insert(int
offset, String str)		在offset位置插入：八種基類類型 & String類型 & Object類型數(shù)據(jù)
StringBuffer
deleteCharAt(int index)		刪除index位置字符
StringBuffer delete(int
start, int end)		刪除[start, end)區(qū)間內的字符
StringBuffer replace(int
start, int end, String str)		將[start, end)位置的字符替換為str
String substring(int start)從start開始一直到末尾的字符以String的方式返回
String substring(int
start，int end)		將[start, end)范圍內的字符以String的方式返回
StringBuffer reverse()反轉字符串
String toString()將所有字符按照String的方式返回

String和StringBuilder最大的區(qū)別在于String的內容無法修改，而StringBuilder的內容可以修改。

和StringBuffer的區(qū)別也是。頻繁修改字符串的情況考慮使用StringBuilder / StringBuffer。

2、String、StringBuffer、StringBuilder的區(qū)別

（1）String的內容不可修改，StringBuffer和StringBuilder的內容可修改。

（2）StringBuffer和StringBuilder的大部分功能一樣。

（3）StringBuffer采用同步處理，屬于線程安全操作，StringBuilder未采用同步處理，不屬于線程安全操作。

總結

到此這篇關于Java中字符串String常用方法的文章就介紹到這了,更多相關Java字符串String內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

相關文章

最新評論