Added window examples by time and by signal

Froussios · Froussios · commit 67f14d9aa63a · 2015-05-09T16:10:14.000+02:00
diff --git a/Part 4 - Concurrency/3. Sequences of coincidence.md b/Part 4 - Concurrency/3. Sequences of coincidence.md
@@ -77,6 +77,25 @@ You can contruct windows that overlap or skip elements, just like you would with
 public final Observable<Observable<T>> window(long timespan, long timeshift, java.util.concurrent.TimeUnit unit)
 ```
 
+```java
+Observable.interval(100, TimeUnit.MILLISECONDS)
+	.take(5)
+	.window(250, 100, TimeUnit.MILLISECONDS)
+	.flatMap(o -> o.toList())
+	.subscribe(System.out::println);
+```
+Output
+```
+[0, 1]
+[0, 1, 2]
+[1, 2, 3]
+[2, 3, 4]
+[3, 4]
+[4]
+```
+
+In this example, a ne window begins every 100ms and lasts 250ms. The first window opens at time 0ms and remains open long enough to catch `[0, 1]` (interval emits the first value at time 100ms). Every subsequent window remains open long enough to catch the next 3 values, except for when the values stop.
+
 ### Window with signal
 
 Lastly, you can define windows using another observable. Every time your signaling observable emits a value, the old window closes and a new one starts.
@@ -87,6 +106,27 @@ Alternatively, to have overlapping windows, you can provide a function that uses
 
 ![](https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/window2.png)
 
+Here's an example with overlapping windows based on signaling observables
+
+```java
+Observable.interval(100, TimeUnit.MILLISECONDS)
+	.take(5)
+	.window(
+		Observable.interval(100, TimeUnit.MILLISECONDS),
+		o -> Observable.timer(250, TimeUnit.MILLISECONDS))
+	.flatMap(o -> o.toList())
+	.subscribe(System.out::println);
+```
+Output
+```
+[1, 2]
+[2, 3]
+[3, 4]
+[4]
+[]
+```
+
+This example is the same as the previous example: a new window opens every 100ms and lasts 250ms, with the exception that the first window starts at 100ms rather than 0ms. We see a difference in results, however. The window that begins at time 100ms does not catch the value that is emitted at 100ms, and the same goes for every other window. This happens because the `interval` event that begins the window fires just after the `interval` event that is the value. Even though the two events are simultaneous in theory, in practice there is no such guarantee.
 
 ## Join
 
