Generic wildcards in Java functions: upper and lower bounds

In Java, generic wildcards allow generic types to be represented without specifying specific types. The upper bound wildcard character (<? extends T>) represents a type parameter T or any subclass thereof, allowing subclass data to be accepted in a list. The lower wildcard character (<? super T>) represents T or any of its superclasses, allowing the superclass data in the list to be accepted. Wildcards can be used to implement resizable array lists with generics, allowing handling of various types and addition/removal operations.

Generic wildcards in Java functions: upper and lower bounds

In Java, we can use wildcards to represent generics Types allow us to use generics without specifying a specific type. This article will explore upper and lower wildcards and demonstrate their usage through practical examples.

Upper limit wildcard character

Upper limit wildcard character (<? extends T>) represents the type parameter T or any of its subclasses kind. For example:

public static <T extends Number> double sum(List<T> numbers) {
  double total = 0;
  for (T num : numbers) {
    total += num.doubleValue();
  }
  return total;
}

This function can accept any Number (such as Integer, Double) or a list of its subclasses. We can safely pass any list that satisfies the Number constraint to this function as follows:

List<Integer> ints = List.of(1, 2, 3);
double sumIntegers = sum(ints); // 编译通过

Lower bound wildcard

Lower bound wildcard(<? super T>) represents the type parameter T or any of its superclasses. For example:

public static <T super Number> void process(List<T> entities) {
  for (T entity : entities) {
    System.out.println(entity.getClass().getName());
  }
}

This function can accept a list of any Number superclass (such as Object, Serializable). We can safely pass any list that satisfies the Number superclass constraints to this function as follows:

List<Object> objects = List.of("Hello", 123);
process(objects); // 编译通过

Practical Case

Consider a resizable array List, we can use generic wildcards to achieve it:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ResizableArrayList<E> {

  private List<E> list;

  public ResizableArrayList() {
    this(new ArrayList<>());
  }

  public ResizableArrayList(List<? super E> initialList) {
    list = new ArrayList<>(initialList);
  }

  public void addAll(List<? extends E> elements) {
    list.addAll(elements);
  }

  public void removeAll(List<? super E> elements) {
    list.removeAll(elements);
  }

  public List<E> getList() {
    return list;
  }

  public static void main(String[] args) {
    ResizableArrayList<Integer> numbers = new ResizableArrayList<>(
        Arrays.asList(1, 2, 3)
    );
    numbers.addAll(Arrays.asList(4, 5, 6));
    numbers.removeAll(Arrays.asList(2, 3));

    System.out.println(numbers.getList()); // [1, 4, 5, 6]
  }
}

This resizable array list can handle any typeE, allowing us to add or remove various objects to the list.

The above is the detailed content of Generic wildcards in Java functions: upper and lower bounds. For more information, please follow other related articles on the PHP Chinese website!