Работа со строками в java: объявление и инициализация, объединение и добавление, как найти длину и сравнить

Введение в строки. Класс String

Последнее обновление: 31.10.2018

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

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

public static void main(String[] args) {
        
    String str1 = "Java";
    String str2 = new String(); // пустая строка
    String str3 = new String(new char[] {'h', 'e', 'l', 'l', 'o'});
    String str4 = new String(new char[]{'w', 'e', 'l', 'c', 'o', 'm', 'e'}, 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[] {'h', 'e', 'l', 'l', 'o'});
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

Самый простой способ объединить строки в Java – это использовать +. Это работает так:

String text1 = "Hello";

String text2 = "Jim";

System.out.println(text1 + " " + text2);

Однако это не очень эффективно, потому что каждый раз, когда вы пишете +, вы создаете новый объект String. По этой причине вы можете использовать StringBuilder или более старую поточно-ориентированную версию StringBuffer.

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" to");
sb.append(" you");
System.out.println(sb.toString());

Более того, поскольку append() возвращает ссылку на сам объект StringBuilder, мы можем написать что-то вроде этого с тем же эффектом:

StringBuilder sb = new StringBuilder();
sb.append("Hello")
.append(" to")
.append(" you");
System.out.println(sb.toString());

Подстрока Java: выбор частей строк

Чтобы получить часть строки, используйте метод substring.

String substring(int beginIndex, int endIndex)

Длина выбранной подстроки равна endIndex – startIndex.

Вот несколько примеров.

String text = "The quick brown fox";
// Everything from index 4 onwards
System.out.println(text.substring(4));
// Index 0 up to but not including index 3.
System.out.println(text.substring(0, 3));

Java Array String: объединение массивов строк

Удивительно, но в ядре Java нет способа объединения массивов строк, хотя такие методы существуют в различных библиотеках.

Вы всегда можете создать свои собственные. Следующий класс объявляет именно такой метод и использует его для соединения массива строк. Вы можете легко адаптировать это для работы с ArrayList или Vector или чем-то еще.

package caveofprogramming.aquarium;
package caveofprogramming.aquarium;

import java.util.*;

public class Test {
    public static String join(String[] strings, String glue) {
    
        StringBuilder sb = new StringBuilder();
        
        for(int i=0; i < strings.length; i++) {
            sb.append(strings);
            
            if(i < strings.length - 1) {
                sb.append(glue);
            }
        }
        
        return sb.toString();
    }
    
    public static void main(String [] args) {

        String texts[] = {"Hello", "to", "you"};
        System.out.println(join(texts, " "));
    }
}

Java String Split: разделение строк

Вы можете разбить строку на массив токенов, используя метод split (REGEX).

Давайте посмотрим на некоторые примеры.

Чтобы разделить пробелом (это также работает для вкладок):

String text = "The quick brown fox";
String text = "The quick brown fox";
        
// Split on whitespace
String [] tokens = text.split("\s+");
        
for(int i=0; i < tokens.length; i++) {
    System.out.println(tokens);
}

Разделим электронный адрес на части

String text = "[email protected]";

// Split on @ and .
// The double backslashes make this regular
// expression look more confusing than it is.
// We are escaping once for the sake of the
// regex, and again for the sake of Java.
String [] tokens = text.split("+");

for(int i=0; i < tokens.length; i++) {
    System.out.println(tokens);
}

Зачем нужен std::string?

Мы уже знаем, что строки C-style используют массивы типа char для хранения целой строки. Если вы попытаетесь что-либо сделать со строками C-style, то вы очень быстро обнаружите, что работать с ними трудно, запутаться легко, а проводить отладку сложно.

Строки C-style имеют много недостатков, в первую очередь связанных с тем, что вы должны самостоятельно управлять памятью. Например, если вы захотите поместить строку в буфер, то вам сначала нужно будет динамически выделить буфер правильной длины:

char *strHello = new char;

1	char*strHello=newchar7;

Не забудьте учесть дополнительный символ для нуль-терминатора! Затем вам нужно будет скопировать значение:

strcpy(strHello, «Hello!»);

1	strcpy(strHello,»Hello!»);

И здесь вам нельзя прогадать с длиной буфера, иначе произойдет ! И, конечно, поскольку строка выделяется динамически, то вы должны её еще и правильно удалить:

delete[] strHello;

1	deletestrHello;

Не забудьте использовать форму оператора delete, которая работает с массивами, а не обычную форму оператора delete.

