Since Java 8, there are some standard options to do this in JDK:

Collection<E> in = ...
Object[] mapped = in.stream().map(e -> doMap(e)).toArray();
// or
List<E> mapped = in.stream().map(e -> doMap(e)).collect(Collectors.toList());

See java.util.Collection.stream() and java.util.stream.Collectors.toList().

The function Function<? super T,? extends R> mapper of the map method basically represents any function taking one parameter and returning a value so in this specific case the lambda p -> new Student(p.getId(), p.getName()) is a function taking a Person p and returning a Student hence fits into that perfectly.

To look at it another way, the lambda is equivalent to:

.map(new Function<Person, Student>() {
     @Override
      public Student apply(Person p) {
            return new Student(p.getId(), p.getName());
      }
})

You can do it with a simple function that accepts String and a Function<String, T> that will convert every string element using this function. The good news is that this function may return any type you want: Integer, Double, BigDecimal, String or any other type you want. In below example I use a method reference like:

• Integer::valueOf to convert elements to Integer values
• Double::valueOf to convert elements to Double values
• String::valueOf to convert elements to String values

Consider following example:

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;

public class ParsingStringTest {

    public static void main(String[] args) {
        String str = "1, , 3, 4, 5, , 7, sasd, aaa, 0";

        List<Double> doubles = parse(str, Double::valueOf);
        List<Integer> integers = parse(str, Integer::valueOf);
        List<String> strings = parse(str, String::valueOf);

        System.out.println(doubles);
        System.out.println(integers);
        System.out.println(strings);

        Double[] array = doubles.toArray(new Double[doubles.size()]);

        System.out.println(Arrays.toString(array));
    }

    public static <T> List<T> parse(String str, Function<String, T> parseFunction) {
        return Arrays.stream(str.split(","))
                .filter(s -> !s.isEmpty())
                .map(s -> {
                    try {
                        return parseFunction.apply(s.trim());
                    } catch (Exception e) {}
                    return null;
                })
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
    }
}

Console output for following example is:

[1.0, 3.0, 4.0, 5.0, 7.0, 0.0]
[1, 3, 4, 5, 7, 0]
[1, , 3, 4, 5, , 7, sasd, aaa, 0]
[1.0, 3.0, 4.0, 5.0, 7.0, 0.0]

I hope it helps.

strings.stream().map(s->map.put(s, s));

does nothing, since the stream pipeline is not processed until you execute a terminal operation. Therefore the Map remains empty.

Adding a terminal operation to the stream pipeline will cause map.put(s, s) to be executed for each element of the Stream required by the terminal operation (some terminal operations require just one element, while others require all elements of the Stream).

On the other hand, the second stream pipeline:

strings.stream().forEach(s->map.put(s, s));

ends with a terminal operation - forEach - which is executed for each element of the Stream.

That said, both snippets are misusing Streams. In order to populate a Collection or a Map based on the contents of the Stream, you should use collect(), which can create a Map or a Collection and populate it however you like. forEach and map have different purposes.

For example, to create a Map:

List<String> strings = Lists.newArrayList("1", "2");
Map<String, String> map = strings.stream()
                                 .collect(Collectors.toMap(Function.identity(),
                                                           Function.identity()));
System.out.println(map);