Learn Intermediate Java: Generics and Collections

Creating Generic Algorithms

Generics in Java allow you to create algorithms that work with different types while maintaining type safety.

                                
public class Box<T> {
  private T content;
  public void setContent(T content) {
    this.content = content;
  }
  public T getContent() {
    return content;
  }
}

                              

Understanding Generics

Generics enable you to define classes, interfaces, and methods with type parameters. This provides flexibility and type safety.

                                

  List<String> names = new ArrayList<>();  // List of Strings
  Map<Integer, String> map = new HashMap<>();  // Map with Integer keys and String values

                              

Benefits of Generics

Generics improve type safety and reduce runtime errors by ensuring that you use the correct type at compile time.

Using `List` instead of `List` ensures that only integers can be added to the list, preventing type errors.

Using Diamond Operators

The diamond operator (`<>`) allows you to omit the type parameter on the right-hand side when creating instances of generic classes.

                                
List names = new ArrayList<>(); // Type is inferred from the declaration

                              

Defining Lower Bounds with super

The `super` keyword is used to specify a lower bound for a wildcard type parameter, meaning you can use that type or its superclasses.

                                
List<? super Integer> list = new ArrayList<>(); // Can add Integer or its subclasses

                              

Using Wildcards

Wildcards (`?`) are used to represent an unknown type. They help in writing more flexible code.

                                
List<?> list = new ArrayList<String>(); // List of unknown type

                              

Defining Upper Bounds with extends

The `extends` keyword specifies an upper bound for a wildcard or type parameter, meaning you can use that type or its subclasses.

                                
List<? extends Number> list = new ArrayList<Integer>(); // List of Numbers or subclasses

                              

Using Wrapper Classes

Wrapper classes (e.g., `Integer`, `Double`) are used to wrap primitive types and allow them to be used with generics.

                                
List<Integer> numbers = new ArrayList<>(); // Integer wraps the primitive int