Java string: работа со строками в java

Метод format()

Для придания получившихся в итоге выполнения программы готовых строк используется метод String.format. Java обзавелась этим решением, начиная с 5 версии.

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

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

Git Essentials

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

Аналогично, существует версия этого метода, которая не заботится о регистре символов. Например, две предыдущие строки:

String s1 = "Hello World";
String s2 = "hello world";

System.out.println(s1.compareToIgnoreCase(s2));

Теперь бы вернулся:

Метод contentEquals()

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

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

метод сравнивает s и s. С его помощью вам не нужно преобразовывать в для сравнения – метод сам справится с этим:

String s1 = "aaaa";
StringBuffer s2 = new StringBuffer("");

for (int i = 0; i < 4; i++) {
    s2.append('a');
}

System.out.println(s1.contentEquals(s2));

С помощью предыдущего метода вы не можете сравнить с . Таким образом, вы можете.

Этот код возвращает:

true

StringUtils – Apache Commons

Библиотека Apache Commons – это надежная библиотека, наполненная бесчисленными удобными методами и классами.

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

StringUtils.равно()

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

String s1 = "Hello";
String s2 = new String("Hello");

System.out.println(StringUtils.equals(s1, s2));
System.out.println(StringUtils.equals(s1, null));
System.out.println(StringUtils.equals(null, null));

Это вернулось бы:

true
false
true

Он также обеспечивает нулевую безопасность и проверяет наличие значений. Сравнение двух значений вернет .

StringUtils.equalsIgnoreCase()

Метод работает таким же образом:

String s1 = "Hello";
String s2 = new String("hello");

System.out.println(StringUtils.equalsIgnoreCase(s1, s2));
System.out.println(StringUtils.equalsIgnoreCase(s1, null));
System.out.println(StringUtils.equalsIgnoreCase(null, null));

Это возвращает:

true
false
true

StringUtils.equalsAny()

– это первый метод, который делает что-то совершенно новое. Он принимает и vararg. Если какие-либо из переменных можно найти в строке

System.out.println(StringUtils.equalsAny("Hello World", "Hello", "World"));
System.out.println(StringUtils.equalsAny("Java is great!", "Java", "great!"));

Это вернулось бы:

true
true

Примечание: Метод чувствителен к регистру.

StringUtils.equalsAnyIgnoreCase()

Конечно, у нас также есть вариант метода без учета регистра:

System.out.println(StringUtils.equalsAnyIgnoreCase("Hello World", "HELLO", "world"));
System.out.println(StringUtils.equalsAnyIgnoreCase("Java is great!", "JavA", "GrEat!"));

Они также вернутся:

true
true

StringUtils.сравните()

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

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

String s1 = "a";
String s2 = "b";

System.out.println(StringUtils.compare(s1, s2));

Это возвращает:

-1

StringUtils.compareIgnoreCase()

Наконец, версия предыдущего метода без учета регистра-

Он сравнивает лексикографическое значение строк, не принимая во внимание регистр:

String s1 = "A";
String s2 = "a";

System.out.println(StringUtils.compareIgnoreCase(s1, s2));

Это обычно возвращается так как строчные буквы отделены от их заглавных аналогов 32 местами. Однако это возвращает:

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

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

Для сравнения строк в Java используйте equals(), а не ==.

== сообщит вам, если две ссылки ссылаются на один и тот же объект. Чтобы проверить, идентичны ли две строки, .equals делает то, что вы хотите.

Следующая программа иллюстрирует это:

// Here's some text.
String text1 = "Hello there";

// Here's the same text.
String text2 = "Hello there";

// Here's a second reference to the 
// first string.
String text3 = text1;

// The first two strings are equal
// (contain the same text)
if(text1.equals(text2)) {
    System.out.println("text1 matches text2.");
}

// ... and in this case they are the same object, 
// which presumably is due to optimization by the
// virtual machine. DO NOT rely on this!!
if(text1 == text2) {
    System.out.println("text1 and text2 are the same object (oddly)");
}

// text2 and text3 ARE clearly the same object, however.
if(text2 == text3) {
    System.out.println("text2 and text3 are the same object.");
}

