| = |
x = y |
Assignment operator (Right associative). Assigns the value of
y to the L-value x. Note that the data type of
x must match the data type
of y, and cannot be null. |
| += |
x += y |
Addition assignment operator (Right associative). Adds the
value of y to the original
value of x and then reassigns
the new value to x. See + for additional information. x
and y cannot be
null. |
| *= |
x *= y |
Multiplication assignment operator (Right associative).
Multiplies the value of y with
the original value of x and
then reassigns the new value to x. Note that x
and y must be Integers or
Doubles, or a combination. x
and y cannot be
null. |
| -= |
x -= y |
Subtraction assignment operator (Right associative). Subtracts
the value of y from the
original value of x and then
reassigns the new value to x.
Note that x and y must be Integers or Doubles, or a
combination. x
and y cannot be
null. |
| /= |
x /= y |
Division assignment operator (Right associative). Divides the
original value of x with the
value of y and then reassigns
the new value to x. Note that
x and y must be Integers or Doubles, or a
combination. x
and y cannot be
null. |
| |= |
x |= y |
OR assignment operator (Right associative). If x, a Boolean, and y, a Boolean, are both false, then
x remains false. Otherwise,
x is assigned the value of
true. x
and y cannot be
null. |
| &= |
x &= y |
AND assignment operator (Right associative). If x, a Boolean, and y, a Boolean, are both true, then
x remains true. Otherwise,
x is assigned the value of
false. x
and y cannot be
null. |
| <<= |
x <<= y |
Bitwise shift left assignment operator. Shifts each bit in
x to the left by y bits so that the high order bits
are lost, and the new right bits are set to 0. This value is then
reassigned to x. |
| >>= |
x >>= y |
Bitwise shift right signed assignment operator. Shifts each
bit in x to the right by
y bits so that the low
order bits are lost, and the new left bits are set to 0 for positive
values of y and 1 for negative
values of y. This value is then
reassigned to x. |
| >>>= |
x >>>= y |
Bitwise shift right unsigned assignment operator. Shifts each
bit in x to the right by
y bits so that the low
order bits are lost, and the new left bits are set to 0 for all values
of y. This value is then
reassigned to x. |
| ? : |
x ? y : z |
Ternary operator (Right associative). This operator acts as a
short-hand for if-then-else statements. If x, a Boolean, is true, y is the result. Otherwise z is the result. Note that x cannot be null. |
| && |
x && y |
AND logical operator (Left associative). If x, a Boolean, and y, a Boolean, are both true, then
the expression evaluates to true. Otherwise the expression evaluates to
false. Note:
-
&& has
precedence over ||
- This operator exhibits “short-circuiting”
behavior, which means y is evaluated only if x is true.
-
x
and y cannot be
null.
|
| || |
x || y |
OR logical operator (Left associative). If x, a Boolean, and y, a Boolean, are both false, then
the expression evaluates to false. Otherwise the expression evaluates to
true. Note:
-
&& has
precedence over ||
- This operator exhibits “short-circuiting”
behavior, which means y is evaluated only if x is false.
- x
and y cannot be
null.
|
| == |
x == y |
Equality operator. If the value of x equals the value of y, the expression evaluates to
true. Otherwise, the expression evaluates to false. Note:
- Unlike Java, == in
Apex compares object value equality, not reference equality,
except for user-defined types. Consequently:
- String comparison using == is
case-insensitive
- ID comparison using == is case-sensitive, and does not
distinguish between 15-character and 18-character
formats
- User-defined types are compared by reference, which
means that two objects are equal only if they
reference the same location in memory. You can
override this default comparison behavior by
providing equals and hashCode methods
in your class to compare object values instead.
- For sObjects and sObject arrays, == performs a deep
check of all sObject field values before returning its
result. Likewise for collections and built-in Apex objects.
- For records, every field must have the same value for
== to evaluate
to true.
-
x or y can be the literal
null.
- The comparison of any two values can never result in
null.
- SOQL and SOSL use =
for their equality operator, and not ==. Although Apex and
SOQL and SOSL are strongly linked, this unfortunate syntax
discrepancy exists because most modern languages use = for assignment and
== for
equality. The designers of Apex deemed it more valuable to
maintain this paradigm than to force developers to learn a
new assignment operator. The result is that Apex developers
must use == for
equality tests in the main body of the Apex code, and
= for equality
in SOQL and SOSL queries.
|
| === |
x === y |
Exact equality operator. If x and y reference
the exact same location in memory, the expression evaluates to true.
Otherwise, the expression evaluates to false. |
| < |
x < y |
Less than operator. If x is less than y,
the expression evaluates to true. Otherwise, the expression evaluates to
false. Note:
- Unlike other database stored procedures, Apex does not
support tri-state Boolean logic, and the comparison of any two values can never result in
null.
- If x or y equal null and are Integers,
Doubles, Dates, or Datetimes, the expression is false.
- A non-null String or ID value is always greater
than a null
value.
- If x
and y are IDs,
they must reference the same type of object. Otherwise,
a runtime error results.
- If x or y is an ID and the
other value is a String, the String value is validated
and treated as an ID.
-
x and y cannot be
Booleans.
- The comparison of two strings is performed according to the
locale of the context user and is case-insensitive.
|
| > |
x > y |
Greater than operator. If x is greater than y, the expression evaluates to true. Otherwise, the
expression evaluates to false. Note:
- The comparison of any two values can never result in
null.
- If x or y equal null and are Integers,
Doubles, Dates, or Datetimes, the expression is false.
- A non-null String or ID value is always greater
than a null
value.
- If x
and y are IDs,
they must reference the same type of object. Otherwise,
a runtime error results.
- If x or y is an ID and the
other value is a String, the String value is validated
and treated as an ID.
-
x and y cannot be
Booleans.
- The comparison of two strings is performed according to the
locale of the context user and is case-insensitive.
|
| <= |
x <= y |
Less than or equal to operator. If x is less than or equal to y, the expression evaluates to
true. Otherwise, the expression evaluates to false. Note:
- The comparison of any two values can never result in
null.
- If x or y equal null and are Integers,
Doubles, Dates, or Datetimes, the expression is false.
- A non-null String or ID value is always greater
than a null
value.
- If x
and y are IDs,
they must reference the same type of object. Otherwise,
a runtime error results.
- If x or y is an ID and the
other value is a String, the String value is validated
and treated as an ID.
-
x and y cannot be
Booleans.
- The comparison of two strings is performed according to the
locale of the context user and is case-insensitive.
|
| >= |
x >= y |
Greater than or equal to operator. If x is greater than or equal to
y, the expression evaluates
to true. Otherwise, the expression evaluates to false. Note:
- The comparison of any two values can never result in
null.
- If x or y equal null and are Integers,
Doubles, Dates, or Datetimes, the expression is false.
- A non-null String or ID value is always greater
than a null
value.
- If x
and y are IDs,
they must reference the same type of object. Otherwise,
a runtime error results.
- If x or y is an ID and the
other value is a String, the String value is validated
and treated as an ID.
-
x and y cannot be
Booleans.
- The comparison of two strings is performed according to the
locale of the context user and is case-insensitive.
|
| != |
x != y |
Inequality operator. If the value of x does not equal the value of
y, the expression evaluates
to true. Otherwise, the expression evaluates to false. Note:
- String comparison using != is case-insensitive
- Unlike Java, != in
Apex compares object value equality, not reference equality,
except for user-defined types.
- For sObjects and sObject arrays, != performs a deep
check of all sObject field values before returning its
result.
- For records, !=
evaluates to true if the records have different values for
any field.
- User-defined types are compared by reference, which means
that two objects are different only if they reference
different locations in memory. You can override this default
comparison behavior by providing equals and hashCode methods in your
class to compare object values instead.
-
x or y
can be the literal null.
- The comparison of any two values can never result in
null.
|
| !== |
x !== y |
Exact inequality operator. If x and y do not
reference the exact same location in memory, the expression evaluates to
true. Otherwise, the expression evaluates to false. |
| + |
x + y |
Addition operator. Adds the value of x to the value of y according to the following rules:
- If x and y are Integers or Doubles,
adds the value of x to
the value of y. If a
Double is used, the result is a Double.
- If x is a Date and
y is an Integer,
returns a new Date that is incremented by the specified number
of days.
- If x is a Datetime and
y is an Integer or
Double, returns a new Date that is incremented by the specified
number of days, with the fractional portion corresponding to a
portion of a day.
- If x is a String and
y is a String or
any other type of non-null argument, concatenates y to the end of x.
|
| - |
x - y |
Subtraction operator. Subtracts the value of y from the value of x according to the following rules:
- If x and y are Integers or Doubles,
subtracts the value of y from the value of x. If a Double is used, the
result is a Double.
- If x is a Date and
y is an Integer,
returns a new Date that is decremented by the specified number
of days.
- If x is a Datetime and
y is an Integer or
Double, returns a new Date that is decremented by the specified
number of days, with the fractional portion corresponding to a
portion of a day.
|
| * |
x * y |
Multiplication operator. Multiplies x, an Integer or Double, with
y, another Integer or
Double. Note that if a double is used, the result is a Double. |
| / |
x / y |
Division operator. Divides x, an Integer or Double, by y, another Integer or Double. Note
that if a double is used, the result is a Double. |
| ! |
!x |
Logical complement operator. Inverts the value of a Boolean,
so that true becomes false, and false becomes true. |
| - |
-x |
Unary negation operator. Multiplies the value of x, an Integer or Double, by -1.
Note that the positive equivalent + is also syntactically valid, but does not have a
mathematical effect. |
| ++ |
x++ ++x
|
Increment operator. Adds 1 to the value of x, a variable of a numeric type. If
prefixed (++x), the expression
evaluates to the value of x after the increment. If postfixed (x++), the expression evaluates to
the value of x before the increment. |
| -- |
x-- --x
|
Decrement operator. Subtracts 1 from the value of x, a variable of a numeric type. If
prefixed (--x), the expression
evaluates to the value of x after the decrement. If postfixed (x--), the expression evaluates to
the value of x before the decrement. |
| & |
x & y |
Bitwise AND operator. ANDs each bit in x with the corresponding bit in
y so that the result bit is
set to 1 if both of the bits are set to 1. This operator is not valid
for types Long or Integer. |
| | |
x | y |
Bitwise OR operator. ORs each bit in x with the corresponding bit in
y so that the result bit is
set to 1 if at least one of the bits is set to 1. This operator is not
valid for types Long or Integer. |
| ^ |
x ^ y |
Bitwise exclusive OR operator. Exclusive ORs each bit in
x with the corresponding
bit in y so that the result bit
is set to 1 if exactly one of the bits is set to 1 and the other bit is
set to 0. |
| ^= |
x ^= y |
Bitwise exclusive OR operator. Exclusive ORs each bit in
x with the corresponding
bit in y so that the result bit
is set to 1 if exactly one of the bits is set to 1 and the other bit is
set to 0. Assigns the result of the exclusive OR operation to x. |
| << |
x << y |
Bitwise shift left operator. Shifts each bit in x to the left by y bits so that the high order bits
are lost, and the new right bits are set to 0. |
| >> |
x >> y |
Bitwise shift right signed operator. Shifts each bit in
x to the right by y bits so that the low order bits
are lost, and the new left bits are set to 0 for positive values of
y and 1 for negative values
of y. |
| >>> |
x >>> y |
Bitwise shift right unsigned operator. Shifts each bit in
x to the right by y bits so that the low order bits
are lost, and the new left bits are set to 0 for all values of y. |
| () |
(x) |
Parentheses. Elevates the precedence of an expression x so that it is evaluated first in
a compound expression. |
j