1
JAVA : Collections & Data Structures Library Cheat Sheet
1. Arrays
Declare an array: int[] myArray;
Initialize an array: int[] myArray = {1, 2, 3, 4, 5};
Create an array with size: int[] myArray = new int[5];
Access element: int element = myArray[0];
Set element: myArray[0] = 10;
Get array length: int length= [Link];
Copy array: int[] newArray = [Link] (myArray, [Link]);
Copy range: int[] partialArray = [Link] (myArray, 1, 4);
Fill array: [Link] (myArray, 0);
Sort array: [Link](myArray);
Compare arrays: boolean isEqual = [Link](array1, array2);
Binary search: int index = [Link] (myArray, 3);
Convert to List: List<Integer> list = [Link](myArray);
Print array: [Link]([Link](myArray));
Multi-dimensional array: int[][] matrix = new int[3][3];
2. ArrayList
Create an ArrayList: ArrayList<Integer> list = new ArrayList<>();
Create ArrayList with initial capacity: ArrayList<String> list = new ArrayList<>(10);
Create ArrayList from another collection: ArrayList<String> list = new ArrayList<>(anotherList);
Add element: [Link]("element");
Add element at index: [Link](0, "element");
Add all elements from another collection: [Link](anotherList);
Get element at index: String element = [Link](0);
Set element at index: [Link](0, "newElement");
Remove element: [Link]("element");
Remove element at index: [Link](0);
Remove all elements from another collection: [Link](anotherList);
Retain all elements from another collection: [Link] (anotherList);
Clear all elements: [Link]();
Check if list contains element: boolean contains = [Link]("element");
Get index of element: int index = [Link]("element");
Get last index of element: int lastIndex = [Link]("element");
Check if list is empty: boolean isEmpty = [Link]();
Get size of list: int size = [Link]();
Convert list to array: Object[] array = [Link]();
Convert list to typed array: String[] array = [Link](new String[0]);
Get sublist: List<String> subList = [Link](1, 4);
Sort list: [Link](list);
Reverse list: [Link] (list);
Mukund Bane
2
Shuffle list: [Link] (list);
Find min element: String min = [Link](list);
Find max element: String max = [Link](list);
Fill list with element: [Link](list, "element");
Copy list: ArrayList<String> copy = new ArrayList<>(list);
Convert to synchronized list: List<String> syncList = [Link] (list);
Create unmodifiable view of list: List<String> unmodifiableList=
[Link](list);
Iterate over list: for (String element : list) { }
Iterate with index: for (int i = 0; i < [Link](); i++) { }
Iterate using iterator: Iterator<String> iter = [Link](); while ([Link]()) { }
Iterate using listIterator: ListIterator<String> listIter = [Link]();
Remove if condition is met: [Link] (element -> [Link]());
Replace all elements: list. replaceAll(String:: toUpperCase);
For each operation: [Link] ([Link]::println);
Convert to stream: Stream<String> stream = [Link]();
Join elements to string: String joined = [Link](", ", list);
Check if any element satisfies condition boolean any = [Link]().anyMatch
(String::isEmpty);
Check if all elements satisfy condition: boolean all = [Link]().allMatch(s -> [Link]() > 2);
Find first element satisfying condition: Optional <String> first [Link]().filter(s ->
[Link]("A")).findFirst();
3. HashMap
Create HashMap with initial capacity: HashMap<String, Integer> map = new HashMap<> (16);
Create HashMap from another map: HashMap<String, Integer> map = new
HashMap<>(anotherMap);
Put key-value pair: [Link]("key", 1);
Put if absent: [Link] ("key", 1);
Get value by key: Integer value = [Link]("key");
Get value by key with default: Integer value = [Link]("key", 0);
Remove key-value pair: [Link]("key");
Remove key-value pair if value matches: [Link]("key", 1);
Clear all entries: [Link]();
Check if key exists: boolean containsKey = [Link]("key");
Check if value exists: boolean containsValue = [Link](1);
Get set of keys: Set<String> keys = [Link]();
Get collection of values: Collection<Integer> values = [Link]();
Get set of entries: Set<[Link]<String, Integer>> entries = [Link]();
Check if map is empty: boolean isEmpty = [Link]();
Get size of map: int size = [Link]();
Replace value for key: [Link]("key", 2);
Replace value if old value matches: [Link]("key", 1, 2);
Merge values: [Link]("key", 1, Integer::sum);
Mukund Bane
3
Compute value if absent: [Link] ("key", k-> [Link]());
Compute value if present: [Link] ("key", (k, v) -> v + 1);
Compute value: [Link]("key", (k, v) -> (v == null) ? 1 : v + 1);
For each operation: [Link]((k, v) -> [Link](k + " ": +v);
Convert to synchronized map: Map<String, Integer> syncMap =
[Link](map);
Create unmodifiable view of map: Map<String, Integer> unmodifiableMap =
[Link](map);
Iterate over entries: for ([Link]<String, Integer> entry : [Link]()) { }
Iterate over keys: for (String key [Link]()) { }
Iterate over values: for (Integer value: [Link]()) { }
Convert to stream: Stream<Map. Entry<String, Integer>> stream = [Link]().stream();
4. HashSet
Create a HashSet: HashSet<String> set = new HashSet<>();
Create HashSet with initial capacity: HashSet<String> set = new HashSet<>(16);
Create HashSet from another collection: HashSet<String> set = new
HashSet<>(anotherCollection);
Add element: [Link]("element");
Remove element: [Link]("element");
Clear all elements: [Link]();
Check if element exists: boolean contains = [Link]("element");
Check if set is empty: boolean isEmpty = [Link]();
Get size of set: int size = [Link]();
Add all elements from another collection: [Link](anotherCollection);
Remove all elements from another collection: [Link](anotherCollection);
Retain all elements from another collection: [Link] (anotherCollection);
Convert set to array: Object[] array = [Link]();
Convert set to typed array: String[] array = [Link](new String[0]);
Iterate over set: for (String element : set) { }
Iterate using iterator: Iterator<String> iter = [Link](); while ([Link]()) { }
Remove if condition is met: [Link] (element -> [Link]());
For each operation: [Link]([Link]::println);
Convert to stream: Stream<String> stream = [Link]();
Check if any element satisfies condition: boolean any = [Link]().anyMatch
(String::isEmpty);
Check if all elements satisfy condition: boolean all = [Link]().allMatch(s -> [Link]() > 2);
Find first element satisfying condition: Optional<String> first = [Link]().filter(s ->
[Link]("A")).findFirst();
Convert to synchronized set: Set<String> syncSet = [Link] (set);
Create unmodifiable view of set: Set<String> unmodifiableSet =
[Link](set);
Convert to TreeSet (sorted): TreeSet<String> treeSet = new TreeSet<>(set);
Check if set is subset of another set: boolean isSubset = [Link] (anotherSet);
Mukund Bane
4
Perform union of two sets: [Link](anotherSet);
Perform intersection of two sets: set. retainAll (anotherSet);
Perform difference of two sets: [Link](anotherSet);
5. LinkedList
Create a LinkedList: LinkedList<String> list = new LinkedList<>();
Create LinkedList from another collection: LinkedList<String> list =
LinkedList<>(anotherCollection);
Add element: [Link]("element");
Add element at index: [Link](0, "element");
Add element at the beginning: [Link]("element");
Add element at the end: [Link] ("element");
Remove first occurrence of element: [Link]("element");
Remove element at index: [Link](0);
Remove first element: [Link]();
Remove last element: [Link]();
Get first element: String first = [Link]();
Get last element: String last = [Link]();
Set element at index: [Link](0, "newElement");
Check if list contains element: boolean contains = [Link]("element");
Get index of first occurrence: int index = [Link]("element");
Get index of last occurrence: int lastIndex = [Link]("element");
Get element at index: String element = [Link](0);
Clear all elements: [Link]();
Check if list is empty: boolean isEmpty =[Link]();
Get size of list: int size = [Link]();
Convert list to array: Object[] array = [Link]();
Convert list to typed array: String[] array = [Link] (new String[0]);
Get sublist: List<String> subList = [Link](1, 4);
Add all elements from another collection: [Link] (anotherCollection);
Add all elements from another collection at index: [Link] (1, anotherCollection);
Remove all elements from another collection: [Link] (anotherCollection);
Retain all elements from another collection: [Link] (anotherCollection);
Iterate over list: for (String element : list) { }
Iterate using iterator: Iterator<String> iter = [Link](); while ([Link]()) { }
Iterate using list iterator: ListIterator<String> listIter = [Link]();
Iterate in reverse: Iterator<String> descendingIter = [Link]();
Remove if condition is met: [Link] If (element -> [Link]());
Replace all elements: list. replaceAll(String:: toUpperCase);
For each operation: [Link] ([Link]::println);
Convert to stream: Stream<String> stream =[Link]();
Peek at first element: String first = list. peek();
Peek at last element: String last = [Link]();
Poll first element: String polled = [Link]();
Mukund Bane
5
Poll last element: String polled = [Link]();
Push element onto stack: [Link]("element");
Pop element from stack: String popped =[Link]();
Sort list: [Link](list);
Reverse list: [Link] (list);
Shuffle list: Collections. shuffle (list);
Find min element: String min = [Link](list);
Find max element: String max = [Link](list);
6. Stack
Create Stack: Stack<String> stack = new Stack<>();
Push element: [Link]("Hello");
Pop element: String popped = [Link]();
Peek top element: String top = [Link]();
Check if empty: boolean isEmpty =[Link]();
Get size: int size = [Link]();
Search element: int position = [Link]("Hello");
Clear stack: [Link]();
7. Queue (Using LinkedList)
Create Queue: Queue<String> queue = new LinkedList<>();
Add element: [Link]("Hello");
Offer element: [Link] ("World");
Remove element: String removed = [Link]();
Poll element: String polled = [Link]();
Peek front element: String front = [Link]();
Check if empty: boolean isEmpty [Link]();
Get size: int size = [Link]();
Clear queue: [Link]();
Contains element: boolean contains = [Link]("Hello");
8. PriorityQueue
Create PriorityQueue: PriorityQueue<Integer> pq = new PriorityQueue<>();
Create with comparator: PriorityQueue<String> pq = new
PriorityQueue<>([Link]());
Add element: [Link](5);
Offer element: [Link] (3);
Remove element: Integer removed = [Link]();
Poll element: Integer polled = [Link]();
Peek top element: Integer top = [Link]();
Mukund Bane
6
Check if empty: boolean isEmpty = [Link]();
Get size: int size = [Link]();
Clear queue: [Link]();
Contains element: boolean contains = [Link](5);
Convert to array: Object[] array = [Link]();
Iterator: Iterator<Integer> it = [Link]();
9. TreeMap
Create TreeMap: TreeMap<String, Integer> map = new TreeMap<>();
Put key-value pair: [Link]("One", 1);
Get value: Integer value = [Link]("One");
Remove key-value pair: [Link]("One");
First key: String firstKey = [Link]();
Last key: String lastKey = [Link]();
Lower key: String lowerKey = [Link]("One");
Higher key: String higherKey = [Link]("One");
Floor key: String floorKey = map. floorKey("One");
Ceiling key: String ceilingKey= [Link]("One");
First entry: [Link]<String, Integer> firstEntry = [Link]();
Last entry: [Link]<String, Integer> lastEntry = [Link]();
Lower entry: [Link]<String, Integer> lower Entry = [Link]("One");
Higher entry: [Link]<String, Integer> higherEntry [Link]("One");
Floor entry: [Link]<String, Integer> floorEntry = [Link]("One");
Ceiling entry: [Link]<String, Integer> ceilingEntry = [Link]("One");
Poll first entry: [Link]<String, Integer> firstEntry = [Link]();
Poll last entry: [Link]<String, Integer> lastEntry = [Link]();
Submap: SortedMap<String, Integer> subMap = [Link]("A", "D");
Headmap: SortedMap<String, Integer> headMap = [Link]("D");
Tailmap: SortedMap<String, Integer> tailMap = [Link]("D");
Descending key set: NavigableSet<String> descKeys= [Link]();
Descending map: NavigableMap<String, Integer> descMap = [Link]();
10. TreeSet
Create TreeSet: TreeSet<String> set = new TreeSet<>();
Add element: [Link]("Hello");
Remove element: [Link]("Hello");
First element: String first = [Link]();
Last element: String last = [Link]();
Lower element: String lower = set. lower ("Hello");
Mukund Bane
7
Higher element: String higher=[Link] ("Hello");
Floor element: String floor = [Link]("Hello");
Ceiling element: String ceiling= [Link] ("Hello");
Poll first: String first = [Link]();
Poll last: String last = [Link]();
Subset: SortedSet<String> subSet = [Link] ("A", "D");
Headset: SortedSet<String> headSet = [Link] ("D");
Tailset: SortedSet<String> tailSet = [Link]("D");
Descending set: NavigableSet<String> descSet = [Link]();
Iterator: Iterator<String> it= [Link]();
Descending iterator: Iterator<String> descIt = [Link]();
11. String
Create a String: String str = "Hello, World!";
Create String from char array: String str = new String (new char[]{'H', 'e', '1', '1', 'o'});
Create String from byte array: String str = new String(new byte[]{72, 101, 108, 108, 111},
StandardCharsets.UTF_8);
Get length of string: int length = [Link]();
Get character at index: char ch = [Link](0);
Get substring: String sub = [Link](0, 5);
Concatenate strings: String concat = [Link](" How are you?");
Check if string contains substring: boolean contains = [Link]("World");
Check if string starts with prefix: boolean startsWith = [Link]("Hello");
Check if string ends with suffix: boolean endsWith = [Link]("!");
Compare strings: int result = [Link]("Hello");
Compare strings ignoring case: int result = [Link]("HELLO");
Convert to lowercase: String lower = [Link]();
Convert to uppercase: String upper = [Link]();
Trim whitespace: String trimmed = [Link]();
Replace character: String replaced = [Link]('o', '0');
Replace sequence: String replaced = [Link]("World", "Java");
Replace first occurrence: String replaced = [Link]("1", "L");
Replace all occurrences: String replaced = [Link]("1", "L");
Split string: String[] parts = [Link](", ");
Join strings: String joined= [Link](", ", "Hello", "World");
Check if string is empty: boolean isEmpty = [Link]();
Check if string is blank: boolean isBlank = [Link]();
Get index of character: int index = [Link]('o');
Get last index of character: int lastIndex = [Link]('o');
Get index of substring: int index = [Link]("World");
Get last index of substring: int lastIndex = [Link]("o");
Convert to char array: char[] chars = [Link]();
Get bytes: byte[] bytes = [Link]();
Get bytes with charset: byte[] bytes= [Link](StandardCharsets.UTF_8);
Mukund Bane
8
Matches regex: boolean matches = [Link]("Hello.*");
Format string: String formatted = [Link]("Hello, %s!", "World");
Repeat string: String repeated = "Hello". repeat (3);
Strip leading spaces: String stripped = [Link]();
Strip trailing spaces: String stripped = [Link]();
Strip all spaces: String stripped = [Link]();
Convert to int: int num = [Link]("123");
Convert to long: long num = [Link]("123");
Convert to double: double num= [Link]("123.45");
Convert to float: float num= [Link]("123.45");
Convert to boolean: boolean bool = [Link]("true");
Convert int to String: String str = [Link](123);
Convert long to String: String str = [Link](123L);
Convert double to String: String str = [Link](123.45);
Convert float to String: String str = [Link](123.45f);
Convert boolean to String: String str = [Link](true);
Convert to StringBuilder: StringBuilder sb = new StringBuilder(str);
Convert to StringBuffer: StringBuffer sb = new StringBuffer(str);
Intern string: String internedStr = [Link]();
Compare string references: boolean isEqual = str1 == str2;
Compare string content: boolean isEqual = [Link](str2);
Compare string content ignoring case: boolean isEqual = [Link](str2);
Check if string is palindrome: boolean isPalindrome = [Link](new
StringBuilder(str).reverse().toString());
Get Unicode code point at index: int codePoint = [Link](0);
Get Unicode code point before index: int code Point = [Link](1);
Count Unicode code points: int count = [Link](0, [Link]());
Get index by Unicode code point: int index = [Link] (0, 1);
Convert to character stream: IntStream charStream = [Link]();
Convert to code point stream: IntStream codePointStream = [Link]();
Check if string contains only digits: boolean isDigits = [Link]("\\d+");
Check if string contains only letters: boolean isLetters = [Link](" [a-zA-Z]+");
Check if string contains only letters and digits: boolean isAlphanumeric = [Link]("[a-zA-
Z0-9]+");
Mukund Bane