全部教學 » Java字串操作範例程式

Java字串操作範例程式

2019-10-16 22:23:50

在本小節中，提供了一些java中的字串程式，以幫助您提高編碼技巧。請嘗試自己解決這些問題再看答案，以便更好地學習。

在這些範例中也嘗試使用java中引入的所有最新功能，例如Stream，lambda表示式，功能介面等。

1. 如何在String中獲取不同的字元及其計數？

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class DistinctCharsCount {

    public static void main(String[] args) {

        printDistinctCharsWithCount("abc");
        printDistinctCharsWithCount("abcab3");
        printDistinctCharsWithCount("hi there, i am maxsu");
    }

    private static void printDistinctCharsWithCount(String input) {
        Map<Character, Integer> charsWithCountMap = new HashMap<>();

        // 使用Java 8中的Map合併方法
        for (char c : input.toCharArray())
            charsWithCountMap.merge(c, 1, Integer::sum);
        System.out.println(charsWithCountMap);

        // 另一種方法是使用最新的Java增強功能而不是for迴圈，但有點複雜
        List<Character> list = input.chars().mapToObj(c -> (char) c).collect(Collectors.toList());

        list.stream().forEach(c -> charsWithCountMap.merge(c, 1, Integer::sum));

        System.out.println(charsWithCountMap);

    }

}

2. 編寫一個java程式來反轉String

有很多方法可以反轉String，一些常見的是：

  • 使用StringBuilder/StringBuffer類的reverse()方法；
  • 使用char/byte陣列並反向遍歷並填充結果字串；

但是，如果不確定輸入String內容，應該使用StringBuilder內建的reverse()方法。因為使用char和byte陣列可能會產生不需要的結果。

public class ReverseAString {

    public static void main(String[] args) {

        reverseInputString("abc");
        reverseInputString("???sd??"); //special chars
    }

    private static void reverseInputString(String input) {
        StringBuilder sb = new StringBuilder(input);
        String result = sb.reverse().toString();
        System.out.println(result);
    }

}

3. 如何檢查字串是否是回文？

回文串是反向串也是相同的串。所以可以反轉輸入字串並檢查兩個字串是否相等。或者可以使用String charAt(int index)方法來檢查回文串。


public class PalindromeString {

    public static void main(String[] args) {

        checkPalindromeString("abc");
        checkPalindromeString("abcba");
        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 + " is palindrome = "+result);

    }

}

4. 如何刪除字串中所有出現的給定字元？

String類中沒有remove函式，但在這種情況下可以使用replaceAll()。這是一個簡單的程式，演示了如何做到這一點。

public class RemoveCharFromString {

    public static void main(String[] args) {

        removeCharFromString("abcbcdjfkd", 'c');
        removeCharFromString("Maxsu", 'a');
        removeCharFromString("?????", '?');

    }

    private static void removeCharFromString(String input, char c) {
        String result = input.replaceAll(String.valueOf(c), "");
        System.out.println(result);
    }

}

5. 如何以程式設計方式證明String是不可變的？

知道String在java中是不可變的，但新開發人員仍然對此感到困惑。試著理解這種混亂的原因。

String s1 = "Java";

s1 = "Python";

在上面的程式碼片段中，s1值已經改變，它是一個String物件。那麼怎麼能說String是不可變的呢？

要理解的最重要的一點是如何在java中建立字串。當使用字串文字建立String時，它不會更改原始String的值。它在字串池中建立一個新的String並更改該變數的參照。所以原始字串值永遠不會改變，這就是字串不可變的原因。


public class StringImmutabilityTest {

    public static void main(String[] args) {

        String s1 = "Java"; 
        String s2 = s1;

        System.out.println(s1 == s2);

        s1 = "Python"; 

        System.out.println(s1 == s2); 
        System.out.println(s2); 

    }
}

6. 編寫一個程式來計算字串中的單詞數量？

這個程式的簡單解決方案似乎是input.split(" ").length，但是如果字串沒有正確格式化並且它包含前導和尾隨空格，重複多個空格和製表符，這將不起作用。

幸運的是，String split()函式將正規表示式作為引數，可以使用它來計算字串中的單詞數。

public class CountNumberOfWordsInString {

    public static void main(String[] args) {

        countNumberOfWords("My name is Maxsu");
        countNumberOfWords("I Love Java Programming");
        countNumberOfWords(" This    is  not   properly formatted        line ");
    }

    private static void countNumberOfWords(String line) {

        String trimmedLine = line.trim();
        int count = trimmedLine.isEmpty() ? 0 : trimmedLine.split("\\s+").length;

        System.out.println(count);
    }

}

