Introduction
An Interface which has only one abstract method (SAM: Single Abstract Method) is called Functional Interface. It is used annotation @FunctionalInterface: An informative annotation type used to indicate that an interface type declaration is intended to be a functional interface as defined by the Java Language Specification. Conceptually, a functional interface has exactly one abstract method. Since default methods have an implementation, they are not abstract. If an interface declares an abstract method overriding one of the public methods of java.lang.Object, that also does not count toward the interface's abstract method count since any implementation of the interface will have an implementation from java.lang.Object or elsewhere.

Runnable, ActionListener, Comparable, Comparator, Callable Are some of the examples of functional interface. There is no need to use the abstract Keyword as it is optional to use the interface
why use Functional Interface?

It is used for enabling functional programming to java language. Functional Interface is also used for defining Lambda Expressions to Pass a function directly as argument to method.

Some Other Functional Interfaces

• Consumer Interface
• Predicate Interface 
• Marker Interfaces

Consumer Interface:  Consumer interface has no return value it returns nothing. there are functional variables of the consumer -DoubleConsumer, IntConsumer and LongConsumer. These variables accept primitives values as arguments.
package com.a143mk.SpringBoot.interfaces; import java.util.ArrayList; import java.util.List; import java.util.function.Consumer; public class ConsumerInterfaceExample { static void addList(List<Integer> list){ // Return sum of list values int result = list.stream().mapToInt(Integer::intValue).sum(); //The Integer class wraps a value of the primitive type int in an object. An object of //type Integercontains a single field whose type is int. //:: is used for Direct Call method intValue. System.out.println("Sum of list values: "+result); } public static void main(String[] args) { // Creating a list and adding values List<Integer> list = new ArrayList<Integer>(); list.add(10); list.add(20); list.add(30); list.add(40); // Referring method to String type Consumer interface Consumer<List<Integer>> consumer = ConsumerInterfaceExample::addList; // :: is used for Direct Call method. consumer.accept(list); // Calling Consumer method Consumer<String> print = x -> System.out.println(x); print.accept("javaA143mk"); // java } }
Predicate Interface : it is a functional interface whose functional method is test(obj), that takes an argument and return boolean value.
package com.a143mk.SpringBoot.interfaces; import java.util.function.Predicate; public class Java8PredicatImpl { public static void main(String[] args) { Predicate<Integer> pr = a -> (a > 18); // Creating predicate System.out.println(pr.test(10)); // Calling Predicate method } }
The predicate functionl interface can also be implemented using a class.

Marker Interfaces: Marker Interface is an empity interface (no field or argument).
Marker Interface are serializable, cloneable and remote interface. All these interfaces are empity interfae.
package com.a143mk.SpringBoot.interfaces; //car marker interface interface Car { } //Engine marker interface interface Engine { } //class that implements the Car marker interface class Vehicle implements Car { static void isVehicle() { System.out.println("Car is a vehicle."); } } //class that implements the Engine marker interface class Status implements Engine { static void isWorking() { System.out.println("Yes, engine is working."); } } //main class public class A134mkMarkeInterface { public static void main(String args[]) { //invoking the methods of the class Vehicle.isVehicle(); Status.isWorking(); } }

The Map interface maps unique keys to values. A key is an object that you use to retrieve a value at a later date.
Architecture of Map interface:

Hashtable: Hashtable is similar to HashMap except it is synchronized.
import java.util.Hashtable; /** * * @author manojkumar */ public class HashtableExample { public static void main(String []args){ //Create String hashtable Object. Hashtable<String, String> hashtable=new Hashtable<String, String>(); hashtable.put("Sum", "67"); hashtable.put("Total", "654"); System.out.println("String, hashtable Contains :"+hashtable); //Create Integer hashtable Object. Hashtable<Integer, Integer> hashtableint=new Hashtable<Integer, Integer>(); hashtableint.put(1,2); hashtableint.put(3,4); System.out.println("Integer, hashtable Contains :"+hashtableint); } }
Output:         String, hashtable Contains :{Total=654, Sum=67}
                     Integer, hashtable Contains :{3=4, 1=2}  
LinkedHashMap: It is Hashtable and LinkedList implementation of  map interface. LinkedHashMap has a doublelinkedlist Running through all its elements.
import java.util.LinkedHashMap; public class LinkedHashMapExample { public static void main(String []args){ //Create LinkedHashMap Object. LinkedHashMap<String, Integer> linkedhashmap=new LinkedHashMap<String, Integer>(); linkedhashmap.put("Hi", 1); linkedhashmap.put("manoj", 2); linkedhashmap.put("welcom", 3); System.out.println("Put, LinkedHashMap Contains :"+linkedhashmap); linkedhashmap.remove("manoj"); System.out.println("Remove, LinkedHashMap Contains :"+linkedhashmap); } }
Output:                Put, LinkedHashMap Contains :{Hi=1, manoj=2, welcom=3}
                             Remove, LinkedHashMap Contains :{Hi=1, welcom=3}
HashMap: A HashMap is a Hashtable implementation of map interface, unlike HashMap it contains null keys and values. HashMap does not guarantee that the order of the objects will remain same over the time.
import java.util.HashMap; /** * * @author manojkumar */ public class HashMapExample { public static void main(String []args){ //Create HashMap Object. HashMap<String, Integer> hashmap=new HashMap<String, Integer>(); hashmap.put("Hi", 1); hashmap.put("manoj", 2); hashmap.put("welcom", 3); System.out.println("Put, HashMap Contains :"+hashmap); hashmap.remove("manoj"); System.out.println("Remove, HashMap Contains :"+hashmap); } }
Output:                Put, HashMap Contains :{Hi=1, welcom=3, manoj=2}
                             Remove, HashMap Contains :{Hi=1, welcom=3}
TreeMap: A TreeMap Provides red-block tree based implementation of map interface.
import java.util.TreeMap; /** * * @author manojkumar */ public class TreeMapExample { public static void main(String []args){ //Create TreeMap Object. TreeMap<String, Integer> treemap=new TreeMap<String, Integer>(); treemap.put("Hi", 1); treemap.put("manoj", 2); treemap.put("welcom", 3); System.out.println("Put, treeMap Contains :"+treemap); treemap.remove("manoj"); System.out.println("Remove, treeMap Contains :"+treemap); } }
Output:               Put, treeMap Contains :{Hi=1, manoj=2, welcom=3}
                            Remove, treeMap Contains :{Hi=1, welcom=3}

A Collection represents a group of objects known as its elements. The Collection interface is used to pass around collections of objects where maximum generality is desired.
Architecture of collection Framework:


List Interface: A List is a ordered collection that can contain duplicate values.

1.  ArrayList.
2. LinkedList.
3. Vector. 

ArrayList: ArrayList is said to be the best performing List implementation in normal conditions. In expendable array of value or objects.
Example: Copy Element of java ArrayList to Another java ArrayList.import java.util.ArrayList; import java.util.Collections; public class CopyElementsOfArrayListToArrayListExample { public static void main(String[] args) { //create first ArrayList object ArrayList<string> arrayList1 = new ArrayList<string>(); //Add elements to ArrayList arrayList1.add("1"); arrayList1.add("2"); arrayList1.add("3"); //create another ArrayList object ArrayList<string> arrayList2 = new ArrayList<string>(); //Add elements to Arraylist arrayList2.add("One"); arrayList2.add("Two"); arrayList2.add("Three"); arrayList2.add("Four"); arrayList2.add("Five"); /* To copy elements of one Java ArrayList to another use, static void copy(List dstList, List sourceList) method of Collections class. This method copies all elements of source list to destination list. After copy index of the elements in both source and destination lists would be identical. The destination list must be long enough to hold all copied elements. If it is longer than that, the rest of the destination list's elments would remain unaffected. */ System.out.println("Before copy, Second ArrayList Contains : " + arrayList2); //copy all elements of ArrayList to another ArrayList using copy //method of Collections class Collections.copy(arrayList2,arrayList1); /* Please note that, If destination ArrayList object is not long enough to hold all elements of source ArrayList, it throws IndexOutOfBoundsException. */ System.out.println("After copy, Second ArrayList Contains : " + arrayList2); } }
Output:       Before copy, Second ArrayList Contains : [One, Two, Three, Four, Five]
                  After copy, Second ArrayList Contains : [1, 2, 3, Four, Five]
LinkedList: LinkedList is a bit slower than ArrayList but it performs better in certain conditions.
Example: Copy Elements Of LinkedList To another LinkedList.
import java.util.LinkedList; import java.util.Collections; /** * * @author manojkumar */ public class CopyElementsOfLinkedListToLinkedListExample { public static void main(String[] args) { //create first ListedList object LinkedList<string> LinkedList1 = new LinkedList<string>(); //Add elements to ListedList LinkedList1.add("1"); LinkedList1.add("2"); LinkedList1.add("3"); //create another ListedList object LinkedList<string> LinkedList2 = new LinkedList<string>(); //Add elements to Listedlist LinkedList2.add("One"); LinkedList2.add("Two"); LinkedList2.add("Three"); LinkedList2.add("Four"); LinkedList2.add("Five"); /* To copy elements of one Java ListedList to another use, static void copy(List dstList, List sourceList) method of Collections class. This method copies all elements of source list to destination list. After copy index of the elements in both source and destination lists would be identical. The destination list must be long enough to hold all copied elements. If it is longer than that, the rest of the destination list's elments would remain unaffected. */ System.out.println("Before copy, Second ListedList Contains : " + LinkedList2); //copy all elements of ListedList to another ListedList using copy //method of Collections class Collections.copy(LinkedList2,LinkedList1); /* Please note that, If destination LinkedList object is not long enough to hold all elements of source LinkedList, it throws IndexOutOfBoundsException. */ System.out.println("After copy, Second LinkedList Contains : " + LinkedList2); } }
Output:           Before copy, Second LinkedList Contains : [One, Two, Three, Four, Five]
                        After copy, Second LinkedList Contains : [1, 2, 3, Four, Five]
Vector: Vector is also a grow-able  array of objects but unlike ArrayList. vector is thread safe in nature.
Example: Copy Elements Of Vector To another Vector.
import java.util.Collections; import java.util.Vector; public class CopyElementsOfVectorToVectorExample { public static void main(String[] args) { //create first Vector object Vector v1 = new Vector(); //Add elements to Vector v1.add("1"); v1.add("2"); v1.add("3"); //create another Vector object Vector v2 = new Vector(); //Add elements to Vector v2.add("One"); v2.add("Two"); v2.add("Three"); v2.add("Four"); v2.add("Five"); /* To copy elements of one Java Vector to another use, static void copy(List dstList, List sourceList) method of Collections class. This method copies all elements of source list to destination list. After copy index of the elements in both source and destination lists would be identical. The destination list must be long enough to hold all copied elements. If it is longer than that, the rest of the destination list's elments would remain unaffected. */ System.out.println("Before copy, Second Vector Contains : " + v2); //copy all elements of Vector to another Vector using copy //method of Collections class Collections.copy(v2,v1); /* Please note that, If destination Vector object is not long enough to hold all elements of source Vector, it throws IndexOutOfBoundsException. */ System.out.println("After copy, Second Vector Contains : " + v2); } }
Output:             Before copy, Second Vector Contains : [One, Two, Three, Four, Five]
                        After copy, Second Vector Contains : [1, 2, 3, Four, Five]
Queue Interface: A Queue interface  Provides implementation to hold elements prior to their prcessing.
Example: Add Elements Of Queue java.
import java.util.Queue; import java.util.Collections; import java.util.LinkedList; /** * * @author manojkumar */ public class AddElementsOfQueueExample { public static void main(String[] args) { //create first Queue object Queue<string> Queue1 = new LinkedList<string>(); //Add elements to Queue Queue1.add("1"); Queue1.add("2"); Queue1.add("3"); System.out.println("Before Add, One Queue Contains : " + Queue1); Collections.addAll(Queue1, "manoj"); System.out.println("After Add, Second Queue Contains : " + Queue1); } }
Output:            Before Add, one Queue Contains : [1, 2, 3]
                        After Add, Second Queue Contains : [1, 2, 3, manoj]
PriorityQueue: The PriorityQueue class is implemented as a priority heap.
Example: Add Elements Of PriorityQueue java.
import java.util.Collections; import java.util.PriorityQueue; /** * * @author manojkumar */ public class AddElementsOfPriorityQueueExample { public static void main(String[] args) { //create first Queue object PriorityQueue<string> Queue1 = new PriorityQueue<string>(); //Add elements to Queue Queue1.add("1"); Queue1.add("2"); Queue1.add("3"); System.out.println("Before Add, one PriorityQueue Contains : " + Queue1); Collections.addAll(Queue1, "manoj"); System.out.println("After Add, Second PriorityQueue Contains : " + Queue1); } }
Output:        Before Add, One PriorityQueue Contains : [1, 2, 3]
                    After add, Second PriorityQueue Contains : [1, 2, 3, manoj]
Deque Interface: Deque is an interface you need to instantiate a concrete implementation of the interface in order to use it.
Example: Add Elements Of Deque java.
import java.util.Collections; import java.util.Deque; import java.util.LinkedList; /** * * @author manojkumar */ public class AddElementsOfDequeExample { public static void main(String[] args) { //create first Queue object Deque<string> DequeQueue1 = new LinkedList<string>(); //Add elements to DequeQueue DequeQueue1.add("1"); DequeQueue1.add("2"); DequeQueue1.add("3"); System.out.println("Before Add, One DequeQueue Contains : " + DequeQueue1); Collections.addAll(DequeQueue1, "manoj"); System.out.println("After Add, Second DequeQueue Contains : " + DequeQueue1); } }
Output:         Before Add, One DequeQueue Contains : [1, 2, 3]
                     After Add, Second DequeQueue Contains : [1, 2, 3, manoj]
ArrayDeque: ArrayDeque stores its elements internally in an array
Example: Add Elements Of ArrayDeque java.
import java.util.Collections; import java.util.Deque; /** * * @author manojkumar */ public class ArrayDeque { public static void main(String[] args) { //create first Queue object Deque<string> ArrayDeque1 = new java.util.ArrayDeque<string>(); //Add elements to DequeQueue ArrayDeque1.add("1"); ArrayDeque1.add("2"); ArrayDeque1.add("3"); System.out.println("Before Add, One ArrayDeque Contains : " + ArrayDeque1); Collections.addAll(ArrayDeque1, "manoj"); System.out.println("After Add, Second ArrayDeque Contains : " + ArrayDeque1); } }
Output:          Before Add, One ArrayDeque Contains : [1, 2, 3]
                      After Add, Second ArrayDeque Contains : [1, 2, 3, manoj]
Set Interface: A Set is a Interface that does not contain duplicate values in java.

1. Hashset.
2. TreeSet.
3. LinkedHashSet.

HashSet: HashSet is the best performing implementation of set interface. if stored its elements in a HashTable an does not guarantee of any type of ordering in iteration.
Example: Find Minimum element of Java HashSet Example.
import java.util.HashSet; import java.util.Collections; public class FindMinimumOfHashSetExample { public static void main(String[] args) { //create a HashSet object HashSet hashSet = new HashSet(); //Add elements to HashSet hashSet.add(new Long("9237")); hashSet.add(new Long("4298")); hashSet.add(new Long("2374")); hashSet.add(new Long("2473")); hashSet.add(new Long("3298")); /* To find minimum element of Java HashSet use, static Object min(Collection c) method of Collections class. This method returns the minimum element of Java HashSet according to its natural ordering. */ System.out.println("Minimum Element of Java HashSet is : " + hashSet); Object obj = Collections.min(hashSet); System.out.println("Minimum Element of Java HashSet is : " + obj); } }
Output:            Element of Java HashSet is : [3298, 9237, 2374, 2473, 4298]
                          Minimum Element of Java HashSet is : 2374
TreeSet: TreeSet is a Little show than HashSet and it stored its elements in a red-block tree structure. TreeSet orders its elements on the basis of their values.
Example: Add element of Java TreeSet Example.
import java.util.TreeSet; import java.util.Collections; import java.util.Set; public class GetSynchronizedSetFromTreeSetExample { public static void main(String[] args) { //create TreeSet object TreeSet<string> treeSet = new TreeSet<string>(); treeSet.add("m"); treeSet.add("n"); /* Java TreeSet is NOT synchronized. To get synchronized Set from TreeSet use static void synchronizedSet(Set set) method of Collections class. */ Set set = Collections.synchronizedSet(treeSet); System.out.println("TreeSet Output:"+set); Collections.addAll(set, "Java"); System.out.println("Add elements output:"+set); /* Use this set object to prevent any unsynchronized access to original TreeSet object. */ } }
Output:          TreeSet Output:[m, n]
                       Add elements output:[Java, m, n]
LinkedHashSet: LinkedHashSet is implemented as a Hashtable with a LinkedList running through it. it orders its elements on the basis of order in which they were inserted in the set.
Example: Add element of Java LinkedHashSet Example.
import java.util.Collections; import java.util.LinkedHashSet; import java.util.Set; public class LinkedHashSetExample { public static void main(String[] args) { //create LinkedHashSet object LinkedHashSet<string> treeSet = new LinkedHashSet<string>(); treeSet.add("m"); treeSet.add("n"); Set set = Collections.synchronizedSet(treeSet); System.out.println("LinkedHashSet Output:"+set); Collections.addAll(set, "Java"); System.out.println("Add elements output:"+set); } }
Output:                      LinkedHashSet Output:[m, n]
                                  Add elements output:[m, n, Java]