Course contentsShow
← Java
Lesson 903 of 2,87021. Generics FundamentalsFree lesson

Adding and Retrieving Elements Without Casting

Using add() and get() methods with type-safe operations, eliminating manual casts.

Adding and Retrieving Elements Without Casting

What you'll learn: How generics eliminate manual type casting when working with ArrayList.

The Old Way: Casting Everything

Before generics, every time you retrieved an element from an ArrayList, you had to manually cast it to the correct type. This was tedious, error-prone, and the compiler couldn't help you catch mistakes.

The Generic Way: Type Safety Built-In

With ArrayList<E>, the type parameter tells both the compiler and runtime exactly what type of objects the list contains. This means:

When adding elements using add():

ArrayList<String> names = new ArrayList<String>();
names.add("Alice");  // Compiler knows only String is allowed
names.add("Bob");
// names.add(42);    // Compile error! Integer not allowed

When retrieving elements using get():

String firstName = names.get(0);  // No cast needed!
String secondName = names.get(1); // Returns String directly

Why This Matters

Without generics, you'd write:

ArrayList rawList = new ArrayList();  // Raw type
rawList.add("Alice");
String name = (String) rawList.get(0);  // Manual cast required

With generics, the type parameter ensures get() returns the exact type you specified. No casting, no risk of ClassCastException at runtime, and the code reads cleanly.

The Mechanics

The add(E element) method accepts your type parameter, and E get(int index) returns that same type. The compiler enforces this contract at compile-time, catching type mismatches before your code ever runs.

Key Takeaway: Generics transform ArrayList from requiring manual casts on every retrieval to providing automatic type safety—the compiler knows the element type, so you never cast again.