I think flatMap() is what you're looking for.

For example:

 List<AClass> allTheObjects = map.values()
         .stream()
         .flatMap(listContainer -> listContainer.lst.stream())
         .collect(Collectors.toList());

The general idea has been sketched in the comments: iterate one list, create a map whose keys are the attributes you want to join by, then iterate the other list and check if there's an entry in the map. If there is, get the value from the map and create a new object from the value of the map and the actual element of the list.

It's better to create a map from the list with the higher number of joined elements. Why? Because searching a map is O(1), no matter the size of the map. So, if you create a map from the list with the higher number of joined elements, then, when you iterate the second list (which is smaller), you'll be iterating among less elements.

Putting all this in code:

public static <B, S, J, R> List<R> join(
    List<B> bigger, 
    List<S> smaller,
    Function<B, J> biggerKeyExtractor,
    Function<S, J> smallerKeyExtractor,
    BiFunction<B, S, R> joiner) {

    Map<J, List<B>> map = new LinkedHashMap<>();
    bigger.forEach(b -> 
        map.computeIfAbsent(
                biggerKeyExtractor.apply(b),
                k -> new ArrayList<>())
            .add(b));

    List<R> result = new ArrayList<>();
    smaller.forEach(s -> {
        J key = smallerKeyExtractor.apply(s);
        List<B> bs = map.get(key);
        if (bs != null) {
            bs.forEach(b -> {
                R r = joiner.apply(b, s);
                result.add(r);
            }
        }
    });

    return result;
}

This is a generic method that joins bigger List<B> and smaller List<S> by J join keys (in your case, as the join key is a composite of String and Integer types, J will be List<Object>). It takes care of duplicates and returns a result List<R>. The method receives both lists, functions that will extract the join keys from each list and a joiner function that will create new result R elements from joined B and S elements.

Note that the map is actually a multimap. This is because there might be duplicates as per the biggerKeyExtractor join function. We use Map.computeIfAbsent to create this multimap.

You should create a class like this to store joined results:

public class JoinedResult {

    private final NameProperties properties;
    private final NameEntries entries;

    public JoinedResult(NameProperties properties, NameEntries entries) {
        this.properties = properties;
        this.entries = entries;
    }

    // TODO getters
}

Or, if you are in Java 14+, you might just use a record:

public record JoinedResult(NameProperties properties, NameEntries entries) { }

Or actually, any Pair class from out there will do, or you could even use Map.Entry.

With the result class (or record) in place, you should call the join method this way:

long propertiesSize = namePropertiesList.stream()
    .map(p -> Arrays.asList(p.getMonths(), p.getId()))
    .distinct()
    .count();
long entriesSize = nameEntriesList.steram()
    .map(e -> Arrays.asList(e.getMonths(), e.getId()))
    .distinct()
    .count();

List<JoinedResult> result = propertiesSize > entriesSize ? 
    join(namePropertiesList, 
         nameEntriesList, 
         p -> Arrays.asList(p.getMonths(), p.getId()),
         e -> Arrays.asList(e.getMonths(), e.getId()),
         JoinedResult::new)                                    :
    join(nameEntriesList, 
         namePropertiesList, 
         e -> Arrays.asList(e.getMonths(), e.getId()),
         p -> Arrays.asList(p.getMonths(), p.getId()),
         (e, p) -> new JoinedResult(p, e));

The key is to use generics and call the join method with the right arguments (they are flipped, as per the join keys size comparison).

Note 1: we can use List<Object> as the key of the map, because all Java lists implement equals and hashCode consistently (thus they can safely be used as map keys)

Note 2: if you are on Java9+, you should use List.of instead of Arrays.asList

Note 3: I haven't checked for neither null nor invalid arguments

Note 4: there is room for improvements, i.e. key extractor functions could be memoized, join keys could be reused instead of calculated more than once and multimap could have Object values for single elements and lists for duplicates, etc