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).

Legal Conversions Between Primitive Types

Dotted arrows denote conversions that may lose precision.

Functional Interfaces

Interfaces with a single abstract method. Example:

@FunctionalInterface
public interface Predicate<T> {
boolean test(T t); 
}

Implementations of this interface can be supplied in-line as a lambda expression:

• Anonymous implementations of functional interfaces
• Parameters and body are separated by an “arrow sign” ("->")
• Parameters of the abstract method are on the left of the arrow
• The implementation is on the right of the arrow

Typical usage of lambda expressions:

JButton button = new JButton("MyButton"); button.addActionListener(event -> doSomeImportantStuff(event));

Method References

Lambda expressions represent anonymous functions. You can pass them as method parameters or return them. The same can be done with named methods using method references.

Typical usage of method references:

There are four kinds of method references:

Common Tasks

Bulk Operations With Stream API

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

Conversion Characters

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

Common Tasks

Regular Expression Syntax

Predefined Character Class Names

Flags for Matching

The pattern matching can be adjusted with flags, for example:

Pattern pattern = Pattern.compile(patternString,
Pattern.CASE_INSENSITIVE + Pattern.UNICODE_CASE)

Common Tasks

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 property java.util.logging.config.file when starting the virtual machine. (Note that the LogManager runs before main.)

• 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");

• 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