Кроме того, многие из интуитивно понятных операторов, которые предоставляет язык C++ для работы с числами, такие как , , , , , и попросту не работают со строками C-style. Иногда они могут работать без ошибок со стороны компилятора, но результат будет неверным. Например, сравнение двух строк C-style с использованием оператора на самом деле выполнит сравнение указателей, а не строк. Присваивание одной строки C-style другой строке C-style с использованием оператора будет работать, но выполняться будет копирование указателя (), что не всегда то, что нам нужно. Такие вещи могут легко привести к ошибкам и сбоям в программе, а разбираться с ними не так уж и легко (относительно)!

Суть в том, что работая со строками C-style, вам нужно помнить множество придирчивых правил о том, что делать безопасно, а что — нет; запоминать много функций, таких как strcat() и strcmp(), чтобы использовать их вместо интуитивных операторов; а также самостоятельно выполнять управление памятью.

К счастью, язык C++ предоставляет гораздо лучший способ для работы со строками: классы std::string и std::wstring

Используя такие концепции С++, как конструкторы, деструкторы и перегрузку операторов, std::string позволяет создавать и манипулировать строками в интуитивно понятной форме и, что не менее важно, выполнять это безопасно! Никакого управления памятью, запоминания странных названий функций и значительно меньшая вероятность возникновения ошибок/сбоев

Разделение

Класс Java String содержит метод split(), который можно использовать для разделения String на массив объектов String:

String   source = "A man drove with a car.";
String[] occurrences = source.split("a");

После выполнения этого кода Java массив вхождений будет содержать экземпляры String:

"A m"
"n drove with "
" c"
"r."

Исходная строка была разделена на символы a. Возвращенные строки не содержат символов a. Символы a считаются разделителями для деления строки, а разделители не возвращаются в результирующий массив строк.

Параметр, передаваемый методу split(), на самом деле является регулярным выражением Java, которые могут быть довольно сложными. Приведенное выше соответствует всем символам, даже буквам нижнего регистра.

Метод String split() существует в версии, которая принимает ограничение в качестве второго параметра – limit:

String   source = "A man drove with a car.";
int      limit  = 2;
String[] occurrences = source.split("a", limit);

Параметр limit устанавливает максимальное количество элементов, которое может быть в возвращаемом массиве. Если в строке больше совпадений с регулярным выражением, чем заданный лимит, то массив будет содержать совпадения с лимитом – 1, а последним элементом будет остаток строки из последнего среза – 1 совпадением. Итак, в приведенном выше примере возвращаемый массив будет содержать эти две строки:

"A m"
"n drove with a car."

Первая строка соответствует регулярному выражению. Вторая – это остальная часть строки после первого куска.

Выполнение примера с ограничением 3 вместо 2 приведет к тому, что эти строки будут возвращены в результирующий массив String:

"A m"
"n drove with "
" car."

Обратите внимание, что последняя строка по-прежнему содержит символ в середине. Это потому, что эта строка представляет остаток строки после последнего совпадения (a после ‘n водил с’)

Выполнение приведенного выше примера с пределом 4 или выше приведет к тому, что будут возвращены только строки Split, поскольку в String есть только 4 совпадения с регулярным выражением a.

5 ответов

Лучший ответ

Простое решение без регулярных выражений: найдите индекс первой буквы и разбейте строку в этой позиции.

Дает тебе:

Bentaye
5 Мар 2018 в 14:42

Santosh Thapa
5 Мар 2018 в 09:35

Вы можете использовать регулярные выражения:

thibsc
5 Мар 2018 в 09:37

Ниже у вас есть мое предложение. Работает правильно для упомянутых тестовых данных

( 1a, 12a, 1ab, 12ab, 123a, 123abc )

Решение:

Schakal
5 Мар 2018 в 10:02

Объяснение :

целое регулярное выражение

— граница слова

— цифра от одного до трех раз

— символы от до от одного до трех раз

— это положительный взгляд, вы говорите, что после этих букв вы хотите присутствовать или границы слова, но вы не хотите, чтобы они присутствовали в соответствующей группе (вызывается с {{ Х2 } } )

— совпадающие группы в скобках — в моем регулярном выражении я использовал две совпадающие группы: # 1: # 2: (они печатаются с и {{ Х4 } } )

Если вы еще не очень знакомы с синтаксисом регулярных выражений, возможно, вы захотите взглянуть на документацию Java API по адресу класс Pattern. Существует список доступных вариантов использования регулярных выражений. Стоит попробовать регулярные выражения, так как это может сэкономить много времени при работе со строками в будущем.

Редактировать:

На самом деле это регулярное выражение может быть изменено на:

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

Przemysław Moskal
5 Мар 2018 в 11:07

