Understanding cannot be converted to java.util.Collection<capture 1 of ? extends ...>

Table of Contents

1. Core Concepts
2. Typical Usage Scenarios
3. Common Pitfalls
4. Code Examples
5. Best Practices
6. Conclusion
7. FAQ
8. References

Core Concepts

Generics and Wildcards

Java generics allow us to create classes, interfaces, and methods that can work with different types while providing compile - time type safety. Wildcards, denoted by ?, are used when the exact type is unknown or when we want to create more flexible generic code. There are two types of wildcards: ? extends T (upper - bounded wildcard) and ? super T (lower - bounded wildcard).

Capture Conversion

When a wildcard is used, the Java compiler performs capture conversion. Capture conversion is the process of replacing each wildcard with a unique, unnamed type variable. The “capture 1 of ? extends …” in the error message refers to this unnamed type variable created during capture conversion.

Typical Usage Scenarios

Method Parameter with Wildcards

Suppose you have a method that takes a Collection of some unknown subtype of a specific class. For example, a method that prints the elements of a collection of any subtype of Number.

import java.util.Collection;

public class WildcardExample {
    public static void printNumbers(Collection<? extends Number> numbers) {
        for (Number num : numbers) {
            System.out.println(num);
        }
    }
}

Returning a Collection with Wildcards

You might have a method that returns a collection of some unknown subtype. For example, a method that returns a collection of any subtype of String.

import java.util.ArrayList;
import java.util.Collection;

public class ReturnWildcardExample {
    public static Collection<? extends String> getStrings() {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("Hello");
        return strings;
    }
}

Common Pitfalls

Incompatible Type Assignments

One common pitfall is trying to assign a collection with a wildcard type to a collection with a specific type. Consider the following code:

import java.util.ArrayList;
import java.util.Collection;

public class PitfallExample {
    public static void main(String[] args) {
        Collection<? extends Number> numbers = new ArrayList<>();
        // This will cause a compilation error
        // java.util.Collection<capture of ? extends java.lang.Number> cannot be converted to java.util.Collection<java.lang.Number>
        // Collection<Number> numberCollection = numbers; 
    }
}

The reason for this error is that the Collection<? extends Number> can hold a collection of any subtype of Number, such as Integer or Double. If we were allowed to assign it to a Collection<Number>, we could potentially add a Double to a collection that was originally a collection of Integer, violating type safety.

Adding Elements to a Collection with Upper - Bounded Wildcards

Another pitfall is trying to add elements to a collection with an upper - bounded wildcard.

import java.util.ArrayList;
import java.util.Collection;

public class AddToWildcardCollection {
    public static void main(String[] args) {
        Collection<? extends Number> numbers = new ArrayList<>();
        // This will cause a compilation error
        // numbers.add(1); 
    }
}

Since the compiler doesn’t know the exact type of the collection (it could be a collection of Integer, Double, etc.), it cannot allow adding elements to it.

Code Examples

Example 1: Understanding Capture Conversion

import java.util.ArrayList;
import java.util.Collection;

public class CaptureConversionExample {
    public static void main(String[] args) {
        Collection<? extends Number> numbers = new ArrayList<>();
        // This will cause a compilation error
        // java.util.Collection<capture of ? extends java.lang.Number> cannot be converted to java.util.Collection<java.lang.Number>
        // Collection<Number> numberCollection = numbers; 

        // Correct way to handle the collection
        processNumbers(numbers);
    }

    public static void processNumbers(Collection<? extends Number> numbers) {
        for (Number num : numbers) {
            System.out.println(num);
        }
    }
}

Example 2: Returning a Collection with Wildcards

import java.util.ArrayList;
import java.util.Collection;

public class ReturnWildcardCollectionExample {
    public static Collection<? extends String> getStrings() {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("Java");
        strings.add("Python");
        return strings;
    }

    public static void main(String[] args) {
        Collection<? extends String> result = getStrings();
        for (String str : result) {
            System.out.println(str);
        }
    }
}

Best Practices

Use Wildcards Wisely

Only use wildcards when necessary. If you know the exact type of the collection, use a specific generic type instead of a wildcard.

Read - Only vs. Write - Only Collections

If you need to read elements from a collection, use an upper - bounded wildcard (? extends T). If you need to add elements to a collection, use a lower - bounded wildcard (? super T). For example:

import java.util.ArrayList;
import java.util.Collection;

public class ReadWriteWildcardExample {
    // Read - only
    public static double sum(Collection<? extends Number> numbers) {
        double sum = 0;
        for (Number num : numbers) {
            sum += num.doubleValue();
        }
        return sum;
    }

    // Write - only
    public static void addNumbers(Collection<? super Integer> numbers) {
        numbers.add(1);
        numbers.add(2);
    }

    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        addNumbers(integers);
        double result = sum(integers);
        System.out.println("Sum: " + result);
    }
}

Conclusion

The “cannot be converted to java.util.Collection<capture 1 of ? extends …>” error is a result of the type safety mechanisms in Java’s generics. By understanding the core concepts of generics, wildcards, and capture conversion, you can avoid common pitfalls and write more robust and type - safe code. Remember to use wildcards judiciously and follow the best practices for reading and writing collections.

FAQ

Q1: Why can’t I add elements to a collection with an upper - bounded wildcard?

A1: The compiler doesn’t know the exact type of the collection. It could be a collection of any subtype of the upper - bound type. Adding an element of a specific type might violate the type safety of the collection.

Q2: How can I fix the “cannot be converted to java.util.Collection<capture 1 of ? extends …>” error?

A2: Check your type assignments. If you are trying to assign a collection with a wildcard type to a collection with a specific type, make sure the types are compatible. If necessary, use a method that takes a collection with a wildcard type as a parameter.

Q3: When should I use an upper - bounded wildcard and when should I use a lower - bounded wildcard?

A3: Use an upper - bounded wildcard (? extends T) when you need to read elements from a collection. Use a lower - bounded wildcard (? super T) when you need to add elements to a collection.

References

• Oracle Java Documentation: Generics in Java
• Effective Java by Joshua Bloch

This blog post should help you gain a better understanding of the “cannot be converted to java.util.Collection<capture 1 of ? extends …>” error and how to handle it in your Java code.

• ←Previous
• Next→