У меня есть следующие значения:
int a=1;
int b=0;
int c=2;
int d=2;
int e=1;
Как объединить эти значения, чтобы в итоге я получил строку 10221;
обратите внимание, что умножение a на 10000, b на 1000..... и e на 1 не будет работать с b=0, и поэтому я потеряю его, когда я добавлю значения вверх.
Самый простой (но несколько грязный) способ:
String result = "" + a + b + c + d + e
Изменить: Я не рекомендую это и согласен с комментарием Джона. Добавление этих лишних пустых строк, вероятно, является лучшим компромиссом между коротким и ясностью.
Решение Michael Borgwardt является лучшим для 5 цифр, но если у вас есть переменное количество цифр, вы можете использовать что-то вроде этого:
public static String concatenateDigits(int... digits) {
StringBuilder sb = new StringBuilder(digits.length);
for (int digit : digits) {
sb.append(digit);
}
return sb.toString();
}
Это сработало для меня.
int i = 14;
int j = 26;
int k = Integer.valueOf(String.valueOf(i) + String.valueOf(j));
System.out.println(k);
Это оказалось как 1426
На самом деле,
int result = a * 10000 + b * 1000 + c * 100 + d * 10 + e;
String s = Integer.toString(result);
будет работать.
Примечание: это будет работать только тогда, когда a больше 0, а все b, c, d и e находятся в [0, 9]. Например, если b равно 15, метод Майкла даст вам результат, который вы, вероятно, захотите.
чтобы не забыть метод 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, если вам нужна только первая цифра каждого номера...)
StringBuffer sb = new StringBuffer();
sb.append(a).append(b).append(c)...
Сохранение значений как int предпочтительнее, как показывают другие ответы.
Другие указали, что умножение b на 1000 не должно вызывать проблемы, но если a равно нулю, вы потеряете его. (Вы получите 4-значную строку вместо 5.)
Здесь альтернативный (общий) подход - который предполагает, что все значения находятся в диапазоне 0-9. (Вполне вероятно, что вы добавите некоторый код для исключения, если это окажется недействительным, но я оставил его здесь для простоты.)
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);
}
В этом случае вы бы назвали его с помощью:
String result = concatenateDigits(a, b, c, d, e);
Если вы умножаете b на 1000, вы не потеряете ни одного из значений. См. Ниже математику.
10000
0
200
20
1
=====
10221
Для удовольствия... как НЕ сделать это ; -)
String s = Arrays.asList(a,b,c,d,e).toString().replaceAll("[\\[\\], ]", "");
Не то, чтобы кто-нибудь действительно думал об этом в этом случае, но это иллюстрирует, почему важно предоставить доступ к определенным членам объекта, иначе пользователи API в конечном итоге проанализируют строковое представление вашего объекта, а затем вы застрял, не в состоянии его модифицировать, или рискуя сломать свой код, если вы это сделаете.
Предполагая, что вы начинаете с переменных:
int i=12;
int j=12;
Это даст результат 1212:
System.out.print(i+""+j);
И это даст результат 24:
System.out.print(i+j);
Я бы предложил преобразовать их в строки.
StringBuilder concatenated = new StringBuilder();
concatenated.append(a);
concatenated.append(b);
/// etc...
concatenated.append(e);
Затем преобразование обратно в Integer:
Integer.valueOf(concatenated.toString());
Использовать 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());
Люди беспокоились о том, что происходит, когда a == 0. Простое исправление для этого... перед ним стоит цифра.:)
int sum = 100000 + a*10000 + b*1000 + c*100 + d*10 + e;
System.out.println(String.valueOf(sum).substring(1));
Самый большой недостаток: он создает две строки. Если это очень важно, String.format может помочь.
int sum = a*10000 + b*1000 + c*100 + d*10 + e;
System.out.println(String.format("%05d", sum));
Вы можете использовать
String x = a+"" +b +""+ c+""+d+""+ e;
int result = Integer.parseInt(x);
Лучшие решения уже обсуждаются. Для этого вы могли бы это сделать: Учитывая, что вы всегда имеете дело с 5 цифрами,
(new java.util.Formatter().format("%d%d%d%d%d", a,b,c,d,e)).toString()
Я не утверждаю, что это лучший способ; просто добавляя альтернативный способ взглянуть на подобные ситуации.:)
Как насчет того, чтобы не использовать строки вообще...
Это должно работать для любого количества цифр...
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);
Отмечая обсуждение здесь и следуя общим решениям в в настоящее время наиболее широко распространенным ответом, я бы вероятно, предложите следующую альтернативу:
public static String concatenateDigits(int... digits) {
String result = "";
for (int digit : digits) {
result += digit;
}
return result;
}
Я бы отложил свою первую ссылку для обсуждения того, действительно ли она скомпилирована в тот же самый байт-код, что и исходное решение, но я нахожу его более интуитивным, быстрее читаемым и менее раздутым, чтобы придерживаться языковые функции, а не вызовы API. Но это ясно мнение.
Не могли бы вы просто сделать строки чисел, объединить их и преобразовать строки в целое значение?
После Java 8 вы можете использовать StringJoiner, очень чистый и более гибкий способ (особенно если у вас есть список как входной вместо известного набора переменных 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);
Если вам нужен разделитель, используйте:
String result = values.stream().map(i -> i.toString()).collect(Collectors.joining(","));
Чтобы получить следующий результат:
1,0,2,2,1
публичный класс, соединяющий {
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);
}
}