Объединение строк

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

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

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

String str4 = "Год " + 2015;

Еще один метод объединения — метод join() позволяет
объединить строки с учетом разделителя. Например, две строки

String str1 = "Java";
String str2 = "Hello";

будут сливаться в одно слово «HelloJava», если их
объединить с помощью оператора +:

String str3 = str1 + str2;

но если мы хотим, чтобы две подстроки при
соединении были разделены пробелом, то можно воспользоваться методом join() следующим
образом:

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

В общем случае вместо пробела здесь
можно ставить любой разделитель в виде строки.

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

Сортировка объектов

Показанный ранее пример Arrays.sort() работает только для массивов примитивных типов данных, которые имеют порядок:

естественный;
числовой;
символьный в таблице ASCII (двоичное число, представляющее символ).

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

Вот первый класс для объектов, которые мы хотим отсортировать:

private static class Employee{
    public String name;
    public int    employeeId;

    public Employee(String name, int employeeId){
        this.name       = name;
        this.employeeId = employeeId;
    }
}

Класс Employee – это простая модель сотрудника, у которого есть имя и идентификатор. Вы можете отсортировать массив объектов Employee по имени или по идентификатору сотрудника.

Вот первый пример сортировки массива объектов Employee по их имени с помощью метода Arrays.sort():

Employee[] employeeArray = new Employee;

employeeArray = new Employee("Xander", 1);
employeeArray = new Employee("John"  , 3);
employeeArray = new Employee("Anna"  , 2);

java.util.Arrays.sort(employeeArray, new Comparator() {
    @Override
    public int compare(Employee e1, Employee e2) {
        return e1.name.compareTo(e2.name);
    }
});


for(int i=0; i < employeeArray.length; i++) {
    System.out.println(employeeArray.name);
}

Сначала объявляется массив.
Три объекта Employee создаются и вставляются в массив.
Метод Arrays.sort() вызывается для сортировки массива. В качестве параметра передаем массив employee и реализацию Comparator, которая может определять порядок объектов Employee. Это создает анонимную реализацию интерфейса Comparator.

В примере важно уловить реализацию метода compare() анонимной внутренней реализации интерфейса Comparator. Этот метод возвращает:

положительное число, если первый объект «больше»(позже в порядке сортировки), чем второй объект;
0 – они «равны»(в порядке сортировки);
отрицательное число, если первый объект «меньше» (ранее в порядке сортировки), чем второй объект.

В приведенном выше примере мы просто вызываем метод String.compare(), который выполняет для нас сравнение (сравнивает имена сотрудников).

После сортировки массива мы перебираем его и выводим имена сотрудников. Вывод:

Anna
John
Xander

Обратите внимание, как порядок был изменен по сравнению с порядком, в котором они были первоначально вставлены в массив. Сортировка объектов Employee по их идентификатору сотрудника на основании предыдущего примера с измененной реализацией метода compare() анонимной реализации интерфейса Comparator:

Сортировка объектов Employee по их идентификатору сотрудника на основании предыдущего примера с измененной реализацией метода compare() анонимной реализации интерфейса Comparator:

Employee[] employeeArray = new Employee;

employeeArray = new Employee("Xander", 1);
employeeArray = new Employee("John"  , 3);
employeeArray = new Employee("Anna"  , 2);

java.util.Arrays.sort(employeeArray, new Comparator() {
    @Override
    public int compare(Employee e1, Employee e2) {
        return e1.employeeId - e2.employeeId;
    }
});

for(int i=0; i < employeeArray.length; i++) {
    System.out.println(employeeArray.name);
}

Вывод:

Xander
Anna
John

Чтобы сравнить объекты Employee в массиве сначала по их имени, а если оно совпадает, то по их идентификатору сотрудника, реализация compare():

java.util.Arrays.sort(employeeArray, new Comparator() {
    @Override
    public int compare(Employee e1, Employee e2) {
        int nameDiff = e1.name.compareTo(e2.name);
        if(nameDiff != 0) { return nameDiff; }
    
        return e1.employeeId - e2.employeeId;
    }
});

Пример StringTokenizer (устаревший)

В старые времена разработчики Java использовали класс StringTokenizer для разделения строки.

P.S То Строка#разделить() доступен начиная с JDK 1.4.

Примечание Этот является устаревшим классом, сохраненным по соображениям совместимости; использование не рекомендуется! Пожалуйста, обновите код до .

package com.mkyong;

import java.util.StringTokenizer;

public class SplitString8 {

