The `selector` can do anything that we've learned to do on observables. The usefulness of this is that a single subscription is made for the selector, which can be reused as much as needed. Without this overload, reusing the observable could lead to multiple subscriptions. There is no way to guarantee that the subscriptions would happen at the same exact time and therefore see the exact same sequence.

This method returns an `Observable<T>` instead of a `ConnectableObservable<T>`, so the connection functionality we are about to discuss does not apply there.

There are 8 overloads for `replay`.

ConnectableObservable<T> replay()

<R> Observable<R> replay(Func1<? super Observable<T>,? extends Observable<R>> selector)

<R> Observable<R> replay(Func1<? super Observable<T>,? extends Observable<R>> selector, int bufferSize)

<R> Observable<R> replay(Func1<? super Observable<T>,? extends Observable<R>> selector, int bufferSize, long time, java.util.concurrent.TimeUnit unit)

<R> Observable<R> replay(Func1<? super Observable<T>,? extends Observable<R>> selector, long time, java.util.concurrent.TimeUnit unit)

ConnectableObservable<T> replay(int bufferSize)

ConnectableObservable<T> replay(int bufferSize, long time, java.util.concurrent.TimeUnit unit)

ConnectableObservable<T> replay(long time, java.util.concurrent.TimeUnit unit)

They are different ways of providing one or more of 3 parameters: `bufferSize`, `selector` and `time` (plus `unit` for time).

* `bufferSize` determines the maximum amount of items to be stored and replayed. Upon subscription, the observable will replay the last `bufferSize` number of items. Older items are forgotten. This is useful for conserving memory.

* `time`, `unit` determines how old an element can be before being forgotten. Uopn subscription, the observable will replay items that are newer than `time`.

* `selector` will transform the replayed observable, in the same way that `publish(selector)` works.

Here's an example with `bufferSize`

ConnectableObservable<Long> source = Observable.interval(1000, TimeUnit.MILLISECONDS)

.take(5)

.replay(2);

source.connect();

Thread.sleep(4500);

source.subscribe(System.out::println);

Output

When we `connect`, the source begins emitting the sequence 0,1,2,3,4 in 1s intervals. We sleep for 4.5s before subscribing, which means that the source has emitted 0,1,2,3. 0 and 1 have fallen off the buffer, so only 2 and 3 are replayed. When 4 is emitted, we receive it normally.

When providing a time window, items fall off the buffer based on time

ConnectableObservable<Long> source = Observable.interval(1000, TimeUnit.MILLISECONDS)

.take(5)

.replay(2000, TimeUnit.MILLISECONDS);

source.connect();

Thread.sleep(4500);

source.subscribe(System.out::println);

Output