There cannot be a simpler solution:

• To know the duplicated ids, you must iterate over the entire collection.
• To print all the persons with duplicated ids, you must keep their full list.

As such, you will need to load the entire collection of persons in memory. There's no way around that. If you needed only the duplicate ids but not the Person objects, then you could keep just the ids with their counts, and throw away the Person objects as you go after use, that would be more efficient. (But that's not the case here.)

In any case, your solution can be more concise if you skip the intermediary map variable with the mapping of ids to lists of users:

people.stream()
        .collect(Collectors.groupingBy(Person::getId)).values().stream()
        .filter(peopleWithSameId -> peopleWithSameId.size() > 1)
        .forEach(peopleWithSameId -> System.out.println("People with identical IDs: " + peopleWithSameId));

Btw, in case you're wondering if the .stream() there could be .parallelStream(), it would be pointless, due to the synchronization in the println method of System.out (a PrintStream). (And without synchronization println wouldn't be thread safe anyway.)

You could use IntStream

IntStream.range(0, listA.size())
    .map(index -> 
        new RecordB(listA.get(index).getId(), listA.get(index).getValue(),  listA.get(index).getValue() - (index > 0 ? listA.get(index - 1).getValue() : 0))
    )
    .collect(Collectors.toList())
    

Let's run through each part of the code. First, createSharedListViaStream:

public static List<SchoolObj> createSharedListViaStream(List<SchoolObj> listOne, List<SchoolObj> listTwo)
{
    // We create a stream of elements from the first list.
    List<SchoolObj> listOneList = listOne.stream()
    // We select any elements such that in the stream of elements from the second list
    .filter(two -> listTwo.stream()
    // there is an element that has the same name and school as this element,
        .anyMatch(one -> one.getName().equals(two.getName()) 
            && two.getSchool().equals(one.getSchool())))
    // and collect all matching elements from the first list into a new list.
    .collect(Collectors.toList());
    // We return the collected list.
    return listOneList;
}

After running through the code, it does exactly what you want it to do. Now, let's run through createSharedListViaLoop:

public static List<SchoolObj> createSharedListViaLoop(List<SchoolObj> listOne, List<SchoolObj> listTwo)
{
    // We build up a result by...
    List<SchoolObj> result = new ArrayList<SchoolObj>();
    // going through each element in the first list,
    for (SchoolObj one : listOne)
    {
    // going through each element in the second list,
        for (SchoolObj two : listTwo)
        {
    // and collecting the first list's element if it matches the second list's element.
            if (one.getName().equals(two.getName()) && one.getSchool().equals(two.getSchool()))
            {
                result.add(one);
            }
        }
    }
    // We return the collected list
    return result;
}

So far, so good... right? In fact, your code in createSharedListViaStream is fundamentally correct; instead, it is your createSharedListViaLoop that may be causing discrepancies in output.

Think about the following set of inputs:
List1 = [SchoolObj("nameA","SchoolX"), SchoolObj("nameC","SchoolZ")]
List2 = [SchoolObj("nameA","SchoolX"), SchoolObj("nameA","SchoolX"), SchoolObj("nameB","SchoolY")]

Here, createSharedListViaStream will return the only element of the first list that appears in both lists: SchoolObj("nameA","SchoolX"). However, createSharedListViaLoop will return the following list: [SchoolObj("nameA","SchoolX"),SchoolObj("nameA","SchoolX")]. More precisely, createSharedListViaLoop will collect the correct object, but it will do so twice. I suspect this to be the reason for the output of createSharedListViaStream to be "incorrect" based on comparison to the output of createSharedListViaLoop.

The reason that createSharedListViaLoop does this duplication is based on the lack of termination of its inner for loop. Although we iterate over all elements of the first list to check if they are present in the second, finding a single match will suffice to add the element to the result. We can avoid redundant element addition by changing the inner loop to the following:

for (SchoolObj one : listOne)
    {
    for (SchoolObj two : listTwo)
    {
        if (one.getName().equals(two.getName()) && one.getSchool().equals(two.getSchool()))
        {
            result.add(one);
            break;
        }
    }
}

Additionally, if you don't want duplicate Objects in your list (by location in memory), you can use distinct like so:

List<SchoolObj> result = ...;
result = result.stream().distinct().collect(Collectors.toList());

As a final caution, the above will keep the results distinct in the following scenario:

List<SchoolObj> list = new ArrayList<>();
SchoolObj duplicate = new SchoolObj("nameC", "schoolD");
listOne.add(duplicate);
listOne.add(duplicate);
list.stream().distinct().forEach(System.out::println); 
// prints:
// nameC schoolD

However, it will not work in the following scenario, unless you override the equals method for SchoolObj:

List<SchoolObj> list = new ArrayList<>();
listOne.add(new SchoolObj("nameC", "schoolD"));
listOne.add(new SchoolObj("nameC", "schoolD"));
list.stream().distinct().forEach(System.out::println); 
// prints (unless Object::equals overridden)
// nameC schoolD
// nameC schoolD

My free StreamEx library allows you to process the pairs of the stream elements using additional pairMap intermediate operation. Like this:

StreamEx.of(input).pairMap((current, next) -> doSomethingWith(current, next));

Where input is a Collection, array or Stream. For example, this way you can easily check whether input is sorted:

