В чем разница между операторами и

Разница между операторами : и :: в Java

1) Отличие во всём. 2) В контексте лямбда-выражения, имеющего возвращаемым типом ArrayList или int[] соответственно.

25 апр в 7:59

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

В чем отличие действия операторов «двоеточие» : и «квадроточие» :: ?

Звучит примерно как «В чём разница между Spring и String?». Это просто два совершенно разных оператора. Двоеточие используется, например, в тернарных операторах

int a = b > c ? 10 : 20; 

или при написании цикла в стиле foreach

for (String each : List)

Может быть, ещё где-то, но мне с ходу вспомнились эти два случая.

«Квадроточие» же чаще всего называют ссылкой на метод (method reference) — это сокращённая форма записи лямбда-выражения и, соответственно, она используется только применительно к лямбдам.

Как создать массив и List используя квадроточие типа ArrayList::new и int[]::new ?

Их можно создать в контексте функционального интерфейса Supplier . Вот пример для ArrayList :

List list = . // есть какой-то список list .stream() . // что-то с ним делаем .collect(Collectors.toCollection(ArrayList::new)); 

Отслеживать
ответ дан 25 апр в 11:02
2,314 5 5 золотых знаков 9 9 серебряных знаков 22 22 бронзовых знака

1. В чем отличие действия операторов двоеточие (:) и квадроточие (::)?

В Java символ : используется в разных местах:

1. Как часть тернарного логического оператора ?: , возвращающего одно из двух значений:

String message = age < 16 ? "Детям вход воспрещён" : "Добро пожаловать!"; 

1. В сокращенной конструкции для цикла for-each (Java 5+).
   Фактически этот цикл представляет собой синтаксический сахар для итерации по массивам или объектам, реализующий интерфейс Iterable , т.е. к коллекциям, спискам, сетам (множествам) и т.д.

for (Type Identifier : Expression) Statement 

При этом для массивов цикл for-each преобразуется в классический цикл for со счётчиком:

