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

Где нужны логические операторы

Если коротко, то в условных выражениях, которые могут включать в себя и операторы сравнения (<, >, <=, >=, ==, !=). При вычислении они возвращают значение булева типа.

Условные выражения, в свою очередь, применяются в операторах ветвления (if-else, switch, тернарном). Подробнее об этих операторах тут.

Как применять

Допустим, мы хотим проверить, что значение переменной a больше значений в переменных b и c. То есть сравнить операнд a с двумя другими. Нам поможет логический оператор && (И).

Логический оператор && (И) возвращает true, если слева и справа от него стоят значения true, а иначе — false.

Иными словами, если оба логических высказывания истинны, то и операция && (И) возвращает истину.

Первый пример

Как вычисляется значение выражения (a > b) && (a > c):

Сначала проверяется условие (a > b). Оно вернёт true, так как 6 больше 4. Далее проверяется условие (a > c), которое также вернёт true, ведь 6 больше 3.

Теперь у нас с двух сторон от логического оператора && стоят значения true.

По определению выше или по таблице ещё выше, результат вычисления логического выражения (true && true) равен true.

Второй пример

Результат операции (a > b) вернёт true, так как 6 больше 4, а операция (a > c) уже вернёт false, так как 6 не больше 7.

Значит, слева от логического оператора && стоит true, а справа — false. Следовательно, результат вычисления логического выражения (мы присвоили его булевой переменной d) будет false.

Третий пример

Результат операции сравнения (a > b) равен false, а что вернёт операция (a > c), уже значения не имеет (смотрите определение выше) — результат вычисления логического выражения (мы присвоили его булевой переменной d) будет равен false.

Methods of Java String

Besides those mentioned above, there are various string methods present in Java. Here are some of those methods:

Methods	Description
substring()	returns the substring of the string
replace()	replaces the specified old character with the specified new character
charAt()	returns the character present in the specified location
getBytes()	converts the string to an array of bytes
indexOf()	returns the position of the specified character in the string
compareTo()	compares two strings in the dictionary order
trim()	removes any leading and trailing whitespaces
format()	returns a formatted string
split()	breaks the string into an array of strings
toLowerCase()	converts the string to lowercase
toUpperCase()	converts the string to uppercase
valueOf()	returns the string representation of the specified argument
toCharArray()	converts the string to a array

Класс StringTokenizer

И еще несколько самых частых сценариев работы со строками. Как разбить строку на несколько частей? Для этого есть несколько способов.

Метод

Первый способ разбить строку на несколько частей — использовать метод . В него в качестве параметра нужно передать регулярное выражение: специальный шаблон строки-разделителя. Что такое регулярное выражение, вы узнаете в квесте Java Multithreading.

Пример:

Код	Результат
	Результатом будет массив из трех строк:

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

Класс

В Java есть специальный класс, вся работа которого — разделять строку на подстроки.

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

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

Методы	Описание
	Возвращает следующую подстроку
	Проверяет, есть ли еще подстроки.

Этот класс чем-то напоминает класс , у которого тоже были методы и .

Создать объект можно командой:

Где строка — это , которую будем делить на части. А — это строка, каждый символ которой считается символом-разделителем. Пример:

Код	Вывод на экран

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

Константы

Если вы используете ту же строку (например, «Hello World») в других объявлениях переменных String, виртуальная машина Java может создать в памяти только один экземпляр String. Таким образом, строковый литерал становится де-факто константой или синглтоном. Различные переменные, инициализированные одной и той же константной строкой, будут указывать на один и тот же экземпляр String в памяти.

String myString1 = "Hello World";
String myString2 = "Hello World";

В этом случае виртуальная машина заставит myString1 и myString2 указывать на один и тот же объект String.

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

Если вы хотите быть уверены, что две строковые переменные указывают на отдельные строковые объекты, используйте оператор new следующим образом:

String myString1 = new String("Hello World");
String myString2 = new String("Hello World");

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

java.lang.StringBuilder

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

Так же как и у 
String  у
StringBuilder  есть метод
length() , позволяющий узнать его длину в
char -ах.