Чтобы проверить, является ли объект строкой или нет, используйте instanceof.

// Here's a string.
/ Here's a string.
String text1 = "Hello there";

if(text1 instanceof java.lang.String) {
    System.out.println("It's a string!");
}

Способы случайной генерации строк в java (три)

http-equiv=»Content-Type» content=»text/html;charset=UTF-8″>style=»clear:both;»>

1. Первый типКаждая позиция сгенерированной строки может быть буквой или числом в строке str. Пакет, который необходимо импортировать, — это import java.util.Random;

2. Второй типВы можете указать местоположение как a-z, A-Z или 0-9, а импортируемый пакет — import java.util.Random;

3. Третий типВ пакете org.apache.commons.lang есть класс RandomStringUtils, который имеет функцию randomAlphanumeric (int length), которая может произвольно генерировать строку длины length.

// Создание 5-значной случайной строки, которая искажена в китайской среде RandomStringUtils.random(5);

// Используйте указанные символы для генерации случайной строки длиной 5 бит RandomStringUtils.random(5, new char[]{‘a’,’b’,’c’,’d’,’e’,’f’, ‘1’, ‘2’, ‘3’});

// Создание случайной комбинации букв и цифр указанной длины RandomStringUtils.randomAlphanumeric(5);

// Генерируем строку случайных чисел RandomStringUtils.randomNumeric(5);

// Генерация случайной строки , включая регистр RandomStringUtils.randomAlphabetic(5);

// Генерируем случайную строку от 32 до 126 ASCII  RandomStringUtils.randomAscii(4)  

Интеллектуальная рекомендация

Пожалуйста, реализуйте функцию для преобразованияЗаменить каждый пробел»% 20″. Например, когда строка We We Happy. Строка после замены — We% 20Are% 20Happy. Встроенные функции для строк Pyth…

EventHub :: MeetEvents Method, Mneedtscandevices Переменная процесса вызова подробный анализ         …         if (mNeedToScanDevices…

Просто поймите:   1. Типы элементов в списке могут быть разными, он поддерживает числа, строки и даже списки (так называемая вложенность). 2. Список представляет собой список элементов, заключенн…

Главная идея: ответ: Этот вопрос найти несложно, f указывает, что состояние выбранной точки равно i, это минимальная стоимость, а dis указывает количество сокровищ от начальной точки до i. , а…

Отскок летающей овцы Однажды Лостмонки изобрел сверхэластичное устройство и, чтобы похвастаться перед своими друзьями-овцами, пригласил маленькую овечку поиграть в игру. В начале игры Lostmonkey разме…

Вам также может понравиться

Инструменты: Android Studio activity_main.xml fragment_1.xml fragment_1.java fragment_2.xml fragment_2.java fragment_3.xml fragment_3.java MainActivity.java Эффект интерфейса…

50% людей знают, как использовать Word, чтобы получать платежные ведомости, но только 10% знают, как сделать так, чтобы платежные ведомости Word были строго отформатированы, а сотрудники, которые экон…

Используйте poi для импорта Excel и инкапсуляции его в JavaBean По причинам спроса я недавно сделал импорт в Excel и упаковал его в JavaBean, чтобы реализовать функцию пакетного импорта. И добиться со…

Смени тему На этой картинке изображен темный кимби (кажется, именно кимби создал этот вид) Официальные ярлыки…

 …

Замена символов replace()

Класс Java String содержит метод replace(), который может заменять символы в строке. Он фактически не заменяет символы в существующей строке. Скорее, возвращает новый экземпляр String. Он равен экземпляру String, из которого он был создан, но с заменой указанных символов. Пример:

String source   = "123abc";
String replaced = source.replace('a', '@');

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

123@bc

Метод replace() заменит все символы, соответствующие символу, переданному методу в качестве первого параметра, вторым символом, переданным в качестве параметра.

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

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

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

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

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

Git Essentials

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

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

for (int i = index; i < array.length - 1; i++) {
    array = array;
}

Если бы мы пошли и напечатали измененный массив, это был бы результат:

10, 20, 30, 50, 60, 70, 80, 90, 100, 100

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

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

Сокращенный способ сделать то же самое, что и раньше, но в одной строке кода, – это метод :

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);

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

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

