Java Cheat Sheet : Java Glossary


Java Cheat Sheet
This document is a quick summary of the Java language syntax. It is not complete. It just contains the things you may be likely to forget.

I have most of these common patterns built-in as SlickEdit macros so I don’t have to remember the patterns. I just click a custom icon for the pattern I want. Unfortunately, I thus don’t remember them. Without my editor, I would be at a loss to remember where the parentheses and semicolons go.

Control Structures Precedence
Loops Keywords
Try/Catch/Throw Javadoc
Try/Catch/Finally Regex cheat sheet
Literals HTML cheat sheet
Primitives Links

Control Structures


The variables used in the while (boolean) clause can’t be declared inside the while loop. The inside of the loop is considered a separate inner block.
Unfortunately, a for:each loop will let you reassign the loop variable inside the loop body, without an error message. Don’t do it!.


To help you remember the syntax of catch, think of it as like a method, that gets passed an exception as a parameter.



literal is an explicit number or string constant used in Java programs. Here is a list of all the variant forms I have found Java to support:


Primitive variables include Boolean, char, byte, short, int, long, float and double. Strings, arrays and Objects are not considered primitives.
Java Primitives
Type Signed? Bits Bytes Digits Lowest Highest Mnemonic
Boolean n/a 1 1 1 false true zero/one
char unsigned Unicode 16 2 4:5 '\u0000' [0] aka Character. MIN_VALUE '\uffff' [216-1] aka Character. MAX_VALUE Unicode chars are twice as big as C’s.
byte signed 8 1 2:3 -128 [-27] aka Byte. MIN_VALUE +127 [27-1]aka Byte. MAX_VALUE Bytes are signed, so half the usual 255 range.
short signed 16 2 4:5 -32,768 [-215] aka Short. MIN_VALUE +32,767 [215-1] aka Short. MAX_VALUE 32K
int signed 32 4 9:10 -2,147,483,648 [-231] aka Integer.MIN_VALUE aka -2 gig, roughly -2 billion +2,147,483,647 [231-1] aka Integer. MAX_VALUE. aka 2 gig, roughly 2 billion 2 gig
long signed 64 8 1:19 -9,223,372,036,854,775,807 [-263] aka Long. MIN_VALUE about -9×1018 9,223,372,036,854,775,808 [+263-1] aka Long. MAX_VALUE about 9×1018 9 exabytes, or 9 billion gig
float signed exponent and mantissa 32 4 7 ±1.40129846432481707e-45 aka Float. MIN_VALUE ±3.40282346638528860e+38 aka Float. MAX_VALUE
or roughly ±2127
with about 7 significant digits of accuracy.
A float can exactly represent integers
in the range -224 to +224.
rough, compact float
double signed exponent and mantissa 64 8 16 ±4.94065645841246544e-324 aka Double. MIN_VALUE ±1.79769313486231570e+308 aka Double. MAX_VALUE
or roughly ±21023
with 15 significant digits of accuracy, almost 16 with 15.95 significant digits.
A double can exactly represent integers
in the range -253 to +253.
high precision float

Primitives vs Immutable Wrapper Objects

Contrast that table of primitives, with this table of basic Java types:
Immutable Primitives Immutable Objects
Boolean Boolean
ordinary signed byte Byte
unsigned byte Byte
short Short
char Character
int Integer
long Long
float Float
double Double
char[] String


Java Operator Precedence
Operators near the top are evaluated first.
Precedence Operator Association Notes
0 new Right new, according to the JLS is not officially an operator. It is not usually considered to have precedence since it can occur in only one context, immediately followed by a class name. IIRC (If I Recall Correctly) it was considered to be an operator in the Java 1.0 days.
1 (prefix) ++
(prefix) --
(unary) +
(unary) -
(unary) ~
(unary) !
Right (prefix) ++ prefix means preincrement (add 1).more
-- prefix means predecrement (subtract 1).more
Preincrement increments before sampling the value to use in evaluating the rest of the expression. ! is logical not for booleans. Nearly always, you have to put the expression after ! in parentheses. You might as well make a habit of always doing it. more
(cast) and parenthesis are not officially operators, according the JLS .more
~ tilde is bitwise not for ints. more
(cast) has a multitude of purposes, lumped together under the term casting more
1 (postfix) ++
(postfix) --
Right (postfix) ++ postfix means postincrement (add 1).more
-- postfix means postdecrement (subtract 1 ).more
Postincrement increments immediately after sampling the value to use in evaluating the rest of the expression.
Be very careful about using a pre/post inc/decremented variable elsewhere in an expression. You may be in for a surprise. for example
// Be very careful reusing a pre or post increment variable in an expression.
int x = 2;
int y = x++ * ++x;  // result is y = 8;

