How to use

delete

method

in

android.text.SpannableStringBuilder

public void backspace() {
 int length = captionStringBuilder.length();
 if (length > 0) {
  captionStringBuilder.delete(length - 1, length);
 }
}

 new InputFilter() {
  @Override
  public CharSequence filter(CharSequence source, int start, int end,
      Spanned dest, int dstart, int dend) {

    if (source instanceof SpannableStringBuilder) {
      SpannableStringBuilder sourceAsSpannableBuilder = (SpannableStringBuilder)source;
      for (int i = end - 1; i >= start; i--) { 
        char currentChar = source.charAt(i);
         if (!Character.isLetterOrDigit(currentChar) && !Character.isSpaceChar(currentChar)) {    
           sourceAsSpannableBuilder.delete(i, i+1);
         }     
      }
      return source;
    } else {
      StringBuilder filteredStringBuilder = new StringBuilder();
      for (int i = start; i < end; i++) { 
        char currentChar = source.charAt(i);
        if (Character.isLetterOrDigit(currentChar) || Character.isSpaceChar(currentChar)) {    
          filteredStringBuilder.append(currentChar);
        }     
      }
      return filteredStringBuilder.toString();
    }
  }
}

  builder.delete(i, i + spacesToDelete);
  builderLength -= spacesToDelete;
builder.delete(0, 1);
builderLength--;
 builder.delete(i + 1, i + 2);
 builderLength--;
builder.delete(builderLength - 1, builderLength);
builderLength--;
 builder.delete(i, i + 1);
 builderLength--;
builder.delete(builderLength - 1, builderLength);

@SuppressLint("WrongCall")
private void removeUnneededSpaces(int widthMeasureSpec, int heightMeasureSpec,
                 SpannableStringBuilder builder, FixingResult result) {
  for (Object span : result.spansWithSpacesAfter) {
    int spanEnd = builder.getSpanEnd(span);
    builder.delete(spanEnd, spanEnd + 1);
    try {
      setTextAndMeasure(builder, widthMeasureSpec, heightMeasureSpec);
    } catch (IndexOutOfBoundsException ignored) {
      builder.insert(spanEnd, " ");
    }
  }
  boolean needReset = true;
  for (Object span : result.spansWithSpacesBefore) {
    int spanStart = builder.getSpanStart(span);
    builder.delete(spanStart - 1, spanStart);
    try {
      setTextAndMeasure(builder, widthMeasureSpec, heightMeasureSpec);
      needReset = false;
    } catch (IndexOutOfBoundsException ignored) {
      needReset = true;
      int newSpanStart = spanStart - 1;
      builder.insert(newSpanStart, " ");
    }
  }
  if (needReset) {
    setText(builder);
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  }
}

@Override
public SpannableStringBuilder delete(int start, int end) {
 super.delete(start, end);
 return this;
}

public void delete(int start, int end) {
  try {
    // mSpannableString.replace(start, end, " ", 0, 0);
    mSpannableString = mSpannableString.delete(start, end);
  }catch (Exception e){
  }
}

{               
    SpannableStringBuilder ssb = new SpannableStringBuilder(text);
    for (CharacterStyle c : cs)
      ssb.setSpan(c, start, end, 0);
    // Delete the tokens before and after the span
    ssb.delete(end, end + tokenLen);
    ssb.delete(start - tokenLen, start);
    text = ssb;
  }
  return text;
}

private void formatLinks(SpannableStringBuilder titleSpan) {
  Matcher matcher = urlPattern.matcher(titleSpan);
  while(matcher.find()) {
    titleSpan.delete(matcher.start(), matcher.end());
    titleSpan.insert(matcher.start(), matcher.group(1));
    titleSpan.setSpan(new ForegroundColorSpan(Style.blue),
        matcher.start(), matcher.start() + matcher.group(1).length(), 0);
    matcher = urlPattern.matcher(titleSpan);
  }
}

