Remove specific consecutive element in array

Question

I'm trying to reduce consecutive elements of array to one, but not for all values like:

{3,0,0,0,3,3,3,0,0,0} => {3,0,3,0}

but for specific one, in my example 0:

{3,0,0,0,3,3,3,0,0,0} => {3,0,3,3,3,0}

so only zeros (the threes are intact) are reduced.

I have Java String working code I wrote:

public static String removeConsecutive(String str, char remove) {
    char[] chars = str.toCharArray();

    int current = 0;
    int result  = current;
    while (current < chars.length) {
        if (chars[current] == remove) {
            // keep the first occurrence
            chars[result++] = chars[current++];

            // ignore the others
            while (current < chars.length && chars[current] == remove) {
                ++current;
            }
        } else {            
            chars[result++] = chars[current++];
        }
    }

    return new String(chars, 0, result);
}

and it does the trick:

public static void main(String[] args) {
    System.out.println(removeConsecutive("000300300030303330000", '0'));
}

outputs: 0303030303330

Can anyone suggest any improvements, since it think the code is not perfect. It's doesn't have to be String in use, but with any other array.

Answer 1

Here's the same answer that I gave on you Stack Overflow:

Think this is clearer, and does the job:

public static String removeConsecutive(String str, char remove) {
    StringBuilder sb = new StringBuilder();
    for(char c : str.toCharArray()) {
        int length = sb.length();
        if(c != remove || length == 0 || sb.charAt(length - 1) != c) {
            sb.append(c);
        }
    }
    return sb.toString();
}

Answer 2

You can have the same output with regex , using Arrays.toString(char[]):

System.out.println("000300300030303330000".replaceAll("[0]+", "0"));

or, with a parameter :

char charToRemove = '0' ;
System.out.println("000300300030303330000".replaceAll("[" + charToRemove + "]{1,}", charToRemove + ""));

or change charToRemove + "" in Character.toString(charToRemove) more academic.

Answer 3

Another apporach to the removeConsecutive method, using a StringBuilder and String.charAt():

public static String removeConsecutive(String str, char remove) {
    final StringBuilder sb = new StringBuilder(str.length());
    int i = 0;

    while(i < str.length()) {
        if(i == 0 || str.charAt(i) != remove || str.charAt(i) != str.charAt(i-1)) 
            sb.append(str.charAt(i));
        i++;
    }

    return sb.toString();
}

Answer 4

This is another solution:

public static String removeConsecutive(String str, char remove)
{
    final StringBuilder sb = new StringBuilder(str.length());
    boolean seen = false;

    for (final char c: str.toCharArray()) {
        if (c == remove) {
            if (!seen) {
                sb.append(c);
                seen = true;
            }
            continue;
        }
        seen = false;
        sb.append(c);
    }

    return sb.toString();
}

Answer 5

This may be not the most efficient solution but works fine

public static String removeConsecutive(String str, char remove) {
    String result = str;
    String removeAsString = String.valueOf(remove);
    String searchText =  removeAsString + removeAsString;

    while(result.indexOf(searchText) > -1) {
        result = result.replace(searchtext, removeAsString);
    }

    return result;
}

Answer 6

This one came from my friend, sticking to the original char array idea:

private static String removeConsecutive(final String str, final char remove) {
    final char[] chars = str.toCharArray();

    char current;
    char previous = 0;

    int i = 0, result = 0;
    while (i < chars.length) {
        current = chars[i];

        if (current != previous || current != remove) {
            chars[result++] = current;
        }

        previous = current;
        ++i;
    }

    return new String(chars, 0, result);
}