Found 4348 Articles for Java 8

LongSupplier is a built-in functional interface from java.util.function package. This interface doesn’t expect any input but produces a long-valued output. Since LongSupplier is a functional interface, it can be used as an assignment target for lambda expression and method reference and contains only one abstract method: getAsLong().Syntax@FunctionalInterface public interface LongSupplier {  long getAsLong(); }Example of Lambda Expressionimport java.util.function.LongSupplier; public class LongSupplierLambdaTest {    public static void main(String args[]) {       LongSupplier supplier = () -> {     // lambda expression          return 75;       };       long result = supplier.getAsLong();       System.out.println(result);    } }Output75Example ... Read More

LongPredicate is a functional interface defined in java.util.function package. This interface can be used mainly for evaluating an input of type long and returns an output of type boolean. LongPredicate can be used as an assignment target for a lambda expression or method reference. It contains one abstract method: test() and three default methods: and(), negate() and or().Syntax@FunctionalInterface interface LongPredicate {  boolean test(long value); }Example of Lambda Expressionimport java.util.function.LongPredicate; public class LongPredicateLambdaTest {    public static void main(String args[]) {       LongPredicate longPredicate = (long input) -> {    // lambda expression          if(input == 50) {       ... Read More

A constructor reference is similar to method reference except that the name of a method is new. We can also create a constructor reference with an array type. For instance, if we need to create an integer array by using the constructor reference: int[]:: new, where the parameter is a length of an array.SyntaxArrayTypeName[]::newExample@FunctionalInterface interface ArrayCreator {    int[] makeArray(int number); } public class ArrayConstructorRefTest {    public static void main(String[] args) {       ArrayCreator arrayCreator = int[]::new;   // Constructor Reference for an Array       int[] intArray = arrayCreator.makeArray(10);       for(int i = 0; i < intArray.length; ... Read More

A method reference can also be applicable to constructors in Java 8. A constructor reference can be created using the class name and a new keyword. The constructor reference can be assigned to any functional interface reference that defines a method compatible with the constructor.Syntax::newExample of Constructor Reference with One Argumentimport java.util.function.*; @FunctionalInterface interface MyFunctionalInterface {    Student getStudent(String name); } public class ConstructorReferenceTest1 {    public static void main(String[] args) {       MyFunctionalInterface mf = Student::new;       Function f1 = Student::new;    // Constructor Reference       Function f2 = (name) -> new Student(name);       ... Read More

IntBinaryOperator is a functional interface in Java 8 from java.util.function package. This interface expects two parameters of type int as input and produces an int type result. IntBinaryOperator can be used as an assignment target for a lambda expression or method reference. It contains only one abstract method: applyAsInt().Syntax@FunctionalInterface public interface IntBinaryOperator {  int applyAsInt(int left, int right) }Exampleimport java.util.function.*; public class IntBinaryOperatorTest {    public static void main(String[] args) {       IntBinaryOperator test1 = (a, b) -> a + b; // lambda expression       System.out.println("Addition of two parameters: " + test1.applyAsInt(10, 20));       IntFunction test2 = new IntFunction() {     ... Read More

Function interface is a functional interface from java.util.function package. This interface expects one argument as input and produces a result. Function interface can be used as an assignment target for a lambda expression or method reference. It contains one abstract method: apply(), two default methods: andThen() and compose() and one static method: identity().Syntax@FunctionalInterface public interface Function {  R apply(T t); }Exampleimport java.util.function.Function; public class FunctionTest {    public static void main(String[] args) {       Function f1 = i -> i*4;   // lambda       System.out.println(f1.apply(3));       Function f2 = i -> i+4; // lambda   ... Read More

DoubleSupplier interface is a built-in functional interface defined in java.util.function package. This functional interface doesn’t expect any input but produces a double-valued output. DoubleSupplier interface can be used as an assignment target for lambda expression and method reference. This interface contains only one abstract method: getAsDouble().Syntax@FunctionalInterface public interface DoubleSupplier {    double getAsDouble(); }Example of Lambda Expressionimport java.util.concurrent.ThreadLocalRandom; import java.util.function.DoubleSupplier; public class DoubleSupplierLambdaTest {    public static void main(String args[]) {       DoubleSupplier getRandomDouble = () -> {    // lambda expression          double doubleVal = ThreadLocalRandom.current().nextDouble(0000, 9999);          return Math.round(doubleVal);       };       ... Read More

The functional interface is a simple interface with only one abstract method. A lambda expression can be used through a functional interface in Java 8. We can declare our own/custom functional interface by defining the Single Abstract Method (SAM) in an interface.Syntaxinterface CustomInterface {    // abtstact method }Example@FunctionalInterface interface CustomFunctionalInterface {    void display(); } public class FunctionInterfaceLambdaTest {    public static void main(String args[]) {       // Using Anonymous inner class       CustomFunctionalInterface test1 = new CustomFunctionalInterface() {          public void display() {             System.out.println("Display using Anonymous inner class");         ... Read More

ObjLongConsumer is a functional interface from java.util.function package. This interface accepts an object-valued and long-valued argument as input but doesn't produce any output. ObjLongConsumer can be used as an assignment target for lambda expression and method reference and contains only one abstract method: accept().Syntax@FunctionalInterface public interface ObjLongConsumer {  void accept(T t, long value) }Exampleimport java.util.function.ObjLongConsumer; public class ObjLongConsumerTest {    public static void main(String[] args) {       ObjLongConsumer olc = (employee, number) -> {     // lambda expression          if(employee != null) {             System.out.println("Employee Name: " + employee.getEmpName());         ... Read More

LongFunction is an in-built functional interface defined in java.util.function package. This functional interface expects a long-valued parameter as input and produces a result. LongFunction interface can be used as an assignment target for a lambda expression or method reference. It contains only one abstract method: apply().Syntax@FunctionalInterface public interface LongFunction {  R apply(long value) }Exampleimport java.util.function.LongFunction; public class LongFunctionTest {    public static void main(String[] args) {       LongFunction function1 = (long i) -> { // lambda expression          return i + i;       };       System.out.println("Using Lambda Expression: " + function1.apply(10));       LongFunction ... Read More