Подробно про substring в 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 = "someone@nowhere.com";

// 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);
}

substring(int beginIndex, int endIndex)

Этот метод вернет новый объект String, содержащий подстроку данной строки от указанного startIndex до endIndex. И получит часть String, начиная с данного beginIndex и до указанного endIndex.

public String substring(int beginIndex, int endIndex)

где beginIndex — индекс, с которого нужно начать извлечение возвращаемой подстроки. (включительно) endIndex — индекс, с которого нужно закончить извлечение возвращаемой подстроки. (эксклюзив)

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

public class SubstringTest {  
   public static void main(String[] args) {
      String testString = "ABCDEFGHIJ";
      System.out.println(testString.substring(0,5));
      System.out.println(testString.substring(1,5));
      System.out.println(testString.substring(2,5));
      System.out.println(testString.substring(0,6));
      System.out.println(testString.substring(1,6));
      System.out.println(testString.substring(2,6));
      System.out.println(testString.substring(0,7));
      System.out.println(testString.substring(1,7));
      System.out.println(testString.substring(2,7));
   }
}

Вывод

ABCDE
BCDE
CDE
ABCDEF
BCDEF
CDEF
ABCDEFG
BCDEFG
CDEFG

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

import java.util.Scanner;
public class PrintAllSubstring {  
   public static void main(String[] args) {
      System.out.println("Enter a string:");
      Scanner in = new Scanner(System.in);
      String inputString = in.nextLine();
      for (int beginIndex = 0; beginIndex < inputString.length(); beginIndex++) {
         for (int endIndex = beginIndex + 1; endIndex <= inputString.length(); endIndex++) {
            System.out.println(inputString.substring(beginIndex, endIndex));
         }
      }
   }
}

И вот результат, предполагающий, что была введена строка wxyz.

Enter a string:
wxyz
w
wx
wxy
wxyz
x
xy
xyz
y
yz
z

Вот пример того, как получить середину строки с помощью метода substring в алгоритме.

public class MiddleStrTest {
   public static void main(String[] args) {
      System.out.println("A       --> " + getMiddleString("A"));
      System.out.println("AB      --> " + getMiddleString("AB"));
      System.out.println("ABC     --> " + getMiddleString("ABC"));
      System.out.println("ABCD    --> " + getMiddleString("ABCD"));
      System.out.println("ABCDE   --> " + getMiddleString("ABCDE"));
      System.out.println("ABCDEF  --> " + getMiddleString("ABCDEF"));
      System.out.println("ABCDEFG --> " + getMiddleString("ABCDEFG"));
   }
   private static String getMiddleString(String str) {
      if (str.length() <= 2) {
         return str;
      }
      int beginIndex = (str.length() - 1) / 2;
      int endIndex = beginIndex + 2 - (str.length() % 2);
      return str.substring(beginIndex, endIndex);
   }
}

Вывод

A       --> A
AB      --> AB
ABC     --> B
ABCD    --> BC
ABCDE   --> C
ABCDEF  --> CD
ABCDEFG --> D

Вот пример программы, которая перевернет строку.

public class ReverseTest {
   public static void main(String[] args) {
      System.out.println(reverse("ABCDEFG"));
   }
   private static String reverse(String str) {
      if (str.length() <= 1) {
         return str;
      }
      return reverse(str.substring(1)) + str.substring(0, 1);
   }
}

Это выведет обратную строку ABCDEFG: Вот пример программы, которая проверит, является ли строка палиндромом или нет.

public class PalTest {
   public static void main(String[] args) {
      System.out.println(palindrome("ABCBA"));
      System.out.println(palindrome("ABCCBA"));
      System.out.println(palindrome("ABCCXA"));
      System.out.println(palindrome("ABCDEFG"));
   }
   private static boolean palindrome(String str) {
      if (str.length() <= 1) {
         return true;
      }
      String first = str.substring(0, 1);
      String last = str.substring(str.length() - 1);
      return first.equals(last)
            && palindrome(str.substring(1, str.length() - 1));
   }
}

Вывод

true
true
false
false

Оцени статью

Оценить

Средняя оценка / 5. Количество голосов:

Видим, что вы не нашли ответ на свой вопрос.

Помогите улучшить статью.

