The Essential Java Cheat Sheet

The Core Java Technology is the foundation of Java Platform of JSE. It is utilized in
all classes of Java programming, from desktop to Java Enterprise Edition. This DZone
Refcard gives you an overview of key aspects of the Java language and cheat sheets
on the core library (formatted output, collections, regular expressions, logging,
properties) as well as the most commonly used tools (javac, java, jar). In addition, this
Refcard reviews Java Keywords, Standard Java Packages, Character Escape
Sequences, Collections and Common Algorithms, Regular Expressions, JAR Files and
more.
HTML Preview
Core Java
By Cay S. Horstmann
About CORE JAVA
This refcard gives you an overview of key aspects of the Java language and cheat
sheets on the core library (formatted output, collections, regular expressions, logging,
properties) as well as the most commonly used tools (javac, java, jar).
Java Keywords
Keyword Description Example
abstract an abstract class or method
abstract class Writable { public abstract void
write(Writer out); public void save(String filename) {
... } }
assert
with assertions enabled,
throws an error if condition
not fulfilled
assert param != null; Note: Run with -ea to enable
assertions
boolean
the Boolean type with
values true and false
boolean more = false;
break
breaks out of a switch or
loop
while ((ch = in.next()) != -1) { if (ch == '\n') break;
process(ch); } Note: Also see switch
byte the 8-bit integer type
byte b = -1; // Not the same as 0xFF Note: Be careful
with bytes < 0
case a case of a switch see switch
catch
the clause of a try block
catching an exception
see try
char the Unicode character type char input = 'Q';
class defines a class type class Person { private String name; public
Keyword Description Example
Person(String aName) { name = aName; } public void
print() { System.out.println(name); } }
const not used

continue
continues at the end of a
loop
while ((ch = in.next()) != -1) { if (ch == ' ') continue;
process(ch); }
default
the default clause of a
switch
see switch
do the top of a do/while loop do { ch = in.next(); } while (ch == ' ');
double
the double-precision
floating-number type
double oneHalf = 0.5;
else
the else clause of an if
statement
see if
enum an enumerated type enum Mood { SAD, HAPPY };
extends
defines the parent class of a
class
class Student extends Person { private int id; public
Student(String name, int anId) { ... } public void print()
{ ... } }
final
a constant, or a class or
method that cannot be
overridden
public static final int DEFAULT_ID = 0;
finally
the part of a try block that is
always executed
see try
float
the single-precision
floating-point type
float oneHalf = 0.5F;
for a loop type
for (int i = 10; i >= 0; i--) System.out.println(i); for
(String s : line.split("\\s+")) System.out.println(s);
Note: In the "generalized" for loop, the expression after
the : must be an array or an Iterable
goto not used

if a conditional statement if (input == 'Q') System.exit(0); else more = true;
implements
defines the interface(s) that
a class implements
class Student implements Printable { ... }
import imports a package
import java.util.ArrayList; import
com.dzone.refcardz.*;
instanceof
tests if an object is an
instance of a class
if (fred instanceof Student) value = ((Student)
fred).getId(); Note: null instanceof T is always false
int the 32-bit integer type int value = 0;
interface
an abstract type with
methods that a class can
implement
interface Printable { void print(); }
long the 64-bit long integer type long worldPopulation = 6710044745L;
native
a method implemented by
the host system
new
allocates a new object or
array
Person fred = new Person("Fred");
null a null reference Person optional = null;
Keyword Description Example
package a package of classes package com.dzone.refcardz;
private
a feature that is accessible
only by methods of this
class
see class
protected
a feature that is accessible
only by methods of this
class, its children, and other
classes in the same package
class Student { protected int id; ... }
public
a feature that is accessible
by methods of all classes
see class
return returns from a method int getId() { return id; }
short the 16-bit integer type short skirtLength = 24;
static
a feature that is unique to its
class, not to objects of its
class
public class WriteUtil { public static void
write(Writable[] ws, String filename); public static
final String DEFAULT_EXT = ".dat"; }
strictfp
Use strict rules for floating-
point computations
super
invoke a superclass
constructor or method
public Student(String name, int anId) { super(name); id
= anId; } public void print() { super.print();
System.out.println(id); }
switch a selection statement
switch (ch) { case 'Q': case 'q': more = false; break;
case ' '; break; default: process(ch); break; } Note: If
you omit a break, processing continues with the next
case.
synchronized
a method or code block that
is atomic to a thread
public synchronized void addGrade(String gr) {
grades.add(gr); }
this
the implicit argument of a
method, or a constructor of
this class
public Student(String id) {this.id = id;} public
Student() { this(""); }
throw throws an exception
if (param == null) throw new
IllegalArgumentException();
throws
the exceptions that a
method can throw
public void print() throws PrinterException,
IOException
transient
marks data that should not
be persistent
class Student { private transient Data cachedData; ... }
try
a block of code that traps
exceptions
try { try { fred.print(out); } catch (PrinterException ex)
{ ex.printStackTrace(); } } finally { out.close(); }
void
denotes a method that
returns no value
public void print() { ... }
volatile
ensures that a field is
coherently accessed by
multiple threads
class Student { private volatile int nextId; ... }
while a loop while (in.hasNext()) process(in.next());
Standard Java Packages
java.applet Applets (Java programs that run inside a web page)
java.awt Graphics and graphical user interfaces
java.beans Support for JavaBeans components (classes with properties and event listeners)
java.io Input and output
java.lang Language support
java.math Arbitrary-precision numbers
java.net Networking
java.nio "New" (memory-mapped) I/O
java.rmi Remote method invocations
java.security Security support
java.sql Database support
java.text Internationalized formatting of text and numbers
java.util Utilities (including data structures, concurrency, regular expressions, and logging)
Operator Precedence
Operators with
the same
precedence

