First of all, assuming you are going to create a HashMap, your key class (NameAndAge) must override equals and hashCode().

Second of all, in order to be efficient, I suggest you first create a Map<String,NameAndSalary> from the second List:

Map<String,NameAndSalary> helper =
    nameAndSalaryList.stream()
                     .collect(Collectors.toMap(NameAndSalary::getName,
                                               Function.identity()));

Finally, you can create the Map you want:

Map<NameAndAge,NameAndSalary> output = 
    nameAndAgeList.stream()
                  .collect(Collectors.toMap(Function.identity(),
                                            naa->helper.get(naa.getName())));

Instead of using an auxiliary list to hold the indices, you can have them generated by an IntStream.

Map<Double, String> map = IntStream.range(0, list1.size())
            .boxed()
            .collect(Collectors.toMap(i -> list1.get(i), i -> list2.get(i)));

Been a while since this question was asked but these days I'm partial to something like:

public static <K, V> Map<K, V> zipToMap(List<K> keys, List<V> values) {
    return IntStream.range(0, keys.size()).boxed()
            .collect(Collectors.toMap(keys::get, values::get));
}

For those unfamiliar with streams, what this does is gets an IntStream from 0 to the length, then boxes it, making it a Stream<Integer> so that it can be transformed into an object, then collects them using Collectors.toMap which takes two suppliers, one of which generates the keys, the other the values.

This could stand some validation (like requiring keys.size() be less than values.size()) but it works great as a simple solution.

EDIT: The above works great for anything with constant time lookup, but if you want something that will work on the same order (and still use this same sort of pattern) you could do something like:

public static <K, V> Map<K, V> zipToMap(List<K> keys, List<V> values) {
    Iterator<K> keyIter = keys.iterator();
    Iterator<V> valIter = values.iterator();
    return IntStream.range(0, keys.size()).boxed()
            .collect(Collectors.toMap(_i -> keyIter.next(), _i -> valIter.next()));
}

The output is the same (again, missing length checks, etc.) but the time complexity isn't dependent on the implementation of the get method for whatever list is used.

You should use somethins like:

Map<String, B> mapList2 = list2.stream().collect(Collectors.toMap(B::getCode, 
    Function.identity()); // create temporary map

Map<String,B> result = list1.stream().collect(
            LinkedHashMap::new,
            (map, a) -> map.put(
                   a.getCode(), // get code from A
                   new C(
                           mapList2.get(a.getCode()).getLocation() // get location from B
                           a.getStatus() // get status from A
                   ),  
             Map::putAll); // use LinkedHashMap to keep order       

First, create a Set using the second list. Then use the toMap collector to create the map which has the string as it's key, and it's existence in the setTwo as the value. Here's how it looks.

Set<String> setTwo = new HashSet<>(listTwo);
Map<String, Boolean> existenceMap = listOne.stream()
    .collect(Collectors.toMap(s -> s, setTwo::contains, (a, b) -> a));

One approach is to iterate over values and then iterate over the indexes of each array, matching them to the corresponding index in keys:

List<Map<String, String>> maps = values.stream()
        .map(a -> IntStream.range(0, keys.size())
                .boxed()
                .collect(Collectors.toMap(keys::get, i -> a[i])))
        .collect(Collectors.toList());

The intermediate boxing is unfortunately necessary in order to use the toMap() collector. If you want to avoid the overhead of boxed indexing, you can define a custom collector in the inner stream:

IntStream.range(0, keys.size())
    .collect(HashMap<String, String>::new,
        (m, i) -> m.put(keys.get(i), a[i]),
        HashMap::putAll)

Replace value -> true with a lambda item -> list2.contains(item) or a method reference list2::contains

itemList.stream()
        .collect(Collectors.toMap(Function.identity(), list2::contains));

and read @michalk's comment.

This should be optimal. You first build a map from the currencies to their commercial banks. Then you run through your centrals building a map from commercial to central (looked up in the first map).

    List<CurrencyItem> currenciesByCommercialBank = new ArrayList<>();
    List<CurrencyItem> currenciesByCentralBank = new ArrayList<>();
    // Build my lookup from CurrencyName to CommercialBank.
    Map<CurrencyName, CurrencyItem> commercials = currenciesByCommercialBank
            .stream()
            .collect(
                    Collectors.toMap(
                            // Map from currency name.
                            ci -> ci.getName(),
                            // To the commercial bank itself.
                            ci -> ci));
    Map<CurrencyItem, CurrencyItem> commercialToCentral = currenciesByCentralBank
            .stream()
            .collect(
                    Collectors.toMap(
                            // Map from the equivalent commercial
                            ci -> commercials.get(ci.getName()),
                            // To this central.
                            ci -> ci
                    ));

First stream the keys, and use the toMap collector. You specify what the keys and values of the map are, in terms of an element in the keys list.

The keys of the map are just the elements of the keys list, unchanged, and that the values of the map are the (inner) lists of values that contains the element in the keys list. This is where you can stream the values list and filter.

var result = keys.stream().collect(Collectors.toMap(
    key -> key, // or Function.identity()
    key -> values.stream().filter(value -> value.contains(key)).toList()
));

Just to be clear, I think your code is intended to do the following: update the name of each item in list1 to be the name of any item in list2 that has the same ID. There doesn't seem to be anything checking if the names of items in list1 are null.

If that's correct, then:

list2.forEach(obj2 -> list1.stream()
     .filter(obj1 -> obj1.getId().equals(obj2.getId()))
     .forEach(obj1 -> obj1.setName(obj2.getName()));

If you want to check if name is null, then add a new filter before setting the name:

    .filter(Objects::isNull)

As has been suggested, using a Map<String,List<Employee>> is probably what you want. I constructed a small class and an example to illustrate the process.

      List<Employee> emps = List.of(
            new Employee("001", "Jim"),
            new Employee("002", "Bob"),
            new Employee("001", "June"),
            new Employee("002", "Jean"));

     // For each employee, using departmentId as the key, construct
     // a map containing lists of all employees that have that ID

      Map<String, List<Employee>> empMap = 
          emps
              .stream()
              .collect(
                  Collectors.groupingBy(emp -> emp.departmentId)
              );

      for (Entry<?, ?> e : empMap.entrySet()) {
         System.out.println(e.getKey() + "-->" + e.getValue());
      }



      class Employee {
          public String departmentId;
          public String name;
    
          public Employee(String departmentId, String name) {
             this.departmentId = departmentId;
             this.name = name;
          }
          public String toString() {
             return "(" + departmentId + " " + name + ")";
          }
       }

This displays

001-->[(001 Jim), (001 June)]
002-->[(002 Bob), (002 Jean)]

Another option, which would do the exact same thing is as follows:

This creates an empty map. Then it iterates over the list of employees and computes whether the value for the key exists. If it does, it returns the list and adds the entry to that list. If it doesn't, it then creates the new ArrayList and then adds the employee for that list, storing the list in the provided key.

     Map<String, List<Employee>> emp2 = new HashMap<>();
         for (Employee emp : emps) {
            emp2.compute(emp.departmentId,
               (ID, list) -> list == null ? new ArrayList<>()
                     : list).add(emp);
      }

In this case my preference would be the first method.