Java Reference (preliminary) by Ryan Stansifer, 20 June 2013

1
1.1

character and string literals. Unicode escapes are not the same as character escapes. The complete list of character escapes follows: escape \b \t \n \f \r \" \ \\ Unicode character name
U+0008 backspace U+0009 horizontal tabulation (HT), tab U+000A line feed (LF) aka newline U+000C form feed (FF) U+000D carriage return (CR) U+0022 QUOTATION MARK (double quote) U+0027 APOSTROPHE (single quote) U+005C REVERSE SOLIDUS (backslash)

Lexical Structure
Unicode

Before the Java source program is tokenized, each character is converted from the native character set to the corresponding Unicode character and character sequences of the form \udddd, where d is a hexadecimal digit, are converted to the corresponding Unicode character U+dddd. Some example Unicode characters: escape \u007B \u00D7 \u015C \u0635 \u03A9 \u201C \u5C71 1.2 // /* Comments { S Unicode character name
U+007B LEFT CURLY BRACKET U+00D7 MULTIPLICATION SIGN U+015C LATIN CAPITAL LETTER S WITH CIRCUMFLEX U+0635 ARABIC LETTER SAD U+03A9 GREEK CAPITAL LETTER OMEGA U+201C LEFT DOUBLE QUOTATION MARK U+5C71 CKJV ideograph for mountain

2
2.1

Data
Primitive Data Types

Java has eight fundamental units of data: Boolean. boolean: two-valued type with elements true and false Character. char: values from Unicode (UTF-16) Integral (twos complement). byte, short, int, long Floating point (IEEE754). float, double

) A comment to the end of the line. ) A traditional comment as in C, C++, and C#. */ /* These comments dont nest! */ /** ) Documentation comments may contain HTML and javadoc tags: @author @see @return @throws 1.3 Keywords

*/

All other data types (strings, arrays, user-dened classes, classes in the Java API, etc.) are objects and allocated on the heap and reclaimed implicitly by the garbage collector. Java has no unsigned byte or word type. 2.2 Wrapper Classes

abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for goto if implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while The keywords const and goto not used in the Java grammar. The literals true, false, and null are reserved words in the Java syntax. 1.4 Literals

Corresponding to each primitive data type is a class in the package java.lang: Boolean, Character, Byte, Short, Integer, Long, Float, and Double. These classes contain, box, or wrap a value of the corresponding type. Java automatically boxes and unboxes all the primitive data types bluring the distinction between primitive and non-primitive data. This is especially valuable in the context of generics in which all data must be treated as an object. The wrapper classes have static methods (e.g., parseInt()), and elds (e.g., MAX_VALUE), specic to the individual primitive types. int int long long float float double double Integer.MAX_VALUE Integer.MIN_VALUE Long.MAX_VALUE Long.MIN_VALUE Float.MAX_VALUE Float.MIN_VALUE Double.MAX_VALUE Double.MIN_VALUE 0x7fffffff 0x80000000 0x7fffffffffffffffL 0x8000000000000000L 0x1.fffffP+127f 0x0.000002P-126f 0x1.fffffffffffffP+1023 0x0.0000000000001P-1022
231 1 2.1 109 231 2.1 109 263 1 9.2 1018 263 9.2 1018 3.4 1038 1.4 1045 1.8 10308 4.9 10324

Besides the literals true, false for boolean values, there are several other kinds of literals in Java. The literal null is a distinguished value that belongs to all object types. Character literals are delimited by the single quote and string literals are delimited by the double quote character. Character escapes are present only in 1

2.3

java.lang.String

2.5

Objects

Though not a primitive data type, java.lang.String is an important data type with special syntax (the double quotes) and a predened inx operation (concatenation): "string literal" + " more" A string is an immutable sequence of characters with the following as some of the more common methods. int char String int boolean int length() charAt(int i) substring(int i,int j) indexOf(String s) equals(Object o) compareTo(String s)
string length ith character ith - j-1 characters is s a substring lexicographic ordering

The keyword new creates a new object, a new instance of the class in the heap. Some examples follow: Date now = new Date (); Random rng = new Random (); Color c = new Color (0 , 127 , 255); StringBuilder s = new StringBuilder (); Number n = new BigDecimal (3) Scanner stdin = new Scanner ( System . out ). useDelimiter (); int [] a1 = new int []{1 ,2}; // initialization char [][] a2 = new char [9][7]; List < String > l = new ArrayList < String >(); Strings and arrays are constructed implicitly by literals with special syntax; new String("abc") is legal, but redundant. String s = " abc "; int [] a1 ={1 ,2}; // new optional in array decl int [][] a2 = {{0} ,{0 ,1} ,{0 ,1 ,2}}; However, the keyword new is required in array literals not in a declaration: int x = binarySearch ( new int [] {1 ,4 ,6 ,7 ,9} , 5);