T[] a = Expression; for (int i = 0; i

А для Iterable объектов используется итератор и его методы:

for (I iter = Expression.iterator(); iter.hasNext(); )

1. После меток для передачи управления во вложенных циклах:

int[] arr = ; out: for (int x : arr) < for (int i = 0; i < x; i++) < if (foo(x, i)) < continue out; >else if (bar(i)) < break out; >> > 

1. После меток case в классической форме оператора switch :

enum Weekday(MON, TUE, WED, THU, FRI, SAT, SUN); // . public String getDesc(Weekday wd) < switch (wd) < case SAT: case SUN: return "Week-end"; case MON: return "Manic Monday"; case WED: return "Mini Friday"; case FRI: return "Party time!"; default: return "Workday"; >> 

1. После условий в ассертах (assert) для вывода соответствующих сообщений:

int x = -1; assert x >= 0: "Negative x"; 

"Квадроточие" представляет собой ссылку на метод (Method Reference), добавленную в Java 8 вместе с другими фичами для программирования в функциональном стиле такими как лямбда-выражения, функциональные интерфейсы и т.д., см. похожий вопрос Что значит оператор :: ?.
Официальная документация от Oracle: Method References

Ссылки на метод можно рассматривать как некий более эффективный и читабельный аналог лямбда-выражений.

2. Как создать массив и List , используя квадроточие типа ArrayList::new и int[]::new ?

Ссылки на конструкторы можно рассматривать как реализации соответствующих интерфейсов Supplier , IntFunction и др.:

Supplier> defaultList = ArrayList::new; // ссылка на дефолтный конструктор IntFunction> capacityList = ArrayList::new; // ссылка на конструктор с capacity IntFunction arrayFactory = int[]::new; List list1 = defaultList.get(); // список по умолчанию List list2 = capacityList.apply(20); // список с емкостью 20 int[] arr = arrayFactory.apply(10); // массив из 10 элементов 

Базовые операторы, математика

Многие операторы знакомы нам ещё со школы: сложение + , умножение * , вычитание - и так далее.

В этой главе мы начнём с простых операторов, а потом сконцентрируемся на специфических для JavaScript аспектах, которые не проходят в школьном курсе арифметики.

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

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

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

let x = 1; x = -x; alert( x ); // -1, применили унарный минус

let x = 1, y = 3; alert( y - x ); // 2, бинарный минус вычитает значения

Математика

Поддерживаются следующие математические операторы:

• Сложение + ,
• Вычитание - ,
• Умножение * ,
• Деление / ,
• Взятие остатка от деления % ,
• Возведение в степень ** .

Первые четыре оператора очевидны, а про % и ** стоит сказать несколько слов.

Взятие остатка %

Оператор взятия остатка % , несмотря на обозначение, никакого отношения к процентам не имеет.

Результат a % b – это остаток от целочисленного деления a на b .

alert( 5 % 2 ); // 1, остаток от деления 5 на 2 alert( 8 % 3 ); // 2, остаток от деления 8 на 3 alert( 8 % 4 ); // 0, остаток от деления 8 на 4

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

Оператор возведения в степень a ** b возводит a в степень b .

В школьной математике мы записываем это как a b .

alert( 2 ** 2 ); // 2² = 4 alert( 2 ** 3 ); // 2³ = 8 alert( 2 ** 4 ); // 2⁴ = 16

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

alert( 4 ** (1/2) ); // 2 (степень 1/2 эквивалентна взятию квадратного корня)

Сложение строк при помощи бинарного +

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

Обычно при помощи плюса '+' складывают числа.

Но если бинарный оператор '+' применить к строкам, то он их объединяет в одну:

let s = "моя" + "строка"; alert(s); // моястрока

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

alert( '1' + 2 ); // "12" alert( 2 + '1' ); // "21"

Как видите, не важно, первый или второй операнд является строкой.

Вот пример посложнее:

alert(2 + 2 + '1' ); // будет "41", а не "221"

Здесь операторы работают один за другим. Первый + складывает два числа и возвращает 4 , затем следующий + объединяет результат со строкой, производя действие 4 + '1' = '41' .

Сложение и преобразование строк — это особенность бинарного плюса + . Другие арифметические операторы работают только с числами и всегда преобразуют операнды в числа.

Например, вычитание и деление:

alert( 6 - '2' ); // 4, '2' приводится к числу alert( '6' / '2' ); // 3, оба операнда приводятся к числам

Приведение к числу, унарный +

Плюс + существует в двух формах: бинарной, которую мы использовали выше, и унарной.

Унарный, то есть применённый к одному значению, плюс + ничего не делает с числами. Но если операнд не число, унарный плюс преобразует его в число.

// Не влияет на числа let x = 1; alert( +x ); // 1 let y = -2; alert( +y ); // -2 // Преобразует не числа в числа alert( +true ); // 1 alert( +"" ); // 0

На самом деле это то же самое, что и Number(. ) , только короче.

Необходимость преобразовывать строки в числа возникает очень часто. Например, обычно значения полей HTML-формы — это строки. А что, если их нужно, к примеру, сложить?

Бинарный плюс сложит их как строки:

let apples = "2"; let oranges = "3"; alert( apples + oranges ); // "23", так как бинарный плюс объединяет строки

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

let apples = "2"; let oranges = "3"; // оба операнда предварительно преобразованы в числа alert( +apples + +oranges ); // 5 // более длинный вариант // alert( Number(apples) + Number(oranges) ); // 5

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

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

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

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

Из школы мы знаем, что умножение в выражении 1 + 2 * 2 выполнится раньше сложения. Это как раз и есть «приоритет». Говорят, что умножение имеет более высокий приоритет, чем сложение.

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

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

Отрывок из таблицы приоритетов (нет необходимости всё запоминать, обратите внимание, что приоритет унарных операторов выше, чем соответствующих бинарных):

Приоритет	Название	Обозначение
…	…	…
15	унарный плюс	+
15	унарный минус	-
14	возведение в степень	**
13	умножение	*
13	деление	/
12	сложение	+
12	вычитание	-
…	…	…
2	присваивание	=
…	…	…

Так как «унарный плюс» имеет приоритет 15 , который выше, чем 12 у «сложения» (бинарный плюс), то в выражении "+apples + +oranges" сначала выполнятся унарные плюсы, а затем сложение.

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

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

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

let x = 2 * 2 + 1; alert( x ); // 5

Присваивание = возвращает значение

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

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

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

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

let a = 1; let b = 2; let c = 3 - (a = b + 1); alert( a ); // 3 alert( c ); // 0

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

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

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

Присваивание по цепочке

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

let a, b, c; a = b = c = 2 + 2; alert( a ); // 4 alert( b ); // 4 alert( c ); // 4

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

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

c = 2 + 2; b = c; a = c;

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

Сокращённая арифметика с присваиванием

Часто нужно применить оператор к переменной и сохранить результат в ней же.

let n = 2; n = n + 5; n = n * 2;

Эту запись можно укоротить при помощи совмещённых операторов += и *= :

let n = 2; n += 5; // теперь n = 7 (работает как n = n + 5) n *= 2; // теперь n = 14 (работает как n = n * 2) alert( n ); // 14

Подобные краткие формы записи существуют для всех арифметических и побитовых операторов: /= , -= , **= и так далее.

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

let n = 2; n *= 3 + 5; alert( n ); // 16 (сначала выполнится правая часть, выражение идентично n *= 8)

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

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

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

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

let counter = 2; counter++; // работает как counter = counter + 1, просто запись короче alert( counter ); // 3

let counter = 2; counter--; // работает как counter = counter - 1, просто запись короче alert( counter ); // 1

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

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

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

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

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

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

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

let counter = 1; let a = ++counter; // (*) alert(a); // 2

В строке (*) префиксная форма ++counter увеличивает counter и возвращает новое значение 2 . Так что alert покажет 2 .

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

let counter = 1; let a = counter++; // (*) меняем ++counter на counter++ alert(a); // 1

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

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

let counter = 0; counter++; ++counter; alert( counter ); // 2, обе строки сделали одно и то же

Разница между операторами «=», «==» и «===»?

«=» - оператор присваивания. Оператор присваивания присваивает значение своему левому операнду на основе значения его правого операнда. Первым операндом должна быть переменная, которая присваивает значение своего правого операнда своему левому операнду. То есть x = y присваивает значение y x.

Пример

x=5 y=100

Оператор = ведет себя как другие операторы, поэтому выражения, содержащие его, имеют значение. Это означает, что вы можете связать операторы присваивания следующим образом: x = y = z = 0. В этом случае x, y и z равны нулю.

== operator

Оператор '==' сравнивает две переменные или переменную со значением. Он преобразует операнды, если они не одного типа, а затем применяет строгое сравнение. Если оба операнда являются объектами, тогда JavaScript сравнивает внутренние ссылки, равные, когда операнды относятся к одному и тому же объекту в памяти.

Пример

x==5 x==y 1== 1 // true '1'== 1 // true

=== Оператор

«===» - это тождественный оператор, который возвращает true, если операнды строго равны (см. Выше) без преобразования типа. Он вернет false, даже если их значения равны, но они не одного типа данных.

Например: 999 и «999», в соответствии со значениями одинаковы, но они не одного типа данных, поэтому === вернет false.

Пример

999 === 999 // true 999 === '999' // false

В чем разница между is() и == в Python?

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

Операторы is и == в Python выполняют похожие функции, но работают немного по-разному. И если вы новичок, используете сравнения в коде, стоит понимать разницу. Это поможет реже прибегать к рефакторингу и дебагу.

Оператор ==

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

>>> 1 == 1 True >>> 'abc' == 'abc' True >>> [1, 2, 3] == [1, 2, 3] True 

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

Оператор is()

is() проверяет, являются ли два операнда одним и тем же объектом, то есть указывают ли они на один и тот же объект в памяти.

>>> a = [1, 2, 3] >>> b = a >>> a is b True 

В этом случае a и b указывают на один и тот же список, поэтому a is b возвращает True .

>>> a = [1, 2, 3] >>> b = [1, 2, 3] >>> a is b False 

Здесь a и b указывают на разные списки (несмотря на то, что их значения идентичны), поэтому a is b возвращает False .

Почему не стоит учить Python

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