В отличие от
String  у
StringBuilder  кроме длины есть ещё вместимость/ёмкость (capacity). Вместительность можно узнать с помощью метода
capacity() , она всегда больше или равна длине.

Конструктор	Описание
	Создаёт пустой StringBuilder  вместительностью 16 (16 пустых элементов).
	Создаёт StringBuilder , содержащий символы из последовательности и 16 дополнительных пустых элементов.
	Создаёт пустой StringBuilder  с начальной вместительностью в initCapacity  элементов.
	Создаёт StringBuilder , который содержит указанную строку и 16 дополнительных пустых элементов.

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

Длина и вместительность

Метод	Описание
	Устанавливает длину последовательности символов. Если newLength  меньше length() , то последние символы обрезаются. Если newLength  больше length() , то в конец последовательности добавляются нулевые символы.
	Обеспечивает, что вместительность будет как минимум равной minCapacity .

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

Некоторые методы StringBuilder

Метод	Описание
	Добавляет аргумент, преобразованный в строку, в конец  StringBuilder-а.
	Первый метод удаляет подпоследовательность с start  до end-1  включительно. Второй метод удаляет символ по индексу.
	Вставляет второй аргумент, конвертированный в строку, в позицию index .
	Заменяет указанный символ/ы.
	Меняет порядок символов в StringBuilder  на обратный. Первый символ становится последним и так далее.
	Возвращает строку, содержащую последовательность символов из StringBuilder .

Пример использования StringBuilder:

Java

String andStr = » and Petya»;
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(«Vasya»);
stringBuilder.append(andStr);
stringBuilder.append(» go to school.»);
System.out.println(stringBuilder);

1 2 3 4 5 6

StringandStr=» and Petya»; StringBuilder stringBuilder=newStringBuilder(); stringBuilder.append(«Vasya»); stringBuilder.append(andStr); stringBuilder.append(» go to school.»); System.out.println(stringBuilder);

Цикл статей «Учебник Java 8».

Следующая статья — «Java 8 автоупаковка и распаковка».
Предыдущая статья — «Java 8 числа».

Конвертировать с использованием 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 7 и 8

Ниже приведен пример использования этого компаратора длины строк для сортировки списка строк по их длине. В этом примере мы продемонстрировали программы на JDK 6 и 7 с использованием анонимного класса, и новый способ с использованием лямбда-выражений, который доступен в Java 8. Он занимает всего одну строку и его намного проще понять, если вы знакомы с синтаксисом лямбда-выражений.

Как отсортировать список строк по их длине в Java 7 и 8

Java 6, 7

Import java.util.ArrayList;
Import java.util.Arrays;
Import java.util.Collections;
Import java.util.Comparator;
Import java.util.List;

/ *
 * Программа Java для сортировки списка строк по их длине
 * /

public class StringComparisonByLength{

  Public static void main (String [] args) {

List<String> books = new ArrayList<>(Arrays.asList("Effective Java", "Algorithms", "Refactoring" ));
System.out.println("Sorting List of String by length in JDK 7 ======");
System.out.println("The original list without sorting");
System.out.println(books);

    Comparator<String> byLength = new Comparator<String>(){
      @Override
      Public int compare (String s1, String s2) {
        Return s1.length () - s2.length ();
        }
    };

    Collections.sort(books, byLength);
    System.out.println("The same list after sorting string by length");

    System.out.println(books);
  }
}

Результат

Sorting List of String by length in JDK 7 ======
The original list without sorting 
The same list after sorting string by length

Java 8

Import java.util.ArrayList;
Import java.util.Arrays;
Import java.util.Comparator;
Import java.util.List;
/ *
 * Программа Java для сортировки списка строк по их длине в JDK 8
 * /

public class SortingListOfStringByLength{

  public static void main(String[] args) {

    // В Java 8
    System.out.println("Sorting List of String by length in Java 8 ======");

   List<String> cities = new ArrayList<>(Arrays.asList("London", "Tokyo", "NewYork"));
    System.out.println("The original list without sorting");
    System.out.println(cities);

    cities.sort((first, second) -> Integer.compare(first.length(), second.length()));

    System.out.println("The same list after sorting string by length");
    System.out.println(cities);
  }
}