int[] array = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int index = 3;

Чтобы удалить элемент, нам нужно написать только одну строку кода:

System.arraycopy(array, index + 1, array, index, array.length - index - 1);

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

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

Вывод

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

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

Через DecimalFormat

DecimalFormat – это конкретный подкласс класса NumberFormat, который форматирует десятичные числа. Он имеет множество функций, предназначенных для анализа и форматирования чисел. Вы можете использовать его для форматирования числа в строковое представление по определенному шаблону.

Пример

import java.text.DecimalFormat;
public class Method4
{
	 public static void main(String[] args) 
	 {
	      int number = 12345;
	      DecimalFormat numberFormat = new DecimalFormat("##,###");
	      String str = numberFormat.format(12345);	      
          System.out.println("The number to be converted is: " + number);
	      System.out.println("The string version of 12345 is: " + str);
	 }
	 
}

Вывод

The number to be converted is: 12345
The string version of 12345 is: 12,345

Если вы знаете, как использовать метод DecimalFormat, это лучший вариант для преобразования Integer в String из-за уровня контроля, который можете иметь при форматировании. Можете указать количество знаков после запятой и разделитель запятых для лучшей читаемости, как показано в примере выше.

Дополните строку с помощью библиотек

Кроме того, существуют внешние библиотеки, которые уже предлагают функции заполнения.

3.1. Apache Commons Lang

Apache Commons Lang предоставляет пакет служебных классов Java. Одним из самых популярных является StringUtils .

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

org.apache.commonscommons-lang33.11

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

assertEquals("    123456", StringUtils.leftPad("123456", 10));
assertEquals("0000123456", StringUtils.leftPad("123456", 10, "0"));

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

Существуют также соответствующие методы right Pad () .

Чтобы узнать больше о функциях Apache Commons Lang3, вы можете ознакомиться с нашим вводным руководством . Если вы хотите увидеть другие способы манипулирования строкой с помощью класса StringUtils , пожалуйста, обратитесь к этой статье .

3.2. Google Guava

Еще одна библиотека, которую мы можем использовать, – это Google Guava . Конечно, сначала нам нужно добавить его в проект, добавив :

com.google.guavaguava27.0-jre

А затем используйте Strings class :

assertEquals("    123456", Strings.padStart("123456", 10, ' '));
assertEquals("0000123456", Strings.padStart("123456", 10, '0'));

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

Для правой панели мы можем использовать pad И() метод.

Библиотека Гуавы предлагает гораздо больше функций, и мы рассмотрели многие из них. Вы можете посмотреть здесь статьи, связанные с гуавой .

Concatenating Strings

The String 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 concat() method with string literals, as in −

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

Strings are more commonly concatenated with the + operator, as in −

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

which results in −

"Hello, world!"

Let us look at the following example −

Example

public class StringDemo {

   public static void main(String args[]) {
      String string1 = "saw I was ";
      System.out.println("Dot " + string1 + "Tod");
   }
}

This will produce the following result −

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

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

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

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

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

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

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

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

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

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

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

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

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

Разница между \n и \r

\r и \n – это символы, обозначаемые значениями ASCII 13 (CR) и 10 (LF) соответственно. Они оба представляют собой разрыв между двумя строками , но операционные системы используют их по-разному.

В Windows для начала новой строки используется последовательность из двух символов, за которой сразу же следует LF. И наоборот, в Unix-подобных системах используется только LF.

При написании Java-приложений мы должны обращать внимание на символы разрыва строки, которые мы используем, потому что приложения будут вести себя по-разному в зависимости от операционной системы, в которой они будут работать. Самый безопасный и наиболее совместимый вариант-использовать System.LineSeparator()

Таким образом, нам не придется принимать во внимание операционную систему

Самый безопасный и наиболее совместимый вариант-использовать System.LineSeparator()

Таким образом, нам не придется принимать во внимание операционную систему

Поиск подстроки или символа в строке в Java

В класс включена поддержка поиска определенного символа или подстроки, для этого в нем имеются два метода — и .

— ищет первое вхождение символа или подстроки.

