Как сложить две строки java

Чтобы сравнить на равенство две строки, необходимо воспользоваться методом equals() или Objects.equals() (начиная с Java 7):

import java.util.Objects; public class StringExample5 < public static void main(String[] args) < String str1 = "Hello"; String str2 = "Hi"; System.out.println(str1.equals(str2)); System.out.println(Objects.equals(str1, str2)); >>

Длина строки определяется с помощью метода length() :

public class StringExample6 < public static void main(String[] args) < String str = "Hello"; System.out.println("Длина строки: " + str.length()); >>

Презентацию с видео можно скачать на Patreon .

Как сложить две строки java

Для соединения строк можно использовать операцию сложения ("+"):

String str1 = "Java"; String str2 = "Hello"; String str3 = str1 + " " + str2; System.out.println(str3); // Hello Java

При этом если в операции сложения строк используется нестроковый объект, например, число, то этот объект преобразуется к строке:

String str3 = "Год " + 2015;

Фактически же при сложении строк с нестроковыми объектами будет вызываться метод valueOf() класса String. Данный метод имеет множество перегрузок и преобразует практически все типы данных к строке. Для преобразования объектов различных классов метод valueOf вызывает метод toString() этих классов.

Другой способ объединения строк представляет метод concat() :

String str1 = "Java"; String str2 = "Hello"; str2 = str2.concat(str1); // HelloJava

Метод concat() принимает строку, с которой надо объединить вызывающую строку, и возвращает соединенную строку.

Еще один метод объединения - метод join() позволяет объединить строки с учетом разделителя. Например, выше две строки сливались в одно слово "HelloJava", но в идеале мы бы хотели, чтобы две подстроки были разделены пробелом. И для этого используем метод join() :

String str1 = "Java"; String str2 = "Hello"; String str3 = String.join(" ", str2, str1); // Hello Java

Метод join является статическим. Первым параметром идет разделитель, которым будут разделяться подстроки в общей строке, а все последующие параметры передают через запятую произвольный набор объединяемых подстрок - в данном случае две строки, хотя их может быть и больше

Извлечение символов и подстрок

Для извлечения символов по индексу в классе String определен метод char charAt(int index) . Он принимает индекс, по которому надо получить символов, и возвращает извлеченный символ:

String str = "Java"; char c = str.charAt(2); System.out.println(c); // v

Как и в массивах индексация начинается с нуля.

Если надо извлечь сразу группу символов или подстроку, то можно использовать метод getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) . Он принимает следующие параметры:

• srcBegin : индекс в строке, с которого начинается извлечение символов
• srcEnd : индекс в строке, до которого идет извлечение символов
• dst : массив символов, в который будут извлекаться символы
• dstBegin : индекс в массиве dst, с которого надо добавлять извлеченные из строки символы

String str = "Hello world!"; int start = 6; int end = 11; char[] dst=new char[end - start]; str.getChars(start, end, dst, 0); System.out.println(dst); // world

Сравнение строк

Для сравнения строк используются методы equals() (с учетом регистра) и equalsIgnoreCase() (без учета регистра). Оба метода в качестве параметра принимают строку, с которой надо сравнить:

String str1 = "Hello"; String str2 = "hello"; System.out.println(str1.equals(str2)); // false System.out.println(str1.equalsIgnoreCase(str2)); // true

В отличие от сравнения числовых и других данных примитивных типов для строк не применяется знак равенства ==. Вместо него надо использовать метод equals() .

Еще один специальный метод regionMatches() сравнивает отдельные подстроки в рамках двух строк. Он имеет следующие формы:

boolean regionMatches(int toffset, String other, int oofset, int len) boolean regionMatches(boolean ignoreCase, int toffset, String other, int oofset, int len)

Метод принимает следующие параметры:

• ignoreCase : надо ли игнорировать регистр символов при сравнении. Если значение true , регистр игнорируется
• toffset : начальный индекс в вызывающей строке, с которого начнется сравнение
• other : строка, с которой сравнивается вызывающая
• oofset : начальный индекс в сравниваемой строке, с которого начнется сравнение
• len : количество сравниваемых символов в обеих строках

String str1 = "Hello world"; String str2 = "I work"; boolean result = str1.regionMatches(6, str2, 2, 3); System.out.println(result); // true

