Метод split в java: делим строку на части

Инкремент/декремент

Одной из наиболее частых числовых операций является увеличение или уменьшение на единицу.

Для этого существуют даже специальные операторы:

• Инкремент увеличивает переменную на 1:

• Декремент уменьшает переменную на 1:

Важно:

Инкремент/декремент можно применить только к переменной. Попытка использовать его на значении, типа 5++, приведёт к ошибке.

Операторы и могут быть расположены не только после, но и до переменной.

• Когда оператор идёт после переменной — это «постфиксная форма»: .
• «Префиксная форма» — это когда оператор идёт перед переменной: .

Обе эти инструкции делают одно и то же: увеличивают на .

Есть ли разница между ними? Да, но увидеть её мы сможем, только если будем использовать значение, которое возвращают .

Давайте проясним этот момент. Как мы знаем, все операторы возвращают значение. Операторы инкремента/декремента не исключение. Префиксная форма возвращает новое значение, в то время как постфиксная форма возвращает старое (до увеличения/уменьшения числа).

Чтобы увидеть разницу, вот небольшой пример:

В строке префиксная форма увеличивает и возвращает новое значение . Так что покажет .

Теперь посмотрим на постфиксную форму:

В строке постфиксная форма также увеличивает , но возвращает старое значение (которое было до увеличения). Так что покажет .

Подведём итоги:

• Если результат оператора не используется, а нужно только увеличить/уменьшить переменную, тогда без разницы, какую форму использовать:

• Если хочется тут же использовать результат, то нужна префиксная форма:

• Если нужно увеличить и при этом получить значение переменной до увеличения – нужна постфиксная форма:

Инкремент/декремент можно использовать в любых выражениях

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

Например:

Сравните с:

Хотя технически здесь всё в порядке, такая запись обычно делает код менее читабельным. Одна строка выполняет множество действий – нехорошо.

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

Лучше использовать стиль «одна строка – одно действие»:

Типы чисел с плавающей точкой (по IEEE 754)[править]

Число половинной точности (Binary16, Half precision)править

Число́ полови́нной то́чности  — компьютерный формат представления чисел, занимающий в памяти половину машинного слова (в случае 32-битного компьютера — бит или байта). В силу невысокой точности этот формат представления чисел с плавающей запятой обычно используется в видеокартах, где небольшой размер и высокая скорость работы важнее точности вычислений.

Знак
	Порядок	Мантисса
1,
	14	10		9

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

Ограничения точности

• Целые от нуля до передаются как есть.
• Целые от до округляются к ближайшему чётному целому.
• Целые от до округляются до ближайшего целого, делящегося нацело на четыре.
• Целые от до округляются до ближайшего целого, делящегося на восемь.
• Целые от до округляются до ближайшего целого, делящегося на шестнадцать.
• Целые от до округляются до ближайшего целого, делящегося на тридцать два.

Число одинарной точности (Binary32, Single precision, float)править

Число́ одина́рной то́чности — компьютерный формат представления чисел, занимающий в памяти одно машинное слово (в случае 32-битного компьютера — бита или байта). Используется для работы с вещественными числами везде, где не нужна очень высокая точность.

Знак
	Порядок (8 бит)	Мантисса (23+1 бита)
1,
	30	23		22

Порядок записан со сдвигом .

Число двойной точности (Binary64, Double precision, double)править

Число́ двойно́й то́чности —
компьютерный формат представления чисел, занимающий в памяти два машинных слова (в случае 32-битного компьютера — бита или байт). Часто используется благодаря своей неплохой точности, даже несмотря на двойной расход памяти и сетевого трафика относительно чисел одинарной точности.

Знак
	Порядок(11 бит)	Мантисса(52+1 бит)
1,
	62	52		51

Порядок записан со сдвигом .

Число четверной точности (Binary128, Quadruple precision)править

Число́ четверно́й то́чности —
компьютерный формат представления чисел, занимающий в памяти четыре машинных слова (в случае 32-битного компьютера — бит или байт). Используется в случае необходимости крайне высокой точности.

Знак
	Порядок(15 бит)	Мантисса(112+1 бит)
1,
	126	112		111

