Как объединить две строки в Java? - программирование
Подтвердить что ты не робот

Как объединить две строки в Java?

Я пытаюсь объединить строки в Java. Почему это не работает?

public class StackOverflowTest {  
    public static void main(String args[]) {
        int theNumber = 42;
        System.out.println("Your number is " . theNumber . "!");
    }
}
4b9b3361

ОТВЕТЫ

Ответ 1

Вы можете объединить строки с помощью оператора +:

System.out.println("Your number is " + theNumber + "!");

theNumber неявно преобразуется в String "42".

Ответ 2

Оператор конкатенации в java равен +, а не .

Прочитайте это (включая все подразделы) перед тем, как начать. Попробуйте перестать думать о php-пути;)

Чтобы расширить ваш взгляд на использование строк в Java - оператор + для строк фактически преобразуется (компилятором) во что-то похожее:

new StringBuilder().append("firstString").append("secondString").toString()

Ответ 3

Есть два основных ответа на этот вопрос:

  1. [просто] Используйте оператор + (конкатенация строк). "your number is" + theNumber + "!" (как отмечено в другом месте)
  2. [менее просто]: используйте StringBuilder (или StringBuffer).
StringBuilder value;
value.append("your number is");
value.append(theNumber);
value.append("!");

value.toString();

Я рекомендую не использовать такие операции:

new StringBuilder().append("I").append("like to write").append("confusing code");

Edit: начиная с Java 5 оператор конкатенации строки переводится в StringBuilder называет компилятором. Из-за этого оба метода выше одинаковы.

Примечание: космический товар является ценным товаром, в то же время он демонстрирует

Предупреждение: Пример 1 ниже генерирует несколько экземпляров StringBuilder и менее эффективен, чем пример 2 ниже

Пример 1

String Blam = one + two;
Blam += three + four;
Blam += five + six;

Пример 2

String Blam = one + two + three + four + five + six;

Ответ 4

Из коробки у вас есть 3 способа вставить значение переменной в String как вы пытаетесь достичь:

1. Самый простой способ

Вы можете просто использовать оператор + между String и любым типом объекта или примитива, он автоматически объединит String и

  1. В случае объекта значение String.valueOf(obj) соответствующее String " null ", если obj равно null противном случае значение obj.toString().
  2. В случае типа примитива, эквивалент String.valueOf(<primitive-type>).

Пример с не null объектом:

Integer theNumber = 42;
System.out.println("Your number is " + theNumber + "!");

Выход:

Your number is 42!

Пример с null объектом:

Integer theNumber = null;
System.out.println("Your number is " + theNumber + "!");

Выход:

Your number is null!

Пример с примитивным типом:

int theNumber = 42;
System.out.println("Your number is " + theNumber + "!");

Выход:

Your number is 42!

2. Явный способ и потенциально самый эффективный

Вы можете использовать StringBuilder (или StringBuffer потокобезопасный устаревший аналог) для построения вашей String с использованием методов append.

Пример:

int theNumber = 42;
StringBuilder buffer = new StringBuilder()
    .append("Your number is ").append(theNumber).append('!');
System.out.println(buffer.toString()); // or simply System.out.println(buffer)

Выход:

Your number is 42!

За сцену, это на самом деле, как недавние Java компиляторы преобразовать все String конкатенации сделана с оператором +, единственной разницей с предыдущим способом является то, что у вас есть полный контроль.

Действительно, компиляторы будут использовать конструктор по умолчанию, поэтому емкость по умолчанию (16), поскольку они понятия не имеют, какой будет конечная длина String для построения, что означает, что если конечная длина больше 16, емкость будет обязательно продлен, который имеет цену в плане производительности.

Поэтому, если вы заранее знаете, что размер вашей окончательной String будет больше 16, будет гораздо эффективнее использовать этот подход для обеспечения лучшей начальной емкости. Например, в нашем примере мы создаем String, длина которой больше 16, поэтому для лучшей производительности ее следует переписать следующим образом:

Пример оптимизирован:

int theNumber = 42;
StringBuilder buffer = new StringBuilder(18)
    .append("Your number is ").append(theNumber).append('!');
System.out.println(buffer)

Выход:

Your number is 42!

3. Самый читаемый способ

Вы можете использовать методы String.format(locale, format, args) или String.format(format, args) которые оба используют Formatter для создания вашей String. Это позволяет вам указать формат вашей окончательной String, используя заполнители, которые будут заменены значением аргументов.

Пример:

int theNumber = 42;
System.out.println(String.format("Your number is %d!", theNumber));
// Or if we need to print only we can use printf
System.out.printf("Your number is still %d with printf!%n", theNumber);

Выход:

Your number is 42!
Your number is still 42 with printf!

Самым интересным аспектом этого подхода является тот факт, что у нас есть четкое представление о том, что будет последней String потому что ее гораздо легче читать, а ее намного легче поддерживать.

Ответ 5

java 8 way:

StringJoiner sj1 = new StringJoiner(", ");
String joined = sj1.add("one").add("two").toString();
// one, two
System.out.println(joined);