7. 編寫一個程式來檢查是否建立了兩個具有相同字元的字串？

首先，必須從輸入字串建立一組字元。然後使用Set equals()方法檢查它們是否包含相同的字元。這是一個簡單的程式，用於檢查是否使用相同的字元建立了兩個字串。

import java.util.Set;
import java.util.stream.Collectors;

public class CheckSameCharsInString {

    public static void main(String[] args) {
        sameCharsStrings("abc", "cba");
        sameCharsStrings("aabbcc", "abc");
        sameCharsStrings("abcd", "abc");
        sameCharsStrings("11", "1122");
        sameCharsStrings("1122", "11");    
    }

    private static void sameCharsStrings(String s1, String s2) {

        Set<Character> set1 = s1.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
        Set<Character> set2 = s2.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
        System.out.println(set1.equals(set2));
    }

}

8. 讀取兩個String使用者輸入並檢查是否第一個包含第二個？

這是一個簡單的程式，可以使用String contains()方法來檢查指定的字串是否是此字串的一部分。但是，需要使用Scanner類來讀取使用者輸入。

import java.util.Scanner;

public class StringContainsSubstring {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter First String:");
        String s1 = scanner.nextLine();

        System.out.println("Enter Second String:");
        String s2 = scanner.nextLine();

        scanner.close();

        boolean result = stringContainsSubstring(s1, s2);
        System.out.println(s1+" contains "+s2+" = "+result);
    }

    private static boolean stringContainsSubstring(String string, String substring) {
        boolean result = false;
        result = string.contains(substring);
        return result;
    }

}

執行上面範例程式碼，得到以下結果 -

Enter First String:
Maxsu
Enter Second String:
su
Maxsu contains su = true

9. 如何在不使用第三個變數的情況下交換兩個字串？

可以使用String substring()方法來完成它。下面是一個簡單的演示程式碼片段：

String s1 = "abc";
String s2 = "def";

s1 = s1.concat(s2);
s2 = s1.substring(0,s1.length()-s2.length());
s1 = s1.substring(s2.length());

如果必須寫一個函式來做這件事怎麼辦？ 由於String是不可變的，因此方法結束後方法中String參照的值的更改將消失。此外，無法從java中的方法返回多個物件。因此，必須建立一個容器來儲存輸入字串，然後在方法中執行上述邏輯。下面的程式碼顯示了如何做到這一點，雖然它可能看起來很複雜，但邏輯與上面相同。


package com.journaldev.java.string;

import java.util.Scanner;

public class SwapTwoStrings {

    public static void main(String[] args) {

        Container container = new Container();
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter First String:");
        container.setFirstString(scanner.nextLine());

        System.out.println("Enter Second String:");
        container.setSecondString(scanner.nextLine());
        scanner.close();
        System.out.println(container);
        container = swapStrings(container);
        System.out.println(container);
    }

    private static Container swapStrings(Container container) {
        container.setFirstString(container.getFirstString().concat(container.getSecondString())); //s1 = s1+s2
        container.setSecondString(container.getFirstString().substring(0, container.getFirstString().length()-container.getSecondString().length())); // s2=s1
        container.setFirstString(container.getFirstString().substring(container.getSecondString().length()));
        return container;
    }

}

class Container{
    private String firstString;
    private String secondString;

    public String getFirstString() {
        return firstString;
    }
    public void setFirstString(String firstString) {
        this.firstString = firstString;
    }
    public String getSecondString() {
        return secondString;
    }
    public void setSecondString(String secondString) {
        this.secondString = secondString;
    }

    @Override
    public String toString() {
        return "First String = "+firstString+", Second String = "+secondString;
    }
}

執行上面範例程式碼，得到以下結果 - 

Enter First String:
Java
Enter Second String:
Python
First String = Java, Second String = Python
First String = Python, Second String = Java

10. 編寫一個程式，從輸入字串中找出第一個非重複字元？

參考範例程式碼


package com.journaldev.java.string;

import java.util.ArrayList;
import java.util.List;

public class FindNonRepeatingChar {

    public static void main(String[] args) {

        System.out.println(printFirstNonRepeatingChar("abcaabcdedxy"));
        System.out.println(printFirstNonRepeatingChar("abca"));
        System.out.println(printFirstNonRepeatingChar("aaa"));

    }

    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]) { // match found
                    discardedChars.add(c);
                    break;
                } else if (j == chars.length - 1) { // no match found till end
                    return c;
                }
            }
        }
        return null;
    }

}