Java Arrays Cheat Sheet

Essential methods from Java 8 to Java 17

Sorting Methods

sort(array)
Arguments: 1

Sorts the entire array into ascending order.

// Sort an entire array
int[] nums = {5, 2, 1};
Arrays.sort(nums);
System.out.println(Arrays.toString(nums)); 
// Output: [1, 2, 5]
sort(array, from, to)
Arguments: 3

Sorts the specified range of the array into ascending order.

// Sort a subrange
int[] nums = {9, 8, 7, 6};
Arrays.sort(nums, 1, 3); // Sort indices 1 to 2
System.out.println(Arrays.toString(nums)); 
// Output: [9, 7, 8, 6]
parallelSort(array)
Arguments: 1

Sorts the array using parallel sort (multi-threading).

// Parallel sort entire array
int[] nums = {3, 1, 2, 6, 4, 5};
Arrays.parallelSort(nums);
System.out.println(Arrays.toString(nums)); 
// Output: [1, 2, 3, 4, 5, 6]
parallelSort(array, from, to)
Arguments: 3

Sorts the specified range of the array using parallel sort.

// Parallel sort subrange
int[] nums = {10, 7, 4, 1, 9, 2};
Arrays.parallelSort(nums, 1, 4); // Sort indices 1 to 3
System.out.println(Arrays.toString(nums)); 
// Output: [10, 1, 4, 7, 9, 2]

Searching Methods

binarySearch(array, key)
Arguments: 2

Searches the specified array for the specified key using binary search.

// Binary search entire array
int[] nums = {1, 3, 5, 7};
int index = Arrays.binarySearch(nums, 5);
System.out.println(index); 
// Output: 2
binarySearch(array, from, to, key)
Arguments: 4

Searches a range of the array for the specified key using binary search.

// Binary search in subrange
int[] nums = {1, 3, 5, 7, 9};
int idx = Arrays.binarySearch(nums, 1, 4, 7);
System.out.println(idx); 
// Output: 3

Comparing Methods

equals(array1, array2)
Arguments: 2

Checks if two arrays are equal (same elements in same order).

// Compare arrays
int[] a = {1, 2}, b = {1, 2};
boolean equal = Arrays.equals(a, b);
System.out.println(equal); 
// Output: true
deepEquals(array1, array2)
Arguments: 2

Deep comparison for multi-dimensional arrays.

// Compare multidimensional arrays
int[][] a = {{1,2}}, b = {{1,2}};
boolean deepEqual = Arrays.deepEquals(a, b);
System.out.println(deepEqual); 
// Output: true
compare(array1, array2)
Arguments: 2

Lexicographic comparison of two arrays.

// Lexicographic comparison
int[] a = {1,2}, b = {1,3};
int result = Arrays.compare(a, b);
System.out.println(result); 
// Output: -1
mismatch(array1, array2)
Arguments: 2

Finds the first index where arrays differ.

// Find first mismatch
int[] a = {1,2,3}, b = {1,2,4};
int mismatch = Arrays.mismatch(a, b);
System.out.println(mismatch); 
// Output: 2

Copying & Filling Methods

copyOf(array, newLength)
Arguments: 2

Copies array to a new array of specified length.

// Copy array with new length
int[] nums = {1, 2, 3};
int[] copy = Arrays.copyOf(nums, 5);
System.out.println(Arrays.toString(copy)); 
// Output: [1, 2, 3, 0, 0]
copyOfRange(array, from, to)
Arguments: 3

Copies a subrange of the array.

// Copy subrange of array
int[] nums = {1,2,3,4,5};
int[] sub = Arrays.copyOfRange(nums, 1, 4);
System.out.println(Arrays.toString(sub)); 
// Output: [2, 3, 4]
fill(array, value)
Arguments: 2

Fills entire array with the specified value.

// Fill entire array
int[] filled = new int[4];
Arrays.fill(filled, 7);
System.out.println(Arrays.toString(filled)); 
// Output: [7, 7, 7, 7]
fill(array, from, to, value)
Arguments: 4

Fills part of the array with the specified value.

// Fill subrange of array
int[] nums = {1,2,3,4};
Arrays.fill(nums, 1, 3, 9);
System.out.println(Arrays.toString(nums)); 
// Output: [1, 9, 9, 4]
setAll(array, generator)
Arguments: 2

Sets values using a generator function.

// Set values with generator
int[] nums = new int[5];
Arrays.setAll(nums, i -> i * i);
System.out.println(Arrays.toString(nums)); 
// Output: [0, 1, 4, 9, 16]
parallelSetAll(array, generator)
Arguments: 2

Parallel version of setAll.

// Parallel set values
int[] nums = new int[5];
Arrays.parallelSetAll(nums, i -> i + 10);
System.out.println(Arrays.toString(nums)); 
// Output: [10, 11, 12, 13, 14]

Conversion Methods

asList(...elements)
Arguments: Varargs

Converts array to a fixed-size list.

// Convert array to list
String[] data = {"a", "b"};
List<String> list = Arrays.asList(data);
System.out.println(list); 
// Output: [a, b]
toString(array)
Arguments: 1

Converts 1D array to a readable string.

// Convert 1D array to string
int[] nums = {1,2,3};
System.out.println(Arrays.toString(nums)); 
// Output: [1, 2, 3]
deepToString(array)
Arguments: 1

Converts multi-dimensional array to string.

// Convert 2D array to string
int[][] matrix = {{1,2},{3,4}};
System.out.println(Arrays.deepToString(matrix)); 
// Output: [[1, 2], [3, 4]]
hashCode(array)
Arguments: 1

Returns hash code for 1D array.

// Get hash code of array
int[] nums = {1,2,3};
System.out.println(Arrays.hashCode(nums)); 
// Output: 30817
deepHashCode(array)
Arguments: 1

Returns hash code for multi-dimensional array.

// Get deep hash code
int[][] grid = {{1,2}};
System.out.println(Arrays.deepHashCode(grid)); 
// Output: 994
stream(array)
Arguments: 1

Creates stream from array elements.

// Create stream from array
int[] nums = {1,2,3};
int sum = Arrays.stream(nums).sum();
System.out.println(sum); 
// Output: 6
spliterator(array)
Arguments: 1

Creates spliterator from array.

// Create spliterator
int[] nums = {1,2,3};
Spliterator.OfInt sp = Arrays.spliterator(nums);
sp.forEachRemaining((int n) -> System.out.print(n + " ")); 
// Output: 1 2 3

Utility Methods

parallelPrefix(array, op)
Arguments: 2

Performs parallel prefix operation on array.

// Parallel prefix (cumulative product)
int[] nums = {1, 2, 3, 4};
Arrays.parallelPrefix(nums, (a, b) -> a * b);
System.out.println(Arrays.toString(nums)); 
// Output: [1, 2, 6, 24]
equals(array, start, end, other, oStart, oEnd)
Arguments: 6

Compares ranges of two arrays.

// Compare array ranges
int[] a = {1,2,3,4}, b = {0,2,3,5};
boolean rangeEqual = Arrays.equals(a, 1, 3, b, 1, 3);
System.out.println(rangeEqual); 
// Output: true
compare(array, start, end, other, oStart, oEnd)
Arguments: 6

Lexicographic comparison of array ranges.

// Lex compare array ranges
int[] a = {1,2,3}, b = {1,2,4};
int comp = Arrays.compare(a, 0, 2, b, 0, 2);
System.out.println(comp); 
// Output: 0 (equal)