private static MDBaseListSpan setUnorderSpan(int nested, int start, @NonNull String line, int type, @NonNull SpannableStringBuilder ssb, int color) {
  ssb.delete(start, start + nested * SyntaxKey.KEY_LIST_HEADER.length() + START_POSITION);
  MDUnOrderListSpan span = new MDUnOrderListSpan(10, color, nested, type);
  ssb.setSpan(span,
      start, start + line.length() - (nested * SyntaxKey.KEY_LIST_HEADER.length() + START_POSITION),
      Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
  return span;
}

SpannableStringBuilder sb = new SpannableStringBuilder("this is <b>bold</b> and this is <b>bold too</b>  and this is <b>bold too, again</b>.");
   Pattern p = Pattern.compile("<b>.*?</b>", Pattern.CASE_INSENSITIVE);            
   boolean stop = false;
   while (!stop)
   {
     Matcher m = p.matcher(sb.toString());
     if (m.find()) {
       sb.setSpan(new StyleSpan(android.graphics.Typeface.BOLD), m.start(), m.end(), Spannable.SPAN_INCLUSIVE_INCLUSIVE);
       sb.delete(m.end()-4, m.end());
       sb.delete(m.start(), m.start() + 3);
     }
     else
       stop = true;
   }

@Override
public SpannableStringBuilder delete(final int start, final int end) {
  if (containsDigits(start, end)) {
  return super.delete(start, end);
 }
 final int firstDigitPosition = Math.max(0, indexOfLastDigit(0, start));
 return super.delete(firstDigitPosition, end);
}

public void trim(int count) {
  if(count > 0) {
    int start = length() - count;
    int end = start + count;
    try {
      mSpannableString.delete(start, end);
    }catch (Exception exc){}
  }
}

/**
 * set bullet
 *
 * @param nested the nested number
 * @param start  start position
 * @param line   the content
 * @param ssb    the content
 */
private void setSSB(int nested, int start, @NonNull String line, int type, @NonNull SpannableStringBuilder ssb) {
  ssb.delete(start, start + nested * SyntaxKey.KEY_LIST_HEADER.length() + START_POSITION);
  ssb.setSpan(new MDUnOrderListSpan(10, mColor, nested, type),
      start,
      start + line.length() - (nested * SyntaxKey.KEY_LIST_HEADER.length() + START_POSITION),
      Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}

private static MDBaseListSpan setOrderSpan(int nested, int start, @NonNull String line, @NonNull SpannableStringBuilder ssb, int number, int originalNumber) {
  ssb.delete(start, start + nested * SyntaxKey.KEY_LIST_HEADER.length() + String.valueOf(originalNumber).length());
  ssb.insert(start, String.valueOf(number));
  MDOrderListSpan mdOrderListSpan = new MDOrderListSpan(10, nested, number);
  ssb.setSpan(mdOrderListSpan,
      start, start + line.length() - (nested * SyntaxKey.KEY_LIST_HEADER.length() + String.valueOf(originalNumber).length()),
      Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
  return mdOrderListSpan;
}

SpannableStringBuilder sb = new SpannableStringBuilder("text has <sup>superscript</sup> tag");
   Pattern p = Pattern.compile("<sup>.*?</sup>", Pattern.CASE_INSENSITIVE);            
   boolean stop = false;
   while (!stop)
   {
     Matcher m = p.matcher(sb.toString());
     if (m.find()) {
       sb.setSpan(new SuperscriptSpan(), m.start(), m.end(), Spannable.SPAN_INCLUSIVE_INCLUSIVE);
       sb.delete(m.end()-6, m.end());
       sb.delete(m.start(), m.start() + 5);
     }
     else
       stop = true;
   }

 public static CharSequence colorBackground(CharSequence text) {

  Pattern pattern = Pattern.compile("#(.*?)#");

  SpannableStringBuilder ssb = new SpannableStringBuilder( text );

  if( pattern != null )
  {
    Matcher matcher = pattern.matcher( text );
    int matchesSoFar = 0;
    while( matcher.find() )
    {
      int start = matcher.start() - (matchesSoFar * 2);
      int end = matcher.end() - (matchesSoFar * 2);
      CharacterStyle span = new BackgroundColorSpan(0xFF404040);
      ssb.setSpan( span, start + 1, end - 1, 0 );
      ssb.delete(start, start + 1);
      ssb.delete(end - 2, end -1);
      matchesSoFar++;
    }
  }
  return ssb;
}

/**
 * set key number
 *
 * @param nested         the nested number
 * @param start          start position
 * @param line           the content
 * @param ssb            the content
 * @param number         the key number
 * @param originalNumber the original number
 */
private void setSSB(int nested, int start, @NonNull String line, @NonNull SpannableStringBuilder ssb, int number, int originalNumber) {
  ssb.delete(start, start + nested * SyntaxKey.KEY_LIST_HEADER.length() + String.valueOf(originalNumber).length());
  ssb.insert(start, String.valueOf(number));
  ssb.setSpan(new MDOrderListSpan(10, nested, number),
      start, start + line.length() - (nested * SyntaxKey.KEY_LIST_HEADER.length() + String.valueOf(originalNumber).length()),
      Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
}

@NonNull
@Override
SpannableStringBuilder format(@NonNull SpannableStringBuilder ssb, int lineNumber) {
  ssb.delete(0, 1).delete(ssb.length() - 1, ssb.length());
  ssb.setSpan(new AlignmentSpan.Standard(Layout.Alignment.ALIGN_CENTER), 0, ssb.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
  return ssb;
}

private CharSequence headersToCharSequence(Headers headers) {
  if (headers == null) return null;
  SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder();
  for (int i = 0, size = headers.size(); i < size; i++) {
    Spannable value = new SpannableString(headers.value(i));
    value.setSpan(new ForegroundColorSpan(getResources().getColor(R.color
        .colorTextSecondary)), 0, value.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
    spannableStringBuilder.append(headers.name(i)).append(": ").append(value).append("\n");
  }
  spannableStringBuilder.delete(spannableStringBuilder.length() - 1, spannableStringBuilder
      .length());
  return spannableStringBuilder;
}

/**
 * Parse the given input using {@link TouchableUrlSpan}s rather than vanilla {@link URLSpan}s
 * so that they respond to touch.
 */
public SpannableStringBuilder parseHtml(
    String input,
    ColorStateList linkTextColor) {
  SpannableStringBuilder spanned = fromHtml(input);
  // strip any trailing newlines
  while (spanned.charAt(spanned.length() - 1) == '\n') {
    spanned = spanned.delete(spanned.length() - 1, spanned.length());
  }
  return linkifyPlainLinks(spanned, linkTextColor);
}