generate the Map from Lists using streams

Stream API does not iterate on collections; it rather creates a stream from the source, and you cannot source one stream from two different resources.

You can use a circumventing approach, and this will do what you're looking for:

List<Person> personList = ...;  //pid, personName, personAge;
List<Address> addressList = ...;//pid, location, homeAddress;

HashMap<String, String> map = new HashMap<>();

//get the size of smaller list, as lists are of different sizes.
int size = Math.min(personList.size(), addressList.size());

IntStream.range(0, size)
        .mapToObj(e -> new SimpleEntry<>(personList.get(e).getPid(), addressList.get(e).getLocation()))
        .forEach(e -> map.put(e.getKey(), e.getValue()));

Notes:

1. Make sure you provide appropriate getters in Person and Address;
2. import java.util.AbstractMap.SimpleEntry;

It seems that two steps are needed here:

1. Build a map <pid, location> on the basis of addressList
2. Iterate through personList and use person.pid to map to the address.

In general case, a person may have several addresses which also may be duplicated, so final map may look as <pid, Set<location>>.

// 1. map pid to set of addresses
Map<String, Set<String>> addresses = addressList
        .stream()
        .collect(Collectors.groupingBy(
            Address::getPid, 
            Collectors.mapping(Address::getLocation, Collectors.toSet())
        ));

// 2. map person ids to addresses
Map<String, Set<String>> personAddresses = personList
        .stream()
        .collect(Collectors.toMap(
            Person::getPid,
            person -> addresses.get(person.getPid()), // Set<location>
            (addr1, addr2) -> addr1 // resolve possible conflicts
        ));

If it is guaranteed that the pid/addresses pairs are unique and map <pid, location> can be created, the above code may be simplified:

// 1. map pid to single address
Map<String, String> addressMap = addressList
        .stream()
        .collect(Collectors.toMap(
            Address::getPid, 
            Address::getLocation
        ));

// 2. map person ids to addresses
Map<String, String> personAddress = personList
        .stream()
        .collect(Collectors.toMap(
            Person::getPid,
            // single location, provide default value
            person -> addressMap.getOrDefault(person.getPid(), "Unknown address")
        ));

I would recommend you do it as follows:

• first stream the addressList to create an address map which has the pid as the key and the address as the value.
• then stream the personList, mapping to the id and filtering on the existence of that id in the address map.

This has two advantages.

• The contents of personList and addressList may be in any order.
• Only those ids in personList will be used, ignoring any other ids in the addressList. So the lists are not required to be one-to-one or even the same size.

First, I used two records (classes would also work exactly the same way) to house some data. For this demo, only the pertinent information is included.

record Person(String getPid) {
};
record Address(String getPid, String getLocation) {
};

Next, I create lists with the test data. Both lists will contain id's not in the other.

List<Person> personList = List.of(new Person("id1"),
        new Person("id2"), new Person("id3"), new Person("id6"));
List<Address> addressList =
        List.of(new Address("id3", "Utah"),
                new Address("id1", "Idaho"),
                new Address("id2", "Virginia"),
                new Address("id5", "New York"));

Now create a map of pid to address. If two addresses exist for the same id, only the first encountered is used.

Map<String, Address> addressMap =
        addressList.stream().collect(Collectors
                .toMap(Address::getPid, address -> address,
                        (ad1,ad2)->ad1));

Now create the final map.

• stream the personList and pull out the ids
• now filter to ensure the given id is in the address map.
• and enter the id and the location for given id in the map

Map<String, String> result = personList.stream()
        .map(Person::getPid).filter(addressMap::containsKey)
        .collect(Collectors.toMap(id -> id,
                id -> addressMap.get(id).getLocation));

result.entrySet().forEach(System.out::println);

For the test data, the following is printed.

id2=Virginia
id1=Idaho
id3=Utah