Java 8, Lambda : replace Anonymous inner class by lambda

Question

I've got a class which contains the following:

List roles = ldapTemplate.search(baseDn, replaceFilter, sc,
            new AttributesMapper() {
                public Object mapFromAttributes(Attributes attrs)
                        throws NamingException {
                    return attrs.get("cn").get();
                }
            });

IntelliJ tells me to replace the anonymous inner class with a lambda. So I tried:

List roles = ldapTemplate.search(
    baseDn, replaceFilter, sc,
    (Attributes a)  -> { return a.get("cn").get(); };
);

However, I get a compilation error:

Error:(46, 50) java: incompatible types: inference variable T has incompatible bounds
    equality constraints: java.lang.String
    lower bounds: java.lang.Object

I can't find the solution to this problem. Do you have any ideas?

Answer 1

A simple azure storage Entity Resolver interface and it's implemented method:

EntityResolver<String> orderNumberResolver = new EntityResolver<String>() {
    @Override
    public String resolve(String partitionKey, String rowKey, Date timeStamp,
        HashMap<String, EntityProperty> properties, String etag) {
      return properties.get("SomeColumnName").getValueAsString();
    }
  };

Lambda of the above method will be :

 EntityResolver<String> orderNumberResolver = (
          partitionKey, rowKey, timeStamp, properties, etag
      ) -> properties.get("SomeColumnName").getValueAsString();

It's clear from above example that lambda's are smart enough to handle the type of method parameters according to their anonymous inner class thus it makes the implementation of overridden method easy. Hope this will be helpful.

Answer 2

Try this (removing extra semi colon)

List roles = ldapTemplate.search(
    baseDn, replaceFilter, sc,
    (Attributes a)  -> { return a.get("cn").get(); }            
);

Answer 3

I have the strong feeling that you didn’t post the exact code in your question. Like Bart, I cannot reproduce the error with the code as you have posted.

However, what strikes me is your use of raw types. If your original code looked like this:

List<String> roles = ldapTemplate.search(baseDn, replaceFilter, sc,
    new AttributesMapper() {
        public Object mapFromAttributes(Attributes attrs)
                throws NamingException {
            return attrs.get("cn").get();
        }
    });

(note the changed type of the roles variable) you would get away with just a raw type warning as you implemented AttributesMapper without type arguments and there will be no check whether the returned Object will be valid as an element for a List<String>.

When converting that code into a lambda, you cannot get away with it anymore:

List<String> roles = ldapTemplate.search(baseDn, replaceFilter, sc,
  (Attributes a)  -> { return a.get("cn").get(); }            
);

Now, the compiler will infer the type AttributesMapper<String> for you and produce an error because your lambda expression returns Object instead of String and thus does not fulfill the AttributesMapper<String> interface.

You can fix that by either inserting a type cast to fulfill the AttributesMapper<String> interface or by declaring roles with the raw type List as you already did in the question. However, using the type cast will be the cleaner way (and should be the only one which does not produce compiler warnings):

List<String> roles = ldapTemplate.search(baseDn, replaceFilter, sc,
    a -> (String)a.get("cn").get());

(I simplified the expression to compensate for the included type cast, looks much better, doesn’t it?)

Answer 4

Below code shows get student Comparator using annonymous inner class.

private static final Comparator<StudentDto> studentScoreComparator = new Comparator<StudentDto>() {
            @Override
            public int compare(StudentDto s1, StudentDto s2) {
              if (s2.getScore() < s1.getScore()) {
                return 1;
              }
              return s2.getScore() == s1.getScore() ? 0 : 1;
            }
          };

Using Java8 amd Sonar suggestion to Anonymous inner classes containing only one method should become lambdas Can be converted as below.

private static final Comparator<StudentDto> studentScoreComparator = (s1, s2) -> {
        if (s2.getScore() < s1.getScore()) {
          return 1;
        }
        return s2.getScore() == s1.getScore() ? 0 : 1;
      };

Annonymous inner class which has only one method implementation can be consider as Functional Interface and can be easily treated as Lambda Expression.