Core Java Cheatsheet

Introduction

Java is one of the most popular programming languages in the world, used in million of devices from servers and workstations to tablets, mobile phones and wearables. With this cheatsheet we strive to provide the main concepts and key aspects of the Java programming language. We include details on core language features such as lambda expressions, collections, formatted output, regular expressions, logging, properties as well as the most commonly used tools to compile, package and execute java programs.

Java Keywords

Let’s start with the basics, what follows is a list containing some of the most commonly used Java keywords, their meanings, and short examples. Please note that this is not an exhaustive list of all Java keywords, but it covers many of the commonly used ones. So be sure to consult the documentation for the most up-to-date information.

Java Packages

In Java, a package is a mechanism for organizing and grouping related classes and interfaces into a single namespace. Below you can find some of the most commonly used and the functionality their classes provide. Java has a rich ecosystem of libraries and frameworks, so the packages you use may vary depending on your specific application or project. Remember to import the necessary packages at the beginning of your Java classes to access their functionality.

Java Operators

Operators are a cornerstone aspect to every programming language. They allow you to manipulate data, perform calculations, and make decisions in your programs. Java provides a wide range of operators. Following are the ones most commonly used. The descriptions provide a brief overview of their purposes and usage. The operators at the top of the table have higher precedence, meaning they are evaluated first in expressions. Operators with the same precedence level are evaluated left to right. Be sure to use parentheses to clarify the order of evaluation when needed.

Primitive Types

In Java, primitive types (also known as primitive data types or simply primitives) are the simplest data types used to represent single values. These types are built into the language itself and are not objects like instances of classes and reference types. Java’s primitive types are designed for efficiency and are used to store basic values in memory. Below is a table listing all of Java’s primitive data types, their size in bytes, their range, and some additional notes. Keep in mind that you can convert from byte to short, short to int, char to int, int to long, int to double and float to double without loosing precision since the source type is smaller in size compared to the target one. On the other hand converting from int to float, long to float or long to double may come with a precision loss.

Lambda Expressions

Lambda expressions provide a way to define small, self-contained, and unnamed functions (anonymous functions) right where they are needed in your code. They are primarily used with functional interfaces, which are interfaces with a single abstract method. Lambda expressions provide a way to implement the abstract method of such interfaces without explicitly defining a separate class or method.

The syntax for lambda expressions is concise and consists of parameters surrounded by parenthesis (()), an arrow (->), and a body. The body can be an expression or a block of code.

// Using a lambda expression to define a Runnable
Runnable runnable = () -> System.out.println("Hello, Lambda!");

Functional Interfaces

A functional interface is an interface that has exactly one abstract method, which is used to define a single unit of behavior. Below is an example of such an interface:

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}

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

// Using a lambda expression to define addition
Calculator addition = (a, b) -> a + b;
int result1 = addition.calculate(5, 3);
System.out.println("Addition: " + result1); // Output: Addition: 8
        
// Using a lambda expression to define subtraction
Calculator subtraction = (a, b) -> a - b;
int result2 = subtraction.calculate(10, 4);
System.out.println("Subtraction: " + result2); // Output: Subtraction: 6

Method References

Method references provide a concise way to reference static methods, constructors, or instance methods of objects, pass them as method parameters or return them, much like anonymous functions; making your code more readable and expressive when working with functional interfaces. Let’s update the calculator example to use method references:

public class MethodReferenceCalculator {
    // A static method that performs addition
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        // Using a method reference to the static add method
        Calculator addition = MethodReferenceCalculator::add;
        
        int result = addition.calculate(5, 3);
        System.out.println("Addition result: " + result); // Output: Addition result: 8
    }
}

Collections

Collections play a pivotal role in Java development. Following are some of the most commonly used collection implementation classes along with code snippets illustrating typical use cases. Depending on your specific requirements, you can choose the appropriate one to suit your data storage and retrieval needs.

ArrayList

An array-based list that dynamically resizes as elements are added or removed.

// Create an ArrayList and add elements.
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");

// Iterate through the ArrayList.
for (String name : names) { /*...*/ }

// Add an element by index.
names.set(i, "Charlie");

// Remove an element by index.
names.remove(0);

// Add multiple elements using addAll.
names.addAll(Arrays.asList("David", "Eve"));

// Remove multiple elements using removeAll.
names.removeAll(Arrays.asList("Alice", "Bob"));

// Retrieve an element by index.
String firstPerson = names.get(0);

// Convert ArrayList to an array.
String[] namesArray = names.toArray(new String[0]);

// Convert an array to an ArrayList.
List<String> namesList = Arrays.asList(namesArray);

// Sort elements in natural order.
Collections.sort(names);

// Sort elements using a custom comparator.
Collections.sort(names, new Comparator<String>() { public int compare(String a, String b) { return a.length() - b.length(); } });

// Do something with all elements in the collection
names.forEach(System.out::println);

// Use the Stream API to filter elements.
List<String> filteredNames = names.stream().filter(name -> name.startsWith("A")).collect(Collectors.toList());

// Use the Stream API to perform calculations on elements (e.g., sum of lengths).
int sumOfLengths = names.stream().mapToInt(String::length).sum();