The class java.lang.StringBuilder in a mutable sequence of characters with many of the same methods as java.lang.String. It implements the interface java.lang.CharSequence, but not java.lang.Comparable<StringBuilder>. 2.4 Arrays

Each new object is a different entity in the heap. So new BigDecimal (1) == new BigDecimal (1) yields false, but equals() inherited from Object new BigDecimal (1) . equals ( new BigDecimal (1)) yields true. 2.6 Enumerated Types

Fixed-length arrays have special syntax in Java. For variable-length (dynamic) structures see the generic class java.util.ArrayList. The type of an array is written like this: int[] or String[]. Like all objects an array can be created using the keyword new like this: new int[4] or new String[7]. Elements of an array can be accessed only with integer indices starting with zero: a[0] or b[3]. The length of an array is obtained like this: a.length or b.length (a common mistake is to add () like for String). Strictly speaking there are no multi-dimensional arrays (like in Fortran) only arrays of arrays as in C, and C++. Important static methods from java.util.Arrays include:
String toString ( Type [] a) int hashCode ( Type [] a) boolean equals ( Type [] a , Type [] other ) int int void void void binarySearch binarySearch fill ( Type [] sort ( Type [] sort ( Type [] ( Type [] a , Type key ) ( Type [] a , int from , int to , Type key ) a , Type val ) a) a , int from , int to )

Simple enumerated types provide a convenient way to represent data which has a small set of xed, discrete values. enum Suit { CLUBS , DIAMONDS , HEARTS , SPADES } enum Day { SUN , MON , TUE , WED , THU , FRI , SAT } Enumerated types are a particular kind of class with two static, generated methods, with the following types illustrated with the class Suit: Suit [] values (); Suit valueOf ( String name ); and a common superclass java.lang.Enum<E extends Enum<E>> with methods int compareTo (E o) int ordinal ();

Type [] copyOf ( Type [] a , int new_length ) Type [] copyOfRange ( Type [] a , int from , int to )

where Type is a primitive type. Versions of these function for arrays of objects are also in java.util.Arrays. 2

