Lambda Expression: unchecked call to compareTo(T) as a member of the raw type Comparable

[Charles Sexton]

I have the method below and I have been trying to solve the following warning: unchecked call to compareTo(T) as a member of the raw type Comparable. I can't figure out a way to solve this, any suggestions? I am still quite a nooby with generics and lambdas which is why I am studying and practicing.

    public List<Book> getSortedRecords(Function<Book, Comparable> fieldExtractor) {
        return bookMap
                .values()
                .stream()
                .sorted((Book book1, Book book2) -> fieldExtractor.apply(book1)
                        .compareTo(fieldExtractor.apply(book2)))
                .collect(Collectors.toList());
    }

[Stephan van Hulst]

Your field extractor's type contains a raw type argument.

Comparable is a generic type, so you should parameterize it.

It appears that the method doesn't know the type of the field that will be extracted from the book. At first it may seem reasonable to parameterize your Comparable with the unbounded wildcard:
Comparable<?>. This won't work however, because that means that the field extracted from the first book might not be comparable to the field extracted from the second book. That means that we do care about the type, we just don't know the exact type. The solution is to make the method itself generic:

public <T extends Comparable<? super T>> List<Book> getSortedRecords(Function<Book, T> fieldExtractor)

[Piet Souris]

You can simplify and generalize this a little: list.sort(c), (assuming book.values() is a list-like object)
where c is a Comparator that may include the field extractor.

[Campbell Ritchie]

Do you really mean Comparable? Are you sure it shou‍ldn't be Comparator?

[Piet Souris]

OP's method used in 'sorted' is a comparator, even though compareTo is used.

[Rob Spoor]

Charles Sexton wrote:

                .sorted((Book book1, Book book2) -> fieldExtractor.apply(book1)
                        .compareTo(fieldExtractor.apply(book2)))

FYI, that can be shorter:

                .sorted(Comparator.comparing(fieldExtractor))

It does exactly the same, but you hide it in the comparing method call.

[Charles Sexton]

Rob Spoor wrote:

Charles Sexton wrote:

                .sorted((Book book1, Book book2) -> fieldExtractor.apply(book1)
                        .compareTo(fieldExtractor.apply(book2)))

FYI, that can be shorter:

                .sorted(Comparator.comparing(fieldExtractor))

It does exactly the same, but you hide it in the comparing method call.

So this did work but now I have to cast it to List<Book>. Im not a big fan of casting and try to avoid it at all costs. I am currently trying to find a way without casting.

       return (List<Book>) bookMap
                .values()
                .stream()
                .sorted(Comparator.comparing(fieldExtractor)).collect(Collectors.toList());

[Campbell Ritchie]

Piet Souris wrote:OP's method used in 'sorted' is a comparator . . .

That is what I thought.

If you are having to cast the return type to List<Book>, that is most probably because your book map is not parametrised. You probably have a Map full stop whereas you would be better off with a Map<Something, Book>. Please show us how you are instantiating that Map. You are right to dislike casting.

[Charles Sexton]

If you are having to cast the return type to List<Book>, that is most probably because your book map is not parametrised. You probably have a Map full stop whereas you would be better off with a Map<Something, Book>. Please show us how you are instantiating that Map. You are right to dislike casting.

public class BookTable {

    private Map<Integer, Book> bookMap;

    public BookTable() {
        this.bookMap = new HashMap<>();
    }

    public List<Book> getSortedRecords(
            Function<Book, Comparable> fieldExtractor) {
            
        return (List<Book>) bookMap
                .values()
                .stream()
                .sorted(Comparator.comparing(fieldExtractor))
                .collect(Collectors.toList());
    }
}

[Charles Sexton]

I meant to qoute Campbell above ^^^^

[Charles Sexton]

