Como inserir um caractere em uma string em uma determinada posição?

Estou entrando intcom um valor de 6 dígitos. Quero exibi-lo como um Stringcom um ponto decimal (.) A 2 dígitos do final de int. Eu queria usar um, floatmas foi sugerido para usar Stringpara uma melhor saída de exibição (em vez de 1234.5será 1234.50). Portanto, preciso de uma função que aceite um intparâmetro as e retorne o formatado corretamenteString com um ponto decimal 2 dígitos no final.

Dizer:

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 mencionado nos comentários, um StringBuilder é provavelmente uma implementação mais rápida do que o uso de um StringBuffer . Conforme mencionado nos documentos Java:

Esta classe fornece uma API compatível com StringBuffer, mas sem garantia de sincronização. Essa classe foi projetada para ser usada como um substituto para o StringBuffer nos locais em que o buffer da string estava sendo usado por um único encadeamento (como geralmente é o caso). Sempre que possível, é recomendável que essa classe seja usada preferencialmente ao StringBuffer, pois será mais rápida na maioria das implementações.

Uso:

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

Ou se você precisar de sincronização, use o StringBuffer com uso semelhante:

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);

Na maioria dos casos de uso, usar um StringBuilder(como já respondido) é uma boa maneira de fazer isso. No entanto, se o desempenho importa, essa pode ser uma boa 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 o ApacheCommons3 StringUtils, você também pode fazer

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

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

é basicamente concatenação de substring, mas mais curta se você não se importa em usar bibliotecas ou já depende de StringUtils

Você poderia usar

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

De acordo com os comentários, 12345 / 100.0 seria melhor, assim como o uso de double em vez de float.

Se você estiver usando um sistema em que o float é caro (por exemplo, sem FPU) ou não é permitido (por exemplo, na contabilidade), você pode usar algo como isto:

    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));
    }

Caso contrário, o DecimalFormat é a melhor solução. (a variante StringBuilder acima não funcionará com números pequenos (<100)

Eu acho que uma solução mais simples e mais elegante para inserir uma String em uma determinada posição seria esta linha:

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

Por exemplo, para inserir uma :String ausente no tempo:

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

O que ele faz é corresponder positioncaracteres desde o início da sequência, agrupar e substituir o grupo por si mesmo ( $1) seguido pela insertsequência. Observe o replaceAll, mesmo que sempre exista uma ocorrência, porque o primeiro parâmetro deve ser uma regex.

É claro que ele não tem o mesmo desempenho que a solução StringBuilder, mas acredito que a sucessão e a elegância de uma linha única simples e mais fácil de ler (em comparação com um método enorme) são suficientes para torná-la a solução preferida na maioria dos que não são de desempenho casos de uso críticos.

Nota: Estou resolvendo o problema genérico no título por motivos de documentação; é claro que se você estiver lidando com números decimais, deverá usar as soluções específicas de domínio já propostas.

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

Para Kotlin caras;) a partir da resposta aceita (@ MikeThomsen's)

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

Teste ✅

"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());

Tente o seguinte:

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;
    }