Maybe you are thinking too complicated by trying to find a Stream API solution. The task can be easily solved using basic Collection API operations:

List<Timeslot> timeslots;// the source

TreeSet<Timeslot> sorted=new TreeSet<>(timeslots);
if(sorted.size() != timeslots.size())
  throw new IllegalArgumentException("Every timeslot must strictly precede the following");
// get a list where every timeslot strictly precedes the following:
timeslots=new ArrayList<>(sorted);

The equality of the TreeSet’s elements is only determined by the order. So if there are duplicates according to the order, and this is what your problem is all about, they are removed when converting the list to the set. So if the size differs, there were such duplicates. If not, you can convert the sorted set back to a list, if you need a list. Otherwise, you can just continue using the set instead of the list.

It should be mentioned, since you stated to have a ordering which is not consistent with equals, that the TreeSet will also not be fully compliant with the Set contract as stated in its documentation:

Note that the ordering maintained by a set (whether or not an explicit comparator is provided) must be consistent with equals if it is to correctly implement the Set interface. […] This is so because the Set interface is defined in terms of the equals operation, but a TreeSet instance performs all element comparisons using its compareTo (or compare) method, so two elements that are deemed equal by this method are, from the standpoint of the set, equal. The behavior of a set is well-defined even if its ordering is inconsistent with equals; it just fails to obey the general contract of the Set interface.

Since your operation does not rely on the general contract of the Set interface, as there was no Set before, this is not a problem for this specific use case. Converting to a List as shown above works and so would iterating over the elements, in case you use it without conversion, i.e. don’t need specific list operations.

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

Using the Stream API (Java 8+)

boolean allEqual = list.stream().distinct().limit(2).count() <= 1

or

boolean allEqual = list.isEmpty() || list.stream().allMatch(list.get(0)::equals);

Using a Set:

boolean allEqual = new HashSet<String>(tempList).size() <= 1;

Using a loop:

boolean allEqual = true;
for (String s : list) {
    if(!s.equals(list.get(0)))
        allEqual = false;
}

Issues with OP's code

Two issues with your code:

• Since you're comparing Strings you should use !templist.get(i).equals(first) instead of !=.

• You have return true; while it should be return flag;

Apart from that, your algorithm is sound, but you could get away without the flag by doing:

String first = templist.get(0);
for (int i = 1; i < templist.size(); i++) {
    if(!templist.get(i).equals(first))
        return false;
}
return true;

Or even

String first = templist.get(0);
for (String s : templist) {
    if(!s.equals(first))
        return false;
}
return true;

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.

By far my favorite is to use the org.apache.commons.io.IOUtils helper class from the Apache Commons IO library:

IOUtils.contentEquals( is1, is2 );