總結12個精致的Java字符串操作小技巧

這篇文章主要介紹“總結12個精致的Java字符串操作小技巧”，在日常操作中，相信很多人在總結12個精致的Java字符串操作小技巧問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”總結12個精致的Java字符串操作小技巧”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

01、如何在字符串中獲取不同的字符及其數量?

這道題可以拆解為兩個步驟，第一步，找出不同的字符，第二步，統計出它們的數量。好像有點廢話，是不是?那我先來一個答案吧。

public class DistinctCharsCount {     public static void main(String[] args) {         printDistinctCharsWithCount("itwanger");         printDistinctCharsWithCount("chenmowanger");     }      private static void printDistinctCharsWithCount(String input) {         Map<Character, Integer> charsWithCountMap = new LinkedHashMap<>();          for (char c : input.toCharArray()) {             Integer oldValue = charsWithCountMap.get(c);              int newValue = (oldValue == null) ? 1 :                     Integer.sum(oldValue, 1);              charsWithCountMap.put(c, newValue);         }         System.out.println(charsWithCountMap);     } }

程序輸出的結果是：

{i=1, t=1, w=1, a=1, n=1, g=1, e=1, r=1} {c=1, h=1, e=2, n=2, m=1, o=1, w=1, a=1, g=1, r=1}

說一下我的思路：

1)聲明一個 LinkedHashMap，也可以用 HashMap，不過前者可以保持字符串拆分后的順序，結果看起來更一目了然。

為什么要用 Map 呢?因為 Map 的 key 是不允許重復的，剛好可以對重復的字符進行數量的累加。

2)把字符串拆分成字符，進行遍歷。

3)如果 key 為 null 的話，就表明它的數量要 +1;否則的話，就在之前的值上 +1，然后重新 put 到 Map  中，這樣就覆蓋了之前的字符數量。

思路很清晰，對不對?忍不住給自己鼓個掌。

那，JDK 8 之后，Map 新增了一個很厲害的方法 merge()，一次性為多個鍵賦值：

private static void printDistinctCharsWithCountMerge(String input) {     Map<Character, Integer> charsWithCountMap = new LinkedHashMap<>();      for (char c : input.toCharArray()) {         charsWithCountMap.merge(c, 1, Integer::sum);     }     System.out.println(charsWithCountMap); }

有沒有很厲害?一行代碼就搞定。第一個參數為鍵，第二個參數為值，第三個參數是一個 BiFunction，意思是，如果鍵已經存在了，就重新根據  BiFunction 計算新的值。

如果字符是第一次出現，就賦值為 1;否則，就把之前的值 sum 1。

02、如何反轉字符串?

如果同學們對 StringBuilder 和 StringBuffer 很熟悉的話，這道題就很簡單，直接 reverse() 就完事，對不對?

public class ReverseAString {     public static void main(String[] args) {         reverseInputString("沉默王二");     }     private static void reverseInputString(String input) {         StringBuilder sb = new StringBuilder(input);         String result = sb.reverse().toString();         System.out.println(result);     } }

輸出結果如下所示：

二王默沉

多說一句，StringBuffer 和 StringBuilder 很相似，前者是同步的，所有 public 方法都加了 synchronized  關鍵字，可以在多線程中使用;后者是不同步的，沒有 synchronized 關鍵字，所以性能更佳，沒有并發要求的話，就用 StringBuilder。

03、如何判斷一個字符串是前后對稱的?

什么意思呢?就好像一個字符串，前后一折，是對稱的。就像你站在鏡子前，看到了一個玉樹臨風、閉月羞花的自己。

public class PalindromeString {     public static void main(String[] args) {          checkPalindromeString("沉默王二");         checkPalindromeString("沉默王二 二王默沉");     }      private static void checkPalindromeString(String input) {         boolean result = true;         int length = input.length();         for (int i = 0; i < length / 2; i++) {             if (input.charAt(i) != input.charAt(length - i - 1)) {                 result = false;                 break;             }         }         System.out.println(input + " 對稱嗎？ " + result);      } }

輸出結果如下所示：

沉默王二 對稱嗎？ false 沉默王二 二王默沉 對稱嗎？ true

說一下我的思路：要判斷字符串對折后是否對稱，很簡單，從中間劈開，第一個字符對照最后一個字符，一旦找到不等的那個，就返回 false。

