Java Cheat Sheet : Java Glossary

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

Loops

Try/Catch/Throw

Try/Catch/Finally

Literals

• int

  1, -1, hex ints 0x0f28, Unicode hex '\u003f', octal 027, Integer.MAX_VALUE (2,147,483,647), Integer.MIN_VALUE (-2,147,483,648) Beware! A lead 0 on an integer e.g. 007 implies OCTAL. That was a major design blunder inherited from C, guaranteed to introduce puzzling bugs. Be especially careful when specifying months or days, where you naturally tend to provide a lead 0. Java version 1.7 or later supports binary constants, e.g. 0b01011111 Java version 1.7 or laterallows you to break up numbers with underscores to make them easier to proofread, e.g. -2_147_483_648

• byte / short

  There is no such thing as a byte or short literal. You would have to write it with a cast e.g. (byte)0xff or (short)-99.

• long

  3L, -99l, 0xf011223344L, Long.MAX_VALUE (9,223,372,036,854,775,807), Long.MIN_VALUE (-9,223,372,036,854,775,808). Beware! some compilers will quietly chop the high bits from literals that don’t have a trailing L even when assigning to a long. Java version 1.7 or latersupports binary constants, e.g. 0b01011111LJava version 1.7 or later allows you to break up numbers with underscores to make them easier to proofread, e.g. -2_147_483_648L

• float

  1.0345F, 1.04E-12f, .0345f, 1.04e-13f, Float.NaN.

• double

  5.6E-120D, 123.4d, 0.1, Double.NaN, Math.PI.
  Note floating point literals without the explicit trailing f, F, d or D are considered double. In theory you don’t need a lead 0, e.g. 0.1d may be written .1d, though the Solaris and Symantec compilers seem to require it. With floats and double, the lead zero does not mean octal

• Boolean

  true and false.

• Boolean

  TRUE and TRUE.

• String

  // splitting a string literal over more than one line
  
  String s = "abcdefghijklmnopqrst"
            + "uvwxyz";

  There is no speed penalty for the + concatenation. It is done at compile time. String literals can be used anywhere you might use a String reference, e. g. "abc".charAt(1) is legal. For problematic/awkward/reserved/quotable characters like embedded ", see escape sequences below.

• char

  'A', enclosed in single quotes, or integer forms e.g. (char)45, (char)0x45, '\u003f'. For problematic characters like embedded ', see escape sequences below.

• Escape sequences

  inside char and String literals include:
  ' ' space
  '\u003f' Unicode hex, (must be exactly 4 digits to give a 16-bit Unicode number ).
  Make sure you don’t double the \ e.g "\\u003f" or you will just get the literal hex chars. This can be a hard bug to find if you are comparing your string against a string containing the fancy character.
  \u2007 is Figure Space, a space as wide as a digit, to help in aligning numbers.
  '\n' newline, ctrl-J (10, x0A)
  '\b' backspace, ctrl-H (8, 0x08)
  '\f' formfeed, ctrl-L (12, 0x0C)
  '\r' carriage return, ctrl-M (13, 0x0D)
  '\t' tab, ctrl-I (9, 0x09)
  '\\' backslash,
  '\'' single quote (optional inside " "),
  '\"' double quote (optional inside ' '),
  '\377' octal (must be exactly 3 digits. You can get away with fewer, but then you create an ambiguity if the character following the literal just happens to be in the range 0..7.). This lets you get at only the 8-bit characters in the range 0..377 octal or 0..255 decimal or 0..255 decimal, which still gives you 16-bit Unicode.
  \007 bel, ctrl-G (7, 0x07)
  \010 backspace, ctrl-H (8, 0x08)
  \013 vt vertical tab, ctrl-K (11, 0x0B)
  \032 sub (used in DOS/CPM as eof), ctrl-Z (26, 0x1A)
  \033 esc ctrl-^ (27, 0x1B)

• Unsupported

  
  There is no Pascalian '#nnn' style way of specifying decimal constants. Just use char c = 123;
  The following C forms are not supported: '\a' alert
  '\v' vertical tab
  '\?' question mark
  '\xf2' hex.
  Use the Unicode \uffff form for printable characters. It won’t work for control characters e.g. \u000a because of the rather flat-footed way \u is treated as if it were a pre-processor macro. It literally embeds the corresponding character into your Java source, as if you had typed it. Usually this creates a syntax error.

• 32-bit

  
  Java does not have 32-bit String literals, like C style code points e.g. \U0001d504. Note the capital U vs the usual \ud504 I wrote the SurrogatePair applet to convert C-style code points to a arcane surrogate pairs to let you use 32-bit Unicode glyphs in your programs.

Primitives

Primitives vs Immutable Wrapper Objects

Precedence

Java Operator Precedence

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) ! (cast)	Right (prefix)	++ prefix means preincrement (add 1). -- prefix means predecrement (subtract 1). 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. (cast) and parenthesis are not officially operators, according the JLS . ~ tilde is bitwise not for ints. (cast) has a multitude of purposes, lumped together under the term casting
1	(postfix) ++ (postfix) --	Right (postfix)	++ postfix means postincrement (add 1). -- postfix means postdecrement (subtract 1 ). 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. % is the remainder operator, informally and incorrectly called the modulus operator. / is integer division for ints and floating point division for doubles.
3	+ -	Left (infix)	+ is ordinary addition, integer or floating point. . - is ordinary subtraction, integer or floating point. . 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. .
5	< > <= >= instanceof	Left (infix)	oddly instanceof is considered an operator, even though it cannot operate on expressions.
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.
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)
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.
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)
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.

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

Keywords

Reserved Keywords

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

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.

Javadoc

Learning More