Мантисса(112+1 бит)

Порядок записан со сдвигом .

Обычно этот формат реализуется программно, случаи аппаратной реализации крайне редки. Также не гарантируется поддержка этого типа в языках программирования, хотя кое-где она и реализована (например, компилятор gcc для архитектуры x86 позволяет использовать тип __float128, являющийся программной реализацией числа с четверной точностью).
В совокупности эти факторы делают Quadruple весьма экзотичным и редко встречающимся форматом чисел с плавающей запятой.

Диапазон значений чисел с плавающей запятойправить

Диапазон чисел, которые можно записать данным способом, зависит от количества бит, отведённых для представления мантиссы и показателя. Пара значений показателя (когда все разряды нули и когда все разряды единицы) зарезервирована для обеспечения возможности представления специальных чисел. К ним относятся ноль, значения NaN (Not a Number, «не число», получается как результат операций типа деления нуля на ноль) и .

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

Название в IEEE 754	Название типа переменной в Си	Диапазон значений	Бит в мантиссе	Бит на переменную
Half precision	—	6,10×10-5..65504	11	16
Single presicion	float	-3,4×1038..3,4×1038	23	32
Double precision	double	-1,7×10308..1,7×10308	53	64
Extended precision	На некоторых архитектурах (например в сопроцессоре Intel) long double	-3,4×104932..3,4×104932	65	80

Операция instanceof

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

Java

obj1 instanceof A

1	obj1 instanceofA

Возвращается
true, если
obj1  не
null  и является экземпляром класса
A  или экземпляром дочернего класса
A  или экземпляром класса, реализующего интерфейс
A.

Java

Object obj1 = new String(«test1»);
if (obj1 instanceof String) {
System.out.println(«YES»);
}

1 2 3 4

Objectobj1=newString(«test1»); if(obj1 instanceofString){ System.out.println(«YES»); }

Если левый операнд равен
null, то результатом будет
false. Код ниже выведет “NO”:

Java

Object obj1 = null;
if (obj1 instanceof String) {
System.out.println(«YES»);
} else {
System.out.println(«NO»);
}

1 2 3 4 5 6

Objectobj1=null; if(obj1 instanceofString){ System.out.println(«YES»); }else{ System.out.println(«NO»); }

Операции с числами

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

Арифметические операции

Kotlin поддерживает базовые арифметические операции:

• + (сложение): возвращает сумму двух чисел.

  val x = 5
  val y = 6
  val z = x + y
  println(z)      // z = 11
  

• — (вычитание): возвращает разность двух чисел.

  val x = 5
  val y = 6
  val z = x - y  // z = -1
  

• * (умножение): возвращает произведение двух чисел.

  val x = 5
  val y = 6
  val z = x * y  // z = 30
  

• (деление): возвращает частное двух чисел.

  val x = 60
  val y = 10
  val z = x / y  // z = 6
  

• %: возвращает остаток от целочисленного деления двух чисел.

  val x = 65
  val y = 10
  val z = x % y  // z = 5
  

• ++ (инкремент): увеличивает значение на единицу.

  Префиксный инкремент возвращает увеличенное значение:

  var x = 5
  val y = ++x
  println(x)      // x = 6
  println(y)      // y = 6
  

  Постфиксный инкремент возвращает значение до увеличения на единицу:

  var x = 5
  val y = x++
  println(x)      // x = 6
  println(y)      // y = 5
  

• — (декремент): уменьшает значение на единицу.

  Префиксный декремент возвращает уменьшенное значение:

  var x = 5
  val y = --x
  println(x)      // x = 4
  println(y)      // y = 4
  

  Постфиксный декремент возвращает значение до уменьшения на единицу:

  var x = 5
  val y = x--
  println(x)      // x = 4
  println(y)      // y = 5
  

Также есть ряд операций присвоения, которые сочетают арифметические операции и присвоение:

• +=: присваивание после сложения. Присваивает левому операнду сумму левого и правого операндов: A += B эквивалентно
  A = A + B

• -=: присваивание после вычитания. Присваивает левому операнду разность левого и правого операндов:
  A -= B эквивалентно A = A — B

