Comment insérer un caractère dans une chaîne à une certaine position?

J'entre dans un intavec une valeur à 6 chiffres. Je veux l'afficher sous la forme Stringd' un avec un point décimal (.) À 2 chiffres à partir de la fin de int. Je voulais utiliser un floatmais il a été suggéré de l'utiliser Stringpour une meilleure sortie d'affichage (au lieu de 1234.5l'être 1234.50). Par conséquent, j'ai besoin d'une fonction qui prendra un intcomme paramètre et retournera le correctement formaté Stringavec un point décimal à 2 chiffres de la fin.

Dire:

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

Comme mentionné dans les commentaires, un StringBuilder est probablement une implémentation plus rapide que l'utilisation d'un StringBuffer . Comme mentionné dans la documentation Java:

Cette classe fournit une API compatible avec StringBuffer, mais sans aucune garantie de synchronisation. Cette classe est conçue pour être utilisée en remplacement de StringBuffer dans les endroits où le tampon de chaîne était utilisé par un seul thread (comme c'est généralement le cas). Lorsque cela est possible, il est recommandé d'utiliser cette classe de préférence à StringBuffer car elle sera plus rapide dans la plupart des implémentations.

Utilisation:

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

Ou si vous avez besoin d'une synchronisation, utilisez le StringBuffer avec une utilisation similaire:

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

Dans la plupart des cas d'utilisation, utiliser un StringBuilder(comme déjà répondu) est un bon moyen de le faire. Cependant, si la performance compte, cela peut être une bonne alternative.

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

En utilisant ApacheCommons3 StringUtils, vous pouvez également faire

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

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

c'est essentiellement une concaténation de sous-chaînes mais plus courte si cela ne vous dérange pas d'utiliser des bibliothèques, ou déjà en fonction de StringUtils

Vous pourriez utiliser

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

Selon les commentaires, 12345 / 100.0 serait mieux, tout comme l'utilisation de double au lieu de float.

Si vous utilisez un système où le flottant coûte cher (par exemple pas de FPU) ou n'est pas autorisé (par exemple en comptabilité), vous pouvez utiliser quelque chose comme ceci:

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

Sinon, le DecimalFormat est la meilleure solution. (la variante StringBuilder ci-dessus ne fonctionnera pas avec de petits nombres (<100)

Je pense qu'une solution plus simple et plus élégante pour insérer une chaîne dans une certaine position serait ce one-liner:

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

Par exemple, pour insérer un manquant :dans une chaîne de temps:

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

Il fait correspondre les positioncaractères du début de la chaîne, les groupes et remplace le groupe par lui-même ( $1) suivi de la insertchaîne. Faites attention à replaceAll, même s'il y a toujours une occurrence, car le premier paramètre doit être une expression régulière.

Bien sûr, elle n'a pas les mêmes performances que la solution StringBuilder, mais je pense que la concision et l'élégance en tant que one-liner simple et plus facile à lire (par rapport à une énorme méthode) sont suffisantes pour en faire la solution préférée dans la plupart des non-performances. -cas d'utilisation critiques.

Remarque Je résous le problème générique dans le titre pour des raisons de documentation, bien sûr, si vous avez affaire à des nombres décimaux, vous devez utiliser les solutions spécifiques au domaine déjà proposées.

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

Pour les mecs Kotlin;) de la réponse acceptée (@ MikeThomsen's)

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

Test ✅

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

Essaye ça :

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