java 8 stream groupingBy into collection of custom object

I have the following class structure

public class Store {
    private Long storeId;

	private Long masterStoreId;

	private String operatorIdentifier;
}

public class StoreInfo {

    private String operatorIdentifier;

	private Set<Long> slaveStoreIds;

	public StoreInfo(String operatorIdentifier, Set<Long> slaveStoreIds) {
		super();
		this.operatorIdentifier = operatorIdentifier;
		this.slaveStoreIds = slaveStoreIds;
	}

}

I want to collect the "List<Store" into a "Map<Long, StoreInfo>". Is it possible to do so in a single operation/iteration?

List<Store> stores;

Map<Long, Set<Long>> slaveStoresAgainstMasterStore = stores.stream().collect(Collectors
				.groupingBy(Store::getMasterStoreId, Collectors.mapping(Store::getStoreId, Collectors.toSet())));

Map<Long, StoreInfo> storeInfoAgainstMasterStore = stores.stream()
				.collect(
						Collectors
								.toMap(Store::getMasterStoreId,
										val -> new StoreInfo(val.getOperatorIdentifier(),
												slaveStoresAgainstMasterStore.get(val.getMasterStoreId())),
										(a1, a2) -> a1));

As masterStoreId and operatorIdentifier are same same in group(comfirmed in comment) you can groupingBy both creating pair of them using AbstractMap.SimpleEntry. Then using Collectors.toMap create map.

Map<Long, StoreInfo> storeInfoMap = 
    stores.stream()
          .collect(Collectors.groupingBy(
                      e -> new AbstractMap.SimpleEntry<>(e.getMasterStoreId(),
                                                        e.getOperatorIdentifier()),
                      Collectors.mapping(Store::getStoreId, Collectors.toSet())))
          .entrySet()
          .stream()
          .collect(Collectors.toMap(e -> e.getKey().getKey(),
                            e -> new StoreInfo(e.getKey().getValue(), e.getValue())));

To complete the implementation, you were attempting. You need to ensure merging capability within StoreInfo such as :

public StoreInfo(String operatorIdentifier, Long slaveStoreId) {
    this.operatorIdentifier = operatorIdentifier;
    this.slaveStoreIds = new HashSet<>();
    this.slaveStoreIds.add(slaveStoreId);
}

public static StoreInfo mergeStoreInfo(StoreInfo storeInfo1, StoreInfo storeInfo2) {
    Set<Long> slaveIds = storeInfo1.getSlaveStoreIds();
    slaveIds.addAll(storeInfo2.getSlaveStoreIds());
    return new StoreInfo(storeInfo1.getOperatorIdentifier(), slaveIds);
}

this would simplify the implementation of collector and you an invoke these correspondingly:

Map<Long, StoreInfo> storeInfoAgainstMasterStore = stores.stream()
        .collect(Collectors.toMap(Store::getMasterStoreId,
                store -> new StoreInfo(store.getOperatorIdentifier(), store.getStoreId()),
                StoreInfo::mergeStoreInfo));