boolean isSorted = StreamEx.of(input)
                           .pairMap((current, next) -> next.compareTo(current))
                           .allMatch(cmp -> cmp >= 0);

There's also forPairs terminal operation which is a forEach analog to all pairs of input elements:

StreamEx.of(input).forPairs((current, next) -> doSomethingWith(current, next));

These features work nicely with any stream source (either random access or not) and fully support the parallel streams.

It is very important to understand that the streaming api provided by Java is not just an API, but a different programming paradigm as well. When you use streams you need to embrace the paradigm. You tell streams what you want to achieve, but not how you want to achieve it. And, as with many other things, using streams is not always the best solution. Sometimes, using plain old foor loops makes the code easier to read and probably perform better, too.

Using Streams

If you want to use streams in this example, you could do something similar as below.

As far as I can tell, you are trying to find elements that (based on some criteria) are the same. In other words, you want to group elements based on the value of a property of the Model object.

Let's say our Model class looks like this:

public class Model {
    private int id;
    private String name;

    public Model(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

The example below shows how to group elements of a list of models based on their names.

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class CompareItems {

    public static void main(String[] args) {
        List<Model> items = Arrays.asList(
                new Model(1, "model_1"), new Model(2, "model_2"), new Model(3, "model_1"),
                new Model(4, "model_3"), new Model(5, "model_2"), new Model(6, "model_2"));

        Map<String, Set<Integer>> result = 
                items.stream()
                .collect(Collectors.groupingBy(Model::getName, Collectors.mapping(Model::getId, Collectors.toSet())));

        System.out.println(result);
    }
}

When you print the result object, you will get this:

{model_1=[1, 3], model_3=[4], model_2=[2, 5, 6]}

In the result object you have the name of a model and ID-s of all model objects that have the same name.

Depending on what you want to do, you can then apply the changes to each group by iterating over the result object.

You don't need to compare

List<Integer> c = new ArrayList<>(a);
c.removeAll(b);

And if you don't mind loosing the original list data

a.removeAll(b);

To retrieve a list of strings that start with a particular letter/word:

List<String> resultSet = myList.stream()
                .filter(x -> x.startsWith("a"))
                .collect(Collectors.toList());

To maintain a record of all strings that have the same length, then consider using a groupingBy collector.

 Map<Integer, List<String>> resultSet = myList.stream()
            .collect(Collectors.groupingBy(String::length));

if you know exactly the length of the strings you're interested in then you can do:

List<String> resultSet = myList.stream()
                .filter(x -> x.length() == 5)
                .collect(Collectors.toList());

Also, you can combine the two filter operations to maintain a list of strings that either have specific length or a start with a specific word/letter:

List<String> resultSet = myList.stream()
                               .filter(x -> x.startsWith("a") ||
                                         x.length() == 5)
                               .collect(Collectors.toList());

You can make the code shorter with filter and count, but using loops is cleaner here. Streams are not always the solution.

return Arrays.asList(
    IntStream.range(0, Math.min(a.size(), b.size())).filter(i -> a.get(i) > b.get(i)).count(),
    IntStream.range(0, Math.min(a.size(), b.size())).filter(i -> a.get(i) < b.get(i)).count()
);

Your question’s code does not reflect what you describe in the comments. In the comments you say that all names should be present and the size should match, in other words, only the order may be different.

Your code is

List<Person> people = getPeopleFromDatabasePseudoMethod();
List<String> expectedValues = Arrays.asList("john", "joe", "bill");

assertTrue(people.stream().map(person -> person.getName())
                 .collect(Collectors.toList()).containsAll(expectedValues));

which lacks a test for the size of people, in other words allows duplicates. Further, using containsAll combining two Lists in very inefficient. It’s much better if you use a collection type which reflects you intention, i.e. has no duplicates, does not care about an order and has an efficient lookup:

Set<String> expectedNames=new HashSet<>(expectedValues);
assertTrue(people.stream().map(Person::getName)
                 .collect(Collectors.toSet()).equals(expectedNames));

with this solution you don’t need to test for the size manually, it is already implied that the sets have the same size if they match, only the order may be different.

There is a solution which does not require collecting the names of persons:

Set<String> expectedNames=new HashSet<>(expectedValues);
assertTrue(people.stream().allMatch(p->expectedNames.remove(p.getName()))
           && expectedNames.isEmpty());

but it only works if expectedNames is a temporary set created out of the static collection of expected names. As soon as you decide to replace your static collection by a Set, the first solution doesn’t require a temporary set and the latter has no advantage over it.

You can just add another condition in you .filter() to only return the results which exists in your searchList once you filter the version.

It's slightly better to convert the searchList to a HashSet as you'll bring down the complexity of searching the companies from O(n) to O(1) and it'll also take care of removing any duplicate values you might have. It's even better to pass in the HashSet instead of a list (if you have control over the interface design).

Here is a snippet where I'm first converting the searchList to a set and then adding a new condition in .filter() to only return the companies which are present in the searchList.

public List<Company> getCompanies(String country, List<String> searchList, String version) {
  // Convert the given search list to a set
  final Set<String> searchQueries = new HashSet<>(searchList);
  List<Company> result = countriesByCountryCache.getUnchecked(country)
    .stream()
    .filter(s -> version.compareTo(s.getVersion()) >= 0 && searchQueries.contains(s.getName()))
    .collect(Collectors.toList());

  return result;
}