Comment concaténer des valeurs int dans java?

Question

Je les valeurs suivantes:

int a=1; 
int b=0; 
int c=2; 
int d=2; 
int e=1; 

Comment puis-je concaténer ces valeurs pour que je me retrouve avec une chaîne qui est 10221; s'il vous plaît noter que multipliant a par 10000, b par 1000 ..... et e par 1 ne fonctionnera pas depuis b=0 et donc je vais le perdre quand j'ajouter les valeurs.

Answer 1

En fait,

int result = a * 10000 + b * 1000 + c * 100 + d * 10 + e; 
String s = Integer.toString(result); 

travaillera.

Note: cela ne fonctionnera que lorsque a est supérieur à 0 et tous b, c, d et e sont dans [0, 9]. Par exemple, si b est 15, la méthode de Michael vous obtiendra le résultat que vous voulez probablement.

Answer 2

Si vous multipliez b par 1000, vous ne perdrez aucune des valeurs. Voir ci-dessous pour les maths.

10000 
    0 
    200 
    20 
    1 
===== 
10221 

Answer 3

StringBuffer sb = new StringBuffer(); 
sb.append(a).append(b).append(c)... 

Garder les valeurs comme int tu est préféré, comme les autres réponses que vous montrent.

Answer 4

Je suggère de les convertir en chaînes.

StringBuilder concatenated = new StringBuilder(); 
concatenated.append(a); 
concatenated.append(b); 
/// etc... 
concatenated.append(e); 

convertir ensuite revenir à un entier:

Integer.valueOf(concatenated.toString()); 

Answer 5

Utilisez StringBuilder

StringBuilder sb = new StringBuilder(String.valueOf(a)); 
sb.append(String.valueOf(b)); 
sb.append(String.valueOf(c)); 
sb.append(String.valueOf(d)); 
sb.append(String.valueOf(e)); 
System.out.print(sb.toString()); 

Answer 6

D'autres ont fait remarquer que la multiplication b par 1000 ne devrait pas poser un problème - mais si un étaient zéro, vous finiriez par le perdre. (Vous obtiendrez une chaîne à 4 chiffres au lieu de 5.)

Voici une approche alternative (générale) qui suppose que toutes les valeurs sont comprises entre 0 et 9. (Vous devriez peut-être tout à fait mettre dans un certain code pour lancer une exception si cela se révèle pas être vrai, mais je l'ai laissé ici pour plus de simplicité.)

public static String concatenateDigits(int... digits) 
{ 
    char[] chars = new char[digits.length]; 
    for (int i = 0; i < digits.length; i++) 
    { 
     chars[i] = (char)(digits[i] + '0'); 
    } 
    return new String(chars); 
} 

Dans ce cas, vous appelez avec :

String result = concatenateDigits(a, b, c, d, e); 

Answer 7

La meilleure façon (mais un peu sale):

String result = "" + a + b + c + d + e 

Edit: Je ne recommande pas et suis d'accord avec le commentaire de Jon. L'ajout de ces chaînes vides est probablement le meilleur compromis entre brièveté et clarté.

Answer 8

Michael solution de Borgwardt est le meilleur pour 5 chiffres, mais si vous avez un nombre variable de chiffres, vous pouvez utiliser quelque chose comme ceci:

public static String concatenateDigits(int... digits) { 
    StringBuilder sb = new StringBuilder(digits.length); 
    for (int digit : digits) { 
    sb.append(digit); 
    } 
    return sb.toString(); 
} 

Answer 9

Les gens fretting sur ce qui se passe lorsqu'un == 0. Facile réparer pour cela ... avoir un chiffre avant. :)

int sum = 100000 + a*10000 + b*1000 + c*100 + d*10 + e; 
System.out.println(String.valueOf(sum).substring(1)); 

Plus grand inconvénient: il crée deux chaînes. Si c'est un gros problème, String.format pourrait aider.

int sum = a*10000 + b*1000 + c*100 + d*10 + e; 
System.out.println(String.format("%05d", sum)); 

Answer 10

Vous pouvez utiliser

String x = a+"" +b +""+ c+""+d+""+ e; 
int result = Integer.parseInt(x); 

Answer 11

Pour le plaisir ... Comment PAS pour le faire ;-)

