Java Arrays & StringBuilder Cheat Sheet

Essential methods for Array, StringBuilder, and Character Array manipulation

Java Array Methods (java.util.Arrays Class)

asList(T... a)
Arguments: Varargs

Returns a fixed-size list backed by the specified array.

import java.util.Arrays;
import java.util.List;
String[] arr = {"apple", "banana"};
List<String> list = Arrays.asList(arr);
System.out.println(list); 
// Output: [apple, banana]
binarySearch(array, key)
Arguments: 2

Searches for a specified element using the binary search algorithm (requires sorted array).

import java.util.Arrays;
int[] arr = {10, 20, 30, 40, 50};
int index = Arrays.binarySearch(arr, 30);
System.out.println(index); 
// Output: 2
compare(array1, array2)
Arguments: 2

Lexicographically compares two arrays.

import java.util.Arrays;
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 4};
int result = Arrays.compare(arr1, arr2);
System.out.println(result); 
// Output: -1 (arr1 is "less than" arr2)
copyOf(original, newLength)
Arguments: 2

Copies the specified array, truncating or padding with default values as necessary.

import java.util.Arrays;
int[] original = {1, 2, 3};
int[] copy = Arrays.copyOf(original, 5);
System.out.println(Arrays.toString(copy)); 
// Output: [1, 2, 3, 0, 0]
copyOfRange(original, from, to)
Arguments: 3

Copies a range of the specified array into a new array.

import java.util.Arrays;
int[] original = {1, 2, 3, 4, 5};
int[] rangeCopy = Arrays.copyOfRange(original, 1, 4); // indices 1, 2, 3
System.out.println(Arrays.toString(rangeCopy)); 
// Output: [2, 3, 4]
deepEquals(a1, a2)
Arguments: 2

Checks if two multi-dimensional arrays are deeply equal.

import java.util.Arrays;
int[][] arr1 = {{1, 2}, {3, 4}};
int[][] arr2 = {{1, 2}, {3, 4}};
System.out.println(Arrays.deepEquals(arr1, arr2)); 
// Output: true
deepHashCode(Object[] a)
Arguments: 1

Returns a deep hash code for the array (for multi-dimensional arrays).

import java.util.Arrays;
Object[][] arr = {{1, 2}, {"a", "b"}};
System.out.println(Arrays.deepHashCode(arr)); 
// Output: (an integer hash code)
deepToString(Object[] a)
Arguments: 1

Returns a deep string representation of the array (for multi-dimensional arrays).

import java.util.Arrays;
int[][] arr = {{1, 2}, {3, 4}};
System.out.println(Arrays.deepToString(arr)); 
// Output: [[1, 2], [3, 4]]
equals(array1, array2)
Arguments: 2

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

import java.util.Arrays;
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
System.out.println(Arrays.equals(arr1, arr2)); 
// Output: true
fill(array, value)
Arguments: 2

Assigns the specified value to each element of the array.

import java.util.Arrays;
int[] arr = new int[5];
Arrays.fill(arr, 7);
System.out.println(Arrays.toString(arr)); 
// Output: [7, 7, 7, 7, 7]
hashCode(array)
Arguments: 1

Returns a hash code based on the contents of the array.

import java.util.Arrays;
int[] arr = {1, 2, 3};
System.out.println(Arrays.hashCode(arr)); 
// Output: (an integer hash code)
mismatch(array1, array2)
Arguments: 2

Finds and returns the index of the first mismatch between two arrays.

import java.util.Arrays;
int[] arr1 = {1, 2, 3, 4};
int[] arr2 = {1, 2, 5, 4};
System.out.println(Arrays.mismatch(arr1, arr2)); 
// Output: 2
parallelPrefix(array, operator)
Arguments: 2

Applies a binary operator to each element in the array in parallel (e.g., cumulative sum).

import java.util.Arrays;
int[] arr = {1, 2, 3, 4};
Arrays.parallelPrefix(arr, (a, b) -> a + b);
System.out.println(Arrays.toString(arr)); 
// Output: [1, 3, 6, 10]
parallelSetAll(array, generator)
Arguments: 2

Sets all elements in parallel using a generated function.

import java.util.Arrays;
int[] arr = new int[5];
Arrays.parallelSetAll(arr, i -> i * 2);
System.out.println(Arrays.toString(arr)); 
// Output: [0, 2, 4, 6, 8]
parallelSort(array)
Arguments: 1

Sorts the specified array in parallel (uses multiple threads for large arrays).

import java.util.Arrays;
int[] arr = {5, 1, 4, 2, 8};
Arrays.parallelSort(arr);
System.out.println(Arrays.toString(arr)); 
// Output: [1, 2, 4, 5, 8]
setAll(array, generator)
Arguments: 2

Sets each element using a generated function.

import java.util.Arrays;
int[] arr = new int[3];
Arrays.setAll(arr, i -> i + 10);
System.out.println(Arrays.toString(arr)); 
// Output: [10, 11, 12]
sort(array)
Arguments: 1

Sorts the specified array into ascending order.

