Jak połączyć wartości int w java?

Question

Mam następujące wartości:

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

Jak mogę łączyć te wartości tak, że kończy się z ciągu znaków, który jest 10221; należy pamiętać, że pomnożenie a przez 10000, b przez 1000 ..... i e przez 1 nie będzie działać od b=0 i dlatego stracę go, gdy dodaję wartości do góry.

Answer 1

Właściwie

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

będzie praca.

Uwaga: to będzie działać tylko wtedy, gdy a jest większe niż 0, a wszystkie b, c, d i e są [0, 9]. Jeśli na przykład b ma wartość 15, metoda Michaela da ci wynik, którego prawdopodobnie potrzebujesz.

Answer 2

Jeśli pomnożysz b przez 1000, nie utracisz żadnej z wartości. Zobacz poniżej dla matematyki.

10000 
    0 
    200 
    20 
    1 
===== 
10221 

Answer 3

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

Utrzymanie wartości jak int jest korzystne ty, jak inni odpowiedzi pokazać.

Answer 4

Proponuję przekonwertować je na ciągi.

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

Następnie Nawrócenie liczbą całkowitą:

Integer.valueOf(concatenated.toString()); 

Answer 5

Zastosowanie 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

Inni wskazywali, że pomnożenie b przez 1000 nie powinien powodować problem - ale jeśli były równe zero, w końcu przegrywasz. (Otrzymasz 4-cyfrowy łańcuch zamiast 5.)

Oto alternatywne podejście (ogólne) - które zakłada, że ​​wszystkie wartości mieszczą się w zakresie 0-9. (Powinieneś być może umieścić w jakimś kodem rzucić wyjątek, jeśli okaże się, że nie mogło być prawdziwe, ale zostawiłem go tutaj dla uproszczenia).

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

W tym przypadku chcesz wywołać ją z :

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

Answer 7

Najprostszym (ale nieco brudny) sposób:

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

Edit: nie polecam tego i zgadzam się z komentarzem Jona. Dodanie tych dodatkowych pustych łańcuchów jest prawdopodobnie najlepszym kompromisem pomiędzy krótkością a klarownością.Rozwiązanie

Answer 8

Michaela Borgwardt jest najlepszy do 5 cyfr, ale jeśli masz zmienną liczbę cyfr, można użyć coś takiego:

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

Answer 9

Ludzie cierną nad tym, co się dzieje, gdy == 0. Łatwy Napraw to ... ... masz przed sobą cyfrę. :)

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

Największa wada: tworzy dwa ciągi. Jeśli to wielka sprawa, String.format może pomóc.

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

Answer 10

można użyć

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

Answer 11

Dla zabawy ... jak NIE zrobić to ;-)

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

Nie że ktoś naprawdę myśleć robi to w ten sposób w tym przypadku - ale to ilustruje, dlaczego ważne jest, aby dać dostęp do c niektórych członków obiektu, w przeciwnym razie użytkownicy API będą analizować ciągi znaków obiektu, a następnie utkniesz, że nie będą mogli go zmodyfikować, lub ryzykują przerwanie ich kodu, jeśli to zrobisz.

Answer 12

żeby nie zapomnieć metodę

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

format (%1.1s%1.1s%1.1s%1.1s%1.1s jeśli chcesz tylko pierwszą cyfrę każdego numeru ...)

Answer 13

Najlepsze rozwiązania są już omówione. Do cholery z tym, można to zrobić również: Biorąc pod uwagę, że są zawsze do czynienia z 5 cyfr,

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

ja nie twierdzę, jest to najlepszy sposób; po prostu dodając alternatywny sposób patrzenia na podobne sytuacje. :)

Answer 14

Jak o wcale nie używając strun ...

To powinno działać na dowolnej liczbie cyfr ...

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

Ten pracował dla mnie.

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

Okazało się jako 1426

Answer 16

odnotowując dyskusji here i następującym po ogólnego rozwiązania w currently most widely accepted answer Prawdopodobnie proponuję następującą alternatywę:

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

bym odroczenia na mój pierwszy link do dyskusji o tym, czy w rzeczywistości jest on kompilowany do tego samego kodu bajtowego, co oryginalne rozwiązanie, ale uważam, że jest on nieco bardziej intuicyjny, szybszy do czytania i mniej nadęty, aby trzymać się języka fe atures zamiast wywołań interfejsu API. Ale to jest wyraźnie kwestia opinii.

Answer 17

Zakładając zacząć od zmiennych:

int i=12; 
int j=12; 

To da wyjście 1212:

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

A to da wyjście 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

mogłam po prostu tworzysz ciągi liczb, łączysz je i konwertujesz łańcuchy na wartość całkowitą?

Answer 20

Po Java 8 można użyć StringJoiner, bardzo czysty i bardziej elastyczny sposób (zwłaszcza jeśli masz listę jako wejście zamiast znanego zestawu zmiennych 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); 

Jeśli potrzebujesz separatora zastosowanie:

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

Aby uzyskać następujący wynik:

1,0,2,2,1