如何使用 Lambda 和 Streams 反转 Java 8 中的单个字符串？

Question

I have one string say "Aniruddh" and I want to reverse it using lambdas and streams in Java 8. How can I do it?

Answer 1

Given a string like

String str = "Aniruddh";

the canonical solution is

String reversed = new StringBuilder(str).reverse().toString();

If, perhaps for educational purposes, you want to solve this by streaming over the string's characters, you can do it like

String reversed = str.chars()
    .mapToObj(c -> (char)c)
    .reduce("", (s,c) -> c+s, (s1,s2) -> s2+s1);

This is not only much more complicated, it also has lots of performance drawbacks.

The following solution eliminates boxing related overhead

String reversed = str.chars()
    .collect(StringBuilder::new, (b,c) -> b.insert(0,(char)c), (b1,b2) -> b1.insert(0, b2))
    .toString();

but is still less efficient as inserting into the beginning of an array based buffer implies copying all previously collected data.

So the bottom line is, for real applications, stay with the canonical solution shown at the beginning.

Answer 2

Try this for reverse a string using lambda and streams

import java.util.stream.Stream;
import java.util.stream.Collectors;

    public class Test  {


        public static void main(String[] args) {

            System.out.println(reverse("Anirudh"));;
        }
        public static String reverse(String string) {
            return Stream.of(string)
                .map(word->new StringBuilder(word).reverse())
                .collect(Collectors.joining(" "));
        }
    }

Answer 3

If you really want to do it for learning purposes, why not reverse the char array?

public static String reverse(String test) {
    return IntStream.range(0, test.length())
            .map(i -> test.charAt(test.length() - i - 1))
            .collect(StringBuilder::new, (sb, c) -> sb.append((char) c), StringBuilder::append)
            .toString();
}

Answer 4

Another approach to reversing your String. You can use an IntStream to pull the correct character out of a char array.

public static void main(String[] args) {
    char[] charArray = "Aniruddh".toCharArray();
    IntStream.range(0, charArray.length)
        .mapToObj(i -> charArray[(charArray.length - 1) - i])
        .forEach(System.out::print);
}

Answer 5

使用流实现您所要求的最简单方法可能是：

String result = Stream.of("Aniruddh").map(__ -> "hddurinA").findFirst().get();

Answer 6

Function<String, String> reverse = s -> new StringBuilder(s).reverse().toString();

Answer 7

Here is another way, doesn't seem super efficient but will explain why:

String s = "blast";
IntStream.range(0, s.length()).           // create index [0 .. s.length - 1] 
   boxed().                               // the next step requires them boxed
   sorted(Collections.reverseOrder()).    // indices in reverse order
   map(i -> String.valueOf(s.charAt(i))). // grab each index's character 
   collect(Collectors.joining());         // join each single-character String into the final String

It would be better if there was a way to append all the Characters without converting each to String and then joining them. That's why I said it doesn't seem super efficient.

Answer 8

You can use the below technique to reverse a string using stream.

String str = "Aniruddh";

Stream.iterate(str.length()-1, n-> n >= 0, n-> n-1)
        .map(input::charAt)
        .forEach(System.out::print);

Answer 9

另一种替代方法是将字符串拆分为字符串数组并在其上使用 reduce()。

Stream.of("Aniruddh".split("")).reduce("", (reversed, character) -> character + reversed);

Answer 10

Given a String of length S, reverse the whole string without reversing the individual words in it. Words are separated by dots.

String str="abcd.efg.qwerty";

String reversed = Arrays.asList(str.split("\\.")).stream().map(m -> new 
StringBuilder(m).reverse().toString()).collect(Collectors.joining("."));

System.out.println(reversed);

Answer 11

String str = "Noorus Khan";
       int len = str.length();
        IntStream.range(0, len)
                .map(i -> len - 1 - i)
                .mapToObj(j->str.charAt(j))
                .forEach(System.out::print);

output :: nahK surooN

Answer 12

Following is another approach to reverse the input String str using Java 8 streams API.

String abc = Arrays.asList(str).stream()
    .map(s -> new StringBuilder(s).reverse().toString())
    .collect(Collectors.toList()).get(0);

Answer 13

A custom collector can be handy if you want to achieve it with Stream API ( I'm treating this task exclusively as an exercise ).

Since none of the contributors of this question mentioned this possibility, here's a brief description of how to do that.

Creating a Custom Collector

You can create a custom collector either inline by using one of the versions of the static method Collector.of() or by creating a class that implements the Collector interface.

• Supplier Supplier<A> is meant to provide a mutable container which store elements of the stream. It could be a Collection , StringBuilder or any other mutable object.
• Accumulator BiConsumer<A,T> defines how to add elements into the container provided by the supplier .
• Combiner BinaryOperator<A> combiner() establishes a rule on how to merge two containers in case of parallel execution.
• Finisher Function<A,R> is meant to produce the final result by transforming the mutable container.
• Characteristics allows to provide additional information, for instance Collector.Characteristics.UNORDERED signifies that the collector does not guarantee to preserve initial order of elements when the source of the stream is ordered, which can provide better performance in parallel.

The minimum set of parameters boils down to supplier , accumulator and combiner which resembles the arguments of collect() operation with one difference - combiner argument expected by of() ( as well as the return type of the combiner() method ) is BinaryOperator<A> .

Implementations

The idea behind the first collector is to use ArrayDeque as a mutable container and add each element from the stream of code points to the front of the deque .

Portions of tasks created in parallel will result into several deques has to be combined in reversed order. Therefore, in the combiner the left deque ( containing values from closer to the start of the source string ) gets appended to the right deque ( containing values from closer to the end of the source string ), and the right deque is being returned as a result.

Finisher produces an array int[] of code point and returns a string based on it.

Collector<Integer, Deque<Integer>, String>

String source = "abcdefgh";

String reversed = source.codePoints()
    .boxed()
    .collect(Collector.of(
        ArrayDeque::new,
        Deque::addFirst,
        (Deque<Integer> left, Deque<Integer> right) -> { right.addAll(left); return right; },
        (Deque<Integer> deque) -> new String(
            deque.stream().mapToInt(Integer::intValue).toArray(),
            0,
            deque.size())
    ));

The second collector utilizes char[] as its mutable container which is being populated according to the indices of the source IntStream .

Combiner merges two arrays by peek the largest value for each position of the array.

Finisher utilizes constructor new String(char[]) to generate the resulting string.

Collector<Integer, char[], String>

String reversed = IntStream.range(0, source.length())
    .boxed()
    .collect(Collector.of(
        () -> new char[source.length()],
        (char[] arr, Integer i) -> arr[(source.length() - 1) - i] = source.charAt(i),
        (char[] left, char[] right) -> {
            for (int i = 0; i < left.length; i++) left[i] = (char) Math.max(left[i], right[i]); return left;
        },
        String::new
    ));

Output ( for string "abcdefgh" )

hgfedcba