How to use

replace

method

in

android.text.SpannableStringBuilder

@Override void expand(SpannableStringBuilder target, Map<String, CharSequence> data) {
 value = data.get(key);
 int replaceFrom = getFormattedStart();
 // Add 2 to account for the opening and closing brackets.
 int replaceTo = replaceFrom + key.length() + 2;
 target.replace(replaceFrom, replaceTo, value);
}

@Override void expand(SpannableStringBuilder target, Map<String, CharSequence> data) {
 int start = getFormattedStart();
 target.replace(start, start + 2, "{");
}

 //getting cursor position 
int end = t1.getSelectionEnd();
//getting the selected Text
SpannableStringBuilder selectedStr=new SpannableStringBuilder(t1.getText());
//replacing the selected text with empty String and setting it to EditText
selectedStr.replace(end-1, end, "");
edittext1.setText(selectedStr);

public void replaceAt(int index, String replacement){
  mSpannableString.replace(index,index + replacement.length(),replacement);
}

 public static Spanned csToUpperCase(CharSequence s) {
  SpannableStringBuilder sb = new SpannableStringBuilder(s);
  sb.replace(0, s.length(), s.toString().toUpperCase(Locale.US));
  return sb;
}

 editText = (EditText)mRoot.findViewById(R.id.content);
ImageSpan imageSpan = new ImageSpan(preview);

SpannableStringBuilder builder = new SpannableStringBuilder();
builder.append(editText.getText());

// this is a string that will let you find a place, where the ImageSpan is.
String imgId = "[img=1]"; 

int selStart = editText.getSelectionStart();

// current selection is replaceв with imageId
builder.replace(editText.getSelectionStart(), editText.getSelectionEnd(), imgId);