注意三點：

1)for 循環的下標從 0 開始，到 length/2 結束。

2)下標 i 和 length-i-1 是對稱的。

3)一旦 false 就 break。

04、如何刪除所有出現的指定字符?

字符串類沒有提供 remove() 方法，但提供了 replaceAll() 方法，通過將指定的字符替換成空白字符就可以辦得到，對吧?

public class RemoveCharFromString {     public static void main(String[] args) {         removeCharFromString("沉默王二", '二');         removeCharFromString("chenmowanger", 'n');      }      private static void removeCharFromString(String input, char c) {         String result = input.replaceAll(String.valueOf(c), "");         System.out.println(result);     } }

輸出結果如下所示：

沉默王  chemowager

05、如何證明字符串是不可變的?

字符串不可變的這個事我曾寫過兩篇文章，寫到最后我都要吐了。但是仍然會有一些同學弄不明白，隔段時間就有人私信我，我就不得不把之前的文章放到收藏夾，問的時候我就把鏈接發給他。

之所以造成這個混亂，有很多因素，比如說，Java 到底是值傳遞還是引用傳遞?字符串常量池是個什么玩意?

這次又不得不談，雖然煩透了，但仍然要證明啊!

public class StringImmutabilityTest {     public static void main(String[] args) {         String s1 = "沉默王二";         String s2 = s1;         System.out.println(s1 == s2);          s1 = "沉默王三";         System.out.println(s1 == s2);          System.out.println(s2);     } }

輸出結果如下所示：

true false 沉默王二

1)String s1 = "沉默王二"，Java 在字符串常量池中創建“沉默王二”這串字符的對象，并且把地址引用賦值給 s1

2)String s2 = s1，s2 和 s1 指向了同一個地址引用——常量池中的那個“沉默王二”。

所以，此時 s1 == s2 為 true。

3)s1 = "沉默王三"，Java 在字符串常量池中創建“沉默王三”這串字符的對象，并且把地址引用賦值給 s1，但 s2  仍然指向的是“沉默王二”那串字符對象的地址引用。

所以，此時 s1 == s2 為 false，s2 的輸出結果為“沉默王二”就證明了字符串是不可變的。

06、如何統計字符串中的單詞數?

這道題呢?主要針對的是英文字符串的情況。雖然中文字符串中也可以有空白字符，但不存在單詞這一說。

public class CountNumberOfWordsInString {     public static void main(String[] args) {         countNumberOfWords("My name is Wanger");         countNumberOfWords("I Love Java Programming");         countNumberOfWords(" Java    is  very   important ");     }      private static void countNumberOfWords(String line) {         String trimmedLine = line.trim();         int count = trimmedLine.isEmpty() ? 0 : trimmedLine.split("\\s+").length;          System.out.println(count);     } }

輸出結果如下所示：

4 4 4

split() 方法可以對字符串進行拆分，參數不僅可以是空格，也可以使正則表達式代替的空白字符(多個空格、制表符);返回的是一個數組，通過 length  就可以獲得單詞的個數了。

如果對 split() 方法很感興趣的話，可以查看我之前寫的一篇文章，很飽滿，很豐富。

咦，拆分個字符串都這么講究

07、如何檢查兩個字符串中的字符是相同的?

如何理解這道題呢?比如說，字符串“沉默王二”和“沉王二默”就用了同樣的字符，對吧?比如說，字符串“沉默王二”和“沉默王三”用的字符就不同，理解了吧?

public class CheckSameCharsInString {     public static void main(String[] args) {         sameCharsStrings("沉默王二", "沉王二默");         sameCharsStrings("沉默王二", "沉默王三");     }      private static void sameCharsStrings(String s1, String s2) {         Set<Character> set1 = s1.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());         System.out.println(set1);         Set<Character> set2 = s2.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());         System.out.println(set2);         System.out.println(set1.equals(set2));     } }

輸出結果如下所示：

[默, 沉, 王, 二]  [默, 沉, 王, 二]  true  [默, 沉, 王, 二]  [默, 沉, 三, 王]  false

上面的代碼用到了 Stream 流，看起來很陌生，但很好理解，就是把字符串拆成字符，然后收集到 Set 中，Set  是一個不允許有重復元素的集合，所以就把字符串中的不同字符收集起來了。