В данном случае метод сравнивает 3 символа с 6-го индекса первой строки ("wor") и 3 символа со 2-го индекса второй строки ("wor"). Так как эти подстроки одинаковы, то возвращается true .

И еще одна пара методов int compareTo(String str) и int compareToIgnoreCase(String str) также позволяют сравнить две строки, но при этом они также позволяют узнать больше ли одна строка, чем другая или нет. Если возвращаемое значение больше 0, то первая строка больше второй, если меньше нуля, то, наоборот, вторая больше первой. Если строки равны, то возвращается 0.

Для определения больше или меньше одна строка, чем другая, используется лексикографический порядок. То есть, например, строка "A" меньше, чем строка "B", так как символ 'A' в алфавите стоит перед символом 'B'. Если первые символы строк равны, то в расчет берутся следующие символы. Например:

String str1 = "hello"; String str2 = "world"; String str3 = "hell"; System.out.println(str1.compareTo(str2)); // -15 - str1 меньше чем strt2 System.out.println(str1.compareTo(str3)); // 1 - str1 больше чем str3

Поиск в строке

Метод indexOf() находит индекс первого вхождения подстроки в строку, а метод lastIndexOf() - индекс последнего вхождения. Если подстрока не будет найдена, то оба метода возвращают -1:

String str = "Hello world"; int index1 = str.indexOf('l'); // 2 int index2 = str.indexOf("wo"); //6 int index3 = str.lastIndexOf('l'); //9

Метод startsWith() позволяют определить начинается ли строка с определенной подстроки, а метод endsWith() позволяет определить заканчивается строка на определенную подстроку:

String str = "myfile.exe"; boolean start = str.startsWith("my"); //true boolean end = str.endsWith("exe"); //true

Замена в строке

Метод replace() позволяет заменить в строке одну последовательность символов на другую:

String str = "Hello world"; String replStr1 = str.replace('l', 'd'); // Heddo wordd String replStr2 = str.replace("Hello", "Bye"); // Bye world

Обрезка строки

Метод trim() позволяет удалить начальные и конечные пробелы:

String str = " hello world "; str = str.trim(); // hello world

Метод substring() возвращает подстроку, начиная с определенного индекса до конца или до определенного индекса:

String str = "Hello world"; String substr1 = str.substring(6); // world String substr2 = str.substring(3,5); //lo

Изменение регистра

Метод toLowerCase() переводит все символы строки в нижний регистр, а метод toUpperCase() - в верхний:

String str = "Hello World"; System.out.println(str.toLowerCase()); // hello world System.out.println(str.toUpperCase()); // HELLO WORLD

Split

Метод split() позволяет разбить строку на подстроки по определенному разделителю. Разделитель - какой-нибудь символ или набор символов передается в качестве параметра в метод. Например, разобьем текст на отдельные слова:

String text = "FIFA will never regret it"; String[] words = text.split(" "); for(String word : words)

В данном случае строка будет разделяться по пробелу. Консольный вывод:

FIFA will never regret it

Работа со строками

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

Для создания новой строки мы можем использовать один из конструкторов класса String, либо напрямую присвоить строку в двойных кавычках:

public static void main(String[] args) < String str1 = "Java"; String str2 = new String(); // пустая строка String str3 = new String(new char[] ); String str4 = new String(new char[], 3, 4);//3 -начальный индекс, 4 -кол-во символов System.out.println(str1); // Java System.out.println(str2); // System.out.println(str3); // hello System.out.println(str4); // come >

При работе со строками важно понимать, что объект String является неизменяемым ( immutable ). То есть при любых операциях над строкой, которые изменяют эту строку, фактически будет создаваться новая строка.

Поскольку строка рассматривается как набор символов, то мы можем применить метод length() для нахождения длины строки или длины набора символов:

String str1 = "Java"; System.out.println(str1.length()); // 4

А с помощью метода toCharArray() можно обратно преобразовать строку в массив символов:

String str1 = new String(new char[] ); char[] helloArray = str1.toCharArray();

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

String s = ""; // пустая строка if(s.length() == 0) System.out.println("String is empty");

В этом случае длина строки, возвращаемая методом length(), равна 0.

Класс String имеет специальный метод, который позволяет проверить строку на пустоту - isEmpty() . Если строка пуста, он возвращает true:

String s = ""; // пустая строка if(s.isEmpty()) System.out.println("String is empty");

Переменная String может не указывать на какой-либо объект и иметь значение null :

String s = null; // строка не указывает на объект if(s == null) System.out.println("String is null");

Значение null не эквивалентно пустой строке. Например, в следующем случае мы столкнемся с ошибкой выполнения:

String s = null; // строка не указывает на объект if(s.length()==0) System.out.println("String is empty"); // ! Ошибка

Так как переменная не указывает ни на какой объект String, то соответственно мы не можем обращаться к методам объекта String. Чтобы избежать подобных ошибок, можно предварительно проверять строку на null:

String s = null; // строка не указывает на объект if(s==null || s.length()==0) System.out.println("String is empty");

Основные методы класса String

Основные операции со строками раскрывается через методы класса String, среди которых можно выделить следующие:

• concat() : объединяет строки
• valueOf() : преобразует объект в строковый вид
• join() : соединяет строки с учетом разделителя
• сompareTo() : сравнивает две строки
• charAt() : возвращает символ строки по индексу
• getChars() : возвращает группу символов
• equals() : сравнивает строки с учетом регистра
• equalsIgnoreCase() : сравнивает строки без учета регистра
• regionMatches() : сравнивает подстроки в строках
• indexOf() : находит индекс первого вхождения подстроки в строку
• lastIndexOf() : находит индекс последнего вхождения подстроки в строку
• startsWith() : определяет, начинается ли строка с подстроки
• endsWith() : определяет, заканчивается ли строка на определенную подстроку
• replace() : заменяет в строке одну подстроку на другую
• trim() : удаляет начальные и конечные пробелы
• substring() : возвращает подстроку, начиная с определенного индекса до конца или до определенного индекса
• toLowerCase() : переводит все символы строки в нижний регистр
• toUpperCase() : переводит все символы строки в верхний регистр

Разберем работу этих методов.

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

Или вы могли бы использовать string.Format Для получения более подробной информации о string.formater взглянуть на Formatter документации.

Ota 19 июль 2014, в 12:12

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

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

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

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

Bozho 20 сен. 2010, в 17:33
Поделиться

@Erick Эрик Робертсон, ты не прав. Перечитайте Javadoc из java.lang.String . Использование + неэффективно внутри цикла. В противном случае компилятор использует StringBuilder

Bozho 20 сен. 2010, в 17:48
@Erick: ты путаешь + с += .
BalusC 20 сен. 2010, в 17:48

Вау, это ново для меня. Так было не всегда. Я перестану явно использовать StringBuilder сейчас, когда смогу сделать то же самое с последовательностью + . Однако я все равно буду использовать его при объединении строк в несколько строк, например, когда строки условно добавляются и т. Д. Спасибо!

Erick Robertson 20 сен. 2010, в 18:21
Показать ещё 1 комментарий

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

• [simple] Используйте оператор + (конкатенация строк). "ваш номер" + theNumber + "!" (как указано в другом месте).
• [менее простой]: используйте 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"); 

Изменить: начиная с java 5 оператор конкатенации строк транслируется в вызовы StringBuilder компилятором. Из-за этого оба метода выше равны. Предостережение. Пример 1 ниже генерирует несколько экземпляров StringBuilder и менее эффективен, чем пример 2 ниже

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

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

DwB 20 сен. 2010, в 19:24
Поделиться
JavaC преобразует «+» для использования StringBuilders, см. Stackoverflow.com/questions/1532461/…
ArtB 20 сен. 2010, в 18:20

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

GregD 30 авг. 2013, в 02:25

Не рекомендуется гадать, как компилятор переводит код. Но хорошо известно, что компиляторы java, начиная с java 5, преобразуют строки concats в вызовы StringBuilder, что делает мое утверждение выше предположения.

DwB 22 янв. 2014, в 15:19
Показать ещё 1 комментарий

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(); // System.out.println(joined2); 

Andrey 10 апр. 2017, в 09:25
Поделиться

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

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

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

• В случае объекта значение String.valueOf(obj) , соответствующее String " null ", если obj null в противном случае значение obj.toString() .
• В случае примитивного типа эквивалент String.valueOf() .

Пример с объектом 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 , потому что его гораздо легче читать, поэтому его гораздо проще поддерживать.