Combining to operations using java streams

I'm doing the below two operations

1. Iterating through a list of Objects and creating a map of String, Boolean based on a condition.

		Map<String,Boolean> myMap = new HashMap<>();
		Iterator<Person> iterator = personList.iterator();
			while (iterator.hasNext()) {
				Person person = iterator.next();
				if (isValidperson(person)) {
					if (person.getName() != null) {
						myMap.put(person.getName(), true);
					} else {
						myMap.put(person.getName(), false);
					}
				}
			}

Now Im checking a list of Names against that map that I created above and if the value is true then adding to a final list

			List<String> refinedList = new ArrayList<>();
			for (String name : nameList) {
				if (myMap.get(name) != null && myMap.get(name)) {
					refinedList.add(name);
				}
			}

I need to simplify the logic using Java streams. The above works fine otherwise.

In the first operation you are filtering out all the non-valid persons, and collecting the valid persons to a map, so:

Map<String,Boolean> myMap = personList.stream()
    .filter(YourClass::isValidPerson)
    .collect(Collectors.toMap(x -> x.getName(), x -> x.getName() != null))

But really though, the map is going to have at most one false entry, since you can't add multiple nulls into a HashMap, so there isn't much point in using a HashMap at all.

I suggest using a HashSet:

Set<String> mySet = personList.stream()
    .filter(YourClass::isValidPerson)
    .map(Person::getName)
    .filter(Objects::nonNull)
    .collect(Collectors.toSet())

And then you can easily check contains with O(1) time:

List<String> refinedList = nameList.stream().filter(mySet::contains).collect(Collectors.toList());

You can directly filter the list by checking contains in nameList and collect the names in list

List<String> refinedList = 
    personList.stream()
              .filter(e -> isValidperson(e))
              .map(e -> e.getName())
              .filter(Objects::nonNull)
              .distinct()
              .filter(e -> nameList.contains(e))
              .collect(Collectors.toList());

And it better to create a set from nameList to make the contains() operation faster in O(1)

Set<String> nameSet = new HashSet<String>(nameList);

Note: This will works if nameList doesn't contains duplicate.

This should work.

First, create a list of People.

List<Person> personList = List.of(new Person("Joe"),
		new Person(null), new Person("Barb"), new Person("Anne"), new Person("Gary"));

Then the nameList. Note it is best to put this in a set to

1. avoid duplicates, and
2. make the lookup process more efficient.

Set<String> nameSet = Set.of("Joe", "Anne", "Ralph");

Now this works by

• filtering on a valid vs invalid person.
• mapping those people to a name
• filtering on whether null and then if the name is in the set of names
• and placing in a list.

Note: In some cases, lambdas could be replaced by Method References depending on method types and calling contexts.

List<String> names = personList.stream()
		.filter(person -> isValidperson(person))
		.map(Person::getName)
		.filter(name -> name != null && nameSet.contains(name))
		.collect(Collectors.toList());
				
System.out.println(names);

Prints

[Joe, Anne]

Dummy method since criteria not provided

public static boolean isValidperson(Person person) {
	return true;
}

Simple person class

class Person {
	String name;
	
	public Person(String name) {
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
}

</details>