Спасибо за ваши отзыв!

Конвертировать с использованием StringBuffer или StringBuilder

StringBuilder и StringBuffer — это классы, используемые для объединения нескольких значений в одну строку. StringBuffer является потокобезопасным, но медленным, тогда как StringBuilder не является поточно-ориентированным, но работает быстрее.

Пример 1

class Method5
{
  public static void main(String args[]) 
  { 
    int number1 = -1234;
    StringBuilder sb = new StringBuilder(); 
    sb.append(number1); 
    String str1 = sb.toString(); 
    System.out.println("With StringBuilder method: string = " + str1); 
    StringBuffer SB = new StringBuffer(); 
    SB.append(number1); 
    String str2 = SB.toString(); 
    System.out.println("With StringBuffer method: string = " + str2); 
  } 
}

Вывод

With StringBuilder method: string = -1234
With StringBuffer method: string = -1234

Объект StringBuilder представляет объект String, который можно изменять и обрабатывать как массив с последовательностью символов. Чтобы добавить новый аргумент в конец строки, экземпляр StringBuilder реализует метод append().

Пример 2

class Method6
{
  public static void main(String args[]) 
  { 
	String str1 = new StringBuilder().append(1234).toString(); 
    System.out.println("With StringBuilder method: string = " + str1); 
    String str2 = new StringBuffer().append(1234).toString(); 
    System.out.println("With StringBuffer method: string = " + str2); 
  } 
}

Вывод

With StringBuilder method: string = -1234
With StringBuffer method: string = -1234

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

Поиск с помощью indexOf()

Вы можете искать подстроки в Strings, используя метод indexOf():

String string1 = "Hello World";

int index = string1.indexOf("World");

Индексная переменная будет содержать значение 6 после выполнения этого кода. Метод indexOf() возвращает индекс, в котором находится первый символ в первой соответствующей подстроке. В этом случае W совпадающей подстроки World была найдена по индексу 6. Если подстрока не найдена в строке, метод возвращает -1.

Существует версия метода indexOf(), которая берет индекс, с которого начинается поиск. Таким образом, вы можете искать в строке, чтобы найти более одного вхождения подстроки:

String theString = "is this good or is this bad?";
String substring = "is";

int index = theString.indexOf(substring);
while(index != -1) {
    System.out.println(index);
    index = theString.indexOf(substring, index + 1);
}

Этот код просматривает строку «это хорошо или это плохо?» для вхождений подстроки «is». Для этого используется метод indexOf(substring, index). Параметр index указывает, с какого индекса символа в строке следует начать поиск. В этом примере поиск начинается с 1 символа после индекса, в котором было найдено предыдущее вхождение.

Вывод:

0
5
16
21

Подстрока «is» находится в четырех местах. Два раза в словах «есть» и два раза внутри слова «этот».

Класс Java String также имеет метод lastIndexOf(), который находит последнее вхождение подстроки:

String theString = "is this good or is this bad?";
String substring = "is";

int index = theString.lastIndexOf(substring);
System.out.println(index);

Выход — 21, который является индексом последнего вхождения подстроки «is».

Concatenating Strings

The class includes a method for concatenating two strings:

string1.concat(string2); 

This returns a new string that is string1 with string2 added to it at the end.

You can also use the method with string literals, as in:

"My name is ".concat("Rumplestiltskin");

Strings are more commonly concatenated with the operator, as in

"Hello," + " world" + "!"

which results in

"Hello, world!"

The operator is widely used in statements. For example:

String string1 = "saw I was ";
System.out.println("Dot " + string1 + "Tod");

which prints

Dot saw I was Tod

Such a concatenation can be a mixture of any objects. For each object that is not a , its method is called to convert it to a .

Note: The Java programming language does not permit literal strings to span lines in source files, so you must use the concatenation operator at the end of each line in a multi-line string. For example:

String quote = 
    "Now is the time for all good " +
    "men to come to the aid of their country.";

Breaking strings between lines using the concatenation operator is, once again, very common in statements.

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

В JavaScript для сравнения строк можно использовать операторы меньше и больше:

В JavaScript строки сравниваются посимвольно в алфавитном порядке. Сначала сравниваются первые символы строк, затем вторые, третьи… И как только какой-то символ оказывается меньше, строка считается меньше, даже если в строке больше символов. Если у какой-то строки заканчиваются символы, то она считается меньше, а если символы закончились у обоих строк одновременно – они одинаковые.

Но стоит отметить, что строки имеют внутреннюю кодировку Юникод – каждому символу соответствует свой числовой код.

Есть метод для получения символа по его коду String.fromCharCode():

Выполнить код »
Скрыть результаты

А вот метод charCodeAt() наоборот возвращает числовое значение Unicode символа, индекс которого был передан методу в качестве аргумента:

Выполнить код »
Скрыть результаты

А теперь давайте выведем интервал символов Unicode с кодами от 1025 до 1105:

Выполнить код »
Скрыть результаты

Как видите, не все символы в Юникоде соответствуют их месту в алфавите. Есть некоторые исключения. Строчные буквы идут после заглавных, поэтому они всегда больше. А буква ‘ё’, имеет код, больший чем ‘я’, поэтому ‘ё’(код 1105) > ‘я’(код 1103).

Для правильного сравнения строк используйте метод str1.localeCompare(str2), который сравнивает одну строку с другой и возвращает одно из трех значений:

• Если строка str1 должна располагаться по алфавиту перед str2, возвращается -1.
• Если строка str1 равна str2, возвращается .
• Если строка str1 должна располагаться по алфавиту после str2, возвращается 1.

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

Библиотеки 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.

Git Essentials

Ознакомьтесь с этим практическим руководством по изучению Git, содержащим лучшие практики и принятые в отрасли стандарты. Прекратите гуглить команды Git и на самом деле изучите это!

Файл используется для чтения файлов. Он предлагает методы и , которые возвращают один символ и несколько символов соответственно. Кроме того, он принимает или в конструктор.

Считыватель файлов.чтение(символ[])

Давайте откроем файл с помощью и прочитаем его содержимое:

FileReader in = new FileReader("input.txt");

char[] chars = new char;
int n = in.read(chars, 0, chars.length);

String contents = new String(chars);

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

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

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

Читатель файлов.чтение()

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

FileReader in = new FileReader("input.txt");

StringBuilder sb = new StringBuilder();

while(in.read() != -1) {
	sb.append(in.read());
}

String contents = sb.toString();
in.close();

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

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

Буферизатор

-это объект, предназначенный для чтения текста из потока ввода символов. Он буферизован, что означает, что он использует внутренний буфер для временного хранения. Как мы видели в предыдущем разделе, “обычное” сканирование иногда бывает неэффективным.

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

Давайте создадим экземпляр :

BufferedReader in = new BufferedReader(new FileReader("input.txt"));

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

Давайте используем этот экземпляр для чтения файла и сохранения его содержимого, строка за строкой, в строку:

StringBuilder sb = new StringBuilder();

while(in.readLine != null) {
	sb.append(in.readLine()).append("\n");
}

String contents = sb.toString();
in.close();

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

Вывод

В этой статье мы рассмотрели некоторые распространенные методы чтения файлов в строки на Java. Существует множество вариантов, но большинство из них имеют схожий основной принцип: укажите путь к файлу, прочитайте содержимое в структуру данных (например, или строку); затем выполните некоторую окончательную обработку, чтобы собрать все содержимое файла соответствующим образом.

Мы рассмотрели метод , метод , метод , а также классы , и

Использование сканера

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

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

try (Scanner scanner = new Scanner(text)) {
    scanner.useDelimiter("\\.");           
    assertEquals("Julia Evans was born on 25-09-1984", scanner.next());    
}

В приведенном выше примере мы установили пример String в качестве источника для использования сканером.

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

Наконец, мы утверждаем первый токен из этого вывода с разделителями.

При необходимости мы можем перебрать всю коллекцию токенов, используя цикл while .

while (scanner.hasNext()) {
   // do something with the tokens returned by scanner.next()
}

Метод concat()

Иногда программисту может понадобиться объединить две строки в одну. Это актуально при формировании дат с разными окончаниями, вывода различных составных значений и тому подобные действия. Данная операция легко реализуется с помощью метода concat().

