We Keep Coding

generic VS wildcards in Java

I have these two methods under a generic class:
public class Container<S> {
public void f2(List<Object> l1, List<?> l2) {
l1 = l2; //compilation error row #1
}
public void f3(List<?> c, List<S> l) {
c = l; //ok row #2
l = c; //compilation error row #3
}
}
I really don't undersatand why row 2 is ok- if I transfer this method two lists, one is an object type list and one is a Strings one, I shoule get a compilation error?
would really appriciate to understadn why each row should/shouldn't be compiled.

Why does this compile?
List<?> c, List<S> l;
c = l; // OK
List<?> means (more or less) “list of something” (or more formally “list of unknown”), and a List<S>is one of those.
——
Why does this not compile?
List<Object> l1, List<?> l2;
l1 = l2; //compilation error
If it were allowed, you could then add anything (eg String) to l1, but if l2 is anything other than List<Object> (eg Integer), you’d be putting the wrong type in l2. That’s why this assignment is not allowed.
The other compilation error is more subtle, and also doesn’t have a use case - that is, there’s no reason to assign a typed list to an untyped one - but the wildcard ? really means “unknown, but specific”. This is not the same as “anything”. It’s “something”, but we don’t know what. Type S is something, but the compiler can’t verify that it’s the same something as S.

Generics and wildcards are powerful because they ensure better typechecking during compile time, that's the main purpose of using them. To make sure your code won't break at runtime due to poor type checking.
Source
Although Integer is a subtype of Number, List<Integer> is not a subtype of List<Number> and, in fact, these two types are not related. The common parent of List<Number> and List<Integer> is List<?>.
In order to create a relationship between these classes so that the code can access Number's methods through List<Integer>'s elements, use an upper bounded wildcard:
List<? extends Integer> intList = new ArrayList<>();
List<? extends Number> numList = intList; // OK. List<? extends Integer> is a subtype of List<? extends Number>
Because Integer is a subtype of Number, and numList is a list of Number objects, a relationship now exists between intList (a list of Integer objects) and numList. The following diagram shows the relationships between several List classes declared with both upper and lower bounded wildcards.
To make use of subtyping and polymophism with wildcards you have to use bounded wildcards.
public void f2(List<Object> l1, List<?> l2) {
l1 = l2; //compilation error row #1
}
//correct way of doing it
public void f2(List<? extends Object> l3, List<?> l4) {
l3 = l4;
}
Compiler doesn't see l2 as a subtype of l1
public void f3(List<?> c, List<S> l) {
c = l; //ok row #2
l = c; //compilation error row #3
}
Compiler doesn't see c as a subtype of l (rightly so, this could lead to runtime errors).

Comparable VS <? extends Comparable>

regarding the following code:
public class Test <T extends Comparable>{
public static void main(String[] args){
List<String> lst = Array.asList("abc","def");
System.out.println(func(lst));
}
public static boolean func(List<**here**> lst){
return lst.get(0).compareTo(lst.get(1)) == 0;
}
}
why writing " ? extends Comparable" here would compile , and writing "Comparable" would not compile?
thanks in advance.

This happens because generics are invariant. Even if String is a Comparable, meaning:
String s = "";
Comparable c = s; // would work
Generics of these would not work:
List<Comparable> listC = List.of();
List<String> listS = List.of();
listC = listS; // will fail
And this would not work no matter what is the relationship between Comparable and String.
When you change the definition of that method to:
public static boolean func(List<? extends Comparable> lst) {
...
}
This is said that: wildcard with an extends-bound makes the type covariant.
This means that :
List<? extends Comparable> listC = List.of();
List<String> listS = List.of();
listC = listS; // would work here
Or in simpler words it means that List<String> is a subtype of List<? extends Comparable>.
There is a small price to pay now, because listC is now a producer of elements, meaning you can take elements out of it, but you can not put anything into it.
And well after you understand this, you are not done yet, because the definition of that method would be entirely correct, when written like this:
public static <T extends Comparable<? super T>> boolean func(List<T> lst) {
.....
}

This is because List<SubClass> cannot be cast to List<BaseClass>. Let us suppose that it could
List<String> sList = new ArrayList<>();
List<Comparable> cList = (List<Comparable>) sList;
cList.add(5);
This would be a problem because the integer 5 is not a String and should not be placed in a List<String>.
By using ? extends Comparable you are saying that the function can take a list of anything that has Comparable as a base class (e.g. List<Comparable>, List<String>, List<Integer>, etc.)
To more correctly define your function you should do the following:
public static <T extends Comparable<T>> boolean func(List<T> lst) {}
This enforces that the type is comparable with itself. Your function compares the first and second element in the list, so it is best to ensure that each element in the list is actually comparable with every other element.