Notes
[] . () (method call)
Left to
right
! ~ ++ -- + (unary)
- (unary) () (cast)
new
Right
to left
~ flips each bit of a number
* / %
Left to
right
Be careful when using % with negative numbers. -a % b == -(a % b),
but a % -b == a % b. For example, -7 % 4 == -3, 7 % -4 == 3.
+ -
Left to
right
<< >> >>>
Left to
right
>> is arithmetic shift (n >> 1 == n / 2 for positive and negative
numbers), >>> is logical shift (adding 0 to the highest bits). The right
hand side is reduced modulo 32 if the left hand side is an int or
modulo 64 if the left hand side is a long. For example, 1 << 35 == 1
<< 3.
< <= > >=
instanceof
Left to
right
null instanceof T is always false
== !=
Left to
right
Checks for identity. Use equals to check for structural equality.
&
Left to
right
Bitwise AND; no lazy evaluation with bool arguments
^
Left to
right
Bitwise XOR
|
Left to
right
Bitwise OR; no lazy evaluation with bool arguments
&&
Left to
right
|| Left to

Operators with
the same
precedence

Notes
right
?:
Right
to left
= += -= *= /= %=
&= |= ^= <<= >>=
>>>=
Right
to left
Primitive Types
Type Size Range Notes
int
4
bytes
-2,147,483,648 to 2,147,483, 647 (just over 2
billion)
The wrapper type is Integer. Use
BigInteger for arbitrary precision
integers.
short
2
bytes
-32,768 to 32,767

long
8
bytes
-9,223,372,036,854,775,808 to
9,223,372,036,854,775,807
Literals end with L (e.g. 1L).
byte
1
byte
-128 to 127 Note that the range is not 0 ... 255.
float
4
bytes
approximately -3.40282347E+38F (6-7
significant decimal digits)
Literals end with F (e.g. 0.5F)
double
8
bytes
approximately -1.79769313486231570E+308
(15 significant decimal digits)
Use BigDecimal for arbitrary
precision floating-point numbers.
char
2
bytes
\u0000 to \uFFFF
The wrapper type is Character.
Unicode characters > U+FFFF
require two char values.
boolean true or false

Legal conversions between primitive types
Dotted arrows denote conversions that may lose precision.

