…​from an Optional<T>: Mono#justOrEmpty(Optional<T>)

…​from a potentially null T: Mono#justOrEmpty(T)

…​but lazily captured: use Mono#fromSupplier or wrap just (Flux|Mono) inside defer (Flux|Mono)

an array: Flux#fromArray

a collection or iterable: Flux#fromIterable

a range of integers: Flux#range

a Stream supplied for each Subscription: Flux#fromStream(Supplier<Stream>)

a Supplier<T>: Mono#fromSupplier

a task: Mono#fromCallable, Mono#fromRunnable

a CompletableFuture<T>: Mono#fromFuture

…​but lazily build the Throwable: error(Supplier<Throwable>) (Flux|Mono)

synchronously and one-by-one: Flux#generate

asynchronously (can also be sync), multiple emissions possible in one pass: Flux#create (Mono#create as well, without the multiple emission aspect)

on a 1-to-1 basis (eg. strings to their length): map (Flux|Mono)

on a 1-to-n basis (eg. strings to their characters): flatMap (Flux|Mono) + use a factory method

on a 1-to-n basis with programmatic behavior for each source element and/or state: handle (Flux|Mono)

running an asynchronous task for each source item (eg. urls to http request): flatMap (Flux|Mono) + an async Publisher-returning method

at the start: Flux#startWith(T…​)

at the end: Flux#concatWithValues(T…​)

into a List: collectList, collectSortedList

into a Map: collectMap, collectMultiMap

into an arbitrary container: collect

into the size of the sequence: count

by applying a function between each element (eg. running sum): reduce

into a boolean value from a predicate:

in sequential order: Flux#concat or .concatWith(other) (Flux|Mono)

in emission order (combined items emitted as they come): Flux#merge / .mergeWith(other) (Flux|Mono)

by pairing values:

by coordinating their termination:

selecting the first publisher which…​

triggered by the elements in a source sequence: switchMap (each source element is mapped to a Publisher)

triggered by the start of the next publisher in a sequence of publishers: switchOnNext

…​but at time intervals: Flux.interval(duration).flatMap(tick → myExistingPublisher)

I want a value instead: defaultIfEmpty (Flux|Mono)

I want another sequence instead: switchIfEmpty (Flux|Mono)

…​and I want the completion represented as a Mono<Void>: then (Flux|Mono)

…​and I want to wait for another task to complete at the end: thenEmpty (Flux|Mono)

…​and I want to switch to another Mono at the end: Mono#then(mono)

…​and I want to emit a single value at the end: Mono#thenReturn(T)

…​and I want to switch to a Flux at the end: thenMany (Flux|Mono)

…​until another publisher, which is derived from this value, has completed: Mono#delayUntil(Function)

…​expanding the graph breadth first: expand(Function) (Flux|Mono)

…​expanding the graph depth first: expandDeep(Function) (Flux|Mono)

get notified of / execute additional behavior (sometimes referred to as "side-effects") on:

log what happens internally: log (Flux|Mono)

each represented as Signal object:

as a line in a log: log (Flux|Mono)

based on an arbitrary criteria: filter (Flux|Mono)

restricting on the type of the emitted objects: ofType (Flux|Mono)

by ignoring the values altogether: ignoreElements (Flux.ignoreElements()|Mono.ignoreElement())

by ignoring duplicates:

by taking N elements:

by taking at most 1 element:

by skipping elements:

by sampling items:

and I want an error if the sequence is empty: Flux#single()

and I want a default value if the sequence is empty: Flux#single(T)

and I accept an empty sequence as well: Flux#singleOrEmpty

…​to replace the completion of a successful Flux: .concat(Flux.error(e))

…​to replace the emission of a successful Mono: .then(Mono.error(e))

…​if too much time elapses between onNexts: timeout (Flux|Mono)

…​lazily: error(Supplier<Throwable>) (Flux|Mono)

throwing: error (Flux|Mono)

catching an exception:

the finally block: doFinally (Flux|Mono)

the using pattern from Java 7: using (Flux|Mono) factory method

by falling back:

by retrying…​

by throwing a special IllegalStateException: Flux#onBackpressureError

by dropping excess values: Flux#onBackpressureDrop

by buffering excess values (bounded or unbounded): Flux#onBackpressureBuffer

…​with best available precision and versatility of provided data: timed (Flux|Mono)

…​as a (legacy) Tuple2<Long, T>…​

between each onNext signal: Mono#delayElement, Flux#delayElements

before the subscription happens: delaySubscription (Flux|Mono)

of size: window(int)

of time window(Duration)

of size OR time (window closes when count is reached or timeout elapsed): windowTimeout(int, Duration)

based on a predicate on elements: windowUntil

driven by an arbitrary boundary represented by onNexts in a control Publisher: window(Publisher), windowWhen

into List:

into an arbitrary "collection" type C: use variants like buffer(int, Supplier<C>)

block until I can get the first element: Flux#blockFirst

block until I can get the last element (or null if empty): Flux#blockLast

synchronously switch to an Iterable<T>: Flux#toIterable

synchronously switch to a Java 8 Stream<T>: Flux#toStream

to block until I can get the value: Mono#block

a CompletableFuture<T>: Mono#toFuture

and decide when to trigger the source with connect(): publish() (returns a ConnectableFlux)

and trigger the source immediately (late subscribers see later data): share() (Flux|Mono)

and permanently connect the source when enough subscribers have registered: .publish().autoConnect(n)

and automatically connect and cancel the source when subscribers go above/below the threshold: .publish().refCount(n)

up to n elements: cache(int)

caching latest elements seen within a Duration (Time-To-Live): cache(Duration) (Flux|Mono)

but without immediately triggering the source: Flux#replay (returns a ConnectableFlux)