Java: How to replace consecutive characters with a single character?

How can I replace consecutive characters with a single character in java?

String fileContent = "def  mnop.UVW";
String oldDelimiters = " .";
String newDelimiter = "!";
for (int i = 0; i < oldDelimiters.length(); i++){
    Character character = oldDelimiters.charAt(i);
    fileContent = fileContent.replace(String.valueOf(character), newDelimiter);
}

Current output: def!!mnop!UVW

Desired output: def!mnop!UVW

Notice the two spaces are replaced with two exclamation marks. How can I replace consecutive delimiters with one delimiter?

Since you want to match consecutive characters from the old delimiter, a regex solution doesn't seem to be feasible here. You can instead match char by char if it belongs to one of the old delimiter chars and then set it with the new one as shown below.

import java.util.*;
public class Main{
	public static void main(String[] args) {
	    String fileContent = "def  mnop.UVW";
        String oldDelimiters = " .";
        
        // add all old delimiters in a set for fast checks
        Set<Character> set = new HashSet<>();
        for(int i=0;i<oldDelimiters.length();++i) set.add(oldDelimiters.charAt(i));
        
        /* 
           match all consecutive chars at once, check if it belongs to an old delimiter 
           and replace it with the new one
        */
        
        String newDelimiter = "!";
        StringBuilder res = new StringBuilder("");
        for(int i=0;i<fileContent.length();++i){
            if(set.contains(fileContent.charAt(i))){
                while(i + 1 < fileContent.length() && fileContent.charAt(i) == fileContent.charAt(i+1)) i++;
                res.append(newDelimiter);
            }else{
                res.append(fileContent.charAt(i));        
            }
        }
        
        System.out.println(res.toString());
	}
}

Demo: https://onlinegdb.com/r1BC6qKP8

The biggest difficulty to using a regex for this, is to create an expression from your oldDelimiters string. For example:

String oldDelimiters = " .";
String expression = "\\" + String.join("+|\\", oldDelimiters.split("")) + "+";
String text = "def  mnop.UVW;abc .df";
String result = text.replaceAll(expression, "!");

(Edit: since characters in the expression are now escaped anyway, I removed the character classes and edited the following text to reflect that change.)

Where the generated expression looks like \ +|\.+, i.e. each character is quantified and constitutes one alternative of the expression. The engine will match and replace one alternative at a time if it can be matched. result now contains:

def!mnop!UVW;abc!!df

Not sure how backwards compatible this is due to split() behaviour in previous versions of Java (producing a leading space in splitting on the empty string), but with current versions this should be fine.

Edit: As it is, this breaks if the delimiting characters contain digits or characters representing unescaped regex tokens (i.e. 1, b, etc.).

s = s.replaceAll("([ \\.])[ \\.]+", "$1");

Or if only several same delimiters have to be replaced:

s = s.replaceAll("([ \\.])\+", "$1");

• [....] is a group of alternative characters
• First (...) is group 1, $1
• \\1 is the text of the first group

While not using regex, I thought a solution with StreamS was needed, because everyone loves streams:

private static class StatefulFilter implements Predicate<String> {
	private final String needle;
	private String last = null;
	
	public StatefulFilter(String needle) {
		this.needle = needle;
	}
	
	@Override
	public boolean test(String value) {
		boolean duplicate = last != null && last.equals(value) && value.equals(needle);
		last = value;
		return !duplicate;
	}
}

public static void main(String[] args) {
	System.out.println(
		"def  mnop.UVW"
		.codePoints()
		.sequential()
		.mapToObj(c -> String.valueOf((char) c))
		.filter(new StatefulFilter(" "))
		.map(x -> x.equals(" ") ? "!" : x)
		.collect(Collectors.joining(""))
	);
}

Runnable example: https://onlinegdb.com/BkY0R2twU

Explanation:

Theoretically, you aren't really supposed to have a stateful filter, but technically, as long as the stream is not parallelized, it works fine:

.codePoints() - splits the String into a Stream

.sequential() - since we care about the order of characters, our Stream may not be processed in parallel

.mapToObj(c -> String.valueOf((char) c)) - the comparison in the filter is more intuitive if we convert to String, but it's not really needed

.filter(new StatefulFilter(" ")) - here we filter out any space that comes after another space

.map(x -> x.equals(" ") ? "!" : x) - now we can replace the remaining spaces with exclamation marks

.collect(Collectors.joining("")) - and finally we can join the characters together to reconstitute a String

The StatefulFilter itself is pretty straight forward - it checks whether a) we have a previous character at all, b) whether the previous character is the same as the current character and c) whether the current character is the delimiter (space). It returns false (meaning the character gets deleted) only if all a, b and c are true.