Результат

Sorting List of String by length in Java 8 ====== 
The original list without sorting 
 
The same list after sorting string by length 

Это все, что касается сравнения длины строк Java и сортировки списка String по длине в Java 7 и Java 8. В последней версии языка делать это намного удобнее, поскольку можно создать пользовательский компаратор только одной строкой, используя лямбда-выражение. API JDK 8 содержит множество подобных методов, которые облегчают еще более сложные сравнения. Например, используя метод thenComparing(), можно связать несколько компараторов.

Данная публикация является переводом статьи «How to compare String by their length in Java 7 and 8» , подготовленная редакцией проекта.

Производительность конкатенации

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

String one = "Hello";
String two = " World";

String three = new StringBuilder(one).append(two).toString();

Создается новый StringBuilder, который передает первую строку в свой конструктор, а вторую – в свой метод append(), прежде чем вызвать метод toString(). Этот код фактически создает два объекта: экземпляр StringBuilder и новый экземпляр String, возвращенный методом toString().

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

Вот цикл, содержащий вышеуказанный тип конкатенации строк:

String[] strings = new String[]{"one", "two", "three", "four", "five" };

String result = null;
for(String string : strings) {
    result = result + string;
}

Этот код будет скомпилирован в нечто похожее на это:

String[] strings = new String[]{"one", "two", "three", "four", "five" };

String result = null;
for(String string : strings) {
    result = new StringBuilder(result).append(string).toString();
}

Теперь для каждой итерации в этом цикле создается новый StringBuilder. Кроме того, объект String создается методом toString(). Это приводит к небольшим расходам на создание экземпляров за одну итерацию: один объект StringBuilder и один объект String. Само по себе не является настоящим убийцей производительности, хотя.

Каждый раз, когда выполняется новый код StringBuilder(result), конструктор StringBuilder копирует все символы из результирующего String в StringBuilder. Чем больше итераций цикла, тем больше будет результат String. Чем больше растет результат String, тем больше времени требуется для копирования символов из него в новый StringBuilder и повторного копирования символов из StringBuilder во временную строку, созданную методом toString(). Другими словами, чем больше итераций, тем медленнее становится каждая итерация.

Самый быстрый способ объединения строк – создать StringBuilder один раз и повторно использовать один и тот же экземпляр внутри цикла. Вот как это выглядит:

String[] strings = new String[]{"one", "two", "three", "four", "five" };

StringBuilder temp  = new StringBuilder();
for(String string : strings) {
    temp.append(string);
}
String result = temp.toString();

Этот код избегает как экземпляров объектов StringBuilder и String внутри цикла, так и, следовательно, позволяет избежать двухкратного копирования символов, сначала в StringBuilder, а затем снова в String.

Сравнение строк: equals() или ==?

Хотя в двух переменных содержится одно и то же слово, мы имеем дело с двумя разными объектами и оператор == вернёт false.

Однажды, когда деревья были большими, мне понадобилось сравнить две строки из разных источников. Хотя строки выглядели совершенно одинаково, сравнение при помощи оператора == возвращало false и путало мне все карты. И только потом я узнал, что нужно использовать метод equals(). Строка в Java — это отдельный объект, который может не совпадать с другим объектом, хотя на экране результат выводимой строки может выглядеть одинаково. Просто Java в случае с логическим оператором == (а также !=) сравнивает ссылки на объекты (при работе с примитивами такой проблемы нет):

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.

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

Кроме сравнения строк и поиска подстрок, есть еще одно очень популярное действие — получение подстроки из строки. В предыдущем примере вы как раз видели вызов метода , который возвращал часть строки.

Вот список из 8 методов получения подстрок из текущей строки:

Методы	Описание
	Возвращает подстроку, заданную интервалом символов .
	Повторяет текущую строку n раз
	Возвращает новую строку: заменяет символ на символ
	Заменяет в текущей строке подстроку, заданную регулярным выражением.
	Заменяет в текущей строке все подстроки, совпадающие с регулярным выражением.
	Преобразует строку к нижнему регистру
	Преобразует строку к верхнему регистру
	Удаляет все пробелы в начале и конце строки

Вот краткое описание существующих методов:

Метод

Метод возвращает новую строку, которая состоит из символов текущей строки, начиная с символа под номером и заканчивая . Как и во всех интервалах в Java, символ с номером в интервал не входит. Примеры:

Код	Результат

Если параметр не указывается (а так можно), подстрока берется от символа beginIndex и до конца строки.

Метод

Метод repeat просто повторяет текущую строку раз. Пример:

Код	Результат

Метод

Метод возвращает новую строку, в которой все символы заменены на символ . Длина строки при этом не меняется. Пример:

Код	Результат

Методы и

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

Примеры:

Код	Результат

Методы

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

Метод

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

Код	Результат

Извлекаем символы и подстроки в Java

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

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

Обратите внимание, что индексация начинается с нуля, впрочем, как и в массивах. Если же нужно извлечь сразу группу символов либо подстроку, подойдёт getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

Этот метод принимает ряд параметров:
• srcBegin: индекс в нашей строке, с которого осуществляется начало извлечения символов;
• srcEnd: индекс в нашей строке, до которого осуществляется извлечение символов;
• dst: массив символов (именно в него будут эти символы извлекаться);
• dstBegin: индекс в массиве dst (с него надо добавлять символы, извлечённые из строки).

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

Некоторые методы работы со строками

Ну и напоследок хотелось бы рассказать о нескольких методах типа .

Метод

Метод  позволяет узнать длину строки – сколько в ней символов.

Примеры:

Команда	Примечание
	содержит значение
	содержит значение
	содержит значение

Да, методы можно вызывать у всего, что имеет тип , даже у выражения:

Вызов метода у выражения типа

Метод

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

Примеры:

Команда	Примечание
	содержит строку
	содержит пустую строку
	содержит строку

Метод

Метод  позволяет преобразовать все символы строки в большие (заглавные):

Примеры:

Команда	Примечание
	содержит строку
	содержит строку

Общие понятия

Типом данных в программировании называют совокупность двух множеств: множество значений и множество операций, которые можно применять к ним. Например, к типу данных целых неотрицательных чисел, состоящего из конечного множества натуральных чисел, можно применить операции сложения (+), умножения (*), целочисленного деления (/), нахождения остатка (%) и вычитания (−).

Язык программирования, как правило, имеет набор примитивных типов данных — типы, предоставляемые языком программирования как базовая встроенная единица. В C++ такие типы создатель языка называет фундаментальными типами. Фундаментальными типами в C++ считаются:

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

Поверх перечисленных строятся следующие типы:

• указательные (напр., );
• массивы (напр., );
• ссылочные (напр., );
• другие структуры.

Перейдём к понятию литерала (напр., 1, 2.4F, 25e-4, ‘a’ и др.): литерал — запись в исходном коде программы, представляющаясобой фиксированное значение. Другими словами, литерал — это просто отображение объекта (значение) какого-либо типа в коде программы. В C++ есть возможность записи целочисленных значений, значений с плавающей точкой, символьных, булевых, строковых.

Литерал целого типа можно записать в:

• 10-й системе счисления. Например, ;
• 8-й системе счисления в формате 0 + число. Например, ;
• 16-й системе счисления в формате 0x + число. Например, .

24, 030, 0x18 — это всё записи одного и того же числа в разных системах счисления.
Для записи чисел с плавающей точкой используют запись через точку: 0.1, .5, 4. — либо в
экспоненциальной записи — 25e-100. Пробелов в такой записи быть не должно.

