Строки

Строка – это текст: слово, фраза, предложение, любое сообщение, состоящее из символов.

В Java для работы с текстом используется тип String.

String name = "Иван";
String city = "Казань";
String message = "Привет, мир!";

Строки удобно использовать для имён, названий, сообщений, вводимых пользователем.

Основное

Строковая переменная объявляется так:

String имя = "Текст";

Примеры:

String hello = "Hello";
String empty = "";              // пустая строка
String digits = "12345";

Важно:

  • строка записывается в двойных кавычках: "Java";
  • тип String пишется с большой буквы;
  • строка может быть и пустой ("").

Создание строк

Основной способ – строковый литерал:

String s1 = "Java";
String s2 = "Строки в Java";

Можно собирать строку из чисел и других значений:

int age = 12;
double score = 4.5;

String info = "Возраст: " + age + ", балл: " + score;
// "Возраст: 12, балл: 4.5"

Есть и другие способы (через String.valueOf, конструкторы и т.п.), но в большинстве задач хватает литералов и конкатенации.

Длина строки и доступ к символам

У строки есть длина – количество символов.
Нумерация символов начинается с 0.

String s = "Java";

int n = s.length();    // 4
char c0 = s.charAt(0); // 'J'
char c1 = s.charAt(1); // 'a'

Полезно помнить:

  • последний символ имеет индекс length() - 1;
  • если обратиться к несуществующему индексу, будет ошибка выполнения.

Конкатенация (склейка) строк

Строки можно склеивать оператором +.
Числа и другие типы при этом автоматически превращаются в текст.

String firstName = "Иван";
String lastName  = "Петров";

String fullName = firstName + " " + lastName;
// "Иван Петров"

С числами:

int a = 7;
int b = 3;

String text = "a = " + a + ", b = " + b;
// "a = 7, b = 3"

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

Строки нельзя сравнивать по содержимому через ==.
Для сравнения текста используются методы equals и equalsIgnoreCase.

String s1 = "hello";
String s2 = "hello";
String s3 = "Hello";

boolean a = s1.equals(s2);            // true
boolean b = s1.equals(s3);            // false
boolean c = s1.equalsIgnoreCase(s3);  // true

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

Подстроки и поиск

Часть строки можно получить методом substring:

String s = "abcdef";

String t1 = s.substring(2);      // "cdef"
String t2 = s.substring(1, 4);   // "bcd"

Индексы считаются с 0, правый предел (endIndex) не входит.

Поиск подстроки:

String s = "abracadabra";

int p1 = s.indexOf("bra");  // 1
int p2 = s.indexOf("cad");  // 4
int p3 = s.indexOf("xyz");  // -1 (нет вхождения)

Разбиение строки

Метод split разбивает строку на части по разделителю и возвращает массив строк.

String line = "one two three";

String[] parts = line.split(" ");   // ["one", "two", "three"]

Частый случай – разделение по пробелу или запятой.

Чтение строк с клавиатуры

Через Scanner строки читают так:

Scanner in = new Scanner(System.in);

String word  = in.next();      // одно слово (до пробела)
String line  = in.nextLine();  // вся строка целиком

Если перед nextLine() уже читали числа (nextInt, nextDouble и т.п.), между ними часто нужна «промывка» строки:

int n = in.nextInt();
in.nextLine();                 // читаем остаток строки

String text = in.nextLine();   // теперь читаем настоящую строку

Типичные шаблоны

Подсчёт длины строки

String s = in.nextLine();
int n = s.length();

System.out.println(n);

Проверка префикса и суффикса

String s = in.nextLine();

if (s.startsWith("java")) {
    System.out.println("начинается с java");
}

if (s.endsWith(".txt")) {
    System.out.println("это текстовый файл");
}

Сравнение строк без учёта регистра

String answer = in.nextLine();

if (answer.equalsIgnoreCase("yes")) {
    System.out.println("ДА");
} else {
    System.out.println("НЕТ");
}

Что нужно запомнить

Строки в Java хранятся в типе String и записываются в двойных кавычках:

String s = "Привет";

Длину строки даёт метод length(), отдельный символ – charAt(i).

Для сравнения строк по содержимому используется equals / equalsIgnoreCase, а не оператор ==.

Строки удобно склеивать оператором +, при этом числа автоматически превращаются в текст.

Методы и операции контейнера string

Работа со строками в C++ во многом похожа на работу с vector.

Создать строку из 100 символов b:

string s(100, 'b');

Изменить символ по индексу:

s[i] = '1';

Длина строки:

s.size();

Добавить символ в конец:

s.push_back('a');

Удалить последний символ:

s.pop_back();

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

s = s1 + s2;

Добавление символа через +:

s = s + '!';

Последние две операции обычно медленнее, так как создают копии строк. Для добавления одного символа лучше использовать push_back.

Методы substr, find, rfind

В C++ есть удобные методы для подстрок и поиска.

Метод substr извлекает подстроку заданной длины с заданного индекса:

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string s;
    cin >> s;
    cout << s.substr(3, 2) << endl;
    return 0;
}

Для входа abcdefg результат: de.

Если второй параметр не указан, берётся суффикс до конца строки:

string s;
cin >> s;
cout << s.substr(3) << endl;