Unit Tests

    @Test
    public void getSortedRecordsByTitle() {
        List<Book> sortedList = table.getSortedRecords(Book::getTitle);
        for (int i = 0; i < table.size() - 1; i++) {
            
            String title1 = sortedList.get(i).getTitle();
            String title2 = sortedList.get(i + 1).getTitle();
            
            assertTrue(title1.compareTo(title2) < 0);
        }
    }
    
    @Test
    public void getSortedRecordsByAuthor() {
        List<Book> sortedList = table.getSortedRecords(Book::getAuthor);
        for (int i = 0; i < table.size() - 1; i++) {
            
            String author1 = sortedList.get(i).getAuthor();
            String author2 = sortedList.get(i + 1).getAuthor();
            
            assertTrue(author1.compareTo(author2) < 0);
        }
    }

[Campbell Ritchie]

Try running the code on Eclipse and hover your mouse over each method call. You shou‍ld get a tooltip/popup with things like Collection<Book> or Stream<Book> written on. See whether the penultimate method call still has Stream<Book> and also what type the final method call shows.

[Charles Sexton]

hovering over

table.getSortedRecords(Book::getAuthor);

I get:

<?> List<Book> BookTable.getSortedRecords(Function<Book, Comparable> fieldExtractor)

hovering over

Comparator.comparing(fieldExtractor)

in the

.sorted()

call, I get

 Type safety: The expression of type Comparator needs unchecked conversion to conform to Comparator<? super Book>

hovering over

.collect()

I get

<List<Book>, ?> List<Book> java.util.stream.Stream.collect(Collector<? super Book, ?, List<Book>> collector)

hovering over

.stream() 

I get

Stream<Book> java.util.stream.Stream.sorted(Comparator<? super Book> comparator)

hovering over

.toList() 

in

.collect(Collectors.toList())

I get

<Object> Collector<Object, ?, List<Object>> java.util.stream.Collectors.toList()

[Stephan van Hulst]

Because you're still using raw types.

Comparable is a generic type. Don't use it without specifying type arguments.

Your compiler should actually warn you about this. Is your Eclipse setup to report compiler warnings? If so, fix your warnings.

[Charles Sexton]

so I just added this to remove the warning

@SuppressWarnings("unchecked")

[Campbell Ritchie]

Charles Sexton wrote:so I just added this to remove the warning . . .

Nonononononononono! Don't use suppress warnings until you are absolutely sure you have got all the type right. And you haven't.

[Charles Sexton]

Does this look good? I can't use any other type for comparable but object because I am comparing ints, doubles, strings....etc.... I might want to compare the price of a book.... or the quantity..... of course it wouldn't be int but I would have to do Integer.....

    @SuppressWarnings("unchecked")
    public List<Book> getSortedRecords(Function<Book, Comparable<Object>> fieldExtractor) {
            
        return bookMap
                .values()
                .stream()
                .sorted(Comparator.comparing(fieldExtractor))
                .collect(Collectors.<Book>toList());
    }

[Charles Sexton]

Well I spoke too soon, in my unit tests now I get the following error which is pretty self explanatory....

Multiple markers at this line
	- The type of getTitle() from the type Book is String, this is incompatible with the descriptor's return type: Comparable<Object>
	- The method getSortedRecords(Function<Book,Comparable<Object>>) in the type BookTable is not applicable for the arguments 
	 (Book::getTitle)

occurs

List<Book> sortedList = table.getSortedRecords(Book::getTitle);

[Charles Sexton]

So this worked as stated above but I had no idea what was being said really. Now I do and I completely understand why and whats going on. Thanks to everyone......no @SupressedWarnings()    

    public <T extends Comparable<? super T>> List<Book> getSortedRecords(Function<Book, T> fieldExtractor) {
            
        return bookMap
                .values()
                .stream()
                .sorted(Comparator.comparing(fieldExtractor))
                .collect(Collectors.toList());
    }

[Stephan van Hulst]

Great! Now that you get it, let's go back to Piet's comment.

Why does your method accept a field extractor, only to base a sorting order on, if you can just pass the method a Comparator? That's exactly what they're intended for in the first place:

public List<Book> getSortedRecords(Comparator<? super Book> order)

[Piet Souris]

And it is more general, since you can use book fields that are not Comparable (if any).

[Charles Sexton]

I wanted to use the Function Interface just for learning. Never really played with it or the Streams class. Actually didn't even know these existed until a few days ago.

[Charles Sexton]

Never used Comparator either. I have used comparable several times before.