How to use

replace

method

in

java.lang.StringBuilder

  private static String join(StringBuilder out, Object[] linesToBreak) {
    for (Object line : linesToBreak) {
      out.append(line.toString()).append("\n");
    }
    int lastBreak = out.lastIndexOf("\n");
    return out.replace(lastBreak, lastBreak+1, "").toString();
  }
}

private static String replaceLast(String text, String pattern, String replacement) {
 StringBuilder builder = new StringBuilder(text);
 int lastIndexOf = builder.lastIndexOf(pattern);
 return builder.replace(lastIndexOf, lastIndexOf + pattern.length(), replacement).toString();
}

 private String replaceLast(String text, String pattern, String replacement) {
  StringBuilder builder = new StringBuilder(text);
  int lastIndexOf = builder.lastIndexOf(pattern);
  return builder.replace(lastIndexOf, lastIndexOf + pattern.length(), replacement).toString();
 }
},

/** Replace the source code with the new lines of code. */
public void replaceLines(List<String> lines) {
 sourceBuilder.replace(0, sourceBuilder.length(), Joiner.on("\n").join(lines) + "\n");
}

@Override
public String toString() {
 StringBuilder sb =
   new StringBuilder()
     .append("SizeConfigStrategy{groupedMap=")
     .append(groupedMap)
     .append(", sortedSizes=(");
 for (Map.Entry<Bitmap.Config, NavigableMap<Integer, Integer>> entry : sortedSizes.entrySet()) {
  sb.append(entry.getKey()).append('[').append(entry.getValue()).append("], ");
 }
 if (!sortedSizes.isEmpty()) {
  sb.replace(sb.length() - 2, sb.length(), "");
 }
 return sb.append(")}").toString();
}

protected String format(int intValue) {
  String formatted = Integer.toHexString( intValue );
  StringBuilder buf = new StringBuilder( "00000000" );
  buf.replace( 8 - formatted.length(), 8, formatted );
  return buf.toString();
}

  protected String format(short shortValue) {
    String formatted = Integer.toHexString( shortValue );
    StringBuilder buf = new StringBuilder( "0000" );
    buf.replace( 4 - formatted.length(), 4, formatted );
    return buf.toString();
  }
}

public static String format(short value) {
  String formatted = Integer.toHexString( value );
  StringBuilder buf = new StringBuilder( "0000" );
  buf.replace( 4 - formatted.length(), 4, formatted );
  return buf.toString();
}

public static String format(int value) {
  final String formatted = Integer.toHexString( value );
  StringBuilder buf = new StringBuilder( "00000000" );
  buf.replace( 8 - formatted.length(), 8, formatted );
  return buf.toString();
}

@Override
public String toString() {
 StringBuilder b = new StringBuilder();
 b.append(cl.getName()).append('(');
 for (Class<?> cl : classParams) {
  b.append(' ').append(cl.getName()).append(',');
 }
 b.replace(b.length() - 1, b.length(), " ");
 b.append(')');
 return b.toString();
}

private static boolean replace(final StringBuilder input,
                final String from, final String to) {
  int start = input.indexOf(from);
  if (start == -1) {
    return false;
  }
  final int fromLength = from.length();
  final int toLength = to.length();
  while (start != -1) {
    input.replace(start, start + fromLength, to);
    start = input.indexOf(from, start + toLength);
  }
  return true;
}

 public static void replaceAll(StringBuilder builder, String from, String to)
{
  int index = builder.indexOf(from);
  while (index != -1)
  {
    builder.replace(index, index + from.length(), to);
    index += to.length(); // Move to the end of the replacement
    index = builder.indexOf(from, index);
  }
}

 @Override
 public String toString() {
  StringBuilder sb = new StringBuilder();
  sb.append("( ");
  for (Entry<K, V> entry : entrySet()) {
   sb.append('{').append(entry.getKey()).append(':').append(entry.getValue()).append("}, ");
  }
  if (!isEmpty()) {
   sb.replace(sb.length() - 2, sb.length(), "");
  }
  return sb.append(" )").toString();
 }
}

public static String toBinaryString(byte value) {
  String formatted = Integer.toBinaryString( value );
  if ( formatted.length() > 8 ) {
    formatted = formatted.substring( formatted.length() - 8 );
  }
  StringBuilder buf = new StringBuilder( "00000000" );
  buf.replace( 8 - formatted.length(), 8, formatted );
  return buf.toString();
}

public static String replace( String originalString, String partToMatch, String replacement ) {
  StringBuilder buffer = new StringBuilder( originalString.length() );
  buffer.append( originalString );
  int indexOf = buffer.indexOf( partToMatch );
  while (indexOf != -1) {
    buffer = buffer.replace(indexOf, indexOf + partToMatch.length(), replacement);
    indexOf = buffer.indexOf(partToMatch, indexOf + replacement.length());
  }
  return buffer.toString();
}

static void updateThreadName(Request data) {
 String name = data.getName();
 StringBuilder builder = NAME_BUILDER.get();
 builder.ensureCapacity(Utils.THREAD_PREFIX.length() + name.length());
 builder.replace(Utils.THREAD_PREFIX.length(), builder.length(), name);
 Thread.currentThread().setName(builder.toString());
}

  @AllowSysOut
  public static void main(String[] args) throws UnknownHostException {
    byte[] addressBytes = InetAddress.getLocalHost().getAddress();
    System.out.println( "Raw ip address bytes : " + addressBytes.toString() );

    int addressInt = BytesHelper.toInt( addressBytes );
    System.out.println( "ip address int : " + addressInt );

    String formatted = Integer.toHexString( addressInt );
    StringBuilder buf = new StringBuilder( "00000000" );
    buf.replace( 8 - formatted.length(), 8, formatted );
    String addressHex = buf.toString();
    System.out.println( "ip address hex : " + addressHex );
  }
}

  public static String toBinaryString(long value) {
    String formatted = Long.toBinaryString( value );
    StringBuilder buf = new StringBuilder( StringHelper.repeat( '0', 64 ) );
    buf.replace( 64 - formatted.length(), 64, formatted );
    return buf.toString();
  }
}

public static String toBinaryString(int value) {
  String formatted = Long.toBinaryString( value );
  StringBuilder buf = new StringBuilder( StringHelper.repeat( '0', 32 ) );
  buf.replace( 64 - formatted.length(), 64, formatted );
  return buf.toString();
}

@Override
public String toString() {
 StringBuilder builder = new StringBuilder();
 if (deprecated != null) builder.append(", deprecated=").append(deprecated);
 if (idempotency_level != null) builder.append(", idempotency_level=").append(idempotency_level);
 if (!uninterpreted_option.isEmpty()) builder.append(", uninterpreted_option=").append(uninterpreted_option);
 return builder.replace(0, 2, "MethodOptions{").append('}').toString();
}