180102(화) - RxJava2 (Just)

Mobile/RxJava2 2018. 1. 2. 18:38

RxJava2

Just

just

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item)

Returns a Flowable that emits a single item and then completes.

To convert any object into a Publisher that emits that object, pass that object into the just method.

This is similar to the fromArray(java.lang.Object[]) method, except that from will convert an Iterable object into a Publisher that emits each of the items in the Iterable, one at a time, while the just method converts an Iterable into a Publisher that emits the entire Iterable as a single item.

Backpressure:: The operator honors backpressure from downstream.
Scheduler:: just does not operate by default on a particular Scheduler.

Type Parameters:: T - the type of that item
Parameters:: item - the item to emit
Returns:: a Flowable that emits value as a single item and then completes
See Also:: ReactiveX operators documentation: Just

just

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
                                                                                                                        T item2)

Converts two items into a Publisher that emits those items.

Backpressure:: The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
Scheduler:: just does not operate by default on a particular Scheduler.

Type Parameters:: T - the type of these items
Parameters:: item1 - first item; item2 - second item
Returns:: a Flowable that emits each item
See Also:: ReactiveX operators documentation: Just

just

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
                                                                                                                        T item2,
                                                                                                                        T item3)

Converts three items into a Publisher that emits those items.

Backpressure:: The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
Scheduler:: just does not operate by default on a particular Scheduler.

Type Parameters:: T - the type of these items
Parameters:: item1 - first item; item2 - second item; item3 - third item
Returns:: a Flowable that emits each item
See Also:: ReactiveX operators documentation: Just

just

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
                                                                                                                        T item2,
                                                                                                                        T item3,
                                                                                                                        T item4)

Converts four items into a Publisher that emits those items.

Backpressure:: The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
Scheduler:: just does not operate by default on a particular Scheduler.

Type Parameters:: T - the type of these items
Parameters:: item1 - first item; item2 - second item; item3 - third item; item4 - fourth item
Returns:: a Flowable that emits each item
See Also:: ReactiveX operators documentation: Just

just

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
                                                                                                                        T item2,
                                                                                                                        T item3,
                                                                                                                        T item4,
                                                                                                                        T item5)

Converts five items into a Publisher that emits those items.

Backpressure:: The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
Scheduler:: just does not operate by default on a particular Scheduler.

Type Parameters:: T - the type of these items
Parameters:: item1 - first item; item2 - second item; item3 - third item; item4 - fourth item; item5 - fifth item
Returns:: a Flowable that emits each item
See Also:: ReactiveX operators documentation: Just

just

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
                                                                                                                        T item2,
                                                                                                                        T item3,
                                                                                                                        T item4,
                                                                                                                        T item5,
                                                                                                                        T item6)

Converts six items into a Publisher that emits those items.

Backpressure:: The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
Scheduler:: just does not operate by default on a particular Scheduler.

Type Parameters:: T - the type of these items
Parameters:: item1 - first item; item2 - second item; item3 - third item; item4 - fourth item; item5 - fifth item; item6 - sixth item
Returns:: a Flowable that emits each item
See Also:: ReactiveX operators documentation: Just

just

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
                                                                                                                        T item2,
                                                                                                                        T item3,
                                                                                                                        T item4,
                                                                                                                        T item5,
                                                                                                                        T item6,
                                                                                                                        T item7)

Converts seven items into a Publisher that emits those items.

Backpressure:: The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
Scheduler:: just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of these items

Parameters:

item1 - first item

item2 - second item

item3 - third item

item4 - fourth item

item5 - fifth item

item6 - sixth item

item7 - seventh item

Returns:

a Flowable that emits each item

See Also:

ReactiveX operators documentation: Just

just

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
                                                                                                                        T item2,
                                                                                                                        T item3,
                                                                                                                        T item4,
                                                                                                                        T item5,
                                                                                                                        T item6,
                                                                                                                        T item7,
                                                                                                                        T item8)

Converts eight items into a Publisher that emits those items.

Backpressure:: The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
Scheduler:: just does not operate by default on a particular Scheduler.

Type Parameters:: T - the type of these items
Parameters:: item1 - first item; item2 - second item; item3 - third item; item4 - fourth item; item5 - fifth item; item6 - sixth item; item7 - seventh item; item8 - eighth item
Returns:: a Flowable that emits each item
See Also:: ReactiveX operators documentation: Just

just

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
                                                                                                                        T item2,
                                                                                                                        T item3,
                                                                                                                        T item4,
                                                                                                                        T item5,
                                                                                                                        T item6,
                                                                                                                        T item7,
                                                                                                                        T item8,
                                                                                                                        T item9)

Converts nine items into a Publisher that emits those items.

Backpressure:: The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
Scheduler:: just does not operate by default on a particular Scheduler.

Type Parameters:: T - the type of these items
Parameters:: item1 - first item; item2 - second item; item3 - third item; item4 - fourth item; item5 - fifth item; item6 - sixth item; item7 - seventh item; item8 - eighth item; item9 - ninth item
Returns:: a Flowable that emits each item
See Also:: ReactiveX operators documentation: Just

just

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> Flowable<T> just(T item1,
                                                                                                                        T item2,
                                                                                                                        T item3,
                                                                                                                        T item4,
                                                                                                                        T item5,
                                                                                                                        T item6,
                                                                                                                        T item7,
                                                                                                                        T item8,
                                                                                                                        T item9,
                                                                                                                        T item10)

Converts ten items into a Publisher that emits those items.

Backpressure:: The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
Scheduler:: just does not operate by default on a particular Scheduler.

Type Parameters:: T - the type of these items
Parameters:: item1 - first item; item2 - second item; item3 - third item; item4 - fourth item; item5 - fifth item; item6 - sixth item; item7 - seventh item; item8 - eighth item; item9 - ninth item; item10 - tenth item
Returns:: a Flowable that emits each item
See Also:: ReactiveX operators documentation: Just

'Mobile > RxJava2' 카테고리의 다른 글

180104(목) - RxJava2 (repeat) (0)	2018.01.04
180103(수) - RxJava2 (range) (0)	2018.01.03
171225(월) - RxJava2 (interval) (0)	2017.12.26
RxJava2 (from) (0)	2017.12.18
171215(금) - RxJava2 (empty/never/error) (0)	2017.12.15

작성자

Posted by 식빵남아

고뇌하는 식빵남아

본문