• *=: присваивание после умножения. Присваивает левому операнду произведение левого и правого операндов:
  A *= B эквивалентно A = A * B

• /=: присваивание после деления. Присваивает левому операнду частное левого и правого операндов:
  A /= B эквивалентно A = A / B

• %=: присваивание после деления по модулю. Присваивает левому операнду остаток от целочисленного деления левого операнда на правый:
  A %= B эквивалентно A = A % B

Побитовые операторы

Ряд операций выполняется над двоичными разрядми числа

Здесь важно понимать, как выглядит двоичное представление тех или иных чисел. В частности, число 4 в двоичном виде — 100, а число 15 — 1111

Есть следующие побитовые операторы (они применяются только к данным типов Int и Long):

• shl: сдвиг битов числа со знаком влево

  val z = 3 shl 2     // z = 11 << 2 = 1100 
  println(z)          // z = 12
  val d = 0b11 shl 2
  println(d)          // d = 12
  

  В данном случае число сдвигается на два разряда влево, поэтому справа число в двоичном виде дополняется двумя нулями. То есть в двоичном виде 3 представляет 11. Сдвигаем
  на два разряда влево (дополняем справа двумя нулями) и получаем 1100, то есть в десятичной системе число 12.

• shr: сдвиг битов числа со знаком вправо

  val z = 12 shr 2     // z = 1100 >> 2 = 11
  println(z)          // z = 3
  val d = 0b1100 shr 2
  println(d)          // d = 3
  

  Число 12 сдвигается на два разряда вправо, то есть два числа справа факически отбрасываем и получаем число 11, то есть 3 в десятичой системе.

• ushr: сдвиг битов беззнакового числа вправо

  val z = 12 ushr 2     // z = 1100 >> 2 = 11
  println(z)          // z = 3
  

• and: побитовая операция AND (логическое умножение или конъюнкция). Эта операция сравнивает соответствующие разряды двух чисел и возвращает единицу, если эти разряды обоих чисел равны 1.
  Иначе возвращает 0.

  val x = 5   // 101
  val y = 6   // 110
  val z = x and y     // z = 101 & 110 = 100
  println(z)          // z = 4
  
  val d = 0b101 and 0b110
  println(d)          // d = 4
  

• or: побитовая операция OR (логическое сложение или дизъюнкция). Эта операция сравнивают два соответствуюших разряда обоих чисел и
  возвращает 1, если хотя бы один разряд равен 1. Если оба разряда равны 0, то возвращается 0.

  val x = 5   // 101
  val y = 6   // 110
  val z = x or y     // z = 101 | 110 = 111
  println(z)         // z = 7
  
  val d = 0b101 or 0b110
  println(d)          // d = 7
  

• xor: побитовая операция XOR. Сравнивает два разряда и возвращает 1, если один из разрядов равен 1, а другой равен 0.
  Если оба разряда равны, то возвращается 0.

  val x = 5   // 101
  val y = 6   // 110
  val z = x xor y     // z = 101 ^ 110 = 011
  println(z)         // z = 3
  
  val d = 0b101 xor 0b110
  println(d)          // d = 3
  

• inv: логическое отрицание или инверсия — инвертирует биты числа

  val b = 11  // 1011
  val c = b.inv()
  println(c)      // -12
  

НазадВперед

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

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

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

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

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

Метод

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

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

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

Метод

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

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

Метод

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

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

Методы и

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

Примеры:

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

Методы

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

Метод

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

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

Объявление и инициализация переменных

В общем случае при объявлении переменной в C#, вначале указывается тип данных переменной, затем ее имя:

int nVal;
string strVal;

Задание значения переменной можно произвести в момент инициализации:

int radius = 10;
string name = "John";

либо после инициализаций:

string name;
name = "John";

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

int notInitedVal;
Console.Write(notInitedVal);

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

Ключевое слово new

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

class Rectangle
{
    public double Width = 0;
    public double Height = 0;
}

Данный класс нам нужен только для демонстрации, при разработке собственных классов не стоит создать поля с ключевым словом public. О создании классов и основах объектно-ориентированного программирования будет рассказано в одном из ближайших уроков.

Создадим переменную класса Rectangle