— ищет последнее вхождение символа или подстроки.

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

Чтобы найти первое или последнее вхождение символа, применяйте:  

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

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

Рассмотрим применение этих методов на следующем примере:

Конвертировать с использованием 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(), чтобы получить строковое представление данных.

Java string методы — использование оператора ==

Оператор == проверяет ссылки, а не значения. Это означает, что он проверяет, являются ли сравниваемые элементы одним и тем же объектом. Если две переменные String указывают на один и тот же объект в памяти, сравнение возвращает true. В противном случае — false:

"Java" == "Java" //true

Здесь литералы интернируются компилятором и таким образом ссылаются на один и тот же объект:

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

Приведенные выше переменные String указывают на разные объекты:

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

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

Оператор ‘==’ не сравнивает строки в java, а только ссылки, на которые они строки.

Пример

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

StartWith() и EndWith()

Методы StartWith() и EndWith() проверяют, начинается ли String с определенной подстроки:

String one = "This is a good day to code";

System.out.println( one.startsWith("This")    );
System.out.println( one.startsWith("This", 5) );

System.out.println( one.endsWith("code")    );
System.out.println( one.endsWith("shower")  );

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

• Первая строка (после объявления String) проверяет, начинается ли String с подстроки «This». Поскольку это происходит, метод startWith() возвращает true.
• Вторая строка проверяет, начинается ли строка с подстроки «This» при запуске сравнения с символа с индексом 5. Результат равен false, поскольку символ с индексом 5 равен «i».
• Третья строка проверяет, заканчивается ли String подстрокой «code». Поскольку это происходит, метод endWith() возвращает true.
• Четвертая строка проверяет, заканчивается ли String подстрокой “shower”. Так как это не так, метод endWith() возвращает false.

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

С помощью метода equalsIgnoreCase() вы выполните сравнение строк, что называется, лексикографически, причём различия регистра будут игнорированы. Здесь значение true возвращается в том случае, если аргумент является объектом String и представляет такую же последовательность символов, что и у объекта. Прекрасное решение, если надо осуществить проверку строки на равенство, не учитывая при этом регистр.

class TestClass{
  public static void main (String[] args){
    String str1 = "Java";
    String str2 = "JAVA";
    // возвращается true, ведь обе строки равны без учёта регистра
    if(str1.equalsIgnoreCase(str2)){
      System.out.println("Statement  is true");
    }else{
      System.out.println("Statement is false");
    }
    // возвращается false, т. к. учитывается регистр символов
    if(str1.equals(str2)){
      System.out.println("Statement  is true");
    }else{
      System.out.println("Statement is false");
    }
  }
}

Результат

Statement  is true
Statement is false

Использование Регулярных Выражений

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

В примере Строка дата рождения Джулии находится в формате “дд-мм-гггг”. Мы можем сопоставить этот шаблон с помощью API регулярных выражений Java.

Прежде всего, нам нужно создать шаблон для “дд-мм-гггг”:

Pattern pattern = Pattern.compile("\\d{2}-\\d{2}-\\d{4}");

Затем мы применим шаблон, чтобы найти совпадение из данного текста:

Matcher matcher = pattern.matcher(text);

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

if (matcher.find()) {                                  
    Assert.assertEquals("25-09-1984", matcher.group());
}

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

Получение символов и байтов

Можно получить символ по определенному индексу в строке, используя метод charAt():

String theString = "This is a good day to code";

System.out.println( theString.charAt(0) );
System.out.println( theString.charAt(3) );

Этот код распечатает:

T
s

Так как это символы, расположенные в индексах 0 и 3 в строке.

Вы также можете получить байтовое представление метода String, используя метод getBytes():

String theString = "This is a good day to code";

byte[] bytes1 = theString.getBytes();
byte[] bytes2 = theString.getBytes(Charset.forName("UTF-8");

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

Второй вызов getBytes() возвращает UTF-8-байтовое представление String.

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

Чтобы найти индекс первого вхождения подстроки в строку, используют метод 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

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

Показанный ранее пример 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);
}

1. Сначала объявляется массив.
2. Три объекта Employee создаются и вставляются в массив.
3. Метод 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;
    }
});