blocks.stream()
      .map(block ‑> block.squash())
      .filter(block ‑> block.getColor() != YELLOW)
      .forEach(block ‑> block.display());

		Stream.of(1, 2, 3, 4, 5)
		      .peek((e) -> System.out.println("Stream element:" + e))
		      .filter((e)-> e>1)
		      .peek((e) -> System.out.println("Filtered element:" + e))
		      .map(String::valueOf)
		      .peek((e) -> System.out.println("Mapped element:" + e))
		      .collect(Collectors.toList());

Stream element:1
Stream element:2
Filtered element:2
Mapped element:2
Stream element:3
Filtered element:3
Mapped element:3
Stream element:4
Filtered element:4
Mapped element:4
Stream element:5
Filtered element:5
Mapped element:5

The intermediate operations are classifiable in:

Stateful
    distinct()
    sorted()
    limit (long l)
    skip (long l)

Stateless
    map (Function f)
    flatMap (Function f)
    filter (Predicate p)
    peek (Consumer c)

No storage. A stream is not a data structure that stores elements; instead, it conveys elements from a source such as a data structure, an array, a generator function, or an I/O channel, through a pipeline of computational operations.

Stream<Integer> stream = Stream.of(1, 2, 3);
		
long count = stream.count();
System.out.println(count);
//count = stream.count(); // java.lang.IllegalStateException: stream has already been operated upon or closed
		
Stream<Integer> stream2 = Stream.of(1, 2, 3);
		
Stream<Integer> stream3 = stream2.sorted();
// long count2 = stream2.count(); // java.lang.IllegalStateException: stream has already been operated upon or closed