enum Direction { NORTH (0 ,+1) , EAST (+1 ,0) , SOUTH (0 , -1) , WEST ( -1 ,0); private final int x , y; private Direction ( int x , int y) { this .x=x; this .y=y; } public Direction rotate ( int i) { assert i >=0; // Caution: % and negative numbers return Direction . values ()[( this . ordinal ()+ i )%4]; } } Java provides the support classes EnumSet and EnumHashMap which are used as in the following example: for ( Day d: EnumSet . range ( Day .MON , Day . FRI ) {} EnumSet < Style > set = EnumSet . of ( Style . BOLD , Style . ITALIC );

import static java . lang . Math .*; double double double also for double double double double double long double double double double abs(double x) max(double x,double y) min(double x,double y) int, long, float sqrt(double x) cbrt(double x) pow(double x, double y) atan2(double x,double y) hypot(double x,double y) round(double x) ceil(double x) floor(double x) E PI sin(double theta) cos(double theta) tan(double theta) asin(double theta) acos(double theta) atan(double theta)
absolute value of x maximum of x and y minimum of x and y square root x 3 cube root x xy angle of x and y x2 + y2 closest long x x constant e = 2.71828 constant = 3.14159

3
3.1

Expressions
Test for equality

Java has the binary, inx operator == for testing the equality of values of primitive data types. For objects, the method equals() is usually what is needed. Not equals is !=. String word = n !=1 ? " cats " : " cat "; 3.2 Binary, inx operators type * / % + + << >> >>> < > <= >= 3.3 Boolean Operations num. num. string integral integral integral num. description mult., div., remainder addition subtraction concatenation left shift r. shift with sign extension r. shift with zero extension less/greater than (or equal)

double double double double double double

sine function cosine function tangent function inverse sine function inverse cosine function inverse tangent function

The angles in the trig functions are in radians (not degrees). Use double toRadians(double deg) and double toDegrees(double rad) to convert back and forth. 3.5 java.math.BigInteger and Bitwise Operations

The immutable class BigInteger supports arbitrary-precision integers. Arithmetic methods: BigInteger BigInteger BigInteger BigInteger BigInteger BigInteger BigInteger BigInteger BigInteger BigInteger BigInteger BigInteger[] BigInteger 3 abs() max(BigInteger b) min(BigInteger b) negate() - this add(BigInteger b) this + b subtract(BigInteger b) this - b multiply(BigInteger b) this * b pow(BigInteger b) mod(BigInteger b) (b + this%b)%b remainder(BigInteger b) this % b divide(BigInteger b) this / b divideAndRemainder(BigInteger b) gcd(BigInteger b)

The boolean data type has three operators: !, &&, and ||, for the three familiar operations: negation, conjunction, and disjunction. 3.4 java.lang.Math

The java.lang.Math class has many static members. These members can be called using their simple (i.e., unqualied) name by using the following import declaration:

Set or logic methods: BigInteger BigInteger BigInteger BigInteger and(BigInteger b) or(BigInteger b) xor(BigInteger b) andNot(BigInteger b) this this this this & | & b intersection/conjunction b union/disjunction b symmetric difference b set minus

for (;;) { /* statements */ if ( /* condition */ ) break ; /* statements */ } while ( /* condition */ ) { /* statements */ }

Bitwise methods: BigInteger BigInteger BigInteger BigInteger BigInteger BigInteger boolean not() shiftLeft(int n) shiftRight(int n) clearBit(int n) flipBit(int n) setBit(int n) testBit(int n) this this<<n this>>n this & (1<<n) this (1<<n) this | (1<<n) this & (1<<n) != 0

5
5.1

Functions and Procedures

Statements

< method declaration > ::= [ < type parameter list > ] < type > < identifier > "(" [ < formal parameters list > ] ")" ["throws" < qualified identifier list > ] "{" < method body > "}" 5.2 Varargs

Templates for some compound statements. if ( /* condition */ ) { /* statements executed if true */ } if ( /* condition */ ) { /* statements executed if true */ } else { /* statements executed if false */ } if ( /* condition1 */ ) { /* statements executed if true*/ } else if ( /* condition2 */ ) { /* statements */ } else if ( /* condition3 */ ) { /* statements */ } else { /* statements executed if none of the above*/ } for ( int index =0; index <a. length ; index ++) { /* statements */ } for ( int v: a) { /* statements */ }

Methods can have a variable number of arguments (varargs) in Java. The three periods after the parameters type indicate that the parameter may be passed as an array or as a sequence of zero or more actual arguments of that type. Varags can be used only in the nal argument position. Here are some method declarations in the Java APIs using varargs: PrintWriter printf ( String format , Object ... args ) Method getMethod ( String name , Class <? >... parameterTypes ) Object invoke ( Object obj , Object ... args ) A varargs, formal parameter is accessed exactly as if it were an array. public class Test { public static void main ( String ... args ) { int pass =0 , fail =0; for ( String className : args ) { try { final Class c = Class . forName ( className ); c. getMethod (" test " ). invoke (c. newInstance ()); pass ++: } catch ( Exception ex ) { System . out . printf ("%s failed .% n" , className ); fail ++; } } System . out . printf (" pass =% d; fail =% d%n" , pass , fail ); } }

6
6.1

Input/Output
Standard IO

6.3

java.util.Formatter

Format speciers have the following syntax: % [index $ ] [options] [width] [ . precision] format where index is a decimal integer indicating which argument 1$, 2$, etc. and format is one of the following characters: bB hH sS cC d o xX eE f gG aA tT % n general integral bB hH sS d o xX any type of argument byte, Byte, short, Short, int, Integer, long, Long, BigInteger float, Float, double, Double, BigDecimal char, Character, byte, Byte, short, Short, int, Integer long, Long, Calendar, Date needs no argument needs no argument
" 1512" " 1,512" " 159.17" " +1.5e02" " 159.17" " hello" "hello " "hell " "A"

java.lang.System has static elds for distinguished input and output streams: InputStream in PrintStream out PrintStream err standard input stream standard output stream standard error output stream

Normally the input stream is associated with the keyboard and the output stream is associated with the display device. The class InputStream has a method int read() to read the next byte of data. Often it is convenient to use an InputStream with the class java.util.Scanner which has high-level methods for reading text (see the next subsection). The class PrintStream has high-level methods for printing Java data types as text and two synonymous methods for C-style formatting of data: printf and format. 6.2 java.util.Scanner

oating point character

aA eE f gG cC

date/time percent newline d d f e e s s s c

tT % n 1512 1512 159.16810 159.16810 159.16810 "hello" "hello" "hello" A

The java.util.Scanner is useful in reading and converting input text into Java data types. By default, the input text is delimited by "\\p{javaWhiteSpace}+" boolean hasNext() boolean hasNextType () boolean hasNext(Pattern x) String next() Type nextType () String next(Pattern x)

The boolean function hasNextType () determines if next token in the stream is of that type, and nextType () returns the next token expecting it to be of that type. Type is one of Byte, Short, Int, Long, Float, Double, Boolean, BigInteger, BigDecimal, but not Char. The function returns a value of the appropriate Java data type: byte, short, int, long, float, double, boolean, BigInteger, BigDecimal. hasNext(java.util.regex.Pattern x) determines if the next delimited token matches the regular expression x. And next(java.util.regex.Pattern x) returns the string that matches. The methods skip(Pattern x) and findInHorizon(Pattern x, int h) of the java.util.Scanner class ignore delimiters. To get the next character: char nextChar = scan . findInHorizon (" .(? s)" ,1). charAt (0) Using the empty string as a delimiter to the scanner will result in each token (string) being a single character long. Using the Java string "\\A" as a delimiter will result in one token (string) consisting of the entire input. 5

"%10d" "%,10d" "%10.2f" "%+10.1e" "%10.5g" "%10s" "%-10s" "%-10.4s" "%c"

Simple Program

import java . util . Scanner ; public final class Sum { public static void main ( final String [] args ) { final Scanner stdin = new Scanner ( System . in ); int sum = 0; while ( stdin . hasNextInt ()) { sum += stdin . nextInt (); } System . out . format (" sum = %,d%n" , sum ); } }

C C

Compiling and running with the Sun JDK:

> javac Sum.java > java Sum 1 2 3 4 5

stdin . nextInt () out . printf ()

// where stdin is an instance of Scanner // where out is an instance of PrintWriter

(If the instance is omitted, this is assumed.) By using the style convention that class names are capitalized, static member access is easily distinguished from non-static access. privatemembers declared private are accessible within the class itself. packagemembers declared with no access modier are accessible in classes in the same package. protectedmembers declared protected are accessible in subclasses (in the same package or not) and in the class itself. publicmembers declared public are accessible anywhere the class is accessible. access from same class same package in subclass, out of package non-subclass, out of package 8.3 Inheritance private yes no no no package yes yes no no protected yes yes yes no public yes yes yes yes

8 D 23 There are many IDEs: Emacs, BlueJ, Eclipse, Netbeans

8
8.1

Object-Oriented Programming
Class

A class declaration begins with the word class: < class declaration > ::= "class" < identifier > "{" < class body > "}" < class body > ::= { < class body declaration > } < class body declaration > ::= ";" | "static" < statement block > | { < modifier > } < member declaration > < member declaration > ::= < field declaration > | < method declaration > | < constructor declaration > | < interface declaration > | < class declaration > Note that classes can be nested and that they may contain static initialization blocks. 8.2 Members

A subclass is created by naming the unique superclass. A subclass has only one superclass. If a superclass is not explicitly named, the class Object is the superclass. So, the class Object is the unique root of the Java subclass hierarchy. This has the importance consequence that all objects inherit from Object. < class declaration > ::= "class" < identifier > ["extends" < type > ] "{" < class body > "}" Some of the instantiable subclasses of Object are: java.io.File java.util.Date java.util.Scanner java.lang.String java.lang.StringBuilder java.lang.Exception java.lang.Thread 6

Static members of classes (elds and methods) should be accessed using the class name. (The class name may be omitted if access is from within the same class.) For example, System . out // access static field out in class System Math . abs (3.4) // invoke static method abs in class Math String . format () // invoke static method Arrays . toString ( new int []{1 ,2 ,3}) Direction . values () // Non-static members of classes (elds and methods) may be accessed only via an instance of the class.

8.4

Overriding

One predened annotation is useful for marking overridden methods: @Override public String toString () { return String . format (" representation " ); }

Typical (unchecked) runtime exceptions are NullPointerException and ArrayIndexOutOfBoundsException. These exceptions generally indicate logical errors in the program. try { // block monitored for exceptions } catch ( IOException ex ) { ex . printStackTrace (); } finally { // executed no matter what }

8.5

Abstract Classes

A class declaration may be modied with the keyword abstract marking it as an uninstantiable, abstract class. These classes can have abstract methods: methods declared but with no body of code. Classes inheriting from an abstract class have the responsibility to implement the abstract methods. 8.6 Interfaces

9.1

Assertions

The assert statement is ignored unless assertion checking is enabled with java command line options: -ea -da enable assertion checking disable assertion checking

Interfaces are all abstract classes. Since no code can be inherited from an interface, a class can implement as many interfaces as desired. < class declaration > ::= "class" < identifier > ["extends" < type > ] ["implements" < type list > ] "{" < class body > "}" Two important interfaces are Comparable<T> and Comparator<T>. 8.7 Dynamic Dispatch

java -ea -da:... -da:pack.subpack... pack.Main When enabled, the statement assert expr:str acts like: if (! expr ) throw new AssertionException ( str ); The following lines make use of assertions to clarify the computation of the integer square root of n: assert 0<n : " precond "; int r = 1; while (n >=( r +1)*( r +1)) { assert r*r <= n : " loop inv "; r ++; } assert r*r <= n && n <( r +1)*( r +1);

The following program prints X because the method invoked by the call o.toString() is dynamically determined by the class it refers to (class X) and not statically by the type of the variable o (class Object). class X extends Object { @Override public String toString () { return "X"; } public static void main ( String [] args ) { Object o = new X (); System . out . println (o. toString ()); } }

10

Generics

Java has generic classes and methods. The following is the syntax of a generic class. < class declaration > ::= "class" < identifier > [ < type parameter list > ] ["extends" < type > ] ["implements" < type list > ] "{" < class body > "}"

Exceptions

A checked exception is one that extends the class java.lang.Exception, but does not extend the class java.lang.RuntimeException. 7

11
11.1

Collection Classes
Sequences

Character classes from POSIX, java.lang.Character, Unicode blocks and Unicode categories. \p{Lower} \p{Upper} \p{ASCII} \p{Digit} \p{Alpha} \p{Alnum} \p{Space} \p{XDigit} \p{Cntrl} [a-z] [A-Z] [\x00-\x7F] [0-9] [\p{Lower}\p{Upper}] [\p{Alpha}\p{Digit}] [ \t\n\x0B\f\r] [0-9a-fA-F] [\X00-\X1F\x7F] lower-case letter upper-case letter all ASCII chars same as \d upper and lower case letters and digits same as \s hexadecimal digit control character

ArrayList<E>, LinkedList<E>: List<E> get(i), set(i,e), add(i,e), remove(i) 11.2 Stacks, Queues, Dequeues

ArrayDequeue<E>, LinkedList<E>: Deque<E> addFirst(e), addLast(e), removeFirst(e), removeLast(e) 11.3 Sets

HashSet<E>: Set<E> TreeSet<E>: NavigableSet<E> : SortedSet<E> : Set<E> add(e), contains(e) Set < String > set = new HashSet < String >( Arrays . asList ("a" , " an " , " the " )); 11.4 Dictionaries or Maps

r? r* r+ r {n } r {n,} r {n,m }

zero or one zero or more one or more exactly n times n times or more at least n and no more than m

HashMap<K,V>: Map<K,V> TreeMap<K,V>: NavigableMap<K,V> : SortedMap<K,V> : Map<K,V> put(k,v), get(k), containsKey(k),

12

Regular Expressions java.util.regex

All unmodied quantiers are greedy, meaning they match as many elements of the string as possible without causing the overall match to fail. In contrast, a reluctant quantier will match as few elements of the strings as possible. You can make a quantier reluctant by adding the ? character. A possessive quantier will match as much of the target as possible (like greedy) even if it means that the remainder of the regex will fail. Backtracking is prevented (improving efciency), just like independent (aka atomic) grouping. You can make a quantier possessive by adding the + character. (r) (?<name>r) (?:r) (?>r) capturing group by position; refered to later using \d capturing group by name; refered to later using \k<name> simple group (no capturing, no back reference to it) an independent (no backtracking), non-capturing group

Regular expressions denote patterns of strings and can be represented in Java by special string literals. Regular expressions use \ to escape meta-characters. Character escapes also start with \. One must escape the escape character to write regular expressions as Java stringsthe backslash appears twice. "\\Qa\"b\\E[\\p{Punct}&&[-_]]" Predened character classes. \d \s \w [0-9] [ \t\n\x0B\f\r] [a-zA-Z_0-9] a digit whitespace character character of word

Zero-width (non-capturing) assertions. positive ahead behind (?=r ) (?<=r ) negative (?!r ) (?<!r )