Rectangle rect = new Rectangle();
Console.WriteLine($"Rectangle Width={rect.Width}, Height={rect.Height}");

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

int newInitedValue = new int();
Console.WriteLine("Default int value: " + newInitedValue);

Ключевое слово var. Неявная типизация

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

int v1 = 12345;
var v2 = 12345;

Console.WriteLine($"Type of v1: {v1.GetType()}\nType of v2: {v2.GetType()}");

При работе с var необходимо помнить следующее:

• использовать var можно только для объявления локальных переменных;
• var нельзя использоваться для объявления типа возвращаемого значения, типов полей и параметров;
• при объявлении переменной с использованием var она обязательно должна быть проинициализирована, при этом использовать для этого null запрещено;
• объявлять переменную допускающую null-значение с использованием лексемы ? через var нельзя.

Термины: «унарный», «бинарный», «операнд»

Прежде, чем мы двинемся дальше, давайте разберёмся с терминологией.

• Операнд – то, к чему применяется оператор. Например, в умножении есть два операнда: левый операнд равен , а правый операнд равен . Иногда их называют «аргументами» вместо «операндов».

• Унарным называется оператор, который применяется к одному операнду. Например, оператор унарный минус меняет знак числа на противоположный:

• Бинарным называется оператор, который применяется к двум операндам. Тот же минус существует и в бинарной форме:

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

Присваивание

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

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

Тот факт, что является оператором, а не «магической» конструкцией языка, имеет интересные последствия.

Большинство операторов в JavaScript возвращают значение. Для некоторых это очевидно, например сложение или умножение . Но и оператор присваивания не является исключением.

Вызов записывает в и возвращает его.

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

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

Забавное применение присваивания, не так ли? Нам нужно понимать, как это работает, потому что иногда это можно увидеть в JavaScript-библиотеках.

Однако писать самим в таком стиле не рекомендуется. Такие трюки не сделают ваш код более понятным или читабельным.

Рассмотрим ещё одну интересную возможность: цепочку присваиваний.

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

Опять-таки, чтобы код читался легче, лучше разделять подобные конструкции на несколько строчек:

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

Выделение памяти

Коротко о том, как происходит выделение памяти со стороны кода в фоновом режиме:

• Каждый раз при создании объекта в Java он сохраняется в heap памяти.
• Примитивы и локальные переменные хранятся в stack памяти, переменные-члены — в heap.
• При многопоточности каждый поток имеет собственный stack, но находится в общей куче (heap). О многопоточности поговорим во второй части.
• При вызове какого-либо метода все методы и переменные помещаются в stack. По завершении вызова указатель стека (stack) уменьшается.
• 32-разрядная операционка тратит не более 4GB RAM на Java-приложения. В 64-разрядной затраты памяти на те же элементы увеличиваются вдвое.
• Примитивный тип int тратит в 4 раза меньше памяти, чем Integer.

Графическое представление распределения памяти

Таблица ниже перечисляет различные типы данных и их диапазоны хранимых значений:

Типы данных и диапазоны значений

Использование вне платформы Java

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

Oracle предоставляет платформу Java для использования с Java. Android SDK является альтернативой программной платформы используется в основном для разработки приложений для Android со своей собственной системой графического интерфейса пользователя.

Android

В операционной системе Android широко используются технологии, связанные с Java.

Язык Java — это ключевая опора Android , мобильной операционной системы с открытым исходным кодом . Хотя Android, построенный на ядре Linux , в основном написан на C, использует язык Java в качестве основы для приложений Android, но не использует ни один из его стандартных GUI, SE, ME или других установленных стандартов Java. Язык байт-кода, поддерживаемый Android SDK, несовместим с байт-кодом Java и работает на собственной виртуальной машине, оптимизированной для устройств с низким объемом памяти, таких как смартфоны и планшетные компьютеры . В зависимости от версии Android байт-код либо интерпретируется виртуальной машиной Dalvik, либо компилируется в собственный код средой выполнения Android .

Android не предоставляет полную стандартную библиотеку Java SE, хотя Android SDK действительно включает независимую реализацию большого ее подмножества. Он поддерживает Java 6 и некоторые функции Java 7, предлагая реализацию, совместимую со стандартной библиотекой ( Apache Harmony ).

