Java arrays and collections are fundamental data structures used to store and manipulate groups of data in Java programs. Arrays provide a fixed-size container with fast indexed access, while collections offer flexible, resizable data structures with powerful utility methods.
Quick Reference: Java Arrays and Collections Cheat Sheet
The following quick reference summarizes common operations when working with arrays, lists, sets, and maps in Java.
| Task | Example |
|---|---|
| Declare array | int[] arr = new int[5]; |
| Initialize array | int[] arr = {1,2,3,4,5}; |
| Access array element | int x = arr[0]; |
| Modify array element | arr[1] = 10; |
| Get array length | int len = arr.length; |
| Print array | System.out.println(Arrays.toString(arr)); |
| Print multidimensional array | System.out.println(Arrays.deepToString(arr)); |
| Iterate array with loop | for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); } |
| Iterate array with for-each | for(int n : arr){ System.out.println(n); } |
| Sort array | Arrays.sort(arr); |
| Search element in array | Arrays.binarySearch(arr,5); |
| Copy array | int[] copy = Arrays.copyOf(arr, arr.length); |
| Convert array to list | List<Integer> list = Arrays.asList(1,2,3); |
| Create ArrayList | List<String> list = new ArrayList<>(); |
| Initialize list with values | List<Integer> list = List.of(1,2,3); |
| Add element to list | list.add("value"); |
| Insert element in list | list.add(1,"value"); |
| Access list element | String v = list.get(0); |
| Update list element | list.set(0,"new"); |
| Get list size | int s = list.size(); |
| Remove element from list | list.remove("value"); |
| Remove element by index | list.remove(0); |
| Clear list | list.clear(); |
| Check element in list | list.contains("value"); |
| Iterate list | for(String s : list){ System.out.println(s); } |
| Convert list to array | String[] arr = list.toArray(new String[0]); |
| Sort list | Collections.sort(list); |
| Reverse list | Collections.reverse(list); |
| Shuffle list | Collections.shuffle(list); |
| Create HashSet | Set<String> set = new HashSet<>(); |
| Add element to set | set.add("value"); |
| Check element in set | set.contains("value"); |
| Remove element from set | set.remove("value"); |
| Get set size | set.size(); |
| Iterate set | for(String s : set){ System.out.println(s); } |
| Create HashMap | Map<String,Integer> map = new HashMap<>(); |
| Add key value pair | map.put("a",1); |
| Get value by key | map.get("a"); |
| Check key exists | map.containsKey("a"); |
| Remove key from map | map.remove("a"); |
| Get map size | map.size(); |
| Iterate map keys | for(String k : map.keySet()){ System.out.println(k); } |
| Iterate map entries | for(Map.Entry<String,Integer> e : map.entrySet()){ System.out.println(e); } |
| Clear map | map.clear(); |
| Get all map keys | map.keySet(); |
| Get all map values | map.values(); |
| Stream over collection | list.stream().forEach(System.out::println); |
| Filter collection | list.stream().filter(x -> x>5).toList(); |
| Convert list to set | Set<Integer> s = new HashSet<>(list); |
| Convert set to list | List<Integer> l = new ArrayList<>(set); |
Example: Printing Arrays in Java
Print array using Arrays.toString()
The easiest way to print a one-dimensional array is by using the Arrays.toString() method. This method converts the array into a readable string representation.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(numbers));
}
}Output
[1, 2, 3, 4, 5]Print array using for loop
A traditional for loop allows you to iterate through the array using its index. This gives you more control over formatting and processing.
public class Main {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40};
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
}
}Print array using for-each loop
Java also supports the enhanced for loop (for-each loop) which allows direct iteration over array elements.
public class Main {
public static void main(String[] args) {
int[] numbers = {5, 10, 15, 20};
for (int num : numbers) {
System.out.println(num);
}
}
}Print multi-dimensional arrays using Arrays.deepToString()
For multi-dimensional arrays, Arrays.toString() will not produce readable output. Instead, Java provides Arrays.deepToString().
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[][] matrix = {
{1, 2},
{3, 4}
};
System.out.println(Arrays.deepToString(matrix));
}
}Output
[[1, 2], [3, 4]]Print arrays using Java Streams
Java 8 introduced streams which can also be used to print arrays efficiently.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4};
Arrays.stream(numbers).forEach(System.out::println);
}
}Example: Initializing Lists and Collections
Initialize a list using ArrayList
The most common way to initialize a list is by creating an ArrayList.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
}
}Initialize a list with predefined values
You can initialize a list with values at the time of creation.
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> fruits = Arrays.asList("Apple", "Banana", "Mango");
System.out.println(fruits);
}
}Initialize immutable lists using List.of()
Java 9 introduced List.of() which creates an immutable list.
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> numbers = List.of(1, 2, 3, 4, 5);
System.out.println(numbers);
}
}Immutable lists cannot be modified after creation.
Initialize collections using Arrays.asList()
Arrays.asList() converts an array into a fixed-size list.
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(10, 20, 30);
System.out.println(numbers);
}
}Convert array to list in Java
You can convert arrays into collections easily.
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
String[] arr = {"A", "B", "C"};
List<String> list = Arrays.asList(arr);
System.out.println(list);
}
}Example: Getting Length or Size of Data Structures
Get length of an array using length property
Arrays have a built-in property called length.
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4};
System.out.println(numbers.length);
}
}Output
4Get size of a list using size() method
Collections use the size() method instead of a property.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
System.out.println(names.size());
}
}Compare array length vs list size
Arrays and collections use different approaches to determine the number of elements.
| Data Structure | Method |
|---|---|
| Array | array.length |
| List | list.size() |
| Set | set.size() |
| Map | map.size() |
Handle empty collections safely
Before accessing collection elements, it is good practice to check if the collection is empty.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
if (list.isEmpty()) {
System.out.println("List is empty");
}
}
}Using isEmpty() helps prevent runtime errors when processing collections.
Example: Adding and Removing Elements in Collections
Add elements to a List
You can add elements to a list using the add() method.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Mango");
System.out.println(fruits);
}
}Insert element at specific index
The add(index, element) method allows inserting elements at a specific position.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Mango");
fruits.add(1, "Banana");
System.out.println(fruits);
}
}Remove elements by value
You can remove elements directly by specifying the value.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Mango");
fruits.remove("Banana");
System.out.println(fruits);
}
}Remove elements by index
You can also remove elements using their index position.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Mango");
fruits.remove(0);
System.out.println(fruits);
}
}Clear entire list using clear()
To remove all elements from a list, use the clear() method.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.clear();
System.out.println(fruits);
}
}Example: Searching Elements in Collections
Check if list contains element
The contains() method checks whether a specific element exists in a list.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
if (list.contains("Java")) {
System.out.println("Element found");
}
}
}Find index of element in list
You can determine the position of an element using the indexOf() method.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Mango");
int index = list.indexOf("Banana");
System.out.println(index);
}
}Check if set contains element
Sets also support the contains() method for checking membership.
import java.util.HashSet;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("Linux");
set.add("Java");
System.out.println(set.contains("Java"));
}
}Retrieve value from map using key
Maps store key-value pairs. You can retrieve values using the get() method.
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("John", 25);
map.put("Alice", 30);
System.out.println(map.get("Alice"));
}
}Example: Iterating Collections in Java
Iterate list using for loop
You can iterate through a list using an index-based loop.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
for (int i = 0; i < names.size(); i++) {
System.out.println(names.get(i));
}
}
}Iterate collection using for-each loop
The enhanced for loop is commonly used for iterating collections.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
for (String name : names) {
System.out.println(name);
}
}
}Iterate collections using iterator()
The Iterator interface provides another way to traverse collections.
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}Iterate collections using Java Streams
Streams introduced in Java 8 simplify iteration and data processing.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.stream().forEach(System.out::println);
}
}Example: Converting Between Arrays and Collections
Convert array to ArrayList
You can convert arrays into lists using Arrays.asList().
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
String[] arr = {"A", "B", "C"};
List<String> list = Arrays.asList(arr);
System.out.println(list);
}
}Convert list to array
Collections can be converted back to arrays using toArray().
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
String[] arr = list.toArray(new String[0]);
System.out.println(arr.length);
}
}Convert set to list
Sets can be converted into lists using the ArrayList constructor.
import java.util.HashSet;
import java.util.ArrayList;
import java.util.Set;
import java.util.List;
public class Main {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("Java");
set.add("Linux");
List<String> list = new ArrayList<>(set);
System.out.println(list);
}
}Convert map keys to list
You can convert map keys to a list using keySet().
import java.util.HashMap;
import java.util.Map;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
List<String> keys = new ArrayList<>(map.keySet());
System.out.println(keys);
}
}Example: Sorting Arrays and Collections
Sort arrays using Arrays.sort()
Java provides the Arrays.sort() method for sorting arrays.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] numbers = {5, 2, 8, 1};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));
}
}Sort lists using Collections.sort()
Lists can be sorted using the Collections.sort() method.
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(5);
numbers.add(1);
numbers.add(3);
Collections.sort(numbers);
System.out.println(numbers);
}
}Sort collections using Comparator
A Comparator allows custom sorting logic.
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Charlie");
names.add("Alice");
names.add("Bob");
Collections.sort(names, Comparator.naturalOrder());
System.out.println(names);
}
}Sort collections using lambda expressions
Java 8 introduced lambda expressions for simpler sorting.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(3);
numbers.add(7);
numbers.sort((a, b) -> a - b);
System.out.println(numbers);
}
}Frequently Asked Questions
1. What is the difference between arrays and collections in Java?
Arrays in Java are fixed-size data structures used to store elements of the same type, while collections are dynamic containers provided by the Java Collections Framework that can grow or shrink as elements are added or removed.2. How do you print an array in Java?
You can print an array using the Arrays.toString() method from the java.util.Arrays class or by iterating through the array using a loop.3. How do you initialize a list in Java?
You can initialize a list using classes like ArrayList or LinkedList. For example: List4. How do you find the length of a list in Java?
The length of a list in Java can be obtained using the size() method. For example: list.size() returns the number of elements in the list.5. What are the most commonly used collections in Java?
The most commonly used Java collections include ArrayList for dynamic arrays, LinkedList for linked data structures, HashSet for unique elements, and HashMap for storing key-value pairs.Summary
Arrays and collections are fundamental data structures used in Java to store and manage groups of elements. Arrays provide a fixed-size structure with fast index-based access, making them efficient when the number of elements is known in advance. Collections, on the other hand, are part of the Java Collections Framework and provide dynamic, flexible containers that can grow or shrink as elements are added or removed.
In this guide, we explored multiple practical scenarios including printing arrays, initializing collections, determining array length and list size, adding and removing elements, searching values, iterating through collections, converting between arrays and collections, and sorting data structures. Java provides powerful utility classes such as Arrays, Collections, ArrayList, HashSet, and HashMap to simplify these operations.
Understanding when to use arrays versus collections is important for writing efficient and maintainable Java programs. Arrays are ideal for fixed-size data and performance-sensitive applications, while collections provide flexibility, convenience methods, and advanced data manipulation capabilities. By mastering these structures, developers can effectively manage and process data in modern Java applications.
