Java中字符串String常用方法詳解
一、常用方法
1、字符串構(gòu)造
三種構(gòu)造方法
（1）、直接賦值
String s1 = "hello world"; System.out.println(s1);
（2）、創(chuàng)建出新的對象
String s2 = new String("hello");
System.out.println(s2);（3）、使用字符數(shù)組進行構(gòu)造
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的內(nèi)容都是一樣的，為啥下面輸出false呢？
原因是s1和s2是引用類型，使用上述表達式進行比較，比較的是兩個對象的地址，兩個對象是不同的，地址自然也是不同的。
那么怎么可以比較引用對象的內(nèi)容呢？有以下方法：
（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個字符相同，返回兩個字符串長度差值。
方法內(nèi)部：
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方法一樣，不過忽略大小寫
方法內(nèi)部：
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、轉(zhuǎn)化
（1）數(shù)值和字符串轉(zhuǎn)化
數(shù)值轉(zhuǎn)字符串：
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);
整型轉(zhuǎn)換為字符串型的內(nèi)部代碼：
public static String valueOf(int i) {
return Integer.toString(i);
}double類型轉(zhuǎn)換為字符串型代碼：
public static String valueOf(double d) {
return Double.toString(d);
}boolean轉(zhuǎn)換為字符串的內(nèi)部代碼：
public static String valueOf(boolean b) {
return b ? "true" : "false";
}引用類型轉(zhuǎn)換為字符串型的內(nèi)部代碼：
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}字符串轉(zhuǎn)換為整型 / double類型：
代碼：
int data1 = Integer.parseInt("1234");
Double data2 = Double.parseDouble("12.34");如圖，執(zhí)行效果：
（2）大小寫轉(zhuǎn)換
代碼:
String s1 = "hello";
String s2 = "HELLO";
//小寫轉(zhuǎn)大寫
System.out.println(s1.toUpperCase());
//大寫轉(zhuǎn)小寫
System.out.println(s2.toLowerCase());執(zhí)行效果：
（3）字符串轉(zhuǎn)數(shù)組
代碼：
//字符串轉(zhuǎn)數(shù)組 char[] ch = s1.toCharArray(); //數(shù)組轉(zhuǎn)字符串 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) | 替換所有的指定內(nèi)容 |
| String replaceFirst(String regex, String replacement) | 替換首個內(nèi)容 |
代碼：
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地址，在字符串里寫進轉(zhuǎn)義字符，在字符串里，兩個 “ \\ ” 代表一個 “ \ ”
1. 字符"|","*","+"都得加上轉(zhuǎn)義字符，前面加上 "\\" .
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、字符串截取
從一個完整的字符串截取出部分內(nèi)容，方法如下：
| 方法 | 功能 |
| String substring(int beginIndex) | 從指定索引截取到結(jié)尾 |
| String substring(int beginIndex, int endIndex) | 截取部分內(nèi)容 |
代碼：
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() | 字符串轉(zhuǎn)大寫 |
| String toLowerCase() | 字符串轉(zhuǎn)小寫 |
trim 會去掉字符串開頭和結(jié)尾的空白字符(空格, 換行, 制表符等).
后面兩個函數(shù)只轉(zhuǎn)換字母
二、String的不可變性
String是一種不可變對象. 字符串中的內(nèi)容是不可改變。字符串不可被修改，是因為：
1. String類在設(shè)計時就是不可改變的，String類實現(xiàn)描述中已經(jīng)說明了
String類中的字符實際保存在內(nèi)部維護的value字符數(shù)組中，該圖還可以看出：
1. String類被final修飾，表明該類不能被繼承。
2. value被修飾被final修飾，表明value自身的值不能改變，即不能引用其它字符數(shù)組，但是其引用空間中的內(nèi)容可以修改。
2. 所有涉及到可能修改字符串內(nèi)容的操作都是創(chuàng)建一個新對象，改變的是新對象比如 replace 方法：
原因不是final，
final修飾類表明該類不想被繼承，final修飾引用類型表明該引用變量不能引用其他對象，但是其引用對象中的內(nèi)容是可以修改的代碼驗證如下：
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位置的字符設(shè)置為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ū)間內(nèi)的字符 |
| 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)范圍內(nèi)的字符以String的方式返回 |
| StringBuffer reverse() | 反轉(zhuǎn)字符串 |
| String toString() | 將所有字符按照String的方式返回 |
String和StringBuilder最大的區(qū)別在于String的內(nèi)容無法修改，而StringBuilder的內(nèi)容可以修改。
和StringBuffer的區(qū)別也是。頻繁修改字符串的情況考慮使用StringBuilder / StringBuffer。
2、String、StringBuffer、StringBuilder的區(qū)別
（1）String的內(nèi)容不可修改，StringBuffer和StringBuilder的內(nèi)容可修改。
（2）StringBuffer和StringBuilder的大部分功能一樣。
（3）StringBuffer采用同步處理，屬于線程安全操作，StringBuilder未采用同步處理，不屬于線程安全操作。
總結(jié)
到此這篇關(guān)于Java中字符串String常用方法的文章就介紹到這了,更多相關(guān)Java字符串String內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
java使用HttpSession實現(xiàn)QQ訪問記錄
這篇文章主要介紹了java使用HttpSession實現(xiàn)QQ的訪問記錄的相關(guān)資料,需要的朋友可以參考下2016-03-03
這篇文章主要介紹了JAVA面試題 啟動線程是start()還是run()？為什么？,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-07-07
這篇文章主要介紹了java 中 poi解析Excel文件版本問題解決辦法的相關(guān)資料,需要的朋友可以參考下2017-08-08
SpringDataElasticsearch與SpEL表達式實現(xiàn)ES動態(tài)索引
這篇文章主要介紹了SpringDataElasticsearch與SpEL表達式實現(xiàn)ES動態(tài)索引，文章圍繞主題展開詳細的內(nèi)容介紹，具有一定的參考價值，需要的朋友可以參考一下2022-09-09
這篇文章主要為大家詳細介紹了java實現(xiàn)微信支付結(jié)果通知，具有一定的參考價值，感興趣的小伙伴們可以參考一下2019-01-01
Mybatis-Plus實現(xiàn)公共字段自動填充的項目實踐
本文主要介紹了Mybatis-Plus實現(xiàn)公共字段自動填充的項目實踐，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2023-07-07
Spring攔截器之HandlerInterceptor使用方式
這篇文章主要介紹了Spring攔截器之HandlerInterceptor使用方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-08-08
這篇文章主要介紹了Java中PropertyDescriptor的用法及說明，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-07-07
Java的StringBuilder在高性能場景下的正確用法
StringBuilder?對字符串的操作是直接改變字符串對象本身，而不是生成新的對象，所以新能開銷小.與StringBuffer相比StringBuilder的性能略高,StringBuilder則沒有保證線程的安全，從而性能略高于StringBuffer,需要的朋友可以參考下2023-05-05
Java如何使用Agent和ASM在字節(jié)碼層面實現(xiàn)方法攔截
Agent是一種運行在 Java 虛擬機 (JVM) 上的特殊程序，ASM是一個輕量級的 Java 字節(jié)碼編輯和分析框架，本文為大家介紹了如何利用他們在字節(jié)碼層面實現(xiàn)方法攔截，感興趣的可以了解一下2023-05-05