¿Cómo insertar un carácter en una cadena en una posición determinada?

Me estoy metiendo en un intcon un valor de 6 dígitos. Quiero mostrarlo como a Stringcon un punto decimal (.) A 2 dígitos desde el final de int. Quería usar un floatpero se me sugirió usar Stringpara una mejor salida de pantalla (en lugar de 1234.5lo será 1234.50). Por lo tanto, necesito una función que tome un intparámetro como y devuelva el formato correcto Stringcon un punto decimal a 2 dígitos del final.

Decir:

int j= 123456 
Integer.toString(j); 

//processing...

//output : 1234.56

int j = 123456;
String x = Integer.toString(j);
x = x.substring(0, 4) + "." + x.substring(4, x.length());

Como se mencionó en los comentarios, un StringBuilder es probablemente una implementación más rápida que usar un StringBuffer . Como se menciona en los documentos de Java:

Esta clase proporciona una API compatible con StringBuffer, pero sin garantía de sincronización. Esta clase está diseñada para usarse como un reemplazo directo para StringBuffer en lugares donde un único subproceso estaba utilizando el búfer de cadena (como suele ser el caso). Siempre que sea posible, se recomienda que esta clase se use con preferencia a StringBuffer, ya que será más rápida en la mayoría de las implementaciones.

Uso:

String str = Integer.toString(j);
str = new StringBuilder(str).insert(str.length()-2, ".").toString();

O si necesita sincronización, use StringBuffer con un uso similar:

String str = Integer.toString(j);
str = new StringBuffer(str).insert(str.length()-2, ".").toString();

int yourInteger = 123450;
String s = String.format("%6.2f", yourInteger / 100.0);
System.out.println(s);

En la mayoría de los casos de uso, usar un StringBuilder(como ya se respondió) es una buena manera de hacerlo. Sin embargo, si el rendimiento es importante, esta puede ser una buena alternativa.

/**
 * Insert the 'insert' String at the index 'position' into the 'target' String.
 * 
 * ````
 * insertAt("AC", 0, "") -> "AC"
 * insertAt("AC", 1, "xxx") -> "AxxxC"
 * insertAt("AB", 2, "C") -> "ABC
 * ````
 */
public static String insertAt(final String target, final int position, final String insert) {
    final int targetLen = target.length();
    if (position < 0 || position > targetLen) {
        throw new IllegalArgumentException("position=" + position);
    }
    if (insert.isEmpty()) {
        return target;
    }
    if (position == 0) {
        return insert.concat(target);
    } else if (position == targetLen) {
        return target.concat(insert);
    }
    final int insertLen = insert.length();
    final char[] buffer = new char[targetLen + insertLen];
    target.getChars(0, position, buffer, 0);
    insert.getChars(0, insertLen, buffer, position);
    target.getChars(position, targetLen, buffer, position + insertLen);
    return new String(buffer);
}

Usando ApacheCommons3 StringUtils, también podrías hacer

int j = 123456;
String s = Integer.toString(j);
int pos = s.length()-2;

s = StringUtils.overlay(s,".", pos, pos);

Básicamente es una concatenación de subcadenas, pero más corta si no te importa usar bibliotecas, o ya depende de StringUtils

Podrías usar

System.out.printf("%4.2f%n", ((float)12345)/100));

Según los comentarios, 12345 / 100.0 sería mejor, al igual que el uso de doble en lugar de flotante.

Si está utilizando un sistema donde el flotador es costoso (por ejemplo, sin FPU) o no está permitido (por ejemplo, en contabilidad), podría usar algo como esto:

    for (int i = 1; i < 100000; i *= 2) {
        String s = "00" + i;
        System.out.println(s.substring(Math.min(2, s.length() - 2), s.length() - 2) + "." + s.substring(s.length() - 2));
    }

De lo contrario, DecimalFormat es la mejor solución. (La variante StringBuilder anterior no funcionará con números pequeños (<100)

Creo que una solución más simple y elegante para insertar una cadena en una determinada posición sería esta frase:

target.replaceAll("^(.{" + position + "})", "$1" + insert);

Por ejemplo, para insertar una falta :en una cadena de tiempo:

"-0300".replaceAll("^(.{3})", "$1:");

Lo que hace es, coincide con los positioncaracteres desde el principio de la cadena, agrupa eso y reemplaza el grupo con sí mismo ( $1) seguido por elinsert cadena. Tenga en cuenta el replaceAll, aunque siempre haya una ocurrencia, porque el primer parámetro debe ser una expresión regular.

Por supuesto, no tiene el mismo rendimiento que la solución StringBuilder, pero creo que la concisión y la elegancia como una sola línea simple y más fácil de leer (en comparación con un método enorme) es suficiente para convertirla en la solución preferida en la mayoría de los casos sin rendimiento -críticos casos de uso.

Tenga en cuenta que estoy resolviendo el problema genérico en el título por razones de documentación, por supuesto, si se trata de números decimales, debe usar las soluciones específicas de dominio ya propuestas.

String.format ("% 0d.% 02d", d / 100, d% 100);

Para los tipos de Kotlin;) de la respuesta aceptada (@ MikeThomsen's)

fun String.insert(index: Int, string: String): String {
    return this.substring(0, index) + string + this.substring(index, this.length)
}

Prueba ✅

"ThisTest".insert(4, "Is").should.equal("ThisIsTest")

  public static void main(String[] args) {
    char ch='m';
    String str="Hello",k=String.valueOf(ch),b,c;

    System.out.println(str);

    int index=3;
    b=str.substring(0,index-1 );
    c=str.substring(index-1,str.length());
    str=b+k+c;
}

// Create given String and make with size 30
String str = "Hello How Are You";

// Creating StringBuffer Object for right padding
StringBuffer stringBufferRightPad = new StringBuffer(str);
while (stringBufferRightPad.length() < 30) {
    stringBufferRightPad.insert(stringBufferRightPad.length(), "*");
}

System.out.println("after Left padding : " + stringBufferRightPad);
System.out.println("after Left padding : " + stringBufferRightPad.toString());

// Creating StringBuffer Object for right padding
StringBuffer stringBufferLeftPad = new StringBuffer(str);
while (stringBufferLeftPad.length() < 30) {
    stringBufferLeftPad.insert(0, "*");
}
System.out.println("after Left padding : " + stringBufferLeftPad);
System.out.println("after Left padding : " + stringBufferLeftPad.toString());

Prueba esto :

public String ConvertMessage(String content_sendout){

        //use unicode (004E00650077) need to change to hex (&#x004E&#x;0065&#x;0077;) first ;
        String resultcontent_sendout = "";
        int i = 4;
        int lengthwelcomemsg = content_sendout.length()/i;
        for(int nadd=0;nadd<lengthwelcomemsg;nadd++){
            if(nadd == 0){
                resultcontent_sendout = "&#x"+content_sendout.substring(nadd*i, (nadd*i)+i) + ";&#x";
            }else if(nadd == lengthwelcomemsg-1){
                resultcontent_sendout += content_sendout.substring(nadd*i, (nadd*i)+i) + ";";
            }else{
                resultcontent_sendout += content_sendout.substring(nadd*i, (nadd*i)+i) + ";&#x";
            }
        }
        return resultcontent_sendout;
    }