如何使用使用.map lambda表达式的操作每次使用与列表不同的值？

Question

Forgive me for the title im not sure how to articulate this problem as a question.

Anyway, my questions is this.Take this function,

function(object o, String a) { 
    stuff; 
    return new object o;
}

How would I make it so that when using the .map lambda expression I could apply this operation to each variable in the stream, in order, so that the I could call the function like this .map(l -> function(l, stringArraylist)) so that the function applies for the string in the equivalent position in its arraylist, as L is in its own stream.

Answer 1

the function applies for the string in the equivalent position in its arraylist, as L is in its own stream

This is a bit vague, but it appears you want to apply your function on pairs of elements belonging to two collections (the first collection is of some unspecified type - let's call it SomeClass - and the other is an ArrayList<String> ).

It's not entirely clear what function is supposed to do, since it's not a valid Java method, but based on the return statement I'm assuming it should return an instance of the same type as the argument o :

SomeClass function(SomeClass o, String a) { 
    // some logic 
    return some new instance of SomeClass
}

In order to pair elements of the two collections, you can create an IntStream of the indices (assuming both collections have the same number of elements).

So, assuming you have a Collection<SomeClass> and an ArrayList<String> , you can write:

Collection<SomeClass> first = ...
ArrayList<String> second = ...
IntStream.range(0,first.size())
         .mapToObj (i -> function(first.get(i),second.get(i)))
         ...

This will result in a Stream<SomeClass> created by applying function on each pair of elements. You can collect these elements into a List<SomeClass> or do any other required processing.

For example:

List<SomeClass> output = 
    IntStream.range(0,first.size())
         .mapToObj (i -> function(first.get(i),second.get(i)))
         .collect(Collectors.toList());

Answer 2

I think you ask about how to use Function<T,R> in Java 8 in map method of a certain stream. Here a little example:

List<String> list = Arrays.asList("1","2","3","4","5");
// Both functions are equivalent, I write both to clarify the concept using lambda expression.
//Function<? super String, ? extends Integer> function = stringElement -> Integer.parseInt(stringElement);
Function<? super String, ? extends Integer> function = Integer::parseInt;
list.stream().map(function);