import java.util.Arrays;
int[] arr = {3, 1, 2};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); 
// Output: [1, 2, 3]
spliterator(array)
Arguments: 1

Returns a spliterator over the elements in the array (Java 8+).

import java.util.Arrays;
import java.util.Spliterator;
int[] arr = {1, 2, 3};
Spliterator.OfInt sp = Arrays.spliterator(arr);
sp.forEachRemaining(System.out::println);
// Output:
// 1
// 2
// 3
stream(array)
Arguments: 1

Returns a sequential Stream with the specified array as its source (Java 8+).

import java.util.Arrays;
int[] arr = {1, 2, 3};
int sum = Arrays.stream(arr).sum();
System.out.println(sum); 
// Output: 6
toString(array)
Arguments: 1

Returns a string representation of the array.

import java.util.Arrays;
int[] arr = {1, 2, 3};
System.out.println(Arrays.toString(arr)); 
// Output: [1, 2, 3]

Note: The length property is used to get the size of an array in Java, but it is a field — not a method.

Java StringBuilder Methods

append(value)
Arguments: Various

Appends the specified value (string, char, int, etc.) to the builder.

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
System.out.println(sb); 
// Output: Hello World
insert(int offset, value)
Arguments: 2

Inserts a value at the specified offset position.

StringBuilder sb = new StringBuilder("Java");
sb.insert(4, " is fun");
System.out.println(sb); 
// Output: Java is fun
replace(int start, int end, String str)
Arguments: 3

Replaces the characters between start (inclusive) and end (exclusive) positions with the provided string.

StringBuilder sb = new StringBuilder("Hello World");
sb.replace(6, 11, "Java");
System.out.println(sb); 
// Output: Hello Java
delete(int start, int end)
Arguments: 2

Removes characters between the given start (inclusive) and end (exclusive) indexes.

StringBuilder sb = new StringBuilder("abcdef");
sb.delete(1, 4); // deletes 'bcd'
System.out.println(sb); 
// Output: af
deleteCharAt(int index)
Arguments: 1

Removes the character at the specified index.

StringBuilder sb = new StringBuilder("Java");
sb.deleteCharAt(1); // deletes 'a'
System.out.println(sb); 
// Output: Jva
reverse()
Arguments: 0

Reverses the sequence of characters.

StringBuilder sb = new StringBuilder("hello");
sb.reverse();
System.out.println(sb); 
// Output: olleh
capacity()
Arguments: 0

Returns the current capacity of the StringBuilder.

StringBuilder sb = new StringBuilder("abc");
System.out.println(sb.capacity()); 
// Output: 19 (initial capacity 16 + "abc".length())
ensureCapacity(int minimumCapacity)
Arguments: 1

Increases the capacity, if needed, to ensure it can hold a minimum number of characters.

StringBuilder sb = new StringBuilder("short");
System.out.println("Initial capacity: " + sb.capacity());
sb.ensureCapacity(50);
System.out.println("New capacity: " + sb.capacity()); 
// Output:
// Initial capacity: 21
// New capacity: 50 (or more)
charAt(int index)
Arguments: 1

Returns the character at the specified index.

StringBuilder sb = new StringBuilder("World");
char c = sb.charAt(1);
System.out.println(c); 
// Output: o
setCharAt(int index, char ch)
Arguments: 2

Sets the character at the specified index.

StringBuilder sb = new StringBuilder("apple");
sb.setCharAt(0, 'A');
System.out.println(sb); 
// Output: Apple
length()
Arguments: 0

Returns the length of the character sequence.

StringBuilder sb = new StringBuilder("test");
System.out.println(sb.length()); 
// Output: 4
setLength(int newLength)
Arguments: 1

Sets the new length of the builder. If newLength is less than current length, characters are truncated. If greater, null characters are appended.

StringBuilder sb = new StringBuilder("abcdef");
sb.setLength(3);
System.out.println(sb); 
// Output: abc
substring(int start)
Arguments: 1

Returns a new String that is a substring starting from the specified index to the end.

StringBuilder sb = new StringBuilder("Programming");
String sub = sb.substring(4);
System.out.println(sub); 
// Output: ramming
substring(int start, int end)
Arguments: 2

Returns a new String that is a substring from start (inclusive) to end (exclusive).

StringBuilder sb = new StringBuilder("Hello Java");
String sub = sb.substring(0, 5);
System.out.println(sub); 
// Output: Hello
toString()
Arguments: 0

Converts the builder object to an immutable String.

StringBuilder sb = new StringBuilder("Final String");
String s = sb.toString();
System.out.println(s); 
// Output: Final String
trimToSize()
Arguments: 0

Trims the capacity to the current length. Reduces memory usage if capacity is much larger than actual content.

StringBuilder sb = new StringBuilder(100); // Initial capacity 100
sb.append("small");
System.out.println("Before trim: " + sb.capacity());
sb.trimToSize();
System.out.println("After trim: " + sb.capacity()); 
// Output:
// Before trim: 100
// After trim: 5
getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
Arguments: 4

Copies characters from this sequence into the destination character array.

