here is code to remove a single char. Just extend it with a BitSet to
track which chars to strip to handle multiples.

public class Stripper
  {
  /**
  * Strips out the given char from a String.
  * This should be quicker than other ways of getting the same
effect.
  * See also String.replace and String.replaceAll.
  * @param charToStrip the char e.g. ' ', '/', that you no longer
want in your String .
  * @param s the String, may be empty but not null.
  * @return new String with all instances of charToStrip removed, or
the original
  * String if there were no instances of charToStrip.
  */
  public static String stripper( char charToStrip, String s )
     {
     int place = s.indexOf( charToStrip );
     if ( place < 0 )
        {
        // were no instances, so we can return the original String.
        return s;
        }

     int length = s.length();

     // we know result will be at least one shorter.
     StringBuilder sb = new StringBuilder( length-1 );

     // append first part of s, before first instance of unwanted
char
     sb.append( s.substring( 0, place ) );

     // copy over tail end of string, ignoring unwanted chars.
     for ( int i=place+1; i<length; i++ )
        {
        char c = s.charAt( i );

        if ( c != charToStrip )
           {
           sb.append( c );
           }
        } // end for

     return sb.toString();
     }

  /**
   * test harness
   *
   * @param args not used
   */
  public static void main ( String[] args )
     {
     System.out.println ( stripper( ' ', "hello world" ) ); //
helloworld
     System.out.println ( stripper( ' ', "h e l l o    w o r l d " )
); // helloworld
     System.out.println ( stripper( 'q', "fine as is" ) ); // fine as
is
     }
  } // end class

Sure, if you are willing to spend the space.

Build a boolean array which is indexed by character values.  Set the values in
that array to true for the characters you want to remove. Create a
StringByulder (or StringBuffer) of the same size as the input String.  Iterate
over the chars in the input string, for each one check the value of the array
at the corresponding index, if that is false then append the char to the
StringBuilder.  At the end convert the StringBuilder into a String.

Possible refinements include:

After the run put the relevant slots in the array back to false, that way you
can save it and re-use it later. (Saves initialising 2**16 value).

Use an int[] array instead of a boolean[] array, and do bit-twiddling to index
bit-positions rather than boolean array slots.  (Saves lots of space).

If the characters you are interested in come from a restricted range, then you
can reduce the size of the array accordingly.  (Saves space)

You could use a HashMap(<Character>, <Boolean>) instead of the array.  (Saves
space, but in a different way. May, or may not, save time.)

   -- chris

I'd use something simple like

public final class ReplaceChar {
    public static final void main(String[] arg) {
        String strInp = "DSDFSDFSFSFDAAAAABBBBBBBBRRRRRRARR";
        char[] array = {'A','B','D'};
        String regex = "["+new String(array)+"]";
        System.out.println(strInp.replaceAll(regex,""));
    }
}