static void assertStreamEquals(Stream<?> s1, Stream<?> s2) {
    Iterator<?> iter1 = s1.iterator(), iter2 = s2.iterator();
    while(iter1.hasNext() && iter2.hasNext())
        assertEquals(iter1.next(), iter2.next());
    assert !iter1.hasNext() && !iter2.hasNext();
}

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.)

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.

Let listOne.size() is N and listTwo.size() is M. Then 2-for-loops solution has complexity of O(M*N).

We can reduce it to O(M+N) by indexing listTwo by ids.

Case 1 - assuming listTwo has no objects with the same id

// pair each id with its marks
Map<String, String> marksIndex = listTwo.stream().collect(Collectors.toMap(ObjectTwo::getId, ObjectTwo::getMarks));
// go through list of `ObjectOne`s and lookup marks in the index
listOne.forEach(o1 -> o1.setScore(marksIndex.get(o1.getId())));

Case 2 - assuming listTwo has objects with the same id

    final Map<String, List<ObjectTwo>> marksIndex = listTwo.stream()
            .collect(Collectors.groupingBy(ObjectTwo::getId, Collectors.toList()));

    final List<ObjectOne> result = listOne.stream()
            .flatMap(o1 -> marksIndex.get(o1.getId()).stream().map(o2 -> {
                // make a copy of ObjectOne instance to avoid overwriting scores
                ObjectOne copy = copy(o1);
                copy.setScore(o2.getMarks());
                return copy;
            }))
            .collect(Collectors.toList());

To implement copy method you either need to create a new object and copy fields one by one, but in such cases I prefer to follow the Builder pattern. It also results in more "functional" code.

Your immediate problem is trivial to fix:

Optional<Integer> oi = nums.stream()
                           .filter(x -> x > nextNumber)
                           .findFirst();
System.out.println(oi.isPresent()? "Found: "+oi.get() : "Not found");

However, if you want to write code which optimally computes what you require it to, it is not the right approach. A far better option would be this:

OptionalInt oi = Stream.of(scn.nextLine().split(" "))
                       .mapToInt(Integer::parseInt)
                       .filter(i -> i > nextNumber)
                       .min();
System.out.println(oi.isPresent()? "Found: "+oi.getAsInt() : "Not found");

The advantage is that you never get an ArrayList involved and don't need to autobox the integers at any step, and you actually retrieve the smallest number satisfying the criterion, not the first one.

Look carefully at what you tried:

scoreboard.stream().max(Comparator.comparing(Score::getPoints).get().forEach(System::println);

Here, you're trying to create a Comparator:

Comparator.comparing(Score::getPoints).get().forEach(System::println)

and you've not balanced the parentheses; and you're using a non-existent method, System::println.

Put the parentheses in the right place:

Score maxScore = scoreboard.stream().max(Comparator.comparingInt(Score::getPoints)).get();
                                                                        // Extra  ^

Then print it:

System.out.println(maxScore);

Or, if you're not sure that the stream is non-empty:

Optional<Score> opt = scoreboard.stream().max(...);
opt.ifPresent(System.out::println);

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);