Полемика

Использование технологии Java в Android привело к юридическому спору между Oracle и Google. 7 мая 2012 г. жюри в Сан-Франциско пришло к выводу, что если API-интерфейсы могут быть защищены авторским правом, то Google нарушил авторские права Oracle, используя Java в устройствах Android. Окружной судья Уильям Хаскелл Алсуп постановил 31 мая 2012 г., что API-интерфейсы не могут быть защищены авторским правом, но это было отменено Апелляционным судом США по федеральным округам в мае 2014 г. 26 мая 2016 г. окружной суд принял решение в пользу Решение Google о нарушении авторских прав на Java API в Android является добросовестным использованием. В марте 2018 года это решение было отменено Апелляционным судом, который направил дело об определении размера ущерба в федеральный суд Сан-Франциско. Google подал прошение о выдаче судебного приказа в Верховный суд США в январе 2019 года, чтобы оспорить два решения, вынесенные Апелляционным судом в пользу Oracle.

Разделение

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

JVM, JRE и JDK

Вот так и происходит вся магия: логика (т.е. код) прописывается в java файле, который затем преобразуется в файл класса. Машина его читает и выполняет.

Поток JVM, JRE и JDK 

А теперь подробнее:

• JVM — виртуальная машина Java, выполняющая байт-код Java.
• JVM можно загружать на разном железе. Байт-коды — это машинный язык JVM. Поэтому Java является самым портируемым языком. JVM — это некий объект, который и обеспечивает портируемость. Для разных операционных систем (Mac, Windows, Linux и т.д.) придуманы свои реализации JVM.
• JRE — среда выполнения Java, достаточная для запуска программы.
• JRE = JVM + файлы библиотеки/пакеты классов (Util, Lang, Math etc).
• JDK — пакет средств разработки на Java. Нужен для написания, компиляции и выполнения программы.
• JDK = JRE + инструменты, необходимые для разработки Java-программы.

Логические И и ИЛИ

Логическое И
&&  и Логическое ИЛИ
|| ведут себя вполне ожидаемо для логического И или логического ИЛИ:

Java

boolean b1 = true && true; //true
boolean b2 = true && false; //false
boolean b3 = true || false; // true
boolean b4 = false || false; //false

System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
System.out.println(b4);

1 2 3 4 5 6 7 8 9

booleanb1=true&&true;//true booleanb2=true&&false;//false booleanb3=true||false;// true booleanb4=false||false;//false System.out.println(b1); System.out.println(b2); System.out.println(b3); System.out.println(b4);

Логическое И
&&  вычисляет свой правый операнд только в том случае, если левый равен
true. Если левый операнд равен
false, то сразу возвращается
false. Логическое ИЛИ
||  вычисляет правый операнд только в том случае, если левый равен
false. Если левый операнд равен
true, то сразу возвращается
true. Эти два правила сокращения вычислений позволяют сразу откинуть последующие вычисления, если результат всего выражения уже известен. Это можно использовать для проверки на
null  перед проверкой результата какого-либо метода объекта (будет описано в дальнейшем):

Java

if (obj != null && obj.method1()) { // obj.method1() будет вызывать только
// если проверка obj!= null вернула true.
}

1 2 3

