java-stream，map，与对象无关的键

Question

So I have a list of integer that is insIds, from this I can get a list of ABCs, I want to map them to an entry in map (notice that we can not getInsId from Abc.getIns)

This is what I want it to be: (but since we do not have getInsId we are not able to write this way)

Map<Integer, Integer> insIdToAbcId = abcController
          .findAbcsByInsIds(insIds)
          .stream()
          .collect(Collectors.toMap(Abc::getInsId,
            Abc::getAbcId));

I am not sure how to write it in order to have the mapping relationship I want.

Known list of integer: insIds

Known function that will take insIds and return list:

abcController.findAbcsByInsIds(insIds)

And then is what I am not sure about: how to map insId to AbcId

(expect output: Map<Integer, Integer> insIdToAbcId )

Answer 1

If there's an ordered one-to-one relationship between the items in insIds and the result of findAbcsByInsIds() , you can join the lists by index:

List<Abc> abcs = abcController.findAbcsByInsIds(insIds);
Map<Integer, Integer> insIdToAbcId = IntStream.range(0, insIds.size())
        .boxed()
        .collect(Collectors.toMap(insIds::get, i -> abcs.get(i).getAbcId()));

Answer 2

This is a prime example of a problem where Stream is not the right solution.

After the findAbcsByInsIds() call, you have two lists of equal size, and you want to match them, by position, ie you need to parallel iterate them.

So do that:

List<Integer> insIds = /*...*/
List<Abc> abcList = abcController.findAbcsByInsIds(insIds);

Map<Integer, Integer> insIdToAbcId = new HashMap<>(insIds.size() * 4 / 3 + 1);
Iterator<Integer> insIter = insIds.iterator();
Iterator<Abc> abcIter = abcList.iterator();
while (insIter.hasNext())
    insIdToAbcId.put(insIter.next(), abcIter.next().getAbcId());

This code will perform well, even if lists are LinkedList .
The HashMap was preallocated to appropriate size, so resizing is eliminated, preventing need to rehash, ie for better performance.

Answer 3

Map< Integer, Integer > insIdToAbcId = findAbcsByInsIds( insIds )
            .stream( )
            .collect( HashMap::new, ( map, abc ) -> map.put( insIds.get( map.size( ) ), abc.getAbcId( ) ), ( a, b ) -> {} );

For each version to address the contract concerns about the third parameter

    Map< Integer, Integer > map = new HashMap<>(  );
    findAbcsByInsIds( insIds )
            .forEach( (abc) -> map.put( insIds.get( map.size( ) ), abc.getAbcId( ) ));

This is actually simpler and there in no need for boxing, auxiliary streams of even a collector. But about the collect method one could use an unsupported exception to make sure it is never called, should the implementation details of the underline jre change, it would not change without one's knowledge.