Because
List<String> lst = Array.asList("abc","def");
lst list has generic type String, not Comparable.
String class, hovewer, implement Comparable<String> interface, so it fits in ? extends Comparable generic type.

Generics Upper Bound Wild Card gives compilation error [duplicate]

This question already has answers here:
List<? extends MyType>
(5 answers)
Closed 6 years ago.
I was trying some sample programs on Generics Upper/Lower bounds.. Generics Upper Bound is giving compilation error...But Lower Bound is fine.
I am just trying to put a List of type T into a set and try both Upper and Lower bound scenarios..
Please help to identify the issue with testUpperBound(T t) method and why exactly does the testLowerBound(T t) method compile and the testUpperBound(T t) one doesn't. I checked other similar threads..But still I haven't got it clear.
Please Let me know if need more details .
public class TestGenerics<T>
{
public static void main(String...args)
{
List<String> list = new ArrayList<>();
list.add("New ArrayList");
new TestGenerics<List<String>>().testUpperBound(list);
new TestGenerics<List<String>>().testLowerBound(list);
}
public void testLowerBound(T t)
{
Set<? super ArrayList<T>> lowerBoundSet = new HashSet<>();
lowerBoundSet = new HashSet<List<T>>();
ArrayList<T> list = new ArrayList<>();
list.add(t);
lowerBoundSet.add(list); // compiles..
out.println(lowerBoundSet);
}
public void testUpperBound(T t)
{
Set<? extends List<T>> upperBoundSet = new HashSet<>();
upperBoundSet = new HashSet<List<T>>();
ArrayList<T> list = new ArrayList<>();
list.add(t);
upperBoundSet.add(list); // Doesn't compile..
out.println(upperBoundSet);
}
}

Here you have your answer :
Explanation of the get-put principle
It is java rule, that's all.
I may give you an example with your code why it would be unsafe if compilation passed :
public void extendsExample(){
Set<? extends List<? extends String>> setOfList = new HashSet<>();
Set<ArrayList<String>> setOfArrayList = new HashSet<>();
// now setOfList var refers to a set
// which contains a arraylist of String
setOfList = setOfArrayList;
// compilation fails
setOfList.add(new LinkedList<String>());
}
Imagine the compilation doesn't fail.
It means setOfArrayList instance which is a set which should contain ArrayList instances, contains now a list of LinkedList element.
If you iterate on setOfArrayList you will not have exclusively ArrayList<String> elements as expected. It's no safe and that's why the compilation fails.
Here the example with <? super :
public void superExample(){
Set<? super ArrayList<String>> setOfArrayList = new HashSet<>();
// compilation ok
setOfArrayList.add(new ArrayList<String>());
// new anonymous type derivating from ArrayList
ArrayList<String> derivedArrayList = new ArrayList<String>(){
};
// compilation ok
setOfArrayList.add(derivedArrayList);
}

You can not modify a collection parameterized with <? extends SomeType>. Java just does not allow that as it is not safe action. add() modifies the collection, so you can't do it. There is no such restriction for <? super SomeType>

Simply put, we do not know at compile time what type of lists are contained in the upperBoundSet. It could be a Set<ArrayList<T>>, or it could be a Set<LinkedList<T>>, or it could be one of many other alternatives.
If it turns out to be a Set<LinkedList<T>>, then adding an ArrayList to it is obviously a bad idea. But because we don't know what type the set's contents are, it takes the safer option and blocks it.

? super String Lower Bound Java

I am reading book for OCP of Author Jeanne Boyarsky and Scott Selikoff, Book saying : Page # 122
? super String
With a lower bound, we are telling Java that the list will be a list of String objects or a
list of some objects that are a superclass of String
List<? super String> superString = new ArrayList<>();
superString.add(new String());// Valid
superString.add(new Object()); // Not Valid ? Why?. Object is a super class of String
Other Example:
List<? super IOException> exceptions = new ArrayList<Exception>();
exceptions.add(new Exception()); // Invalid, why ? Exception is a superclass of IOException
exceptions.add(new IOException());
exceptions.add(new FileNotFoundException());
I think this statement
With a lower bound, we are telling Java that the list will be a list of String objects or a
list of some objects that are a superclass of String
Should be
With a lower bound, we are telling Java that the list will be a list of String objects or a
list of some objects whoes super class is String
if this case is true then why we use
List<? super IOException> exceptions = new ArrayList<Exception>();
instead of
List<? super IOException> exceptions = new ArrayList<IOException>();