Collections and Common Algorithms
ArrayList An indexed sequence that grows and shrinks dynamically
LinkedList
An ordered sequence that allows efficient insertions and removal at any
location
ArrayDeque A double-ended queue that is implemented as a circular array
HashSet An unordered collection that rejects duplicates
TreeSet A sorted set
EnumSet A set of enumerated type values
LinkedHashSet A set that remembers the order in which elements were inserted
PriorityQueue A collection that allows efficient removal of the smallest element
HashMap A data structure that stores key/value associations
TreeMap A map in which the keys are sorted
EnumMap A map in which the keys belong to an enumerated type
LinkedHashMap A map that remembers the order in which entries were added
WeakHashMap
A map with values that can be reclaimed by the garbage collector if they are
not used elsewhere
IdentityHashMap A map with keys that are compared by ==, not equals
Common Tasks
List<String> strs = new ArrayList<String>(); Collect strings
strs.add("Hello"); strs.add("World!"); Add strings
for (String str : strs) System.out.println(str);
Do something with all elements in the
collection
Iterator<String> iter = strs.iterator(); while
(iter.hasNext()) { String str = iter.next(); if
(someCondition(str)) iter.remove(); }
Remove elements that match a condition.
The remove method removes the element
returned by the preceding call to next.
strs.addAll(strColl);
Add all strings from another collection of
strings
strs.addAll(Arrays.asList(args))
Add all strings from an array of strings.
Arrays.asList makes a List wrapper for an
array
strs.removeAll(coll);
Remove all elements of another collection.
Uses equals for comparison
if (0 <= i && i < strs.size()) { str = strs.get(i);
strs.set(i, "Hello"); }
Get or set an element at a specified index
strs.insert(i, "Hello"); str = strs.remove(i);
Insert or remove an element at a specified
index, shifting the elements with higher
index values
String[] arr = new String[strs.size()];
strs.toArray(arr);
Convert from collection to array
String[] arr = ...; List<String> lst = Arrays.asList(arr);
lst = Arrays.asList("foo", "bar", "baz");
Convert from array to list. Use the varargs
form to make a small collection.
List<String> lst = ...; lst.sort(); lst.sort(new
Comparator<String>() { public int compare(String a,
Sort a list by the natural order of the
elements, or with a custom comparator.
String b) { return a.length() - b.length(); } }
Map<String, Person> map = new
LinkedHashMap<String, Person>();
Make a map that is traversed in insertion
order (requires hashCode for key type).
Use a TreeMap to traverse in sort order
(requires that key type is comparable).
for (Map.Entry<String, Person> entry :
map.entrySet()) { String key = entry.getKey(); Person
value = entry.getValue(); ... }
Iterate through all entries of the map
Person key = map.get(str); // null if not found
map.put(key, value);
Get or set a value for a given key
Character Escape Sequences
\b backspace \u0008
\t tab \u0009
\n newline \u000A
\f form feed \u000C
\r carriage return \u000D
\" double quote
\' single quote
\\ backslash
\uhhhh (hhhh is a hex number between 0000 and FFFF) The UTF-16 code point with value hhhh
\ooo (ooo is an octal number between 0 and 377) The character with octal value ooo
Note: Unlike in C/C++, \xhh is not allowed
Formatted output with printf
Typical usage
System.out.printf("%4d %8.2f", quantity, price);
String str = String.format("%4d %8.2f", quantity, price);
Each format specifier has the following form. See the tables for flags and conversion
characters.

Flags
Flag Description Example
+ Prints sign for positive and negative numbers +3333.33
space Adds a space before positive numbers | 3333.33|
0 Adds leading zeroes 003333.33
- Left-justifies field |3333.33 |
( Encloses negative number in parentheses (3333.33)
, Adds group separators 3,333.33
# (for f
format)
Always includes a decimal point 3,333.
# (for x or o
format)
Adds 0x or 0 prefix 0xcafe
$
Specifies the index of the argument to be formatted; for example, %1$d
%1$x prints the first argument in decimal and hexadecimal
159 9F
<
Formats the same value as the previous specification; for example, %d
%<x prints the same number in decimal and hexadecimal
159 9F
Conversion characters
Conversion Character Description Example
d Decimal integer 159
x Hexadecimal integer 9f
o Octal integer 237
f Fixed-point floating-point 15.9
e Exponential floating-point 1.59e+01
g General floating-point (the shorter of e and f)
a Hexadecimal floating-point 0x1.fccdp3
s String Hello
c Character H
b boolean true
h Hash code 42628b2
tx Date and time See the next table
% The percent symbol %
n The platform-dependent line separator

