What is the easiest/shortest way to convert a Java 8 Stream
into an array?
This question is related to
java
arrays
java-8
java-stream
you can use the collector like this
Stream<String> io = Stream.of("foo" , "lan" , "mql");
io.collect(Collectors.toCollection(ArrayList<String>::new));
You can do it in a few ways.All the ways are technically the same but using Lambda would simplify some of the code. Lets say we initialize a List first with String, call it persons.
List<String> persons = new ArrayList<String>(){{add("a"); add("b"); add("c");}};
Stream<String> stream = persons.stream();
Now you can use either of the following ways.
Using the Lambda Expresiion to create a new StringArray with defined size.
String[] stringArray = stream.toArray(size->new String[size]);
Using the method reference directly.
String[] stringArray = stream.toArray(String[]::new);
If you want to get an array of ints, with values from 1 to 10, from a Stream<Integer>
, there is IntStream
at your disposal.
Here we create a Stream
with a Stream.of
method and convert a Stream<Integer>
to an IntStream
using a mapToInt
. Then we can call IntStream
's toArray
method.
Stream<Integer> stream = Stream.of(1,2,3,4,5,6,7,8,9,10);
//or use this to create our stream
//Stream<Integer> stream = IntStream.rangeClosed(1, 10).boxed();
int[] array = stream.mapToInt(x -> x).toArray();
Here is the same thing, without the Stream<Integer>
, using only the IntStream
:
int[]array2 = IntStream.rangeClosed(1, 10).toArray();
You can create a custom collector that convert a stream to array.
public static <T> Collector<T, ?, T[]> toArray( IntFunction<T[]> converter )
{
return Collectors.collectingAndThen(
Collectors.toList(),
list ->list.toArray( converter.apply( list.size() ) ) );
}
and a quick use
List<String> input = Arrays.asList( ..... );
String[] result = input.stream().
.collect( CustomCollectors.**toArray**( String[]::new ) );
import java.util.List;
import java.util.stream.Stream;
class Main {
public static void main(String[] args) {
// Create a stream of strings from list of strings
Stream<String> myStreamOfStrings = List.of("lala", "foo", "bar").stream();
// Convert stream to array by using toArray method
String[] myArrayOfStrings = myStreamOfStrings.toArray(String[]::new);
// Print results
for (String string : myArrayOfStrings) {
System.out.println(string);
}
}
}
Try it out online: https://repl.it/@SmaMa/Stream-to-array
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
Integer[] integers = stream.toArray(it->new Integer[it]);
You can convert a java 8 stream to an array using this simple code block:
String[] myNewArray3 = myNewStream.toArray(String[]::new);
But let's explain things more, first, let's Create a list of string filled with three values:
String[] stringList = {"Bachiri","Taoufiq","Abderrahman"};
Create a stream from the given Array :
Stream<String> stringStream = Arrays.stream(stringList);
we can now perform some operations on this stream Ex:
Stream<String> myNewStream = stringStream.map(s -> s.toUpperCase());
and finally convert it to a java 8 Array using these methods:
1-Classic method (Functional interface)
IntFunction<String[]> intFunction = new IntFunction<String[]>() {
@Override
public String[] apply(int value) {
return new String[value];
}
};
String[] myNewArray = myNewStream.toArray(intFunction);
2 -Lambda expression
String[] myNewArray2 = myNewStream.toArray(value -> new String[value]);
3- Method reference
String[] myNewArray3 = myNewStream.toArray(String[]::new);
Method reference Explanation:
It's another way of writing a lambda expression that it's strictly equivalent to the other.
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
int[] arr= stream.mapToInt(x->x.intValue()).toArray();
Convert text to string array where separating each value by comma, and trim every field, for example:
String[] stringArray = Arrays.stream(line.split(",")).map(String::trim).toArray(String[]::new);
Using the toArray(IntFunction<A[]> generator)
method is indeed a very elegant and safe way to convert (or more correctly, collect) a Stream into an array of the same type of the Stream.
However, if the returned array's type is not important, simply using the toArray()
method is both easier and shorter.
For example:
Stream<Object> args = Stream.of(BigDecimal.ONE, "Two", 3);
System.out.printf("%s, %s, %s!", args.toArray());
Source: Stackoverflow.com