Имя, с которым мы можем связать записанные литералами значения, называют переменной. Переменная — это поименованная либо адресуемая иным способом область памяти, адрес которой можно использовать для доступа к данным. Эти данные записываются, переписываются и стираются в памяти определённым образом во время выполнения программы. Переменная позволяет в любой момент времени получить доступ к данным и при необходимости изменить их. Данные, которые можно получить по имени переменной, называют значением переменной.
Для того, чтобы использовать в программе переменную, её обязательно нужно объявить, а при необходимости можно определить (= инициализировать). Объявление переменной в тексте программы обязательно содержит 2 части: базовый тип и декларатор. Спецификатор и инициализатор являются необязательными частями:

const int example = 3;
// здесь const — спецификатор
// int — базовый тип
// example — имя переменной
// = 3 — инициализатор.

Имя переменной является последовательностью символов из букв латинского алфавита (строчных и прописных), цифр и/или знака подчёркивания, однако первый символ цифрой быть не может. Имя переменной следует выбирать таким, чтобы всегда было легко догадаться о том, что она хранит, например, «monthPayment». В конспекте и на практиках мы будем использовать для правил записи переменных нотацию CamelCase. Имя переменной не может совпадать с зарезервированными в языке словами, примеры таких слов: if, while, function, goto, switch и др.

Декларатор кроме имени переменной может содержать дополнительные символы:

• — указатель; перед именем;
• — константный указатель; перед именем;
• — ссылка; перед именем;
• — массив; после имени;
• — функция; после имени.

Инициализатор позволяет определить для переменной её значение сразу после объявления. Инициализатор начинается с литерала равенства (=) и далее происходит процесс задания значения переменной. Вообще говоря, знак равенства в C++ обозначает операцию присваивания; с её помощью можно задавать и изменять значение переменной. Для разных типов он может быть разным.

Спецификатор задаёт дополнительные атрибуты, отличные от типа. Приведённый в примере спецификатор const позволяет запретить последующее изменение значение переменной. Такие неизменяемые переменные называют константными или константой.

Объявить константу без инициализации не получится по логичным причинам:

const int EMPTY_CONST; // ошибка, не инициализована константная переменная
const int EXAMPLE = 2; // константа со значением 2
EXAMPLE = 3; // ошибка, попытка присвоить значение константной переменной

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

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

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

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

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

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

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

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

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

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

Pad a String Using Custom Methods

The String class in Java doesn’t provide a convenient method for padding, so let’s create several methods on our own. First, though, let’s set some expectations:

2.1. Using StringBuilder

We can achieve this with StringBuilder and some procedural logic:

We can see here that if the original text’s length is equal to or bigger than the desired length, we return the unchanged version of it. Otherwise, we create a new String, starting with spaces, and adding the original one.

Of course, if we wanted to pad with a different character we could just use it instead of a .

Likewise, if we want to right pad, we just need to do new StringBuilder(inputString) instead and then add the spaces at the end.

2.2. Using substring

Another way to do the left padding is to create a String with the desired length that contains only pad characters and then use the substring() method:

2.3. Using String.format

And, finally, since Java 5, we can use String.format():

We should note that by default the padding operation will be performed using spaces. That’s the reason why we need to use the replace() method if we want to pad with zeros or any other character.

For the right pad, we just have to use a different flag: %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».

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

.

Как логические операторы работают с целыми числами

Мы уже знаем, что логические операции применимы к логическим аргументам (операндам). Каждый логический операнд — это выражение, которое является истинным (true) или ложным (false) — то есть возвращает булево значение. Иными словами, логический операнд — это выражение типа boolean.

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

Можно. Внутри Java все целочисленные типы представлены двоичными числами разной длины. И к ним уже применимы бинарные логические операторы ^, | и &.

Только в этом случае они работают с двоичным представлением операндов — выполняют операции над их битами попарно (рассматривая их как логические единицы и нули). Поэтому и сами операторы ^, | и & зовутся побитовыми.

Как ^, | и & работают с целочисленными операндами

Рассмотрим пример:

Чтобы повторить вычисления Java, нужно:

1. Перевести значения обоих операндов в двоичную систему счисления.
2. Расположить результаты перевода друг под другом.
3. Сравнять в них число разрядов (дополнить лидирующими нулями).
4. Применить к битам из каждого столбца оператор (&, | или ^).
5. Записать результат каждой операции ниже в том же столбце.
6. Перевести итог в десятичную форму.

