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

我有一个字符串是

“Aniruddh”

，我想在Java8中使用lambdas和streams来反转它。我该怎么做呢？

尝试使用lambda和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(" "));
        }
    }

---

另一种反转字符串的方法。您可以使用IntStream从

char

数组中提取正确的字符

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);
}

如果您真的想学习，为什么不反转char数组呢

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();
}

---

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

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

给定一个字符串

String str = "Aniruddh";

正则解是

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

如果出于教育目的，您希望通过对字符串的字符进行流式处理来解决这个问题，您可以这样做

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

这不仅要复杂得多，而且还有许多性能缺陷

以下解决方案消除了装箱相关的开销

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

但效率仍然较低，因为插入基于数组的缓冲区的开头意味着复制以前收集的所有数据

因此，对于真正的应用程序，底线是使用开头所示的规范解决方案。

函数reverse=s->new StringBuilder（s）.reverse（）.toString（）；
Function<String, String> reverse = s -> new StringBuilder(s).reverse().toString();

这里有另一种方法，似乎效率不高，但将解释原因：

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

---

如果有一种附加所有字符的方法，而不将每个字符转换为

字符串

，然后将它们连接起来，那就更好了。这就是为什么我说它似乎效率不高。

另一种方法是将字符串拆分为一个字符串数组，并对其使用reduce（）

---

给定长度为S的字符串，反转整个字符串，而不反转其中的单个单词。单词用点隔开

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);

---

a） 到目前为止你试过什么？b） 你想重新发明轮子吗？你为什么坚持使用lambdas和streams？欢迎光临！这可能值得一看，其中有一些关于如何提出一个伟大的问题，让你找到你想要的答案的提示。为什么要再次发明轮子？无法使用库函数？？有点像是对@satya的观点的证明。。。在这种情况下，当

新建StringBuilder（word）.reverse（）提供所需效果时，我们真的需要使用streams或lamdas吗？嗯，这是一种过度工程化的方式，通过
reduce
：）即使这是一个有效的答案，你最好对正在发生的事情进行评论，并解释一下你的代码。请解释你的答案。
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);