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.

Collections.sort(commits, Comparator.comparing(GitCommit::getDate));

or even

commits.sort(Comparator.comparing(GitCommit::getDate));

Comparator#compareTo returns an int; while getTime is obviously long.

It would be nicer written like this:

.sort(Comparator.comparingLong(Message::getTime))

According to the Oracle docs on Lambda expressions, they are the same as anonymous classes implementing functional interfaces (interfaces having only one method).

So if you have a method which takes an argument which has a functional interface as its reference type, you can use a lambda expression while calling that method. Example:-

public boolean testString(Predicate<String> tester, String str);

When calling testString, you can make use of a lambda expression to reduce the amount of code needed to write a comparator:-

boolean result = testString(s -> { /* implement Predicate.test */}, str);

Why are lambda expressions useful?

When you want to leave the core functionality of a method to the caller without writing explicit classes/anonymous classes. Expanding the example taken above:-

boolean isStringPalindrome = testString(s -> { /* code to check if string is palindrome */}, "madam");
boolean doesStringContainVowels = testString(s -> { /* code to check if string contains vowels */}, "abc");

Sonar is suggesting to replace

prop.putAll(temp.entrySet().stream()
    .filter( entry -> !prop.containsKey(entry.getKey()))
    .map( new Function<Entry<Object, Object>, Entry<String, String>>(){ 
        @Override
        public Entry<String, String> apply(Entry<Object, Object> entry) {
            return new Entry<String, String>() {
                @Override
                public String setValue(String value) {
                    return value.trim().toLowerCase();
                }

                @Override
                public String getValue() {
                    return ((String) entry.getValue()).trim().toLowerCase();
                }

                @Override
                public String getKey() {
                    return ((String) entry.getKey()).trim().toLowerCase();
                }
            };
        }
    })
    .collect(Collectors.toMap(Entry::getKey, Entry::getValue)));

^{(I removed the unnecessary type arguments in the collector)}

with

prop.putAll(temp.entrySet().stream()
    .filter( entry -> !prop.containsKey(entry.getKey()))
    .map(entry -> new Entry<String, String>() { 
        @Override
        public String setValue(String value) {
            return value.trim().toLowerCase();
        }

        @Override
        public String getValue() {
            return ((String) entry.getValue()).trim().toLowerCase();
        }

        @Override
        public String getKey() {
            return ((String) entry.getKey()).trim().toLowerCase();
        }
    })
    .collect(Collectors.toMap(Entry::getKey, Entry::getValue)));

which uses the lambda expression as replacement for the anonymous inner class implementing Function, not for the Entry implementation.

Still, it doesn’t make sense to implement the Entry interface manually here, especially not with the actually unwanted setValue method in this contract violating way. You only want an immutable Entry instance, therefore, you can create an instance of an existing class instead:

prop.putAll(temp.entrySet().stream()
    .filter( entry -> !prop.containsKey(entry.getKey()))
    .map(entry -> new AbstractMap.SimpleImmutableEntry<>(
        ((String) entry.getKey()).trim().toLowerCase(),
        ((String) entry.getValue()).trim().toLowerCase()))
    .collect(Collectors.toMap(Entry::getKey, Entry::getValue)));

as a last improvement, you can get rid of the Entry instance entirely, when performing the transformation in the functions passed to the toMap collector:

prop.putAll(temp.entrySet().stream()
    .filter( entry -> !prop.containsKey(entry.getKey()))
    .collect(Collectors.toMap(
        entry -> ((String) entry.getKey())  .trim().toLowerCase(),
        entry -> ((String) entry.getValue()).trim().toLowerCase())));

In the Analyze menu, select "Run Inspection by Name...". In the search box, type "Anonymous" and select the one that says "Anonymous class may be replaced by lambda" or something to that effect. Select your scope and start the analysis.

In the results, you can inspect them individually and click the "Replace with lambda" link on the right to make the change, or, if you are brave, you can right click on the node at the top of the results and select the "apply fix" to update all of them.