Formatted output with MessageFormat
Typical usage:
String msg = MessageFormat.format("On {1, date,
long}, a {0} caused {2,number,currency} of damage.",
"hurricane", new GregorianCalendar(2009, 0, 15).
getTime(), 1.0E8);
Yields "On January 1, 1999, a hurricane caused $100,000,000 of damage"
The nth item is denoted by {n,format,subformat} with optional formats and
subformats shown below
{0} is the first item
The following table shows the available formats
Use single quotes for quoting, for example '{' for a literal left curly brace
Use '' for a literal single quote
Format Subformat Example
number none 1,234.567

integer 1,235

currency $1,234.57

percent 123,457%
date none or medium Jan 15, 2009

short 1/15/09

long January 15, 2009

full
Thursday, January 15,
2009
time none or medium 3:45:00 PM

short 3:45 PM

long 3:45:00 PM PST

full 3:45:00 PM PST
choice
List of choices, separated by |. Each choice has
a lower bound (use -\u221E for -)
a relational operator: < for "less than", # or \u2264 for .
a message format string
For example, {1,choice,0#no houses|1#one house|2#{1}
houses}
no house
one house
5 houses
Regular Expressions
Common Tasks
String[] words = str.split("\\s+");
Split a string along white
space boundaries
Pattern pattern = Pattern.compile("[0-9]+"); Matcher matcher =
pattern.matcher(str); String result = matcher.replaceAll("#");
Replace all matches. Here we
replace all digit sequences
with a #.
Pattern pattern = Pattern.compile("[0-9]+"); Matcher matcher =
pattern.matcher(str); while (matcher.find()) {
process(str.substring(matcher.start(), matcher.end())); }
Find all matches.
Pattern pattern = Pattern.compile( "(1?[0-9]):([0-5][0-9])[ap]m");
Matcher matcher = pattern.matcher(str); for (int i = 1; i <=
matcher.groupCount(); i++) { process(matcher.group(i)); }
Find all groups (indicated by
parentheses in the pattern).
Here we find the hours and
minutes in a date.
Regular Expression Syntax
Characters
c The character c
\unnnn, \xnn, \0n,
\0nn, \0nnn
The code unit with the given hex or octal value
\t, \n, \r, \f, \a, \e The control characters tab, newline, return, form feed, alert, and escape
\cc The control character corresponding to the character c
Character Classes
[C1C2 . . .]
Union: Any of the characters represented by C1C2 , . . . The Ci are
characters, character ranges c1-c2, or character classes. Example: [a-zA-Z0-
9_]
[^C1C2 . . .]
Complement: Characters not represented by any of C1C2 , . . . Example: [^0-
9]
[C1&&C2 &&. . .]
Intersection: Characters represented by all of C1C2 , . . . Example: [A-
f&&[^G-`]]
Predefined Character Classes
.
Any character except line terminators (or any character if the DOTALL flag
is set)
\d A digit [0-9]
\D A nondigit [^0-9]
\s A whitespace character [ \t\n\r\f\x0B]
\S A nonwhitespace character
\w A word character [a-zA-Z0-9_]
\W A nonword character
\p{name} A named character class-see table below
\P{name} The complement of a named character class
Boundary Matchers
^ $ Beginning, end of input (or beginning, end of line in multiline mode)
\b A word boundary
\B A nonword boundary
\A Beginning of input
\z End of input
\Z End of input except final line terminator
\G End of previous match
Quantifiers
X? Optional X
X* X, 0 or more times
X+ X, 1 or more times
X{n} X{n,}
X{n,m}
X n times, at least n times, between n and m times
Quantifier Suffixes
? Turn default (greedy) match into reluctant match
+ Turn default (greedy) match into reluctant match
Characters
Set Operations
XY Any string from X, followed by any string from Y
X |Y Any string from X or Y
Grouping
(X) Capture the string matching X as a group
\g The match of the gth group
Escapes
\c The character c (must not be an alphabetic character)
\Q . . . \E Quote . . . verbatim
(? . . . ) Special construct-see API notes of Pattern class
Predefined Character Class Names
Lower ASCII lower case [a-z]
Upper ASCII upper case [A-Z]
Alpha ASCII alphabetic [A-Za-z]
Digit ASCII digits [0-9]
Alnum ASCII alphabetic or digit [A-Za-z0-9]
XDigit Hex digits [0-9A-Fa-f]
Print or Graph Printable ASCII character [\x21-\x7E]
Punct ASCII nonalpha or digit [\p{Print}&&\P{Alnum}]
ASCII All ASCII [\x00-\x7F]
Cntrl ASCII Control character [\x00-\x1F]
Blank Space or tab [ \t]
Space Whitespace [ \t\n\r\f\0x0B]
javaLowerCase Lower case, as determined by Character.isLowerCase()
javaUpperCase Upper case, as determined by Character.isUpperCase()
javaWhitespace White space, as determined by Character.isWhiteSpace()
javaMirrored Mirrored, as determined by Character.isMirrored()
InBlock
Block is the name of a Unicode character block, with spaces removed, such
as BasicLatin or Mongolian.
Category or
InCategory
Category is the name of a Unicode character category such as L (letter) or
Sc (currency symbol).
Flags for matching
The pattern matching can be adjusted with flags, for example:
Pattern pattern = Pattern.compile(patternString,
Pattern.CASE_INSENSITIVE + Pattern.UNICODE_CASE)
Flag Description
CASE_INSENSITIVE
Match characters independently of the letter case. By default, this flag
takes only US ASCII characters into account.
UNICODE_CASE
When used in combination with CASE_INSENSITIVE, use Unicode
letter case for matching.
Flag Description
MULTILINE ^ and $ match the beginning and end of a line, not the entire input.
UNIX_LINES
Only '\n' is recognized as a line terminator when matching ^ and $ in
multiline mode.
DOTALL
When using this flag, the . symbol matches all characters, including line
terminators.
CANON_EQ
Takes canonical equivalence of Unicode characters into account. For
example, u followed by (diaeresis) matches .
LITERAL
The input string that specifies the pattern is treated as a sequence of literal
characters, without special meanings for . [ ] etc.
Logging
Common Tasks
Logger logger =
Logger.getLogger("com.mycompany.myprog.mycategory");
Get a logger for a category
logger.info("Connection successful.");
Logs a message of level FINE.
Available levels are SEVERE,
WARNING,INFO,CONFIG,FINE,
FINER, FINEST, with
corresponding methods severe,
warning, and so on.
logger.log(Level.SEVERE, "Unexpected exception",
throwable);
Logs the stack trace of a Throwable
logger.setLevel(Level.FINE);
Sets the logging level to FINE. By
default, the logging level is INFO,
and less severe logging messages
are not logged.
Handler handler = new FileHandler("%h/myapp.log",
SIZE_LIMIT, LOG_ROTATION_COUNT);
handler.setFormatter(new SimpleFormatter());
logger.addHandler(handler);
Adds a file handler for saving the
log records in a file. See the table
below for the naming pattern. This
handler uses a simple formatter
instead of the XML formatter that
is the default for file handlers.
Logging Configuration Files
The logging configuration can be configured through a logging configuration file, by
default jre/lib/logging.properties. Another file can be specified with the system
propertyjava.util.logging.config.file when starting the virtual machine. (Note that
the LogManager runs before main.)
Configuration Property Description Default
loggerName.level The logging level of the None; the logger inherits
Configuration Property Description Default
logger by the given name the handler from its
parent
handlers
A whitespace or comma-
separated list of class names
for the root logger. An
instance is created for each
class name, using the
default constructor.
java.util.logging.
ConsoleHandler
loggerName.handlers
A whitespace or comma-
separated list of class names
for the given logger
list of class names for the
given logger None
loggerName. useParenthandlers
false if the parent logger's
handlers (and ultimately the
root logger's handlers)
should not be used
true
config
A whitespace or comma-
separated list of class names
for initialization.
None
java.util.logging.FileHandler.level
java.util.logging.ConsoleHandler.level
The default handler level
Level.ALL for
FileHandler, Level.INFO
for ConsoleHandler
java.util.logging.FileHandler.formatter
java.util.logging.ConsoleHandler.formatter
The class name of the
default filter
None
java.util.logging.FileHandler.formatter
java.util.logging.ConsoleHandler.formatter
The class name of the
default formatter
formatter
java.util.logging.
XMLFormatter for
FileHandler,
java.util.logging.
SimpleFormatter for
ConsoleHandler
java.util.logging.FileHandler.encoding
java.util.logging.ConsoleHandler.encoding
The default encoding
default platform
encoding
java.util.logging.FileHandler.limit
The default limit for
rotating log files, in bytes
0 (No limit), but set to
50000 in jre/lib/
logging.properties
java.util.logging.FileHandler.count
The default number of
rotated log files
1
java.util.logging.FileHandler.pattern
The default naming pattern
for log files. The following
tokens are replaced when
the file is created:
Token Description
/ Path separator
%t
System temporary
directory
%h/java%u.log
Configuration Property Description Default
%h
Value of user.home
system property
%g
The generation
number of rotated
logs
%u
A unique number for
resolving naming
conflicts
%% The % character
java.util.logging. FileHandler.append
The default append mode
for file loggers; true to
append to an existing log
file
false
Property Files
Contain name/value pairs, separated by =, :, or whitespace
Whitespace around the name or before the start of the value is ignored
n Lines can be continued by placing an \ as the last character; leading
whitespace on the continuation line is ignored
button1.tooltip = This is a long \
tooltip text.
\t \n \f \r \\ \uxxxx escapes are recognized (but not \b or octal escapes)
Files are assumed to be encoded in ISO 8859-1; use native2ascii to encode non-
ASCII characters into Unicode escapes
Blank lines and lines starting with # or ! are ignored
Typical usage:
Properties props = new Properties();
props.load(new FileInputStream("prog.properties"));
String value = props.getProperty("button1.tooltip");
// null if not present
Also used for resource bundles:
ResourceBundle bundle = ResourceBundle.getBundle("prog");
// Searches for prog_en_US.properties,
// prog_en.properties, etc.
String value = bundle.getString("button1.tooltip");
JAR Files
Used for storing applications, code libraries
By default, class files and other resources are stored in ZIP file format
META-INF/MANIFEST.MF contains JAR metadata
META-INF/services can contain service provider configuration
Use the jar utility to make JAR files
jar Utility Options
Option Description
c
Creates a new or empty archive and adds files to it. If any of the specified file names are
directories, the jar program processes them recursively.
C
Temporarily changes the directory. For example, jar cvfC myprog.jar classes *.class
changes to the classes subdirectory to add class files.
e
Creates a Main-Class entry in the manifest jar cvfe myprog.jar
com.mycom.mypkg.MainClass files
f
Specifies the JAR file name as the second command-line argument. If this parameter is
missing, jar will write the result to standard output (when creating a JAR file) or read it
from standard input (when extracting or tabulating a JAR file).
i Creates an index file (for speeding up lookups in a large archive)
m Adds a manifest to the JAR file. jar cvfm myprog.jar mymanifest.mf files
M Does not create a manifest file for the entries.
t Displays the table of contents. jar tvf myprog.jar
u Updates an existing JAR file jar uf myprog.jar com/mycom/mypkg/SomeClass.class
v Generates verbose output.
x
Extracts files. If you supply one or more file names, only those files are extracted.
Otherwise, all files are extracted. jar xf myprog.jar
O Stores without ZIP compression
common javac options
Option Purpose
-cp or -classpath
Sets the class path, used to search for class files. The class path is a list of
directories, JAR files, or expressions of the form directory/'*' (Unix) or
directory\* (Windows). The latter refers to all JAR files in the given directory.
Class path items are separated by : (Unix) or ; (Windows). If no class path is
specified, it is set to the current directory. If a class path is specified, the
current directory is not automatically included-add a . item if you want to
include it.
-sourcepath
Sets the path used to search for source files. If source and class files are
present for a given file, the source is compiled if it is newer. If no source path
is specified, it is set to the current directory.
-d
Sets the path used to place the class files. Use this option to separate .java and
.class files.
-source Sets the source level. Valid values are 1.3, 1.4, 1.5, 1.6, 5, 6
-deprecation Gives detail information about the use of deprecated features
-Xlint:unchecked Gives detail information about unchecked type conversion warnings
Option Purpose
-cp or -classpath
Sets the class path, used to search for class files. See the previous table for
details. Note that javac can succeed when java fails if the current directory is
on the source path but not the class path.
-ea or -
enableassertions
Enable assertions. By default, assertions are disabled.
-Dproperty=value Sets a system property that can be retrieved by System. getProperty(String)
-jar
Runs a program contained in a JAR file whose manifest has a Main-Class
entry. When this option is used, the class path is ignored.
-verbose
Shows the classes that are loaded. This option may be useful to debug class
loading problems.
-Xmssize
-Xmxsize
Sets the initial or maximum heap size. The size is a value in bytes. Add a
suffix k or m for kilobytes or megabytes, for example, -Xmx10m