String Reverse in Java 8 Using Lambdas

Writing shorter, more expressive lines of code is made possible by the Java 8 feature known as lambda expressions. You may effectively transmit code as data or treat functionality as a method argument using lambda expressions. They are frequently employed in functional programming, giving rise to a more concise technique for implementing functional interfaces.

Lambdas in Java

1. Functional Interfaces

An interface is functional if it has exactly one abstract method. For it to serve as an interface, it must have just one abstract method; it may also include default and static methods.

Examples of functional interfaces in Java are Runnable, Comparator, Consumer, Function, Predicate, etc.

2. Syntax of Lambda Expressions

A lambda expression has the following syntax:

The method's input parameters are listed in the parameter_list; parentheses can be deleted for functional interfaces with a single argument.
The method's implementation code, which may be included in a single expression or a block of code encased in curly braces, is found in the expression_body.

3. Basic Example

The following is a straightforward illustration of a lambda expression for a functional interface that accepts two numbers and returns their sum:

interface SumCalculator {
    int calculate(int a, int b);
}
public class LambdaExample {
    public static void main(String[] args) {
        SumCalculator calculator = (a, b) -> a + b;
        System.out.println(calculator.calculate(5, 7)); // Output: 12
    }
}

Output:

4. Using Lambda with Functional Interfaces

Lambdas can be utilized as a clear substitute for anonymous inner classes when interacting with functional interfaces.
You may use a lambda expression to immediately give the implementation rather than building a long unnamed inner class.

For instance, when utilizing an anonymous inner class and the Runnable functional interface

Runnable r = new Runnable() {
    public void run() {
        System.out.println("Running!");
    }
};

Using lambda expression for the same

5. Capturing Variables

Local or instance variables can be captured by lambda expressions from the scope they are contained in. These variables must be truly final (unable to be changed after being recorded).
The lambda expression supports using captured variables.

public class LambdaVariableCapture {
    public static void main(String[] args) {
        int x = 10;
        Runnable r = () -> {
            System.out.println("Value of x: " + x);
        };
        r.run(); // Output: Value of x: 10
    }
}

Output:

Value of x: 10

6. Method References

Another approach to describe lambda expressions is using method references, particularly when the lambda invokes an existing method. Code is easier to comprehend because method references are clear and simple.

There are four types of method references

Static method reference: ContainingClass::staticMethodName
Instance method reference of a particular object: obj::instanceMethodName
Instance method reference of an arbitrary object of a particular type: ContainingType::methodName
Constructor reference: ClassName::new

7. Using Lambda with Streams

For many actions on collections, including filtering, mapping, reducing, and other processes, Lambdas are frequently used in conjunction with Java Streams.
Lambdas simplify describing the actions on the stream elements, and streams offer a functional way to process data.

The critical element that revolutionized the way Java code is written is lambdas. They encourage using functional programming techniques and make code more expressive and understandable. When appropriately utilized, lambdas may significantly improve the quality of Java code and make it more scalable and manageable.

Java Program String reverse in Java 8 using lamdas

StringReverseWithLambda.java

import java.util.stream.IntStream;
import java.util.stream.Stream;
public class StringReverseWithLambda {
    public static void main(String[] args) {
        String originalString = "Hello, World!";
        IntStream charStream = originalString.chars();
        Stream<String> charStringStream = charStream.mapToObj(ch -> String.valueOf((char) ch));
        String reversedString = charStringStream.reduce((acc, ch) -> ch + acc).orElse("");
        System.out.println(reversedString); // Output: !dlroW ,olleH
    }
}

Output:

!dlroW ,olleH

Java Program without any default String input inside the code

StringReverseWithLambda.java

import java.util.Scanner;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class StringReverseWithLambda {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a string: ");
        String originalString = scanner.nextLine();
        scanner.close();
        IntStream charStream = originalString.chars();
        Stream<String> charStringStream = charStream.mapToObj(ch -> String.valueOf((char) ch));
        String reversedString = charStringStream.reduce((acc, ch) -> ch + acc).orElse("");
        System.out.println("Reversed string: " + reversedString);
    }
}

Output:

Enter a string: Character
Reversed string: retcarahC

The program will ask you to input a string into an input location while you execute it. When we enter the string and hit Enter, the application will turn it round and show the new edition. With no want to alternate the code, you may now enter something string you pick out.

Using Lambdas and Java 8 capabilities, this code example shows how to reverse a text. It is important to note that while this method is intriguing and instructive for learning about streams and lambdas, using StringBuilder or even iterating over the characters in reverse order can be more effective for string reversal jobs.

Next TopicTypes of Threads in Java

← prev next →