Его синтаксис выглядит вот так — string1.concat(string2). Результатом выполнения будет строка, получившаяся от соединения двух исходных. Применять метод не обязательно к объекту типа String. Можно использовать concat и таким образом: «Привет, ».concat(«мир!»). Однако, на практике, чаще всего используют оператор «+», который обладает тем же функционалом. Пример: «Привет, » + «мир!».

String Length

Methods used to obtain information about an object are known as accessor methods. One accessor method that you can use with strings is the method, which returns the number of characters contained in the string object. After the following two lines of code have been executed, equals 17:

String palindrome = "Dot saw I was Tod";
int len = palindrome.length();

A palindrome is a word or sentence that is symmetricit is spelled the same forward and backward, ignoring case and punctuation. Here is a short and inefficient program to reverse a palindrome string. It invokes the method , which returns the ith character in the string, counting from 0.

public class StringDemo {
    public static void main(String[] args) {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length();
        char[] tempCharArray = new char;
        char[] charArray = new char;
        
        // put original string in an 
        // array of chars
        for (int i = 0; i < len; i++) {
            tempCharArray = 
                palindrome.charAt(i);
        } 
        
        // reverse array of chars
        for (int j = 0; j < len; j++) {
            charArray =
                tempCharArray;
        }
        
        String reversePalindrome =
            new String(charArray);
        System.out.println(reversePalindrome);
    }
}

Running the program produces this output:

doT saw I was toD

To accomplish the string reversal, the program had to convert the string to an array of characters (first loop), reverse the array into a second array (second loop), and then convert back to a string. The
class includes a method, , to convert a string, or a portion of a string, into an array of characters so we could replace the first loop in the program above with

palindrome.getChars(0, len, tempCharArray, 0);

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

Класс 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$-

Метод сравнения String compareTo()

Метод сравнения compareTo() применяется, если надо определить лексикографический порядок строк. Он выполняет сравнение значения char, действуя аналогично equals(). Когда 2 строки совпадают, compareTo() вернёт значение «ноль» (результат = 0). Сравнивая 2 строки, он вернёт положительное целое число (результат > 0), если 1-й объект String следует за 2-й строкой. Соответственно, метод вернёт отрицательный результат (результат < 0), когда 1-й объект String будет предшествовать 2-й строке:

result1 == result2  возвращается ;
    result1 > result2   возвращается положительное значение;
    result1 < result2    возвращается отрицательное значение.

Приведём пример:

class TestClass{
  public static void main (String[] args)   {
    String str1 = "Java";
    String str2 = "Java";
    String str3 = "ASP";
    int val = ;
    val = str1.compareTo(str2);
    System.out.println(val);
    val = str1.compareTo(str3);
    System.out.println(val);
    val = str3.compareTo(str1);
    System.out.println(val);
  }
}

Итог:

9
-9

На этом всё, очень надеемся, что этот материал будет вам полезен при сравнении строк в «Джава».

При подготовке статьи использовалась публикация «String Comparison in Java».

Хотите знать больше? Приходите на курс!

.

Оператор для сравнения строк «==»

В первую очередь, надо сказать, что этот оператор проверяет и сравнивает не значения, а ссылки. С его помощью вы сможете проверить, являются ли сравниваемые вами элементы одним и тем же объектом. Когда 2 переменные String указывают на тот же самый объект в памяти, сравнение вернёт true, в обратном случае — false.

"Java" == "Java" //true

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

new String("Java") == "Java" // false

Вышеприведённые переменные String указывают уже на различные объекты.

new String("Java") == new String("Java") // false

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

Итак, мы видим, что оператор == по сути, сравнивает не две строки, а лишь ссылки, на которые указывают строки.

class TestClass{
  public static void main (String[] args){
    // ссылается на тот же объект, возвращая true
    if(  "Java" == "Java" ){
      System.out.println("Statement  is true");
    }else{
      System.out.println("Statement is false");
    }
    // указывает уже на другой объект, возвращая false
    if(new String("Java") == "Java"){
      System.out.println("Statement  is true");
    }else{
      System.out.println("Statement is false");
    }
    // указывает тоже на другой объект, возвращая false
    if(new String("Java") == new String("Java") ){
      System.out.println("Statement  is true");
    }else{
      System.out.println("Statement is false");
    }
  }
}

Итог:

Statement  is true
Statement is false
Statement is false