LinkedList

A doubly-linked list that allows efficient insertion and removal from both ends.

LinkedList<Integer> numbers = new LinkedList<>();
numbers.addFirst(1);
numbers.addLast(2);
numbers.removeFirst();

HashSet

An unordered collection of unique elements, implemented using a hash table.

// Create a HashSet and add unique elements.
HashSet<String> uniqueWords = new HashSet<>();
uniqueWords.add("apple");
uniqueWords.add("banana");

// Iterate through the HashSet.
for (String word : uniqueWords) { /*...*/ }

// Remove an element from the HashSet.
uniqueWords.remove("apple");

// Use the Stream API to check if an element exists.
boolean containsBanana = uniqueWords.stream().anyMatch(word -> word.equals("banana"));

TreeSet

A sorted set that stores elements in natural order or according to a specified comparator.

// Create a TreeSet and add elements (sorted automatically).
TreeSet<Integer> sortedNumbers = new TreeSet<>();
sortedNumbers.add(3);
sortedNumbers.add(1);
sortedNumbers.add(2);

// Iterate through the TreeSet (in ascending order).
for (Integer number : sortedNumbers) { /*...*/ }

// Use the Stream API to find the maximum element.
Optional<Integer> maxNumber = sortedNumbers.stream().max(Integer::compareTo);

HashMap

An unordered collection of key-value pairs, implemented using a hash table.

// Create a HashMap and add key-value pairs.
HashMap<String, Integer> ageMap = new HashMap<>();
ageMap.put("Alice", 25);
ageMap.put("Bob", 30);

// Iterate through the HashMap key-value pairs.
for (Map.Entry<String, Integer> entry : ageMap.entrySet()) { /*...*/ }

// Remove a key-value pair by key.
ageMap.remove("Alice");

// Use the Stream API to transform key-value pairs.
Map<String, Integer> doubledAgeMap = ageMap.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, entry -> entry.getValue() * 2));

TreeMap

A sorted map that stores key-value pairs in natural order or according to a specified comparator.

// Create a TreeMap and add key-value pairs (sorted by key).
TreeMap<String, Double> salaryMap = new TreeMap<>();
salaryMap.put("Alice", 55000.0);
salaryMap.put("Bob", 60000.0);

// Iterate through the TreeMap keys (in ascending order).
for (String name : salaryMap.keySet()) { /*...*/ }

// Iterate through the TreeMap values (in ascending order of keys).
for (Double salary : salaryMap.values()) { /*...*/ }

// Use the Stream API to calculate the total salary.
double totalSalary = salaryMap.values().stream().mapToDouble(Double::doubleValue).sum();

LinkedHashMap

A map that maintains the order of insertion while still providing hash table efficiency.

// Create a LinkedHashMap and add key-value pairs (maintains insertion order).
LinkedHashMap<String, Integer> orderMap = new LinkedHashMap<>();
orderMap.put("First", 1);
orderMap.put("Second", 2);

// Iterate through the LinkedHashMap key-value pairs (in insertion order).
for (Map.Entry<String, Integer> entry : orderMap.entrySet()) { /*...*/ }

// Use the Stream API to extract keys in insertion order.
List<String> keysInOrder = orderMap.keySet().stream().collect(Collectors.toList());

Stack

A data structure that follows the Last-In-First-Out (LIFO) principle.

// Use a Stack to push and pop elements (LIFO).
Stack<String> stack = new Stack<>();
stack.push("Item 1");
stack.push("Item 2");
String topItem = stack.pop();

Queue

A data structure that follows the First-In-First-Out (FIFO) principle.

// Use a LinkedList as a Queue to offer and poll elements (FIFO).
Queue<String> queue = new LinkedList<>();
queue.offer("Task 1");
queue.offer("Task 2");
String nextTask = queue.poll();

PriorityQueue

A priority-based queue, where elements are dequeued based on their priority.

// Use a PriorityQueue to offer and poll elements based on priority.
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
priorityQueue.offer(3);
priorityQueue.offer(1);
int highestPriority = priorityQueue.poll();

Character Escape Sequences

Character escape sequences are used to represent special characters in Java strings. For example, \" is used to include a double quote within a string, and \n represents a newline character. The \uXXXX escape sequence allows you to specify a Unicode character by its hexadecimal code point. Below are some of the most common Character escape sequences in Java.

Output Formatting With printf

Here’s a typical example of output formatting using the printf method. For a full list of format specifiers and flags visit our comprehensive guide here.

String name = "Alice";
int age = 30;
double salary = 55000.75;
boolean married = true;

// Format and print using printf. The %n specifier is used to insert a platform-specific newline character
System.out.printf("Name: %s%n", name); // %s for String
System.out.printf("Age: %d%n", age);   // %d for int
System.out.printf("Salary: %.2f%n", salary); // %.2f for double with 2 decimal places
System.out.printf("Married: %b%n", married); // %b for boolean

Want to master Core Java

Subscribe to our newsletter and download the Core Java Cheatsheet right now!

