Stream.flatMap() 从 char[] 到字符流

Question

import java.util.*; 
import java.util.stream.*; 

class Playground { 

    public static void main(String[] args) 
    { 
        // Creating a character array 
        char arr[] = { '1', '2', '3', '4', '5' }; 

        // --------- Using Stream.of() --------- 
        // Will work efficiently 

        // to convert int array into Stream 
        Stream<char[]> stream = Stream.of(arr); 
        Stream<Integer> s = stream.flatMap((item)->new String(item).chars().mapToObj(a->(char)a));

        // Displaying elements in Stream 
        s.forEach(str -> System.out.print(str + " ")); 
    } 
} 

我正在尝试使用 flatMap() 将 char[] 转换为字符流，但出现以下错误

./Playground/Playground.java:14: error: incompatible types: inference variable R has incompatible bounds
        Stream<Integer> s = stream.flatMap((item)->new String(item).chars().mapToObj(a->(char)a));
                                          ^
    equality constraints: Integer
    lower bounds: U,Character
  where R,T,U are type-variables:
    R extends Object declared in method <R>flatMap(Function<? super T,? extends Stream<? extends R>>)
    T extends Object declared in interface Stream
    U extends Object declared in method <U>mapToObj(IntFunction<? extends U>)
1 error

需要帮助以了解错误以及如何完成此任务。具体如何使用 flatMap() 从 char[] 到字符流来修复这行代码。

Stream<Integer> s = stream.flatMap((item)->new String(item).chars().mapToObj(a->(char)a))

编辑：所以问题不是关于 Stream 而是关于 lambda 表达式，我在意外修复 lambda 表达式后抽搐了线路并弄乱了打字。原行是

Stream<Character> s = stream.flatMap(item->{new String(item).chars().mapToObj(a->(char)a);});

问题是 {} 中缺少 return 语句。然后我把这条线改成了

Stream<Integer> s = stream.flatMap((item)->new String(item).chars())

因为我认为 IntStream::mapToObj 造成了麻烦但是我最后忘记了 boxed() 并得到了另一个类型错误，所以我添加了 IntStream::mapToObj 并发布了问题但忘记将 Stream 类型更改回特点。我很困惑，但现在雾已经散去。谢谢你的好答案。

Answer 1

你快到了。只需将 Stream<Integer> 替换为 Stream<Character>，因为您将在代码中转换为 char。

但是，关于您的代码的问题在于您不必要地flatMapping。 Stream.of 需要一个具有引用类型的数组作为其复合类型。此外，Arrays.stream 没有char[] 的重载。你最终会流过一些保证是单个元素的东西。该元素是您的char[]。

你可以去掉flatMap操作，直接把char数组转成String。

String str = new String(arr);
Stream<Character> characterStream = str.chars().mapToObj(c -> (char) c);

Answer 2

通过这种不必要的操作绕道而行，你还不清楚你想达到什么目的。当您想通过数组流式传输时，只需从该操作开始，而不是创建单个元素流，链接 flatMap，链接另一个 map。

您的代码确实已经包含在其他操作中间使用String 构造函数在char[] 数组上进行流式传输的方法。

char[] arr = { '1', '2', '3', '4', '5' };

new String(arr).chars().forEach(i -> System.out.print(i + " "));

这将打印 Unicode 数字。当您想打印字符时，只需更改终端操作即可：

new String(arr).chars().forEach(i -> System.out.print((char)i + " "));

或

new String(arr).chars().forEach(i -> System.out.printf("%c ", i));

你也可以使用

new String(arr).chars().mapToObj(i -> (char)i).forEach(i -> System.out.print(i+" "));

但这会产生拳击开销，因为它会创建一个Stream<Character>。

---

请注意，new String(arr) 会产生复制开销，因为它会创建一个不可变对象。您可以通过使用来避免这种情况

CharBuffer.wrap(arr).chars().forEach(i -> System.out.printf("%c ", i));

当然，您可以根据需要插入任意数量的花饰，例如

Stream.of(arr)
    .flatMapToInt(array -> CharBuffer.wrap(array).chars())
    .mapToObj(i -> (char)i) // returns a Stream<Character> not Stream<Integer>
    .forEach(i -> System.out.printf("%c ", i));

但没有理由这样做。

Answer 3

您使用了Stream<Integer> 而不是Stream<Character>。如果要使用Stream<Integer>，则需要使用IntStream::boxed或mapToObj(a -> Integer.valueOf(a))，如下图：

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        char arr[] = { '1', '2', '3', '4', '5' };

        Stream<char[]> stream1 = Stream.of(arr);
        Stream<Character> chars = stream1.flatMap(item -> new String(item).chars().mapToObj(a -> (char) a));
        chars.forEach(c -> System.out.print(c + " "));

        System.out.println();

        Stream<char[]> stream2 = Stream.of(arr);
        Stream<Integer> ints = stream2.flatMap(item -> new String(item).chars().boxed());
        ints.forEach(i -> System.out.print(i + " "));

        System.out.println();

        Stream<char[]> stream3 = Stream.of(arr);
        Stream<Integer> integers = stream3.flatMap(item -> new String(item).chars().mapToObj(a -> Integer.valueOf(a)));
        integers.forEach(i -> System.out.print(i + " "));
    }
}

输出：

1 2 3 4 5 
49 50 51 52 53 
49 50 51 52 53 

Answer 4

• 您可以将 Arrays.stream() 用于除 byte、char 或 short 之外的任何数组。
• 您可以将*Stream.of() 用于任何类型* 的原始数组，其中* 是Int 或Double 或Long。
• 您可以将Stream.of() 用于任何对象数组。

以下所有工作都如上所述。

Integer[] IntegerArray = {1,2,3,4};
Arrays.stream(IntegerArray).forEach(System.out::println);
Stream.of(IntegerArray).forEach(System.out::println);

int[] intArray = {1,2,3,4};
Arrays.stream(intArray).forEach(System.out::println);
IntStream.of(intArray).forEach(System.out::println);

double[] doubleArray = {1.2,3.3,4.5,6.7};
Arrays.stream(doubleArray).forEach(System.out::println);
DoubleStream.of(doubleArray).forEach(System.out::println);

String[] stringArray = {"a","b","c","d"};
Stream.of(stringArray).forEach(System.out::println);

要解决你的实际问题，试试这个。

     // Creating a character array 
        char arr[] = { '1', '2', '3', '4', '5' }; 

        // --------- Using Stream.of() --------- 
        // Will work efficiently 

        // to convert int array into Stream 
        Stream<char[]> stream = Stream.of(arr); 


        // Displaying elements in Stream 
        s.forEach(str -> System.out.print(str + " ")); 
        Stream<Integer> s = stream.flatMapToInt((item)->(new String(item)).chars()).boxed();
        //or
        IntStream s = stream.flatMapToInt((item)->(new String(item)).chars());

        // Displaying elements in Stream 
        s.forEach(str -> System.out.print((char)str + " "));