Java Syntax Notes
Primitive Types
Array
String
Collections
HashMap
HashSet
ArrayList
Heap
Queue
Stack
Linked List
1
Primitive Types
Array
One dimensional: int[] myArr = new int[10]; // Integer array of 10 elements
Two dimensional: int[][] myArr = new int[10][20]; // 10 rows, 20 columns
Array literals: int[] myArr = new int[]{1, 2, 3}; // Length calculated during creation
int[] myArr = {1, 2, 3};
int[][] myArr = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} } // 3 rows & cols
Accessing: for (int i = 0; i < myArr.length; i++) { System.out.print(myArr[i]; }
for (int i : myArr) { System.out.print(i); }
String
Creation: String gopha = new String(“ok”);
String literal: String gopha = “ok”;
Size: gopha.length();
Accessing: char[] chArr = gopha.toCharArray();
for (char c : chArr) { System.out.print(c); }
for (int i = 0; i < gopha.length(); i++) { System.out.print(gopha.charAt(i)); }
2
Collections
HashMap
A data structure that maps keys to values. A map cannot contain duplicate keys and each key
can map to at most one value.
Import required: import java.util.HashMap;
Creation: HashMap<String, String> hm = new HashMap<>();
Add element: hm.put(“gopha”, “ok”); // Key is “gopha”, value is “ok”
Update element: hm.put(“gopha”, hm.getOrDefault(“gopha”, “run”));
* Note: Attempts to retrieve the value for the key “gopha” . If not present,
“run” will be used instead and saved for the respective key of “gopha”
Remove element: hm.remove(“gopha”); // Specify key to remove the entire entry
Size: hm.size();
Accessing: for (Map.Entry<String, String> entry : hm.entrySet()) {
System.out.println(entry.getKey() + “ “ + entry.getValue());
}
for (String key : hm.keySet()) { System.out.println(key); }
for (String value : hm.values()) { System.out.println(value); }
Time Complexity:
● Access: O(1)
● Search: O(n)
● Insert: O(1)
● Remove: O(1)
3
HashSet
A collection that uses a Hash table for storage, only allowing unique elements to be added.
Import required: import java.util.HashSet;
Creation: HashSet<String> hs = new HashSet<>();
Add element: hs.add(“gopha ok”);
Remove element: hs.remove(“gopha ok”);
Search element: hs.contains(“gopha ok”);
Size: hs.size();
Accessing: for (String s : hs) {
System.out.println(s);
}
Time Complexity:
● Access: O(1)
● Search: O(1)
● Insert: O(1)
● Remove: O(1)
4
ArrayList
A collection of data elements sequentially ordered from 0 to length - 1. This means that we are
able to access an element inside an ArrayList by its position (index).
Import required: import java.util.ArrayList;
Creation: ArrayList<Integer> list = new ArrayList<>();
List<Integer> list = new ArrayList<>();
Add element: list.add(1);
Update element: list.set(0, 100); // Update index 0’s value to 100
Remove element: list.remove(0); // Remove index 0
list.clear(); // Remove all elements
Size: list.size();
Accessing: for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); }
for (String s : list) { System.out.println(s); }
Sorting: import java.util.Collections;
Collections.sort(list); // Sort ascending
Collections.sort(list, Collections.reverseOrder()); // Sort descending
Time Complexity:
● Access: O(1)
● Search: O(n)
● Insert: O(1) (at the back of the ArrayList)
● Remove: O(n)
5
Heap
A specialized tree based structure data structure that satisfies the heap property: if A is a parent
node of B, then the key (the value) of node A is ordered with respect to the key of node B with
the same ordering applying across the entire heap.
A heap can be classified further as either a "max heap" or a "min heap". In a max heap, the
keys of parent nodes are always greater than or equal to those of the children and the highest
key is in the root node. In a min heap, the keys of parent nodes are less than or equal to those
of the children and the lowest key is in the root node.
Import required: import java.util.PriorityQueue;
Creation: PriorityQueue<Integer> pq = new
PriorityQueue<>(Collections.reverseOrder); // Max heap
* Note: Omit “Collections.reverseOrder” for a min heap by default
PriorityQueue<Map.Entry<String, Integer>> pq = new PriorityQueue<>(
(a, b) -> a.getValue().equals(b.getValue()) ?
a.getKey().compareTo(b.getKey()) :
a.getValue() - b.getValue()
); // Max heap that contains pairs - if values for pairs are the same,
// then they will be sorted ascending (a-z) according to key
Add element: pq.add(10);
View top element: pq.peek(); // Returns but does not remove the top element
Remove element: pq.poll(); // Returns and removes the top element
Size: pq.size();
Time Complexity:
● Access Max / Min: O(1)
● Insert: O(log(n))
● Remove Max / Min: O(log(n))
6
Queue
A collection of elements, supporting two principle operations: enqueue, which inserts an
element into the queue, and dequeue, which removes an element from the queue.
Import required: import java.util.Queue;
Creation: Queue<Integer> q = new LinkedList<>(); // Specify as a LinkedList!
Add element: q.add(10);
View top element: q.peek(); // Returns head or null if empty
Remove element: q.poll(); // Returns head or null if empty
Size: q.size();
q.isEmpty(); // Returns true if the queue is empty
Time Complexity:
● Access: O(n)
● Search: O(n)
● Insert: O(1)
● Remove: O(1)
7
Stack
A collection of elements, with two principle operations: push, which adds to the collection, and
pop, which removes the most recently added element.
Import required: import java.util.Stack;
Creation: Stack<Integer> st = new Stack<>();
Add element: st.push(10);
View top element: st.peek(); // Returns but does not remove the top element
Remove element: st.pop(); // Returns and removes the top element
Size: st.size();
st.isEmpty(); // Returns true if the stack is empty
Time Complexity:
● Access: O(n)
● Search: O(n)
● Insert: O(1)
● Remove: O(1)
8
Linked List
A linear collection of data elements, called nodes, each pointing to the next node by means of a
pointer. It is a data structure consisting of a group of nodes which together represent a
sequence.
Import required: import java.util.LinkedList;
Creation: LinkedList<Integer> list = new LinkedList<>();
Add element: list.add(1);
Update element: list.set(0, 100); // Update index 0’s value to 100
Remove element: list.remove(0); // Remove index 0
list.clear(); // Remove all elements
Size: list.size();
Accessing: for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); }
for (int i : list) { System.out.println(s); }
Time Complexity:
● Access: O(n)
● Search: O(n)
● Insert: O(1)
● Remove: O(1)