You need to understand, that these bounds (lower and upper) exist for restricting/specifying the variable's type, and not for restricting/specifying the type of elements inside such a collection.
An example:
List<? super String> variable = new ArrayList<CharSequence>();
With this statement, you first create an ArrayList whose elements can be of type CharSequence or a subtype of it (e.g. String or StringBuilder).
With that declaration it should be clear that you can not add an Object into this list. It simply does not implement the CharSequence interface. The compiler takes care of that.
Lower and upper bounds exist for making subtypes of generic types. Their use is explained in this question about PECS.
In fact, a List<? super String> is a list with a concrete element's type, but this concrete type is not known at this moment. See my example initialisation. The concrete type is the CharSequence. It simply means that all elements are of that concrete type (or a subtype), but that is not known in the variable's own type.

Here's a link to a good explanation Difference between <? super T> and <? extends T> in Java
The book is correct "? super String" means that the list may contain Strings or a supertype of String (eg. Object, CharSequence)
In you example:
List<? super String> superString = new ArrayList<>();
superString.add(new String());// 1
superString.add(new Object()); // 2
Write operations:
1 - is valid for any type of list you could've created , since String is an Object, a CharSequence...
List<? super String> list = new ArrayList<Object>();
list.add("String");
2 - not valid because it doesn't cover all cases
List<? super String> list = new ArrayList<String>();
list.add(new Object());
Given the declared type List<? super String> you can only add Strings (and String subtypes) , anything less than a String (supertypes) may not correspond to the actual element type.
Example:
Here's an example :
interface MyInterface {
}
class MyInterfaceImpl implements MyInterface {
}
class MyInterfaceImplExtra extends MyInterfaceImpl {
}
You may have the following situations:
List<? super MyInterfaceImpl> myList = new ArrayList<MyInterfaceImpl>();
Doesn't compile because myList variable may point to a list of either MyInterfaceImpl or MyInterface or Object. When adding to the list it's unclear exactly what kind of list you actually have, thus you are allowed only values that are applicable for all cases.
myList.add(new MyInterface(){}); // - compile error "not applicable for the arguments"
myList.add(new MyInterfaceImpl()); // - works fine
myList.add(new MyInterfaceImplExtra()); // - works fine
An example where you get a list of values. The element type is Object , a more concrete type can't be guaranteed. For example here you expect Strings but get a List<? super String> that actually contains Objects so you get a java.lang.ClassCastException
List<String> result = (List<String>) getList();
System.out.println(result.get(0));
public static List<? super String> getList(){
List<Object> list = new ArrayList<Object>();
list.add(new Object());
return list;
}
Usage example in Java 8 :
You have the following method declaration in the Stream interface that restricts the predicate type to be T or supertype.
Stream<T> filter(Predicate<? super T> predicate);
This ensures that given a class Person that defines name and Employee that extends Person and defines an extra field id , you can't do something like this:
List<Person> list = new ArrayList<Person>() {{
add(new Person("John"));
add(new Person("Max"));
add(new Person("Megan"));
}};
list.stream().filter((Employee e) -> e.getId().startsWith("1")); // compile error

Java Generic Method Question

Consider this code:
public <T> List<T> meth(List<?> type)
{
System.out.println(type); // 1
return new ArrayList<String>(); // 2
}
It does not compile at line 2, saying that List is required.
Now, if it's changed to:
public <T> List<?> meth(List<T> type)
{
System.out.println(type); // 1
return new ArrayList<String>(); // 2
}
It does compile. Why? I thought the difference between declaring a generic type with T and using the wildcard was that, when using the wildcard, one cannot add new elements to a collection. Why would <?> allow a subtype of List to be returned? I'm missing something here, what's the explicit rule and how it's being applied?

The difference is in the return type declaration. List<String> is not a subtype of List<T>, but it is a subtype of List<?>.
List<?> makes no assumptions regarding its type variable, so the following statements are valid:
List<?> l0 = new ArrayList<String>();
List<?> l1 = new ArrayList<Object>();
List<? extends Number> ltemp = null;
List<?> l2 = ltemp;
List<T> assumes that the type argument will be resolved in the context of client (e.g. type use), when you declared it as List<String> or List<Object>. Within the method body, you cannot make any assumptions about it either.

In the first case, T is not necessarily a superclass of String. If you choose a T like Integer and call the method, it'll fail; so it won't compile. However, the second will compile as surely, any ArrayList<String> is a valid List of something.

As said earlier, String isn't a subtype of T, so it's why it does not work. However, this code works :
public <T> List<T> meth(List<?> type)
{
System.out.println(type); // 1
return new ArrayList<T>(); // 2
}
and is more in the idea of what you want, I think.