import java.util.Arrays;
StringBuilder sb = new StringBuilder("example");
char[] dest = new char[10];
sb.getChars(0, 3, dest, 0); // Copies 'exa'
System.out.println(Arrays.toString(dest)); 
// Output: [e, x, a, , , , , , , ]
indexOf(String str)
Arguments: 1

Returns the index of the first occurrence of the specified substring.

StringBuilder sb = new StringBuilder("test string");
System.out.println(sb.indexOf("str")); 
// Output: 5
lastIndexOf(String str)
Arguments: 1

Returns the last occurrence of the specified substring.

StringBuilder sb = new StringBuilder("abcabc");
System.out.println(sb.lastIndexOf("abc")); 
// Output: 3
offsetByCodePoints(int index, int codePointOffset)
Arguments: 2

Returns the index within this sequence that is offset by `codePointOffset` code points starting from `index`.

StringBuilder sb = new StringBuilder("Hello\uD83D\uDE00World");
int newIndex = sb.offsetByCodePoints(0, 6);
System.out.println(newIndex); 
// Output: 7
codePointAt(int index)
Arguments: 1

Returns the Unicode code point at the specified index.

StringBuilder sb = new StringBuilder("Test\uD83D\uDC4D"); // Thumbs up emoji
System.out.println(sb.codePointAt(4)); 
// Output: 128077
codePointBefore(int index)
Arguments: 1

Returns the Unicode code point before the specified index.

StringBuilder sb = new StringBuilder("Test\uD83D\uDC4D");
System.out.println(sb.codePointBefore(6)); 
// Output: 128077
codePointCount(int beginIndex, int endIndex)
Arguments: 2

Returns the number of Unicode code points between two indices.

StringBuilder sb = new StringBuilder("A\uD83D\uDE00B");
System.out.println(sb.codePointCount(0, sb.length())); 
// Output: 3 (A, emoji, B)
subSequence(int start, int end)
Arguments: 2

Returns a new character sequence from start (inclusive) to end (exclusive).

StringBuilder sb = new StringBuilder("abcdef");
CharSequence cs = sb.subSequence(1, 4);
System.out.println(cs); 
// Output: bcd

Note: StringBuilder performs better than String for many string modifications due to its mutability.

Java Character Array Methods (char[])

Common Operations:

  • Declaration: char[] letters;
  • Initialization: char[] vowels = {'a', 'e', 'i', 'o', 'u'};
  • Access: letters[i]
  • Iteration (for loop): for (int i = 0; i < arr.length; i++) { ... }
  • Iteration (enhanced for loop): for (char c : arr) { ... }
  • Modification: arr[2] = 'z';
  • Comparison: Arrays.equals(arr1, arr2);
  • Sorting: Arrays.sort(arr);
  • Printing (as String): System.out.println(Arrays.toString(arr));
  • Conversion from String: char[] array = str.toCharArray();
  • Conversion to String: String s = new String(arr);

Utility Methods from java.util.Arrays:

equals(char[] a, char[] a2)
Arguments: 2

Checks if two character arrays are equal.

import java.util.Arrays;
char[] arr1 = {'a', 'b'};
char[] arr2 = {'a', 'b'};
System.out.println(Arrays.equals(arr1, arr2)); 
// Output: true
copyOf(char[] original, int newLength)
Arguments: 2

Copies the specified character array, truncating or padding as necessary.

import java.util.Arrays;
char[] original = {'x', 'y'};
char[] copy = Arrays.copyOf(original, 4);
System.out.println(Arrays.toString(copy)); 
// Output: [x, y, , ] (empty chars)
copyOfRange(char[] original, int from, int to)
Arguments: 3

Copies a range of the specified character array into a new array.

import java.util.Arrays;
char[] original = {'a', 'b', 'c', 'd'};
char[] rangeCopy = Arrays.copyOfRange(original, 1, 3);
System.out.println(Arrays.toString(rangeCopy)); 
// Output: [b, c]
fill(char[] a, char val)
Arguments: 2

Fills the character array with the specified value.

import java.util.Arrays;
char[] arr = new char[3];
Arrays.fill(arr, 'Z');
System.out.println(Arrays.toString(arr)); 
// Output: [Z, Z, Z]
sort(char[] a)
Arguments: 1

Sorts the character array in ascending order.

import java.util.Arrays;
char[] arr = {'c', 'a', 'b'};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); 
// Output: [a, b, c]
toString(char[] a)
Arguments: 1

Returns a string representation of the character array.

import java.util.Arrays;
char[] arr = {'J', 'A', 'V', 'A'};
System.out.println(Arrays.toString(arr)); 
// Output: [J, A, V, A]
binarySearch(char[] a, char key)
Arguments: 2

Searches the array for a key, returns the index or negative insertion point (requires sorted array).

import java.util.Arrays;
char[] arr = {'a', 'b', 'c', 'd'};
int index = Arrays.binarySearch(arr, 'c');
System.out.println(index); 
// Output: 2

Tip: Character arrays are often used for manual string manipulation, conversion, or when working with sensitive data (since char arrays can be cleared from memory).