Functional Interface in Java

package programs;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;

public class ContainsDuplicate {

    public static void main(String[] args) {
        List<Integer> arr = Arrays.asList(1,2,3,1,2);
        Map<Integer,Integer> map = new LinkedHashMap<>();

        for (int i = 0; i < arr.size(); i++) {
                map.put(arr.get(i), map.getOrDefault(arr.get(i), 0) + 1);
        }
        System.out.println(map.keySet()+"<value>"+map.values());
        System.out.println(map.entrySet());
        map.entrySet().stream()
                .filter(x -> x.getValue() > 1)
                .forEach(entry ->
                        System.out.println("Key->"+entry.getKey()+"::Value"+entry.getValue()));
        System.out.println("-------------------------------");
        map.entrySet().stream()
                .filter(new Predicate<Map.Entry<Integer, Integer>>() {
                    @Override
                    public boolean test(Map.Entry<Integer, Integer> integerIntegerEntry) {
                        return integerIntegerEntry.getValue() > 1;
                    }
                })
                .forEach(new Consumer<Map.Entry<Integer, Integer>>() {
                    @Override
                    public void accept(Map.Entry<Integer, Integer> integerIntegerEntry) {
                        System.out.println("Key->" + integerIntegerEntry.getKey()
                                + "::Value" + integerIntegerEntry.getValue());
                    }
                });
        System.out.println("----------Supplier---------------------");
        Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return 10;
            }
        };

        Stream.generate(supplier)
                .limit(5)
                .forEach(System.out::println);

        Optional<String> name = Optional.of("Tapas");

        String value = name.orElseGet(new Supplier<String>() {
            @Override
            public String get() {
                return "Unknown";
            }
        });
        System.out.println("----------Function---------------------");
        arr.stream().map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) {
                return integer+2;
            }
        }).forEach(System.out::println);
        ////////
        map.entrySet().stream().map(new Function<Map.Entry<Integer, Integer>, Integer>() {
            @Override
            public Integer apply(Map.Entry<Integer, Integer> integerIntegerEntry) {
                return integerIntegerEntry.getValue();
            }
        }).forEach(System.out::println);
    }


}