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= myArray.length;
 Copy array: int[] newArray = Arrays.copyOf (myArray, myArray.length);
 Copy range: int[] partialArray = Arrays.copyOfRange (myArray, 1, 4);
 Fill array: Arrays.fill (myArray, 0);
 Sort array: Arrays.sort(myArray);
 Compare arrays: boolean isEqual = Arrays.equals(array1, array2);
 Binary search: int index = Arrays.binarySearch (myArray, 3);
 Convert to List: List<Integer> list = Arrays.asList(myArray);
 Print array: System.out.println(Arrays.toString(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: list.add("element");
 Add element at index: list.add(0, "element");
 Add all elements from another collection: list.addAll(anotherList);
 Get element at index: String element = list.get(0);
 Set element at index: list.set(0, "newElement");
 Remove element: list.remove("element");
 Remove element at index: list.remove(0);
 Remove all elements from another collection: list.removeAll(anotherList);
 Retain all elements from another collection: list.retainAll (anotherList);
 Clear all elements: list.clear();
 Check if list contains element: boolean contains = list.contains("element");
 Get index of element: int index = list.indexOf("element");
 Get last index of element: int lastIndex = list.lastIndexOf("element");
 Check if list is empty: boolean isEmpty = list.isEmpty();
 Get size of list: int size = list.size();
 Convert list to array: Object[] array = list.toArray();
 Convert list to typed array: String[] array = list.toArray(new String[0]);
 Get sublist: List<String> subList = list.subList(1, 4);
 Sort list: Collections.sort(list);
 Reverse list: Collections.reverse (list);

Mukund Bane
 2

 Shuffle list: Collections.shuffle (list);

 Find min element: String min = Collections.min(list);
 Find max element: String max = Collections.max(list);
 Fill list with element: Collections.fill(list, "element");
 Copy list: ArrayList<String> copy = new ArrayList<>(list);
 Convert to synchronized list: List<String> syncList = Collections.synchronizedList (list);
 Create unmodifiable view of list: List<String> unmodifiableList=
Collections.unmodifiableList(list);
 Iterate over list: for (String element : list) { }
 Iterate with index: for (int i = 0; i < list.size(); i++) { }
 Iterate using iterator: Iterator<String> iter = list.iterator(); while (iter.hasNext()) { }
 Iterate using listIterator: ListIterator<String> listIter = list.listIterator();
 Remove if condition is met: list.removeIf (element -> element.isEmpty());
 Replace all elements: list. replaceAll(String:: toUpperCase);
 For each operation: list.forEach (System.out::println);
 Convert to stream: Stream<String> stream = list.stream();
 Join elements to string: String joined = String.join(", ", list);
 Check if any element satisfies condition boolean any = list.stream().anyMatch
(String::isEmpty);
 Check if all elements satisfy condition: boolean all = list.stream().allMatch(s -> s.length() > 2);
 Find first element satisfying condition: Optional <String> first list.stream().filter(s ->
s.startsWith("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: map.put("key", 1);
 Put if absent: map.putIfAbsent ("key", 1);
 Get value by key: Integer value = map.get("key");
 Get value by key with default: Integer value = map.getOrDefault("key", 0);
 Remove key-value pair: map.remove("key");
 Remove key-value pair if value matches: map.remove("key", 1);
 Clear all entries: map.clear();
 Check if key exists: boolean containsKey = map.containsKey("key");
 Check if value exists: boolean containsValue = map.containsValue(1);
 Get set of keys: Set<String> keys = map.keySet();
 Get collection of values: Collection<Integer> values = map.values();
 Get set of entries: Set<Map.Entry<String, Integer>> entries = map.entrySet();
 Check if map is empty: boolean isEmpty = map.isEmpty();
 Get size of map: int size = map.size();
 Replace value for key: map.replace("key", 2);
 Replace value if old value matches: map.replace("key", 1, 2);
 Merge values: map.merge("key", 1, Integer::sum);

Mukund Bane
 3

 Compute value if absent: map.computeIfAbsent ("key", k-> k.length());

 Compute value if present: map.computeIfPresent ("key", (k, v) -> v + 1);
 Compute value: map.compute("key", (k, v) -> (v == null) ? 1 : v + 1);
 For each operation: map.forEach((k, v) -> System.out.println(k + " ": +v);
 Convert to synchronized map: Map<String, Integer> syncMap =
Collections.synchronizedMap(map);
 Create unmodifiable view of map: Map<String, Integer> unmodifiableMap =
Collections.unmodifiableMap(map);
 Iterate over entries: for (Map.Entry<String, Integer> entry : map.entrySet()) { }
 Iterate over keys: for (String key map.keySet()) { }
 Iterate over values: for (Integer value: map.values()) { }
 Convert to stream: Stream<Map. Entry<String, Integer>> stream = map.entrySet().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: set.add("element");
 Remove element: set.remove("element");
 Clear all elements: set.clear();
 Check if element exists: boolean contains = set.contains("element");
 Check if set is empty: boolean isEmpty = set.isEmpty();
 Get size of set: int size = set.size();
 Add all elements from another collection: set.addAll(anotherCollection);
 Remove all elements from another collection: set.removeAll(anotherCollection);
 Retain all elements from another collection: set.retainAll (anotherCollection);
 Convert set to array: Object[] array = set.toArray();
 Convert set to typed array: String[] array = set.toArray(new String[0]);
 Iterate over set: for (String element : set) { }
 Iterate using iterator: Iterator<String> iter = set.iterator(); while (iter.hasNext()) { }
 Remove if condition is met: set.removeIf (element -> element.isEmpty());
 For each operation: set.forEach(System.out::println);
 Convert to stream: Stream<String> stream = set.stream();
 Check if any element satisfies condition: boolean any = set.stream().anyMatch
(String::isEmpty);
 Check if all elements satisfy condition: boolean all = set.stream().allMatch(s -> s.length() > 2);
 Find first element satisfying condition: Optional<String> first = set.stream().filter(s ->
s.startsWith("A")).findFirst();
 Convert to synchronized set: Set<String> syncSet = Collections.synchronizedSet (set);
 Create unmodifiable view of set: Set<String> unmodifiableSet =
Collections.unmodifiableSet(set);
 Convert to TreeSet (sorted): TreeSet<String> treeSet = new TreeSet<>(set);
 Check if set is subset of another set: boolean isSubset = set.containsAll (anotherSet);

Mukund Bane
 4

 Perform union of two sets: set.addAll(anotherSet);

 Perform intersection of two sets: set. retainAll (anotherSet);
 Perform difference of two sets: set.removeAll(anotherSet);

5. LinkedList

 Create a LinkedList: LinkedList<String> list = new LinkedList<>();

 Create LinkedList from another collection: LinkedList<String> list =
LinkedList<>(anotherCollection);
 Add element: list.add("element");
 Add element at index: list.add(0, "element");
 Add element at the beginning: list.addFirst("element");
 Add element at the end: list.addLast ("element");
 Remove first occurrence of element: list.remove("element");
 Remove element at index: list.remove(0);
 Remove first element: list.removeFirst();
 Remove last element: list.removeLast();
 Get first element: String first = list.getFirst();
 Get last element: String last = list.getLast();
 Set element at index: list.set(0, "newElement");
 Check if list contains element: boolean contains = list.contains("element");
 Get index of first occurrence: int index = list.indexOf("element");
 Get index of last occurrence: int lastIndex = list.lastIndexOf("element");
 Get element at index: String element = list.get(0);
 Clear all elements: list.clear();
 Check if list is empty: boolean isEmpty =list.isEmpty();
 Get size of list: int size = list.size();
 Convert list to array: Object[] array = list.toArray();
 Convert list to typed array: String[] array = list.toArray (new String[0]);
 Get sublist: List<String> subList = list.subList(1, 4);
 Add all elements from another collection: list.addAll (anotherCollection);
 Add all elements from another collection at index: list.addAll (1, anotherCollection);
 Remove all elements from another collection: list.removeAll (anotherCollection);
 Retain all elements from another collection: list.retainAll (anotherCollection);
 Iterate over list: for (String element : list) { }
 Iterate using iterator: Iterator<String> iter = list.iterator(); while (iter.hasNext()) { }
 Iterate using list iterator: ListIterator<String> listIter = list.listIterator();
 Iterate in reverse: Iterator<String> descendingIter = list.descendingIterator();
 Remove if condition is met: list.remove If (element -> element.isEmpty());
 Replace all elements: list. replaceAll(String:: toUpperCase);
 For each operation: list.forEach (System.out::println);
 Convert to stream: Stream<String> stream =list.stream();
 Peek at first element: String first = list. peek();
 Peek at last element: String last = list.peekLast();
 Poll first element: String polled = list.poll();

Mukund Bane
 5

 Poll last element: String polled = list.pollLast();

 Push element onto stack: list.push("element");
 Pop element from stack: String popped =list.pop();
 Sort list: Collections.sort(list);
 Reverse list: Collections.reverse (list);
 Shuffle list: Collections. shuffle (list);
 Find min element: String min = Collections.min(list);
 Find max element: String max = Collections.max(list);

6. Stack

 Create Stack: Stack<String> stack = new Stack<>();

 Push element: stack.push("Hello");
 Pop element: String popped = stack.pop();
 Peek top element: String top = stack.peek();
 Check if empty: boolean isEmpty =stack.isEmpty();
 Get size: int size = stack.size();
 Search element: int position = stack.search("Hello");
 Clear stack: stack.clear();

7. Queue (Using LinkedList)

 Create Queue: Queue<String> queue = new LinkedList<>();

 Add element: queue.add("Hello");
 Offer element: queue.offer ("World");
 Remove element: String removed = queue.remove();
 Poll element: String polled = queue.poll();
 Peek front element: String front = queue.peek();
 Check if empty: boolean isEmpty queue.isEmpty();
 Get size: int size = queue.size();
 Clear queue: queue.clear();
 Contains element: boolean contains = queue.contains("Hello");

8. PriorityQueue

 Create PriorityQueue: PriorityQueue<Integer> pq = new PriorityQueue<>();

 Create with comparator: PriorityQueue<String> pq = new
PriorityQueue<>(Comparator.reverseOrder());
 Add element: pq.add(5);
 Offer element: pq.offer (3);
 Remove element: Integer removed = pq.remove();
 Poll element: Integer polled = pq.poll();
 Peek top element: Integer top = pq.peek();

Mukund Bane
 6

 Check if empty: boolean isEmpty = pq.isEmpty();

 Get size: int size = pq.size();
 Clear queue: pq.clear();
 Contains element: boolean contains = pq.contains(5);
 Convert to array: Object[] array = pq.toArray();
 Iterator: Iterator<Integer> it = pq.iterator();

9. TreeMap

 Create TreeMap: TreeMap<String, Integer> map = new TreeMap<>();

 Put key-value pair: map.put("One", 1);
 Get value: Integer value = map.get("One");
 Remove key-value pair: map.remove("One");
 First key: String firstKey = map.firstKey();
 Last key: String lastKey = map.lastKey();
 Lower key: String lowerKey = map.lowerKey("One");
 Higher key: String higherKey = map.higherKey("One");
 Floor key: String floorKey = map. floorKey("One");
 Ceiling key: String ceilingKey= map.ceilingKey("One");
 First entry: Map.Entry<String, Integer> firstEntry = map.firstEntry();
 Last entry: Map.Entry<String, Integer> lastEntry = map.lastEntry();
 Lower entry: Map.Entry<String, Integer> lower Entry = map.lowerEntry("One");
 Higher entry: Map.Entry<String, Integer> higherEntry map.higherEntry("One");
 Floor entry: Map.Entry<String, Integer> floorEntry = map.floorEntry("One");
 Ceiling entry: Map.Entry<String, Integer> ceilingEntry = map.ceilingEntry("One");
 Poll first entry: Map.Entry<String, Integer> firstEntry = map.pollFirstEntry();
 Poll last entry: Map.Entry<String, Integer> lastEntry = map.pollLastEntry();
 Submap: SortedMap<String, Integer> subMap = map.subMap("A", "D");
 Headmap: SortedMap<String, Integer> headMap = map.headMap("D");
 Tailmap: SortedMap<String, Integer> tailMap = map.tailMap("D");
 Descending key set: NavigableSet<String> descKeys= map.descendingKeySet();
 Descending map: NavigableMap<String, Integer> descMap = map.descendingMap();

10. TreeSet

 Create TreeSet: TreeSet<String> set = new TreeSet<>();

 Add element: set.add("Hello");
 Remove element: set.remove("Hello");
 First element: String first = set.first();
 Last element: String last = set.last();
 Lower element: String lower = set. lower ("Hello");

Mukund Bane
 7

 Higher element: String higher=set.higher ("Hello");

 Floor element: String floor = set.floor("Hello");
 Ceiling element: String ceiling= set.ceiling ("Hello");
 Poll first: String first = set.pollFirst();
 Poll last: String last = set.pollLast();
 Subset: SortedSet<String> subSet = set.subSet ("A", "D");
 Headset: SortedSet<String> headSet = set.headSet ("D");
 Tailset: SortedSet<String> tailSet = set.tailSet("D");
 Descending set: NavigableSet<String> descSet = set.descendingSet();
 Iterator: Iterator<String> it= set.iterator();
 Descending iterator: Iterator<String> descIt = set.descendingIterator();

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 = str.length();
 Get character at index: char ch = str.charAt(0);
 Get substring: String sub = str.substring(0, 5);
 Concatenate strings: String concat = str.concat(" How are you?");
 Check if string contains substring: boolean contains = str.contains("World");
 Check if string starts with prefix: boolean startsWith = str.startsWith("Hello");
 Check if string ends with suffix: boolean endsWith = str.endsWith("!");
 Compare strings: int result = str.compareTo("Hello");
 Compare strings ignoring case: int result = str.compareToIgnoreCase("HELLO");
 Convert to lowercase: String lower = str.toLowerCase();
 Convert to uppercase: String upper = str.toUpperCase();
 Trim whitespace: String trimmed = str.trim();
 Replace character: String replaced = str.replace('o', '0');
 Replace sequence: String replaced = str.replace("World", "Java");
 Replace first occurrence: String replaced = str.replaceFirst("1", "L");
 Replace all occurrences: String replaced = str.replaceAll("1", "L");
 Split string: String[] parts = str.split(", ");
 Join strings: String joined= String.join(", ", "Hello", "World");
 Check if string is empty: boolean isEmpty = str.isEmpty();
 Check if string is blank: boolean isBlank = str.isBlank();
 Get index of character: int index = str.indexOf('o');
 Get last index of character: int lastIndex = str.lastIndexOf('o');
 Get index of substring: int index = str.indexOf("World");
 Get last index of substring: int lastIndex = str.lastIndexOf("o");
 Convert to char array: char[] chars = str.toCharArray();
 Get bytes: byte[] bytes = str.getBytes();
 Get bytes with charset: byte[] bytes= str.getBytes(StandardCharsets.UTF_8);

Mukund Bane
 8

 Matches regex: boolean matches = str.matches("Hello.*");

 Format string: String formatted = String.format("Hello, %s!", "World");
 Repeat string: String repeated = "Hello". repeat (3);
 Strip leading spaces: String stripped = str.stripLeading();
 Strip trailing spaces: String stripped = str.stripTrailing();
 Strip all spaces: String stripped = str.strip();
 Convert to int: int num = Integer.parseInt("123");
 Convert to long: long num = Long.parseLong("123");
 Convert to double: double num= Double.parseDouble("123.45");
 Convert to float: float num= Float.parseFloat("123.45");
 Convert to boolean: boolean bool = Boolean.parseBoolean("true");
 Convert int to String: String str = String.valueOf(123);
 Convert long to String: String str = String.valueOf(123L);
 Convert double to String: String str = String.valueOf(123.45);
 Convert float to String: String str = String.valueOf(123.45f);
 Convert boolean to String: String str = String.valueOf(true);
 Convert to StringBuilder: StringBuilder sb = new StringBuilder(str);
 Convert to StringBuffer: StringBuffer sb = new StringBuffer(str);
 Intern string: String internedStr = str.intern();
 Compare string references: boolean isEqual = str1 == str2;
 Compare string content: boolean isEqual = str1.equals(str2);
 Compare string content ignoring case: boolean isEqual = str.equalsIgnoreCase(str2);
 Check if string is palindrome: boolean isPalindrome = str.equals(new
StringBuilder(str).reverse().toString());
 Get Unicode code point at index: int codePoint = str.codePointAt(0);
 Get Unicode code point before index: int code Point = str.codePointBefore(1);
 Count Unicode code points: int count = str.codePointCount(0, str.length());
 Get index by Unicode code point: int index = str.offsetByCodePoints (0, 1);
 Convert to character stream: IntStream charStream = str.chars();
 Convert to code point stream: IntStream codePointStream = str.codePoints();
 Check if string contains only digits: boolean isDigits = str.matches("\\d+");
 Check if string contains only letters: boolean isLetters = str.matches(" [a-zA-Z]+");
 Check if string contains only letters and digits: boolean isAlphanumeric = str.matches("[a-zA-
Z0-9]+");

Mukund Bane