08、如何判斷一個字符串包含了另外一個字符串?

這道題有點簡單，對吧?上一道還用 Stream 流，這道題就直接送分了?不用懷疑自己，就用字符串類的 contains() 方法。

public class StringContainsSubstring {     public static void main(String[] args) {         String s1 = "沉默王二";         String s2 = "沉默";          System.out.println(s1.contains(s2));     } }

輸出結果如下所示：

true

contains() 方法內部其實調用的是 indexOf() 方法：

public boolean contains(CharSequence s) {     return indexOf(s.toString()) >= 0; }

09、如何在不用第三個變量的情況下交換兩個字符串?

這道題就有點意思了，對吧?尤其是前提條件，不使用第三個變量。

public class SwapTwoStrings {     public static void main(String[] args) {         String s1 = "沉默";         String s2 = "王二";          s1 = s1.concat(s2);         s2 = s1.substring(0,s1.length()-s2.length());         s1 = s1.substring(s2.length());          System.out.println(s1);         System.out.println(s2);     } }

輸出結果如下所示：

王二 沉默

說一下我的思路：

1)通過 concat() 方法把兩個字符串拼接到一塊。

2)然后通過 substring() 方法分別取出第二個字符串和第一個字符串。

10、如何從字符串中找出第一個不重復的字符?

來，上個例子來理解一下這道題。比如說字符串“沉默王沉沉默二”，第一個不重復的字符是“王”，對吧?因為“沉”重復了，“默”重復了。

public class FindNonRepeatingChar {     public static void main(String[] args) {         System.out.println(printFirstNonRepeatingChar("沉默王沉沉默二"));         System.out.println(printFirstNonRepeatingChar("沉默王沉"));         System.out.println(printFirstNonRepeatingChar("沉沉沉"));     }      private static Character printFirstNonRepeatingChar(String string) {         char[] chars = string.toCharArray();          List<Character> discardedChars = new ArrayList<>();          for (int i = 0; i < chars.length; i++) {             char c = chars[i];              if (discardedChars.contains(c))                 continue;              for (int j = i + 1; j < chars.length; j++) {                 if (c == chars[j]) {                     discardedChars.add(c);                     break;                 } else if (j == chars.length - 1) {                     return c;                 }             }         }         return null;     } }

輸出結果如下所示：

王 默 null

說一下我的思路：

1)把字符串拆分成字符數組。

2)聲明一個 List，把重復的字符放進去。

3)外層的 for 循環，從第一個字符開始，如果已經在 List 中，繼續下一輪。

4)嵌套的 for 循環，從第一個字符的下一個字符(j = i + 1)開始遍歷，如果找到和之前字符重復的，就加入到 List  中，跳出內層的循環;如果找到最后(j == chars.length - 1)也沒有找到，就是第一個不重復的字符，對吧?

11、如何檢查字符串中只包含數字?

有一種很傻的解法，就是用 Long.parseLong(string) 對字符串強轉，如果轉不成整形，那肯定不是只包含數字，對吧?

但這種方法也太不可取了，所以還得換一種巧妙的，就是使用正則表達式。

public class CheckIfStringContainsDigitsOnly {     public static void main(String[] args) {         digitsOnlyString("123 沉默王二");         digitsOnlyString("123");      }      private static void digitsOnlyString(String string) {         if (string.matches("\\d+")) {             System.out.println("只包含數字的字符串：" + string);         }     } }

輸出結果如下所示：

只包含數字：123

12、如何實現字符串的深度拷貝?

由于字符串是不可變的，所以可以直接使用“=”操作符將一個字符串拷貝到另外一個字符串，并且互不影響。

public class JavaStringCopy {     public static void main(String args[]) {         String str = "沉默王二";         String strCopy = str;          str = "沉默王三";         System.out.println(strCopy);     } }

輸出結果如下所示：

沉默王二

這個例子和之前證明字符串是不可變的例子幾乎沒什么差別，對吧?這的確是因為字符串是不可變的，如果是可變對象的話，深度拷貝就要注意了，最好使用 new  關鍵字返回新的對象。

public Book getBook() {     Book clone = new Book();     clone.setPrice(this.book.getPrice());     clone.setName(this.book.getName());     return clone; }

到此，關于“總結12個精致的Java字符串操作小技巧”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！