In order to help you master Core Java, we have compiled a kick-ass all-in-one cheatsheet with all the popular and most used cases! Besides studying them online, you may also download the Cheatsheet in PDF format!!

Download Now

Thank you!

We will contact you soon.

Regular Expressions

Regular expressions are powerful tools for pattern matching and text manipulation. Below are some typical use cases.

// Matching a Simple Pattern
String text = "Hello, World!";
String pattern = "Hello, .*";
boolean matches = text.matches(pattern);

// Finding All Email Addresses in a Text
String text = "Contact us at john@example.com and jane@test.org for assistance.";
String emailPattern = "\\b\\S+@\\S+\\.[A-Za-z]+\\b";
Pattern pattern = Pattern.compile(emailPattern);
Matcher matcher = pattern.matcher(text);
while (matcher.find()) {
    String email = matcher.group();
    // Process or store the found email addresses
}

// Replacing All Occurrences of a Word
String text = "The quick brown fox jumps over the lazy dog.";
String replacedText = text.replaceAll("fox", "cat");

// Splitting a String into Words
String text = "Java is a versatile programming language.";
String[] words = text.split("\\s+");

// Validating a Date Format
String date = "2023-10-05";
String datePattern = "\\d{4}-\\d{2}-\\d{2}";
boolean isValid = date.matches(datePattern);

Below are some of the most commonly used regular expression syntax elements in Java.

Matching Flags

Pattern matching can be adjusted with flags. You can embed them at the beginning of the pattern of use them as shown below:

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

Logging

In Java’s core logging implementation (java.util.logging), the logging configuration is specified through a properties file (jre/lib/logging.properties). You can specify another file by using the system property java.util.logging.config.file when running your application. Below are some common properties used in the logging.properties file, along with their descriptions:

An example logging configuration file is provided below.

# Set the default logging level for all loggers
.level = INFO

# Handlers specify where log records are output
handlers = java.util.logging.ConsoleHandler

# Specify the log level for a specific logger
com.example.myapp.MyClass.level = FINE

# ConsoleHandler properties
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

# FileHandler properties
java.util.logging.FileHandler.level = ALL
java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter

Property Files

A properties file is a simple text file used to store configuration settings or key-value pairs. It is commonly used for configuring applications, as it provides a human-readable and editable format. Properties files are commonly used for application configuration, internationalization, and other scenarios where key-value pairs need to be stored in a structured and easily editable format.

• Properties files typically use the .properties file extension.
• Each line in the properties file represents a key-value pair. The key and value are separated by an equal sign (=) or a colon (:).
• You can include comments in properties files by prefixing a line with a hash (#) or an exclamation mark (!). Comments are ignored when reading properties.
• Whitespace characters (spaces and tabs) before and after the key and value are ignored.
• You can escape special characters like spaces, colons, and equals signs using a backslash (\).

Below is an example of loading and storing data in a properties file programmatically.

Properties properties = new Properties();
try {
  FileInputStream fileInputStream = new FileInputStream("config.properties");
  properties.load(fileInputStream);
  fileInputStream.close();

  // Access properties
  String value = properties.getProperty("key");
  System.out.println("Value for key: " + value);

  // Update properties
  properties.setProperty("key1", "value1");
  properties.setProperty("key2", "value2");
  FileOutputStream fileOutputStream = new FileOutputStream("config.properties");
  properties.store(fileOutputStream, "My Configuration");
  fileOutputStream.close();

} catch (IOException e) {
  e.printStackTrace();
}

javac command

javac is the Java Compiler, a command-line tool included in the Java Development Kit (JDK). Its main purpose is to compile Java source code files (files with a .java extension) into bytecode files (files with a .class extension) that can be executed by the Java Virtual Machine (JVM).

Below are some of the most commonly used options with the javac command. They allow you to customize the compilation process, specify source and target versions, control error handling, and manage classpaths and source file locations. You can use these options to tailor the compilation of your Java code to your project’s specific requirements.

jar command

Jar (Java Archive) files are a common way to package and distribute Java applications, libraries, and resources.

• Jar files are archive files that use the ZIP format, making it easy to compress and bundle multiple files and directories into a single file.
• Jar files can contain both executable (class files with a main method) and non-executable (resources, libraries) components.
• A special file called META-INF/MANIFEST.MF can be included in a jar file. It contains metadata about the jar file, such as its main class and version information.
• Java provides command-line tools like jar and jarsigner to create, extract, and sign jar files.

Below is a table with some common jar command options and what they do:

java command

The java command is used to run Java applications and execute bytecode files (compiled Java programs) on the Java Virtual Machine (JVM). It serves as the primary entry point for launching and executing Java applications.

Below are some of the common options used with the java command for controlling the behavior of the Java Virtual Machine (JVM) and Java applications. Depending on your specific use case, you may need to use some of these options to configure the JVM or your Java application.

Popular 3rd party Java Libraries

Java has an enormous ecosystem of third-party libraries and frameworks. Below are just a few available that will greatly improve the development experience. Each library serves a specific purpose and can significantly simplify various aspects of your code, from handling data to simplifying testing and improving code quality. Depending on your project’s requirements, you may find these libraries and others to be valuable additions to your Java toolkit.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.