// This adds a span to display image where the imageId is. If you do builder.toString() - the string will contain imageId where the imageSpan is.
// you can use it later - if you want to find location of imageSpan in text;
builder.setSpan(imageSpan, selStart, selStart + imgId.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
editText.setText(builder);

 EditText resultEditText = (EditText)  getActivity().findViewById(R.id.result);

int curPostion;

curPostion = resultEditText.getSelectionEnd();

//getting the selected Text
SpannableStringBuilder selectedStr = new SpannableStringBuilder(resultEditText.getText());

//replacing the selected text with empty String
selectedStr.replace(curPostion - 1, curPostion, "");

//Store postition
int afterDelPosition = curPostion - 1;

@Override void expand(SpannableStringBuilder target, Map<String, CharSequence> data) {
 value = data.get(key);
 int replaceFrom = getFormattedStart();
 // Add 2 to account for the opening and closing brackets.
 int replaceTo = replaceFrom + key.length() + 2;
 target.replace(replaceFrom, replaceTo, value);
}

@NonNull
@Override
public SpannableStringBuilder replace(int start, int end, CharSequence tb, int tbstart, int tbend) {
  // On certain software keyboards, the editor appears to append a word minus the last character when it is really
  // trying to just delete the last character. Until we can figure out the root cause of this issue, the following
  // code remaps this situation to do a proper delete.
  if (start == end && start - tbend - 1 >= 0 && tb.length() > 1) {
    String insertString = tb.subSequence(tbstart, tbend).toString();
    String previousString = subSequence(start - tbend - 1, start - 1).toString();
    if (insertString.equals(previousString)) {
      // Delete a character
      return super.replace(start - 1, start, "", 0, 0);
    }
  }
  return super.replace(start, end, tb, tbstart, tbend);
}

@Override void expand(SpannableStringBuilder target, Map<String, CharSequence> data) {
 int start = getFormattedStart();
 target.replace(start, start + 2, "{");
}

protected static boolean replace(SpannableStringBuilder ssb, String key, String replace) {
  boolean isHandledBackSlash = false;
  int index;
  while (true) {
    String text = ssb.toString();
    index = text.indexOf(key);
    if (index == -1) {
      break;
    }
    isHandledBackSlash = true;
    ssb.replace(index, index + key.length(), replace);
  }
  return isHandledBackSlash;
}

/**
 * replace line change, DOS to Unix and Mac to Unix
 *
 * @param ssb         the original text content
 * @param target      the target to match
 * @param replacement the replacement text
 */
public static void standardizeLineEndings(SpannableStringBuilder ssb, String target, String replacement) {
  String string = ssb.toString();
  while (string.indexOf(target) != -1) {
    int start = string.indexOf(target);
    ssb.replace(start, start + target.length(), replacement);
    string = ssb.toString();
  }
}

@Override
SpannableStringBuilder format(@NonNull SpannableStringBuilder ssb, int lineNumber) {
  ssb.replace(0, ssb.length(), " ");
  ssb.setSpan(new MDHorizontalRulesSpan(mColor, mHeight), 0, ssb.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
  return ssb;
}

@Override
public SpannableStringBuilder replace(int start, int end, CharSequence tb) {
 blockWatchers();
 super.replace(start, end, tb);
 unblockwatchers();
 return this;
}

@Override
public SpannableStringBuilder replace(int start, int end, CharSequence tb, int tbstart,
  int tbend) {
 blockWatchers();
 super.replace(start, end, tb, tbstart, tbend);
 unblockwatchers();
 return this;
}

 public static Spanned removeImageSpanObjects(String inStr) {
  SpannableStringBuilder spannedStr = (SpannableStringBuilder) Html
      .fromHtml(inStr.trim());
  Object[] spannedObjects = spannedStr.getSpans(0, spannedStr.length(),
      Object.class);
  for (int i = 0; i < spannedObjects.length; i++) {
    if (spannedObjects[i] instanceof ImageSpan) {
      ImageSpan imageSpan = (ImageSpan) spannedObjects[i];
      spannedStr.replace(spannedStr.getSpanStart(imageSpan),
          spannedStr.getSpanEnd(imageSpan), "");
    }
  }
  return spannedStr;
}

private SpannableStringBuilder removeImageChar(SpannableStringBuilder text) {
  SpannableStringBuilder buf = new SpannableStringBuilder(text);
  DynamicDrawableSpan[] styles =
      buf.getSpans(0, buf.length(), DynamicDrawableSpan.class);
  for (DynamicDrawableSpan style : styles) {
    if (style instanceof HorizontalLineSpan
        || style instanceof RescalableImageSpan) {
      int start = buf.getSpanStart(style);
      int end = buf.getSpanEnd(style);
      buf.replace(start, end, "");
    }
  }
  return buf;
}

@Override
public SpannableStringBuilder replace(final int start, final int end, final CharSequence text,
  final int textStart, final int textEnd) {
 phoneFormatter.format(this, start, end, text, textStart, textEnd);
 final CharSequence phoneNumber = phoneFormatter.getFormattedPhone();
 final SpannableStringBuilder result = super.replace(0, length(), phoneNumber, 0, phoneNumber.length());
 final int selection = phoneFormatter.getSelection();
 if (selection != -1 && selection <= result.length()) {
  Selection.setSelection(result, selection);
 }
 return result;
}

private static String getTextWithPasswords(CharSequence seq) {
  SpannableStringBuilder lstr = new SpannableStringBuilder(seq);
  for (PasswordSpan span : lstr.getSpans(0, lstr.length(), PasswordSpan.class)) {
    lstr.replace(lstr.getSpanStart(span), lstr.getSpanEnd(span), span.mPassword);
    lstr.removeSpan(span);
  }
  return lstr.toString();
}

public void format(final Editable to, final int toStart, final int toEnd, final CharSequence from,
  final int fromStart, final int fromEnd) {
 final int selectionStart = Selection.getSelectionStart(to);
 final int selectionEnd = Selection.getSelectionStart(to);
 buffer.clear();
 buffer.append(to);
 if (selectionStart != -1 && selectionEnd != -1) {
  Selection.setSelection(buffer, selectionStart, selectionEnd);
 }
 buffer.replace(toStart, toEnd, from, fromStart, fromEnd);
 if (!TextUtils.isGraphic(buffer)) {
  return;
 }
 formatPhoneNumberInput(buffer);
}