Replace sequence of non-alphabet with one dash using Pattern

What I am trying to achieve:

I have a string that looks like this: ��[1]����important?@~?@~?@~?@~?@~alsoimportant�@~@~@~

Basically, inside the string, there are words (composed of only the alphabet) with gibberish (one or multiple non-alphabet) before and after.

I would like to retain the alphabet with the sequence of non-alphabet replaced by one dash only. If possible, use Java Pattern, because it is quite efficient.

What I tried:

public static void main(String[] args)  {
        final String input = "��[1]����important?@~?@~?@~?@~?@~alsoimportant�@~@~@~";
        final String clean = input.replaceAll("[^a-zA-Z]", "-");
        System.out.println(clean);
        // print ---------important---------------alsoimportant-------
        // would like -important-alsoimportant-
    }

Question:

With my current solution:

• It is not using Pattern
• there are a number of dashes equal to the number of non-alphabet. I just need one.
  What is a good way to achieve this?

You can use the + quantifier in your regular expression to match 1+ consecutive non-alphabet characters:

 final String input = "��[1]����important?@~?@~?@~?@~?@~alsoimportant�@~@~@~";
 final String clean = input.replaceAll("[^a-zA-Z]+", "-"); 
 System.out.println(clean); // prints -important-alsoimportant-

Similar goes for the Pattern (might be helpful if you're doing this replacement multiple times):

final Pattern NON_ALPHABET = Pattern.compile("[^a-zA-Z]+");
final String input = "��[1]����important?@~?@~?@~?@~?@~alsoimportant�@~@~@~";
final String clean = NON_ALPHABET.matcher(input).replaceAll("-");
System.out.println(clean); // prints the same

Here's another way if you focus on the words. I'd like to use Pattern.compile("[a-zA-Z]+") to solve the problem. After getting the expected words, say, "important" and "alsoimportant", it is convenient to use StringBuilder to join them together.

public class Main {
    public static void main(String[] args) {
        String input = "��[1]����important?@~?@~?@~?@~?@~alsoimportant�@~@~@~";
        Pattern pattern = Pattern.compile("[a-zA-Z]+");
        Matcher matcher = pattern.matcher(input);
        StringBuilder builder = new StringBuilder("-");
        while (matcher.find()) {
            builder.append(matcher.group()).append("-");
        }
        System.out.println(builder); // output "-important-alsoimportant-"
    }
}

Note: The pattern above assumes that all of the words consist only of letters from 'a' to 'z' or 'A' to 'Z'. Yet some of the words, like "mp3" would be regarded as the combination of the word "mp" and gibberish '3'. To avoid this, just change the pattern to Pattern.compile("\\w+").

As I have said before, regular expressions, like streams, are a good general tool but not always as efficient as imperative programming. The following was about 37% more efficient that using String.replaceAll

boolean seen = false;
StringBuilder sb = new StringBuilder();
for (char c : input.toCharArray()) {
    if (!Character.isAlphabetic(c)) {
        if (!seen) {
            sb.append("-");
            seen = true;
        }
    } else {
        sb.append(c);
        seen = false;
    }
}
String result = sb.toString();

Although the time differences were significant, the time required was very small. As such it wouldn't really make a big difference in this particular problem and I would have probably opted for String.replaceAll myself.

> "It is not using Pattern"

It is, actually.
The String#replaceAll method is utilizing the Pattern class.

> "there are a number of dashes equal to the number of non-alphabet. I just need one. What is a good way to achieve this?"

The effect you're looking to achieve can be done with the + quantifer.
This will attempt to match 1 or more of the the preceding value, in this case the character class.

final String input = "��[1]����important?@~?@~?@~?@~?@~alsoimportant�@~@~@~";
final String clean = input.replaceAll("[^a-zA-Z]+", "-");
System.out.println(clean);
// print ---------important---------------alsoimportant-------
// would like -important-alsoimportant-

Output

-important-alsoimportant-

If you'd like to implement the Pattern and Matcher classes explicitly, you can use the following.

Pattern pattern = Pattern.compile("[^a-zA-Z]+");
Matcher matcher = pattern.matcher(input);
System.out.println(matcher.replaceAll("-"));

Output

-important-alsoimportant-