Array Cheat Sheet: A Quick Reference for Java Developers

Arrays:

1. Fixed Size:

• Arrays have a fixed size once they are created, and their size cannot be changed.

2. Homogeneous Elements:

• Elements in an array must be of the same data type (homogeneous).

3. Direct Access:

• Elements in an array can be directly accessed using their index (zero-based).

4. Syntax:

• Declaration: int[] myArray;
• Initialization: myArray = new int[5];
• Combined: int[] myArray = new int[5];

5. Length Property:

• Arrays have a length property that provides the number of elements in the array.

6. Performance:

• Generally provides better performance in terms of access time compared to lists.

7. Primitive Types:

• Arrays can store both primitive data types and objects.

Lists (e.g., ArrayList):

1. Dynamic Size:

• Lists can dynamically grow or shrink in size as needed.

2. Heterogeneous Elements:

• Elements in a list can be of different data types (heterogeneous).

3. Access via Iterator or Index:

• Elements in a list can be accessed using iterators or by their index.

4. Syntax (ArrayList):

• Declaration: List<Integer> myList;
• Initialization: myList = new ArrayList<>();
• Combined: List<Integer> myList = new ArrayList<>();

5. Methods:

• Lists provide various methods for adding, removing, and accessing elements (add, remove, get, etc.).

6. Performance:

• Lists may have slightly lower performance for direct element access compared to arrays but offer more flexibility.

7. Autoboxing:

• Lists store objects, so primitive types need to be wrapped (autoboxed) into their corresponding wrapper classes.

8. Implementation Classes:

• Java provides several implementations of the List interface, such as ArrayList, LinkedList, and Vector.

9. Thread Safety:

• Most list implementations are not inherently thread-safe. For concurrent access, consider using Collections.synchronizedList or other concurrent collections.

10. Recommended Use:

• Lists are preferred when you need a dynamic collection with operations like insertion and deletion, and the size may change over time.
• Arrays are suitable when the size is fixed, and direct access to elements is crucial for performance.