如何从字符串中删除符号并将它们放回去？

Question

Global task is to swap longest word with shortest word in text. I need to remove symbols for example ,.?? from text(to count length of word) and update array of words, do some logic and after put them back.

My solution:

Map<Integer, String> idxToSymbolMap = new HashMap<>();

// remove symbols and save them to map
void deleteSymbols(String[] array) {
        String[] symbols = {POINT, QUESTION_MARK, EXCLAMATION_MARK, COMMA};
        for (int i = 0; i < array.length; i++) {
            for (String s : symbols) {
                if (array[i].contains(s)) {
                    array[i] = array[i].replace(s, EMPTY_STRING);
                    idxToSymbolMap.put(i, s);
                }
            }
        }
    }
// some code here...

// add symbols back
void addBackSymbols(String[] array) {
        for (int i = 0; i < array.length; i++) {
            int idx = i;
            idxToSymbolMap.forEach((k, v) -> {
                if (k == idx) {
                    array[idx] +=  v;
                }
            });
        }
    }

How could I do that better, cleaner? Is possible using replaceAll or something else?

Answer 1

I guess what you have is the right approach, imo.

However, you can make it cleaner:

String[] symbols = {".", "?", "!", ","};
for (int i = 0; i < array.length; i++) {
    for (String s: symbols) {
        if (array[i].contains(s)) {
            array[i] = array[i].replace(s, "");
            idxToSymbolMap.put(i, s);
        }
    }
}

Or using java 8+:

IntStream.range(0, array.length).forEach(i ->
        Arrays.stream(symbols).filter(s -> array[i].contains(s)).forEach(s -> {
            idxToSymbolMap.put(i, s);
            array[i] = array[i].replace(s, "");
        }));

And replace it:

IntStream.range(0, array.length).forEach(
    idx -> idxToSymbolMap.keySet().stream().filter(key -> key == idx)
        .forEach(key -> array[idx] += idxToSymbolMap.get(key)));

Answer 2

Map<String, List<Integer>> will be the best fit for this requirement where the key is the symbol and value is the list of indices where the symbol exists in the text.

For the sake of testing, let's replace each occurrence of [.,??] with # , print the replaced string and get back the original string.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Map<Character, List<Integer>> symbolToIdxMap = new HashMap<>();

        // Test string
        String text = "abc .123,  xyz! hello . hi";

        // Regex pattern
        String strPattern = "[\\.\\,\\!\\?]";
        Pattern pattern = Pattern.compile(strPattern);
        Matcher matcher = pattern.matcher(text);
        int index;

        // Store the symbols and their indices in the map
        while (matcher.find()) {
            // Index at which any of [.,!?] is found
            index = matcher.start();

            // Character at `index`
            Character symbol = text.charAt(index);

            // If the List<Integer> for `symbol` exists, get it return a new
            // ArrayList<Integer> to `idxList`
            List<Integer> idxList = symbolToIdxMap.getOrDefault(symbol, new ArrayList<Integer>());

            // Add `index` to `idxList`
            idxList.add(index);

            // Put `idxList` as the value of `symbol`
            symbolToIdxMap.put(symbol, idxList);
        }

        // Replace the symbols in the text
        String replaced = text.replaceAll(strPattern, "#");
        System.out.println("Replaced: " + replaced);

        // Restore original string
        StringBuilder sb = new StringBuilder(replaced);
        for (Entry<Character, List<Integer>> entry : symbolToIdxMap.entrySet()) {
            // Replace the character at all indices in the list with the corresponding
            // character
            for (Integer idx : entry.getValue()) {
                sb.setCharAt(idx, entry.getKey());
            }
        }

        // Display original string
        System.out.println("Original: " + sb);
    }
}

Output:

Replaced: abc #123#  xyz# hello # hi
Original: abc .123,  xyz! hello . hi