Come concatenare i valori int in java?

Ho i seguenti valori:

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

Come concatenare questi valori in modo che finisca con una stringa che è 10221 ; si noti che moltiplicando a per 10000, b per 1000 ….. e e per 1 non funzionerà poiché b=0 e quindi lo perderò quando aggiungo i valori.

Il modo più semplice (ma un po ‘sporco):

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

Modifica: non lo consiglio e sono d’accordo con il commento di Jon. Aggiungere quelle stringhe extra vuote è probabilmente il miglior compromesso tra carenza e chiarezza.

La soluzione di Michael Borgwardt è la migliore per 5 cifre, ma se hai un numero variabile di cifre, puoi usare qualcosa del genere:

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

Questo ha funzionato per me.

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

Risultò come 1426

In realtà,

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

funzionerà

Nota: questo funziona solo quando a è maggiore di 0 e tutti b , c , d ed e sono in [0, 9]. Ad esempio, se b è 15, il metodo di Michael ti darà il risultato che vorresti.

solo per non dimenticare il metodo di 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 se si desidera solo la prima cifra di ciascun numero …)

Se moltiplichi b per 1000, non perderai nessuno dei valori. Vedi sotto per la matematica.

 10000 0 200 20 1 ===== 10221 
 StringBuffer sb = new StringBuffer(); sb.append(a).append(b).append(c)... 

Tieni i valori come int come preferito, come le altre risposte ti mostrano.

Altri hanno sottolineato che moltiplicare b per 1000 non dovrebbe causare problemi – ma se uno fosse zero, finiresti per perderlo. (Avresti una stringa di 4 cifre invece di 5.)

Ecco un approccio alternativo (scopo generale) – che presuppone che tutti i valori siano compresi nell’intervallo 0-9. (Probabilmente dovresti inserire un codice per lanciare un’eccezione se non risulta vero, ma l’ho lasciato qui per semplicità.)

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

In questo caso lo chiameresti con:

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

Per divertimento … come NON farlo 😉

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

Non che qualcuno possa davvero pensare di farlo in questo modo – ma questo spiega perché è importante dare accesso a determinati membri dell’object, altrimenti gli utenti API finiscono per analizzare la rappresentazione in stringa del proprio object, e quindi non si è bloccati in grado di modificarlo, o rischiare di rompere il loro codice se lo fai.

Suggerirei di convertirli in stringhe.

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

Quindi riconvertire in un intero:

 Integer.valueOf(concatenated.toString()); 

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

Le persone si sono preoccupate di ciò che accade quando un == 0. Facile soluzione per quello … avere una cifra prima. 🙂

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

Il più grande svantaggio: crea due stringhe. Se questo è un grosso problema, String.format potrebbe aiutare.

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

Puoi usare

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

Che dire di non usare le stringhe …

Questo dovrebbe funzionare per qualsiasi numero di cifre …

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

Supponendo che inizi con le variabili:

 int i=12; int j=12; 

Questo darà l’output 1212 :

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

E questo darà l’output 24 :

 System.out.print(i+j); 

Dopo Java 8 puoi usare StringJoiner , un modo molto pulito e più flessibile (specialmente se hai un elenco come input al posto del noto insieme di variabili ae):

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

Se hai bisogno di un separatore usa:

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

Per ottenere il seguente risultato:

1,0,2,2,1

Le migliori soluzioni sono già state discusse. Per favore, potresti fare anche questo: visto che hai sempre a che fare con 5 cifre,

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

Non sto affermando che questo è il modo migliore; aggiungendo semplicemente un modo alternativo di guardare a situazioni simili. 🙂

Notando la discussione qui e seguendo la soluzione generale nella risposta attualmente più ampiamente accettata, suggerirei probabilmente la seguente alternativa:

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

Vorrei rimandare al mio primo link per la discussione se questo è in realtà compilato allo stesso byte-code della soluzione originale, ma lo trovo un po ‘più intuitivo, più veloce da leggere e meno gonfiato per attaccare alle caratteristiche del linguaggio piuttosto rispetto alle chiamate API. Ma questa è una questione di opinione chiaramente.

Non potresti semplicemente creare le stringhe di numeri, concatenarli e convertire le stringhe in un valore intero?

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