StringJoiner sj2 = new StringJoiner(", ","{", "}");
String joined2 = sj2.add("Jake").add("John").add("Carl").toString();
// {Jake, John, Carl}
System.out.println(joined2);

Ответ 6

Вы должны быть программистом PHP.

Используйте знак +.

System.out.println("Your number is " + theNumber + "!");

Ответ 7

"+" вместо "."

Ответ 8

Используйте + для конкатенации строк.

"Your number is " + theNumber + "!"

Ответ 9

Это должно работать

public class StackOverflowTest
{  
    public static void main(String args[])
    {
        int theNumber = 42;
        System.out.println("Your number is " + theNumber + "!");
    }
}

Ответ 10

Для точной операции конкатенации двух строк используйте:

file_names = file_names.concat(file_names1);

В вашем случае используйте + вместо .

Ответ 11

Для лучшей производительности используйте str1.concat(str2), где str1 и str2 - строковые переменные.

Ответ 12

В символе java concatenate есть "+". Если вы пытаетесь объединить две или три строки при использовании jdbc, используйте это:

String u = t1.getString();
String v = t2.getString();
String w = t3.getString();
String X = u + "" + v + "" + w;
st.setString(1, X);

Здесь "" используется только для пробелов.

Ответ 13

В Java символ конкатенации "+", а не ".".

Ответ 14

"+" not "."

Но будьте осторожны с конкатенацией строк. Здесь ссылка, представляющая некоторые мысли из IBM DeveloperWorks.

Ответ 15

Первый метод: вы можете использовать знак "+" для конкатенации строк, но это всегда происходит в печати. Другой способ: класс String включает метод для объединения двух строк: string1.concat(string2);

Ответ 16

import com.google.common.base.Joiner;

String delimiter = "";
Joiner.on(delimiter).join(Lists.newArrayList("Your number is ", 47, "!"));

Это может быть чрезмерным ответом на вопрос op, но хорошо знать о более сложных действиях соединения. Этот вопрос в stackoverflow высоко оценивает в целом поисковые запросы Google в этой области, поэтому хорошо знать.

Ответ 17

вы можете использовать stringbuffer, stringbuilder и, как и все, что было до меня упомянуто, "+". Я не уверен, насколько быстро "+" (я думаю, что это самый быстрый для более коротких строк), но дольше я думаю, что построитель и буфер примерно равны (построитель немного быстрее, потому что он не синхронизирован).

Ответ 18

Вы можете объединить строки с помощью оператора +:

String a="hello ";
String b="world.";
System.out.println(a+b);

Вывод:

hello world.

Что он

Ответ 19

вот пример для чтения и конкатенации 2 строк без использования третьей переменной:

public class Demo {
    public static void main(String args[]) throws Exception  {
        InputStreamReader r=new InputStreamReader(System.in);     
        BufferedReader br = new BufferedReader(r);
        System.out.println("enter your first string");
        String str1 = br.readLine();
        System.out.println("enter your second string");
        String str2 = br.readLine();
        System.out.println("concatenated string is:" + str1 + str2);
    }
}

Ответ 20

Есть несколько способов сделать это, но Oracle и IBM говорят, что использование + - это плохая практика, потому что, по сути, каждый раз, когда вы объединяете String, вы в конечном итоге создаете дополнительные объекты в памяти. Он будет использовать дополнительное пространство в JVM, и вашей программе может не хватить места или она будет работать медленнее.

Использование StringBuilder или StringBuffer - лучший способ сделать это. Пожалуйста, посмотрите на комментарий Николаса Филлато выше, например, связанный с StringBuffer.

String first = "I eat";  String second = "all the rats."; 
System.out.println(first+second);

Ответ 21

Таким образом, из умелого ответа вы могли бы получить ответ, почему ваш фрагмент не работает. Теперь я добавлю свои предложения о том, как сделать это эффективно. Эта статья является хорошим местом, где автор рассказывает о различных способах объединения строк, а также о результатах сравнения времени между различными результатами.

Различные способы объединения строк в Java

  1. Используя оператор + (20 + "")
  2. Используя метод concat в классе String
  3. Использование StringBuffer
  4. С помощью StringBuilder

Способ 1:

Это не рекомендуемый способ. Зачем? Когда вы используете его с целыми числами и символами, вы должны явно помнить о преобразовании целого числа в toString() перед добавлением строки, иначе это приведет к обработке символов в ASCI int и выполнению сложения сверху.

String temp = "" + 200 + 'B';

//This is translated internally into,

new StringBuilder().append( "" ).append( 200 ).append('B').toString();

Способ 2:

Это внутренняя реализация метода concat

public String concat(String str) {
    int olen = str.length();
    if (olen == 0) {
        return this;
    }
    if (coder() == str.coder()) {
        byte[] val = this.value;
        byte[] oval = str.value;
        int len = val.length + oval.length;
        byte[] buf = Arrays.copyOf(val, len);
        System.arraycopy(oval, 0, buf, val.length, oval.length);
        return new String(buf, coder);
    }
    int len = length();
    byte[] buf = StringUTF16.newBytesFor(len + olen);
    getBytes(buf, 0, UTF16);
    str.getBytes(buf, len, UTF16);
    return new String(buf, UTF16);
}