// long count2 = stream2.count(); // java.lang.IllegalStateException: stream has already been operated upon or closed

		
Stream<Integer> stream4 = Stream.of(1, 3, 4, 0);
stream4.filter(e->e>0);
stream4.map(e->e); // Exception ...

		List<Integer> list = new ArrayList<>(100);
		for(int i=0; i<1000; i++)
			list.add(i);

		Thread t1 = new Thread(() -> {
			try {
				Thread.sleep(1000);
				for (int i=10;i<1000;i++) {
					list.add(i);
					System.out.println(Thread.currentThread().getName() + i);
				}	
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});

		t1.start();
		Thread.sleep(1000);
		list.stream().peek(i->System.out.println(Thread.currentThread().getName())).forEach(System.out::println);

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$ArrayListSpliterator.forEachRemaining(Unknown Source)

		Integer[] array = new Integer[1100];
		for(int i=0; i<100; i++)
			array[i] = i;

		Thread t1 = new Thread(() -> {
			try {
				Thread.sleep(1100);
				for (int i=100;i<1000;i++) {
					array[i] = i;
					System.out.println(Thread.currentThread().getName() + ":" + i);
				}	
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});

		t1.start();
		Thread.sleep(1000);
		Stream.of(array).peek(e->{
			try {
				Thread.sleep(1);
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}
		}).forEach(System.out::println);
		
		System.out.println(Arrays.toString(array));

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Thread-0:100
Thread-0:101
Thread-0:102
Thread-0:103

...

Thread-0:997
Thread-0:998
Thread-0:999
16
17
18
19
20
21
22

....

100
101

...

Sorting a stream is necessarily an eager/blocking operation.

sorted() is a stateful intermediate operation which has been implemented by buffering the entire contents and sorting it,
 before passing any elements to the downstream operations

List<String> result = Stream.of("java", "streams", "are", "great", "stuff")
    .filter(s -> {
                  System.out.println("filtering " + s);
                  return s.length()>=4;
                 })
    .map(s -> {
               System.out.println("mapping " + s);
               return s.toUpperCase();
              })
    .limit(3)
    .collect(Collectors.toList());
System.out.println("Result:");
result.forEach(System.out::println);

String[] source = { "java", "streams", "are", "great", "stuff"};
List<String> result = new ArrayList<>();
int limit = 3;
for(String s: source) {
    System.out.println("filtering " + s);
    if(s.length()>=4) {
        System.out.println("mapping " + s);
        String t = s.toUpperCase();
        if(limit-->0) {
            result.add(t);
        }
        else break;
    }
}

public class InvocationOrder {
	  public static void main (String[] args) {
	        IntStream stream = IntStream.range(1, 5);
	        stream = stream.peek(i -> log("starting", i)).sorted().peek(i -> log("SORT:", i))
	                       .filter(i -> { log("filtering", i);
	                                      return i % 2 == 0;})
	                       .peek(i -> log("post filtering", i));
	        log("Invoking terminal method count.");
	        log("The count is", stream.count());
	        
	        System.out.println(); 
	        	        
	        IntStream stream2 = IntStream.range(1, 5).parallel();
	        stream2 = stream2.peek(i -> log("starting", i)).sorted().peek(i -> log("SORT:", i))
	                       .filter(i -> {
	                           log("filtering", i);
	                           return i % 2 == 0;
	                       })
	                       .peek(i -> log("post filtering", i));
	        log("Invoking terminal method count.");
	        log("The count is", stream2.count());
	    }
	  
	    public static void log (Object... objects) {
	        String s = LocalTime.now().toString();
	        for (Object object : objects) {
	            s += " - " + object.toString();
	        }
	        System.out.println(s);
	        // putting a little delay so that we can see a clear difference
	        // with parallel stream.
	        try {
	            Thread.sleep(1);
	        } catch (InterruptedException e) {
	            e.printStackTrace();
	        }
	    }
}

21:07:40.734 - Invoking terminal method count.
21:07:40.741 - starting - 1
21:07:40.742 - SORT: - 1
21:07:40.743 - filtering - 1
21:07:40.744 - starting - 2
21:07:40.745 - SORT: - 2
21:07:40.746 - filtering - 2
21:07:40.747 - post filtering - 2
21:07:40.748 - starting - 3
21:07:40.749 - SORT: - 3
21:07:40.750 - filtering - 3
21:07:40.751 - starting - 4
21:07:40.752 - SORT: - 4
21:07:40.754 - filtering - 4
21:07:40.755 - post filtering - 4
21:07:40.756 - The count is - 2

21:07:40.759 - Invoking terminal method count.
21:07:40.767 - starting - 4
21:07:40.770 - starting - 3
21:07:40.772 - starting - 1
21:07:40.772 - starting - 2
21:07:40.775 - SORT: - 2
21:07:40.774 - SORT: - 3
21:07:40.776 - filtering - 2
21:07:40.776 - filtering - 3
21:07:40.777 - post filtering - 2
21:07:40.777 - SORT: - 4
21:07:40.778 - SORT: - 1
21:07:40.778 - filtering - 4
21:07:40.779 - filtering - 1
21:07:40.779 - post filtering - 4
21:07:40.780 - The count is - 2

21:10:11.934 - Invoking terminal method count.
21:10:11.955 - starting - 8
21:10:11.958 - starting - 4
21:10:11.959 - starting - 7
21:10:11.960 - starting - 1
21:10:11.974 - starting - 3
21:10:11.977 - SORT: - 1
21:10:11.978 - filtering - 1
21:10:11.979 - SORT: - 3
21:10:11.985 - filtering - 3
21:10:11.986 - SORT: - 4
21:10:11.987 - filtering - 4
21:10:11.988 - post filtering - 4
21:10:11.989 - SORT: - 7
21:10:11.990 - filtering - 7
21:10:11.993 - SORT: - 8
21:10:11.997 - filtering - 8
21:10:12.002 - post filtering - 8
21:10:12.007 - The count is - 2

21:10:12.009 - Invoking terminal method count.
21:10:12.018 - starting - 3
21:10:12.019 - starting - 1
21:10:12.020 - starting - 7
21:10:12.021 - starting - 4
21:10:12.022 - starting - 8
21:10:12.026 - SORT: - 4
21:10:12.027 - filtering - 4
21:10:12.028 - post filtering - 4
21:10:12.029 - SORT: - 8
21:10:12.030 - filtering - 8
21:10:12.036 - post filtering - 8
21:10:12.036 - SORT: - 3
21:10:12.038 - SORT: - 7
21:10:12.038 - filtering - 3
21:10:12.039 - filtering - 7
21:10:12.040 - SORT: - 1
21:10:12.041 - filtering - 1
21:10:12.042 - The count is - 2