Java challengers #2: сравнение строк
Содержание:
- Введение в строки. Класс String
- Поиск с помощью indexOf()
- Оператор для сравнения строк «==»
- java.lang.StringBuilder
- 2 Класс Double
- Creating Strings
- Производительность конкатенации
- Математика
- JSON
- Методы
- 3 String Pool
- Классы StringBuilder и StringBuffer
- 3 Создание подстрок
- Класс Object и его методы
- 1 Конкатенация — склеивание строк
- Решение распространенных проблем
- Структура программы
- Concatenating Strings
Введение в строки. Класс 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.length() == 0) 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(): соединяет строки с учетом разделителя
-
сompare(): сравнивает две строки
-
charAt(): возвращает символ строки по индексу
-
getChars(): возвращает группу символов
-
equals(): сравнивает строки с учетом регистра
-
equalsIgnoreCase(): сравнивает строки без учета регистра
-
regionMatches(): сравнивает подстроки в строках
-
indexOf(): находит индекс первого вхождения подстроки в строку
-
lastIndexOf(): находит индекс последнего вхождения подстроки в строку
-
startsWith(): определяет, начинается ли строка с подстроки
-
endsWith(): определяет, заканчивается ли строка на определенную подстроку
-
replace(): заменяет в строке одну подстроку на другую
-
trim(): удаляет начальные и конечные пробелы
-
substring(): возвращает подстроку, начиная с определенного индекса до конца или до определенного индекса
-
toLowerCase(): переводит все символы строки в нижний регистр
-
toUpperCase(): переводит все символы строки в верхний регистр
Разберем работу этих методов.
НазадВперед
Поиск с помощью 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».
Оператор для сравнения строк «==»
В первую очередь, надо сказать, что этот оператор проверяет и сравнивает не значения, а ссылки. С его помощью вы сможете проверить, являются ли сравниваемые вами элементы одним и тем же объектом. Когда 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
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-а. | |
| Первый метод удаляет подпоследовательность с 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 |
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 числа».
2 Класс Double
Класс , в общем-то, аналогичен классу , только является оберткой не для типа , а для типа . У него тоже есть интересные нам поля и методы, рассмотрим некоторые из них:
Интересных полей у класса шесть:
| Поле | Описание |
|---|---|
| Минус бесконечность | |
| Плюс бесконечность | |
| Минимальное значение экспоненты (2x) | |
| Максимальное значение экспоненты (2x) | |
| Минимальное значение типа | |
| Максимальное значение типа |
Бесконечность
Если вы разделите на , получите отрицательную бесконечность, если на — положительную бесконечность. Тип может не только делить на ноль, но и хранить такие значения.
Экспонента числа
С экспонентой тоже все просто. Число double внутри состоит из мантисы и экспоненты. Только вот значение экспоненты — это не , а . Если экспонента вырастет на , итоговое значение числа станет больше в два раза.
, в итоге получаем примерно равно
Также у класса есть интересные методы:
| Методы | Описание |
|---|---|
| Возвращает строку — шестнадцатеричное представление числа | |
| Проверяет, является ли переданное число бесконечностью. | |
| Проверяет, является ли переданное число | |
| Оборачивает переданный в | |
| Возвращает число, полученное из строки |
Из интересного можно отметить наличие метода , который возвращает , если переданное в него число было плюс или минус бесконечность.
Аналогично работает и метод — проверяет, является ли переданное в него число : специальная константа, обозначающая неопределенность (Not a Number, Не число).
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.
Производительность конкатенации
При объединении строк вам следует остерегаться возможных проблем с производительностью. Конкатенация двух строк будет преобразована компилятором 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.
Математика
Float или Double?
Программисты часто не могут выбрать необходимую точность для чисел с плавающей запятой. Float требует всего 4 байта, но имеет только 7 значащих цифр, а Double в два раза точнее (15 цифр), но в два раза прожорливее.
Фактически, большинство процессоров могут одинаково эффективно работать как с Float, так и с Double, поэтому воспользуйтесь рекомендацией Бьорна Страуструпа (автор языка С++):
Проверка на нечетность
Можно ли использовать этот код для точного определения нечетного числа?
Надеюсь, вы заметили хитрость. Если мы решим таким образом проверить отрицательное нечетное число (например, -5), остаток от деления не будет равен единице, поэтому воспользуйтесь более точным методом:
Он не только решает проблему отрицательных чисел, но и работает более производительно, чем предыдущий метод. Арифметические и логические операции выполняются намного быстрее, чем умножение и деление.
JSON
Сериализация и Десериализация
JSON — невероятно удобный и полезный синтаксис для хранения и обмена данными. Java полностью поддерживает это.
Прим. перев. Для использования JSON из примера необходимо подключить библиотеку JSON Simple.
Вы можете сериализовать данные следующим образом:
Получается следующая строка JSON:
Десериализация в Java выглядит так:
Используемый в примере файл JSON (jsonDemoFile.json):
Прим. перев. В Java проектах очень часто для работы с JSON используют библиотеки Gson от Google или Jackson. Обе библиотеки очень популярны и хорошо поддерживаются. Попробуйте и их.
Методы
Последнее обновление: 17.04.2018
Если переменные и константы хранят некоторые значения, то методы содержат собой набор операторов, которые выполняют определенные действия.
Общее определение методов выглядит следующим образом:
тип_возвращаемого_значения название_метода (){
// тело метода
}
Модификаторы и параметры необязательны.
По умолчанию главный класс любой программы на Java содержит метод main, который служит точкой входа в программу:
public static void main(String[] args) {
System.out.println("привет мир!");
}
Ключевые слова и являются модификаторами. Далее идет тип возвращаемого значения.
Ключевое слово указывает на то, что метод ничего не возвращает.
Затем идут название метода — main и в скобках параметры метода — . И в фигурные скобки заключено тело метода — все действия,
которые он выполняет.
Создадим еще несколько методов:
public class Program{
public static void main (String args[]){
}
void hello(){
System.out.println("Hello");
}
void welcome(){
System.out.println("Welcome to Java 10");
}
}
Здесь определены два дополнительных метода: hello и welcome, каждый из которых выводит некоторую строку на консоль. Методы определяются внутри класса — в данном случае внутри класса Program,
в котором определен метод main.
Но если мы скомпилируем и запустим данную программу, то мы ничего не увидим на консоли. В примере выше мы определили два метода, но мы их нигде не вызываем. По умолчанию в программе Java
выполняется только метод main и все его содержимое. Поэтому, если мы хотим, чтобы другие методы тоже выполнялись, их надо вызвать в методе main.
Вызов метода осуществляется в форме:
имя_метода(аргументы);
После имени метода указываются скобки, в которых перечисляются аргументы — значения для параметров метода.
Например, определим и выполним несколько методов:
public class Program{
public static void main (String args[]){
hello();
welcome();
welcome();
}
static void hello(){
System.out.println("Hello");
}
static void welcome(){
System.out.println("Welcome to Java 10");
}
}
В методе main вызывается один раз метод hello и два раза метод welcome. В этом и заключается одно из преимуществ методов: мы можем вынести некоторые общие действия в
отдельный метод и затем вызывать многократно их в различных местах программы. Поскольку оба метода не имеют никаких параметров, то после их названия при вызове ставятся пустые скобки.
Также следует отметить, что чтобы вызвать в методе main другие методы, которые определены в одном классе с методом main, они должны иметь модификатор
.
В итоге после компиляции и выполнения программы мы увидим на консоли:
Hello Welcome to Java 10 Welcome to Java 10
НазадВперед
3 String Pool
Все строки, которые были заданы в коде в , во время работы программы хранятся в памяти в так называемом . — это специальный массив для хранения строк. Цель его создания — оптимизация хранения строк:
Во-первых, строки, заданные в коде, нужно все-таки где-то хранить. Код — это команды, а данные (тем более такие большие как строки) нужно хранить в памяти отдельно от кода. В коде фигурируют только ссылки на объекты-строки.
Во-вторых, все одинаковые литералы можно хранить в памяти только один раз. Так оно и работает. Когда код вашего класса загружается Java-машиной, все строковые литералы добавляются в , если их там еще нет. Если уже есть, просто используется ссылка на строку из .
Поэтому если в своем коде вы присвоите нескольким -переменным одинаковые литералы, переменные будут содержать одинаковые ссылки. В литерал будет добавлен только один раз, во всех остальных случаях будет браться ссылка на уже загруженную в строку.
Как это примерно работает:
| Код | Работа с StringPoll |
|---|---|
Именно поэтому переменные и будут хранить одинаковые ссылки.
Метод
Ну и самое интересное: вы можете программно добавить любую строку в . Для этого нужно просто вызвать метод у -переменной.
Метод добавит строку в , если ее еще там нет, и вернет ссылку на строку из .
| Код | Примечание |
|---|---|
Вряд ли вы будете часто пользоваться этим методом, однако о нем любят спрашивать на собеседованиях, поэтому лучше о нем знать, чем не знать.
Классы StringBuilder и StringBuffer
Давайте теперь разберемся со StringBuilder и StringBuffer классами. По сути дела, это почти одинаковые классы. Единственное различие между ними: StringBuffer работает медленнее, но он потокобезопасный. Его использование целесообразно при написании программ на многопоточность.
Если Вы посмотрите на код выше, то последний метод, который я написал была конкатенация строк. То есть простое объединение строк в одну. Когда Вы работаете с классом String, результатом такой операции будет новый объект. Если программа конкатенирует много строк это может существенно потребить ресурсы памяти. В отличие от String классы StringBuilder, StringBuffer конкатенируют строки не создавая новый объект. У них есть метод append().
- StringBuilder string = new StringBuilder(«Hello world»);
- String str = «!!!»;
- System.out.println(string.append(str));//Hello world!!!
Все остальные методы которые есть у класса String есть у данных классов.
Теперь Вы знаете больше о строках в Java. Предлагаю закрепить наши знания и написать небольшую программу для проверки логина и пароля. Пользователь вводит логин и пароль; если пароль совпадает, то вывести в консоль приветствие.
Вот что у меня получилось:
- package com.string;
- import java.util.Scanner;
- public class StringVariables {
- private final static String PASSWORD = «pass43_4L»;
- private final static String LOGIN = «user»;
- public static void main(String args) {
- System.out.println(«Введите логин»);
- Scanner in = new Scanner(System.in);
- String login = in.nextLine();
- System.out.println(«Введите пароль»);
- String password = in.nextLine();
- if (LOGIN.equalsIgnoreCase(login)){
- if (PASSWORD.equals(password)){
- System.out.println(«Приветствую » + login);
- }
- else {
- System.out.println(«Неверный пароль»);
- }
- }
- else
- System.out.println(«Неверный логин»);
- }
- }
3 Создание подстрок
Кроме сравнения строк и поиска подстрок, есть еще одно очень популярное действие — получение подстроки из строки. В предыдущем примере вы как раз видели вызов метода , который возвращал часть строки.
Вот список из 8 методов получения подстрок из текущей строки:
| Методы | Описание |
|---|---|
| Возвращает подстроку, заданную интервалом символов . | |
| Повторяет текущую строку n раз | |
| Возвращает новую строку: заменяет символ на символ | |
| Заменяет в текущей строке подстроку, заданную регулярным выражением. | |
| Заменяет в текущей строке все подстроки, совпадающие с регулярным выражением. | |
| Преобразует строку к нижнему регистру | |
| Преобразует строку к верхнему регистру | |
| Удаляет все пробелы в начале и конце строки |
Вот краткое описание существующих методов:
Метод
Метод возвращает новую строку, которая состоит из символов текущей строки, начиная с символа под номером и заканчивая . Как и во всех интервалах в Java, символ с номером в интервал не входит. Примеры:
| Код | Результат |
|---|---|
Если параметр не указывается (а так можно), подстрока берется от символа beginIndex и до конца строки.
Метод
Метод repeat просто повторяет текущую строку раз. Пример:
| Код | Результат |
|---|---|
Метод
Метод возвращает новую строку, в которой все символы заменены на символ . Длина строки при этом не меняется. Пример:
| Код | Результат |
|---|---|
Методы и
Метод заменяет все вхождения одной подстроки на другую. Метод заменяет первое вхождение переданной подстроки на заданную подстроку. Строка, которую заменяют, задается регулярным выражением. Разбирать регулярные выражения мы будем в квесте Java Multithreading.
Примеры:
| Код | Результат |
|---|---|
Методы
С этими методами мы познакомились, когда только в первый раз учились вызывать методы класса .
Метод
Метод удаляет у строки пробелы с начала и с конца строки. Пробелы внутри строки никто не трогает. Примеры:
| Код | Результат |
|---|---|
Класс Object и его методы
Последнее обновление: 21.04.2018
Хотя мы можем создать обычный класс, который не является наследником, но фактически все классы наследуются от класса Object.
Все остальные классы, даже те, которые мы добавляем в свой проект, являются неявно производными от класса Object.
Поэтому все типы и классы могут реализовать те методы, которые определены в классе Object. Рассмотрим эти методы.
toString
Метод служит для получения представления данного объекта в виде строки. При попытке вывести строковое представления
какого-нибудь объекта, как правило, будет выводиться полное имя класса. Например:
public class Program{
public static void main(String[] args) {
Person tom = new Person("Tom");
System.out.println(tom.toString()); // Будет выводить что-то наподобие Person@7960847b
}
}
class Person {
private String name;
public Person(String name){
this.name=name;
}
}
Полученное мной значение (в данном случае ) вряд ли может служить хорошим строковым описанием объекта.
Поэтому метод нередко переопределяют. Например:
public class Program{
public static void main(String[] args) {
Person tom = new Person("Tom");
System.out.println(tom.toString()); // Person Tom
}
}
class Person {
private String name;
public Person(String name){
this.name=name;
}
@Override
public String toString(){
return "Person " + name;
}
}
Метод hashCode
Метод hashCode позволяет задать некоторое числовое значение, которое будет соответствовать данному объекту или его хэш-код.
По данному числу, например, можно сравнивать объекты.
Например, выведем представление вышеопределенного объекта:
Person tom = new Person("Tom");
System.out.println(tom.hashCode()); // 2036368507
Но мы можем задать свой алгоритм определения хэш-кода объекта:
class Person {
private String name;
public Person(String name){
this.name=name;
}
@Override
public int hashCode(){
return 10 * name.hashCode() + 20456;
}
}
Получение типа объекта и метод getClass
Метод позволяет получить тип данного объекта:
Person tom = new Person("Tom");
System.out.println(tom.getClass()); // class Person
Метод equals
Метод equals сравнивает два объекта на равенство:
public class Program{
public static void main(String[] args) {
Person tom = new Person("Tom");
Person bob = new Person("Bob");
System.out.println(tom.equals(bob)); // false
Person tom2 = new Person("Tom");
System.out.println(tom.equals(tom2)); // true
}
}
class Person {
private String name;
public Person(String name){
this.name=name;
}
@Override
public boolean equals(Object obj){
if (!(obj instanceof Person)) return false;
Person p = (Person)obj;
return this.name.equals(p.name);
}
}
Метод equals принимает в качестве параметра объект любого типа, который мы затем приводим к текущему, если они являются объектами
одного класса.
Оператор instanceof позволяет выяснить, является ли переданный в качестве параметра объект объектом определенного класса,
в данном случае класса Person. Если объекты принадлежат к разным классам, то их сравнение не имеет смысла, и возвращается значение false.
Затем сравниваем по именам. Если они совпадают, возвращаем true, что будет говорить, что объекты равны.
НазадВперед
1 Конкатенация — склеивание строк
Есть очень интересная и простая вещь, которую можно делать со строками в Java — их можно склеивать. Такая операция называется конкатенация. Ну или чтобы легче запомнилось — Кон-Котэ-Нация. Хотя часто ее называют «склеивание строк» или даже просто «сложение строк».
Чтобы склеить две строки, нужно использовать знак . Это очень просто:
Конкатенация двух строк
Примеры:
| Команда | Примечание |
|---|---|
| содержит строку | |
| содержит строку | |
| содержит строку |
Ну и, конечно, одновременно можно складывать много строк, а также складывать строки и переменные.
Примеры:
| Команда | Примечание |
|---|---|
| содержит строку содержит строку содержит строку |
В последнем примере видно, что текст в переменной плохо читается, т.к. в нем не хватает пробелов. Чтобы задать один пробел или несколько, нужно просто написать их в коде и обернуть в двойные кавычки. Это проще, чем кажется:
Строка, содержащая один пробел
Кстати, если между кавычками совсем не оставить места (написать две двойные кавычки подряд), получится так называемая «пустая строка»:
Пустая строка
С одной стороны, она вроде бы и есть, а с другой, при ее выводе на экран ничего не выводится. И при склейке с другими строками ничего не происходит. Эдакий аналог нуля, только для строк.
Решение распространенных проблем
Содержимое директории
Java позволяет вам получать имена всех подкаталогов и файлов в папке в виде массива, который затем можно последовательно прочитать:
Выполнение консольных команд
Java позволяет выполнять консольные команды прямо из кода, используя класс
Очень важно не забывать об обработке исключений
Например, давайте попробуем открыть файл PDF через терминал Java (на Linux’e):
Воспроизведение звуков
Звук — важный компонент многих десктопных приложений и игр. Язык программирования Java предоставляет средства для работы с ним.
Отправка email
Отправить электронную почту на Java очень просто. Вам просто нужно установить Java Mail и указать путь к нему в пути к классам проекта.
Получение координат курсора
Чтобы фиксировать события мыши, вам необходимо реализовать интерфейс . Когда курсор попадает в определенную область, срабатывает обработчик события , из которого вы можете получить точные координаты (используя Swing для UI)
Структура программы
Последнее обновление: 12.04.2018
Основным строительным блоком программы на языке Java являются инструкции (statement).
Каждая инструкция выполняет некоторое действие, например, вызовы методов, объявление переменных и присвоение им значений. После завершения инструкции в Java ставится точка с запятой (;). Данный знак указывает компилятору на
конец инструкции. Например:
System.out.println("Hello Java!");
Данная строка представляет вызов метода , который выводит на консоль строку «Hello Java!». В данном случае вызов
метода является инструкцией и поэтому завершается точкой с запятой.
Кроме отдельных инструкций распространенной конструкцией является блок кода. Блок кода содержит набор инструкций, он заключается в фигурные скобки, а инструкции помещаются между открывающей и закрывающей фигурными скобками:
{
System.out.println("Hello!");
System.out.println("Welcome to Java!");
}
В этом блоке кода две инструкции, которые выводят на консоль определенную строку.
Выполнение программы. Метод main
Java является объектно-ориентированным языком, поэтому всю программу можно представить как набор взаимодействующих между собой классов и объектов.
В первой главе при создании первого приложения программа была определена следующим образом:
public class Program{
public static void main (String args[]){
System.out.println("Hello Java!");
}
}
То есть основу нашей программы составляет класс Program. При определении класса вначале идет модификатор доступа public,
который указывает, что данный класс будет доступен всем, то есть мы сможем его запустить из командной строки. Далее идет ключевое слово class,
а затем название класса. После названия класса идет блок кода, в котором расположено содержимое класса.
Входной точкой в программу на языке Java является метод main, который определен в классе Program. Именно с него начинается
выполнение программы. Он обязательно должен присутствовать в программе. При этом его заголовок может быть только таким:
public static void main (String args[])
При запуске приложения виртуальная машина Java ищет в главном классе программы метод main с подобным заголовком, и после его обнаружения запускает его.
Вначале заголовка метода идет модификатор , который указывает, что метод будет доступен извне. Слово указывает, что метод
main — статический, а слово — что он не возвращает никакого значения. Далее в скобках у нас идут параметры метода — —
это массив args, который хранит значения типа String, то есть строки. При запуске программы через этот массив мы можем передать в программу различные данные.
После заголовка метода идет его блок, который содержит набор выполняемых инструкций.
Комментарии
Код программы может содержать комментарии. Комментарии позволяют понять смысл программы, что делают те или иные ее части. При компиляции комментарии
игнорируются и не оказывают никакого влияния на работу приложения и на его размер.
В Java есть два типа комментариев: однострочный и многострочный. Однострочный комментарий размещается на одной строке после двойного слеша //.
А многострочный комментарий заключается между символами /* текст комментария */. Он может размещаться на нескольких строках.
Например:
/*
многострочный комментарий
Объявление нового класса,
который содержит код программы
*/
public class Program{ // начало объявления класса Program
// определение метода main
public static void main (String args[]){ // объявление нового метода
System.out.println("Hello Java!"); // вывод строки на консоль
} // конец объявления нового метода
} // конец объявления класса Program
НазадВперед
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 −