// it works as if you had coded:
int x = 2;
int a = x++;   // a=2; x=3;
int b = ++x;   // b=4; x=4
int y = a * b; // y = 8
2 *
Left (infix) * is integer multiplication for ints and floating pointmultiplication for doubles.more
% is the remainder operator, informally and incorrectly called the modulus operator.more
/ is integer division for ints and floating point division for doubles.more
3 +
Left (infix) + is ordinary addition, integer or floating point. more.
- is ordinary subtraction, integer or floating point. more.
a - b - c means (a - b) - c not a - ( b - c ), additive operations are performed left to right. + also means concatenation.
4 <<
Left (infix) There is no <<< operator because it would be identical to <<. You have to keep your wits about you when doing unsigned shifts to remember all right shifts must be done with >>>. In Java version 1.5 or later the following methods are built-in letting you avoid much low-level bit fiddling: e.g. Integer.highestOneBit, lowestOneBit, numberOfLeadingZeros, numberOfTrailingZeros, bitCount, rotateLeft, rotateRight, reverse, signum and reverseBytes. more.
5 <
Left (infix) oddly instanceof is considered an operator, even though it cannot operate on expressions.more
6 ==
Left (infix) == is for comparison. != means not equal.= is for assignment. Pascal’s <> not equal will not work. == and != work on booleans too, often saving a forest of if/elses.
7 & Left (infix) Bitwise AND masking mostly for for ints.more
8 ^ Left (infix)

XOR (exclusive OR) for ints. It is the difference operator. It is true if the boolean operands are different, e. g.

false ^ false == false
false ^ true == true
true ^ false == true
true ^ true == false

It is useful in cryptography because of this magic property of encryption and decryption with a random scrambler number.

long encrypted = message ^ scrambler;
long decryped = encrypted ^ scrambler;

If you XOR twice with the scrambler, you get right back where you started. For booleans it is clearer to use a != b instead of a ^ b and a == b instead of !( a ^ b)more

9 | Left (infix) bitwise OR mostly for ints.
int e = ( a & b << 2 ) | ( c & ( d >>> 1 ) );
// if you trust precedence can be written more tersely:
int e = a & b << 2 | c & d >>> 1;
10 && Left (infix) short circuit logical AND for booleans.more
11 || Left (infix) short circuit logical OR for booleans. So when you say:
if ( ( ( lowest <= a ) && ( a <= biggest ) ) || notNeeded )

all those parentheses are nugatory (computer jargon for not necessary but won’t hurt). You could just as easily have written it, trusting precedence, as:

if ( lowest <= a && a <= biggest || notNeeded )
12 ? : Right (ternary) more
13 =
Right (infix) a += b means a = a + b; a *= b means a = a * b; etc. These make proofreading easier by eliminating typing a variable name twice. more

The most important extra rule is that parameters to a method are evaluated left to right.


Reserved Keywords

Java reserves some words. They cannot be used as variable, method or class names.

Java Keywords
abstract default if private this
assert do implements protected throw
Boolean double import public throws
break else instanceof return transient
byte enum int short try
case extends interface static void
catch final long strictfp volatile
char finally native super while
class float new switch
continue for package synchronized
Reserved keywords (not currently in use)
const goto      
Reserved Literals
null true false    

The bold ones I consider more important since they demark major blocks of code. assert arrived with JDK (Java Development Kit) 1.4. enum arrived with JDK 1.5. const and goto are not currently used. They may be there just in case C++ programmers use them by mistake to enable the compiler to give a more meaningful error message.


Learning More

This page is posted
on the web at:

Optional Replicator mirror
on local hard disk J:

Canadian Mind Products
Please the feedback from other visitors, or your own feedback about the site.
Contact Roedy. Please feel free to link to this page without explicit permission.

Your face IP:[]
You are visitor number