Для входа abcdefg результат: defg.

find возвращает индекс первого вхождения подстроки:

string s;
cin >> s;
cout << s.find("bcd") << endl;

Для входа abcdqwerbcd результат: 1.

Если подстроки нет, возвращается специальное большое значение (string::npos). В учебных примерах часто приводят к int, тогда получится -1:

string s;
cin >> s;
cout << (int)s.find("bcd") << endl;

Для входа aaaaaaa результат: -1.

rfind ищет последнее (самое правое) вхождение:

string s;
cin >> s;
cout << (int)s.rfind("bcd") << endl;

Для входа abcdqwerbcd результат: 8.

Количество вхождений подстроки в строку

Задача: найти, сколько раз строка ss встречается как подстрока в строке s.

Решение (с пересечениями):

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string s, ss;
    getline(cin, s);
    getline(cin, ss);
    int cnt = 0;
    int pos = s.find(ss);
    while (pos != -1){
        ++cnt;
        pos = s.find(ss, pos + 1);
    }
    cout << cnt << endl;
    return 0;
}

Для s = aaaaa, ss = aa ответ будет 4 (пересекающиеся вхождения считаются).

Если нужны только непересекающиеся вхождения:

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string s, ss;
    getline(cin, s);
    getline(cin, ss);
    int cnt = 0;
    int pos = s.find(ss);
    while (pos != -1){
        ++cnt;
        pos = s.find(ss, pos + ss.length());
    }
    cout << cnt << endl;
    return 0;
}

Разделение строки на слова

Задача: дана строка, нужно разделить её на слова.

Решение:

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main()
{
    string s;
    getline(cin, s);
    vector<string> words(1, "");
    for (auto c: s){
        if (c == ' '){
            words.push_back("");
        } else {
            words.back().push_back(c);
        }
    }
    for (auto word: words){
        cout << word << endl;
    }
    return 0;
}

Если разделитель другой, меняем условие:

if (c == ',')

Если разделителей несколько:

if (c == ' ' || c == ',')

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

Функция getline и лексикографический порядок

Строки в C++ хранятся в типе string:

string s1, s2;
cin >> s1 >> s2;

Если во входе Hello World!, то в s1 будет Hello, а в s2 — World!.

Для string нужно подключить библиотеку:

#include <string>

Часто удобнее читать строку целиком, включая пробелы:

string s;
getline(cin, s);

Лексикографический порядок: сравнение идёт слева направо до первого различающегося символа. Меньше та строка, у которой код этого символа меньше. Если одна строка является началом другой, то меньшая — более короткая.

Примеры:

  • digit < dinosaur, потому что g идёт раньше, чем n.
  • dig < digit, потому что dig — начало строки digit.

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

В C++ строки можно сравнивать лексикографически оператором <.

Программа, которая выводит меньшую из двух строк:

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string a, b;
    getline(cin, a);
    getline(cin, b);
    if (a < b){
        cout << a;
    } else {
        cout << b;
    }
    return 0;
}

Извлечение цифр из строки

Задача: дана строка. Нужно выделить все цифры из строки.

Например, для строки 123aba23 45 результат: 1232345.

Решение:

#include <iostream>
#include <string>
#include <cctype>
using namespace std;

int main()
{
    string s, d = "";
    getline(cin, s);
    for (auto c: s){
        if (isdigit(c)){
            d.push_back(c);
        }
    }
    cout << d;
    return 0;
}

По материалам:
М. Густокашин. Введение в программирование на языке C++. Сириус Курсы. Перейти к курсу.

В Python строки имеют тип str.

name = "Иван"
city = "Казань"
message = "Привет, мир!"

print(message)

Длина строки – len(s), символ по индексу – s[i]. Индексация начинается с 0.

s = "Java"
n = len(s)     # 4
c0 = s[0]      # 'J'

Склейка строк – +, а для удобного формата часто используют f‑строки:

age = 12
score = 4.5

info = f"Возраст: {age}, балл: {score}"
print(info)

Сравнение по содержимому делается через ==:

a = "hello"
b = "hello"

print(a == b)  # True

Подстроки обычно берут срезом, а поиск делают через find:

s = "abracadabra"

t = s[3:7]          # "acad"
p = s.find("cad")   # 4, если нет – -1

Разбиение строки по пробелам:

line = "one two three"
parts = line.split()
print(parts)  # ['one', 'two', 'three']

Тип строки

Java: String

C++: std::string

Python: str

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

Java: s1.equals(s2) (без учёта регистра: equalsIgnoreCase)

C++: a == b

Python: a == b

Длина строки

Java: s.length()

C++: s.size() (или s.length())

Python: len(s)

Символ по индексу

Java: s.charAt(i) возвращает char

C++: s[i] возвращает char

Python: s[i] возвращает строку длины 1

Подстрока

Java: s.substring(l, r) – правая граница r не входит

C++: s.substr(l, len) – второй параметр это длина

Python: s[l:r] – правая граница r не входит

Склейка строк

Java: оператор +. Если склеек много, обычно используют StringBuilder.

C++: + и +=.

Python: +. Если склеек много, обычно собирают части и соединяют через ''.join(parts).

Чтение строки целиком

Java: Scanner.nextLine()

C++: getline(cin, line)

Python: input()