if(obj!=null&&obj.method1()){// obj.method1() будет вызывать только // если проверка obj!= null вернула true. }

4 Деление целых и вещественных чисел в Java

При делении целого числа на целое остаток всегда отбрасывается. Как же тогда, скажем, поделить на , чтобы получить ?

Поначалу кажется, что правильный вариант такой:

Однако не все так просто. Дело в том, что Java-машина сначала вычислит значение выражения и только потом присвоит результат в переменную . А деление выполнится нацело. Т.е.  будет содержать или, если быть более точным,

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

В любом из этих выражений  будет содержать значение

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

Тут есть хитрое (и очевидное) решение — заставить Java-машину преобразовать переменные в вещественные, умножив их на вещественную единицу — 

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

Примеры:

Команда	Порядок выполнения	Результат

Подсписок списка

Метод subList () может создавать новый List с подмножеством элементов из исходного List.

Метод subList () принимает 2 параметра: начальный индекс и конечный индекс. Начальный индекс — это индекс первого элемента из исходного списка для включения в подсписок.

Конечный индекс является последним индексом подсписка, но элемент в последнем индексе не включается в подсписок. Это похоже на то, как работает метод подстроки Java String.

List list      = new ArrayList();

list.add("element 1");
list.add("element 2");
list.add("element 3");
list.add("element 4");

List sublist = list.subList(1, 3);

После выполнения list.subList (1,3) подсписок будет содержать элементы с индексами 1 и 2.

Преобразовать list в set

Вы можете преобразовать список Java в набор(set), создав новый набор и добавив в него все элементы из списка. Набор удалит все дубликаты.

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

List list = new ArrayList();

list.add("element 1");
list.add("element 2");
list.add("element 3");
list.add("element 3");

Set set = new HashSet();
set.addAll(list);

Обратите внимание, что список содержит элемент String 3 два раза. Набор будет содержать эту строку только один раз

Таким образом, результирующий набор будет содержать строки:  ,  and  .

Общие списки

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

List<MyObject> list = new ArrayList<MyObject>();

Этот список теперь может содержать только экземпляры MyObject. Затем вы можете получить доступ к итерации его элементов без их приведения.

MyObject myObject = list.get(0);

for(MyObject anObject : list){
   //do someting to anObject...
}

Стиль оформления кода

Существует негласные правила оформления стиля при написании кода. Старайтесь их придерживаться. Также запоминайте оформление кода в документации и справочниках. Например, принято записывать имена классов с большой буквы (class JavaQuickCourseActivity). Если имя состоит из нескольких слов, то каждое слово в имени также начинается с большой буквы. Использовать символы подчеркивания или тире нежелательно (Java_Quick_Course_Activity или Java-Quick-Course-Activity).

Для методов и переменных используется такой же формат, только первый символ записывается с маленькой буквы, например, resultButton.

Константы принято писать только большими буквами — IDD_LIST_NAMES. В этом случае одного взгляда достаточно, чтобы сразу определить, что перед вами константа.

На первых порах вам этого достаточно.

Загрузка статического и динамического класса

• Добавление класса для запуска в JVM называется загрузкой класса.
• Классы загружаются статично с помощью нового оператора.
• Первый класс загружается через метод static main(). Затем подгружаются остальные классы.
• В серверных проектах отсутствует main(), поскольку сервер сам отвечает за всю инфраструктуру. Первый класс для загрузки отмечается в config файле. Довольно часто фреймворк реализует метод main() и предоставляет API. Пример: Контейнерный класс вызывает метод init() в сервлетах.
• main нужен для запуска Java-программы из командной строки в JVM.
• Если при загрузке статического класса не находится ссылка на класс, то выбрасывается NoClassDefinationFoundException.
• Динамические классы загружаются через программный вызов при выполнении. Пример: Class.forName(String ClassName);
• ClassNotFoundException выбрасывается при загрузке динамического класса.

Дата и Время

System.currentTimeMillis или System.nanoTime?

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

Метод возвращает текущее количество миллисекунд с начала эры Unix в формате Long. Его точность составляет от 1 до 15 тысячных долей секунды в зависимости от системы.

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

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

Валидация Даты из строки

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

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

Результат:

Краткие выводы

• Все логические операторы применяются к булевским выражениям, то есть таким, о которых можно сказать, true они или false.
• Если операторы , или применяются к числам, речь идёт уже не о логических операциях, а о побитовых. То есть оба числа переводятся в двоичную систему и к этим числам побитово применяют операции логического сложения, умножения или вычитания.
• В математической логике операторам и соответствуют конъюнкция и дизъюнкция.
• Логическое И похоже на умножения 1 (true) и 0 (false).
• Логическое ИЛИ напоминает поиск максимума среди 1 (true) и 0 (false).
• Для побитового отрицания целого числа a используется операция .
• Для логического отрицания булевского выражения a используется операция .
• Отрицательные числа хранятся и обрабатываются в дополнительном коде.
• Поразрядный сдвиг вправо может сохранять знак (), а может — не сохранять ().