String s = Arrays.asList(a,b,c,d,e).toString().replaceAll("[\\[\\], ]", ""); 

Non que tout le monde serait vraiment penser le faire de cette façon dans ce cas - mais cela illustre pourquoi il est important de donner accès à c ertains membres de l'objet, sinon les utilisateurs de l'API finissent par analyser la représentation sous forme de chaîne de votre objet, puis vous êtes bloqué de ne pas pouvoir le modifier, ou vous risquez de casser leur code si vous le faites.

Answer 12

juste pour ne pas oublier la méthode format

String s = String.format("%s%s%s%s%s", a, b, c, d, e); 

(%1.1s%1.1s%1.1s%1.1s%1.1s si vous voulez seulement le premier chiffre de chaque numéro ...)

Answer 13

Les meilleures solutions sont déjà discutées. Pour le plaisir de le faire, vous pouvez le faire ainsi: Étant donné que vous êtes toujours affaire à 5 chiffres,

(new java.util.Formatter().format("%d%d%d%d%d", a,b,c,d,e)).toString() 

Je ne prétends pas que c'est la meilleure façon; Il suffit d'ajouter un autre moyen de regarder des situations similaires. :)

Answer 14

Que diriez-vous de ne pas utiliser les chaînes du tout ...

Cela devrait fonctionner pour un certain nombre de chiffres ...

int[] nums = {1, 0, 2, 2, 1}; 

int retval = 0; 

for (int digit : nums) 
{ 
    retval *= 10; 
    retval += digit; 
} 

System.out.println("Return value is: " + retval); 

Answer 15

Cela a fonctionné pour moi.

int i = 14; 
int j = 26; 
int k = Integer.valueOf(String.valueOf(i) + String.valueOf(j)); 
System.out.println(k); 

Il est avéré que 1426

Answer 16

Prenant note du débat here et en suivant la solution générale dans le currently most widely accepted answer je ne serais probablement suggérer l'alternative suivante:

public static String concatenateDigits(int... digits) { 
    String result = ""; 
    for (int digit : digits) { 
    result += digit; 
    } 
    return result; 
} 

Je remettrais à mon premier lien pour la discussion de savoir si cela est en fait compilé avec le même byte-code que la solution originale, mais je le trouve un peu plus intuitif, plus rapide à lire et moins gonflé à coller à la langue fe plutôt que des appels d'API. Mais c'est une question d'opinion clairement.

Answer 17

En supposant que vous commencer par les variables:

int i=12; 
int j=12; 

Cela donnera la sortie 1212:

System.out.print(i+""+j); 

Et cela donne une sortie 24:

System.out.print(i+j); 

Answer 18

public class joining { 

    public static void main(String[] args) { 
     int a=1; 
     int b=0; 
     int c=2; 
     int d=2; 
     int e=1; 

     String j = Long.toString(a); 
     String k = Long.toString(b); 
     String l = Long.toString(c); 
     String m = Long.toString(d); 
     String n = Long.toString(e); 

     /* String s1=Long.toString(a); // converting long to String 
     String s2=Long.toString(b); 
     String s3=s2+s1; 
     long c=Long.valueOf(s3).longValue(); // converting String to long 
     */ 

     System.out.println(j+k+l+m+n); 
    } 
} 

Answer 19

Couldn Ne faites-vous pas les chaînes de nombres, les concaténer, et convertir les chaînes à une valeur entière?

Answer 20

Après Java 8 vous pouvez utiliser le StringJoiner, d'une manière très propre et plus souple (surtout si vous avez une liste en entrée au lieu de jeu connu de variables ae):

int a = 1; 
int b = 0; 
int c = 2; 
int d = 2; 
int e = 1; 
List<Integer> values = Arrays.asList(a, b, c, d, e); 
String result = values.stream().map(i -> i.toString()).collect(Collectors.joining()); 
System.out.println(result); 

Si vous avez besoin d'un séparateur utilisation:

String result = values.stream().map(i -> i.toString()).collect(Collectors.joining(",")); 

Pour obtenir le résultat suivant:

1,0,2,2,1