Потренируемся: вычислим сами 3 & 5

Число 3 в двоичной системе счисления имеет вид 11, а число 5 — 101.

Так как у числа 5 три разряда в двоичной системе, а у числа 3 — всего два, добавим лидирующий ноль к числу 3 в двоичной системе и получим 011.

Берём цифры из обоих чисел и применяем к ним попарно оператор & (AND):

3(10) = 011(2)	1	1
	&	&	&
5(10) = 101(2)	1	1
	=	=	=
001(2) = 1(10)	1

Преобразование с использованием Integer.toString(int)

Класс Integer имеет статический метод, который возвращает объект String, представляющий параметр int, указанный в функции Integer.toString(int). Этот подход, в отличие от других, может возвращать исключение NullPointerException.

Синтаксис

Есть два разных выражения для метода Integer.toString():

public static String toString(int i)

public static String toString(int i, int radix)

Параметры

Параметры этого метода:

• i: целое число, которое будет преобразовано.
• radix: используемая система счисления базы для представления строки.

Возвращаемое значение

Возвращаемое значение для обоих выражений – строка Java, представляющая целочисленный аргумент «i». Если используется параметр radix, возвращаемая строка определяется соответствующим основанием.

Пример

package MyPackage;
public class Method1 
{
	public static void main(String args[]) 
	{
		  int n = Integer.MAX_VALUE;
		  String str1 = Integer.toString(n);
		  System.out.println("The output string is: " + str1);
		  int m = Integer.MIN_VALUE;
		  String str2 = Integer.toString(m);
		  System.out.println("The output string is: " + str2);
	}
	 
}

Конкатенация — склеивание строк

Есть очень интересная и простая вещь, которую можно делать со строками в Java — их можно склеивать. Такая операция называется конкатенация. Ну или чтобы легче запомнилось — Кон-Котэ-Нация. Хотя часто ее называют «склеивание строк» или даже просто «сложение строк».

Чтобы склеить две строки, нужно использовать знак . Это очень просто:

Конкатенация двух строк

Примеры:

Команда	Примечание
	содержит строку
	содержит строку
	содержит строку

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

Примеры:

Команда	Примечание
	содержит строку содержит строку содержит строку

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

Строка, содержащая один пробел

Кстати, если между кавычками совсем не оставить места (написать две двойные кавычки подряд), получится так называемая «пустая строка»:

Пустая строка

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

Creating Strings

The most direct way to create a string is to write −

String greeting = "Hello world!";

Whenever it encounters a string literal in your code, the compiler creates a String object with its value in this case, «Hello world!’.

As with any other object, you can create String objects by using the new keyword and a constructor. The String class has 11 constructors that allow you to provide the initial value of the string using different sources, such as an array of characters.

Example

public class StringDemo {

   public static void main(String args[]) {
      char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };
      String helloString = new String(helloArray);  
      System.out.println( helloString );
   }
}

This will produce the following result −

Output

hello.

Note − The String class is immutable, so that once it is created a String object cannot be changed. If there is a necessity to make a lot of modifications to Strings of characters, then you should use String Buffer & String Builder Classes.

Возведение в степень

Возвести число в степень можно двумя способами:

1. простое умножение;
2. используя метод (двойное основание, двойной показатель степени).

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

Простое умножение в Java работает в 300-600 раз эффективнее, кроме того, его можно дополнительно оптимизировать:

JIT оптимизация

Код Java обрабатывается с использованием JIT-компиляции: сначала он транслируется в платформенно-независимый байт-код, а затем в машинный код. При этом оптимизируется все возможное, и разработчик может помочь компилятору создать максимально эффективную программу.

В качестве примера рассмотрим две простые операции:

Давайте измерим время выполнения каждого из них:

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

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

Вы можете узнать больше об этом эксперименте здесь. Или  можете провести свой собственный тест, используя онлайн-компилятор Java.