    public static void main(String[] args) {

        String test = "abc.def.123";
        // the delimiter is a string, not regex, no need to escape the dot
        StringTokenizer token = new StringTokenizer(test, ".");

        while (token.hasMoreTokens()) {
            System.out.println(token.nextToken());
        }

    }

}

Выход

abc
def
123

Определение Нашего Примера

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

String countries = "Russia,Germany,England,France,Italy";
String ranks = "1,2,3,4,5,6,7";

И на протяжении всего этого урока мы преобразуем приведенные выше строки в списки строк и целых чисел, которые мы будем хранить в:

List convertedCountriesList;
List convertedRankList;

Наконец, после того, как мы выполним наши преобразования, ожидаемые результаты будут:

List expectedCountriesList = Arrays.asList("Russia", "Germany", "England", "France", "Italy");
List expectedRanksList = Arrays.asList(1, 2, 3, 4, 5, 6, 7);

Использование стрингутилов

Библиотеки Apache Commons добавляют некоторые полезные методы для управления основными типами Java. Apache Commons Lang предоставляет множество вспомогательных утилит для API java.lang, в первую очередь String методы манипулирования.

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

assertEquals("United States of America", 
  StringUtils.substringBetween(text, "(", ")"));

Существует упрощенная версия этого метода в случае, если подстрока вложена между двумя экземплярами одной и той же строки

substringBetween(String str, String tag)

Метод substringAfter из того же класса получает подстроку после первого вхождения разделителя.

Разделитель не возвращается:

assertEquals("the USA (United States of America).", 
  StringUtils.substringAfter(text, "living in "));

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

Разделитель не возвращается:

assertEquals("Julia Evans", 
  StringUtils.substringBefore(text, " was born"));

Вы можете ознакомиться с этим руководством, чтобы узнать больше об обработке String с помощью API Apache Commons Lang.

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

Для извлечения
символов по индексу в классе String определен метод

char charAt(int
index)

Он принимает
индекс, по которому надо получить символов, и возвращает извлеченный символ:

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

(здесь как и в
массивах первый индекс равен 0).

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

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 charend - start;
str.getChars(start, end, dst, );
System.out.println(dst); // world

Строковые функции в Python

Python предоставляет различные встроенные функции, которые используются для работы со строками.

Метод	Описание
	Выводит первый символ строки заглавными буквами. Эта функция устарела в python3
	Возвращает версию строки, пригодную для сравнений без регистра.
	Возвращает строку, заполненную пробелами, причем исходная строка центрируется с равным количеством пробелов слева и справа.
	Подсчитывает количество вхождений подстроки в строку между начальным и конечным индексом.
	Декодирует строку.
	Кодирование строки. Кодировка по умолчанию — .
	Возвращает булево значение, если строка заканчивается заданным суффиксом между begin и end.
	Определяет табуляцию в строке до нескольких пробелов. По умолчанию количество пробела равно 8.
	Возвращает значение индекса строки, в которой найдена подстрока между начальным и конечным индексами.
	Возвращает форматированную версию строки, используя переданное значение.
	Выбрасывает исключение, если строка не найдена. Работает так же, как и метод .
	Возвращает true, если символы в строке являются буквенно-цифровыми, т.е. алфавитами или цифрами, и в ней есть хотя бы один символ. В противном случае возвращается .
	Возвращает , если все символы являются алфавитными и есть хотя бы один символ, иначе .
	Возвращает , если все символы строки являются десятичными.
	Возвращает , если все символы являются цифрами и есть хотя бы один символ, иначе .
	Возвращает , если строка является действительным идентификатором.
	Возвращает , если символы строки находятся в нижнем регистре, иначе .
	Возвращает , если строка содержит только числовые символы.
	Возвращает , если все символы строки являются печатными или строка пустая, в противном случае возвращает .
	Возвращает , если символы строки находятся в верхнем регистре, иначе .
	Возвращает , если символы строки являются пробелами, иначе .
	Возвращает , если строка имеет правильный заголовок, и в противном случае. Заголовок строки — это строка, в которой первый символ в верхнем регистре, а остальные символы в нижнем регистре.
	Он объединяет строковое представление заданной последовательности.
	Возвращает длину строки.
	Возвращает строки, заполненные пробелами, с исходной строкой, выровненной по левому краю до заданной ширины.
	Он преобразует все символы строки в нижний регистр.
	Удаляет все пробелы в строке, а также может быть использован для удаления определенного символа из строки.
	Он ищет разделитель в строке и возвращает часть перед ним, сам разделитель и часть после него. Если разделитель не найден, возвращается кортеж в виде переданной строка и двух пустых строк.
	Возвращает таблицу перевода для использования в функции .
	Заменяет старую последовательность символов на новую. Если задано значение , то заменяются все вхождения.
	Похож на , но обходит строку в обратном направлении.
	Это то же самое, что и , но обходит строку в обратном направлении.
	Возвращает строку с пробелами, исходная строка которой выровнена по правому краю на указанное количество символов.
	Он удаляет все пробелы в строке, а также может быть использован для удаления определенного символа.
	Он аналогичен функции , но обрабатывает строку в обратном направлении. Возвращает список слов в строке. Если разделитель не указан, то строка разделяется в соответствии с пробелами.
	Разделяет строку в соответствии с разделителем . Строка разделяется по пробелу, если разделитель не указан. Возвращает список подстрок, скомпонованных с разделителем.
	Он возвращает список строк в каждой строке с удаленной строкой.
	Возвращает булево значение, если строка начинается с заданной строки между и .
	Он используется для выполнения функций и над строкой.
	Он инвертирует регистр всех символов в строке.
	Он используется для преобразования строки в заглавный регистр, т.е. строка будет преобразована в .
	Он переводит строку в соответствии с таблицей перевода, переданной в функцию .
	Он преобразует все символы строки в верхний регистр.
	Возвращает исходную строку, дополненную нулями минимального количества символов (параметр ); предназначена для чисел, сохраняет любой заданный знак (за вычетом одного нуля).
	Ищет последнее вхождение указанной строки и разбивает строку на кортеж, содержащий три элемента (часть перед указанной строкой, саму строку и часть после нее).

Описание

Метод возвращает новый массив.

Если разделитель найден, он удаляется из строки, а подстроки возвращаются в массиве. Если разделитель опущен, массив будет содержать только один элемент, состоящий из всей строки. Если разделитель является пустой строкой, строка будет преобразована в массив символов.

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

null

Alias

String is an alias for , or depending on a compiler setting.

If compiler directive {$H} or {$LongStrings} has been used with an «on» parameter ( {$H+} or {$LongStrings ON} ), then a String type is the same as an AnsiString type, if not ( {$H-} or {$LongStrings OFF} ), it is a ShortString type. What String is an alias for can also be set by the -Sh command line option. FPC also supports {$mode delphiunicode} for Delphi compatible UTF16 support.

NOTE: The {$mode} compiler directive will also set the String alias. After the compiler mode is set to FPC (the default), ObjFPC, MacPAS or TP, String will be an alias for ShortString. After the compiler mode is set to Delphi, String will be an alias for AnsiString. So the String alias setting should be made following the compiler mode setting to prevent it from being overridden:

{$H+}            // String is an alias for AnsiString
{$mode ObjFPC}   // also affects String alias - String is now an alias for ShortString
{$H+}            // String is now an alias for AnsiString

A String variable declared with a length specifier will always be a ShortString regardless of the compiler setting for String alias.

{$H+}            // String is an alias for AnsiString
var
   name  String25; // name is a ShortString variable since a length specification overrides the alias setting

Note that all types of longstring are managed types, whereas ShortStrings are not managed types: they have no reference count.

Введите строку с помощью пользовательских методов

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

assertEquals("    123456", padLeftZeros("123456", 10));
assertEquals("0000123456", padLeftZeros("123456", 10));

2.1. Использование StringBuilder

Мы можем достичь этого с помощью StringBuilder и некоторой процедурной логики:

public String padLeftZeros(String inputString, int length) {
    if (inputString.length() >= length) {
        return inputString;
    }
    StringBuilder sb = new StringBuilder();
    while (sb.length() < length - inputString.length()) {
        sb.append('0');
    }
    sb.append(inputString);

    return sb.toString();
}

Здесь мы видим, что если длина исходного текста равна или больше желаемой длины, мы возвращаем его неизмененную версию. В противном случае мы создадим новую строку , , начинающуюся с пробелов, и добавим исходную.

Конечно, если бы мы хотели pad с другим символом, мы могли бы просто использовать его вместо .

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

2.2. Использование подстроки

Другой способ сделать левое заполнение – создать Строку нужной длины, содержащую только символы заполнения, а затем использовать метод substring () :

StringBuilder sb = new StringBuilder();
for (int i = 0; i < length; i++) {
    sb.append(' ');
}

return sb.substring(inputString.length()) + inputString;

2.3. Использование String.format

И, наконец, начиная с Java 5, мы можем использовать String .format() :

return String.format("%1$" + length + "s", inputString).replace(' ', '0');

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

Для правильной площадки нам просто нужно использовать другой флаг: %1$-