Java Flowable.just方法代码示例

import io.reactivex.Flowable; //导入方法依赖的package包/类
/**
 * Insert or update all
 * @param items
 * @return List of item copied from realm
 */
@Override
public Flowable<Optional<List<T>>> insertOrUpdate(List<T> items) {
    final Realm realm = Realm.getDefaultInstance();
    realm.beginTransaction();
    items = realm.copyToRealmOrUpdate(items);
    realm.commitTransaction();
    List<T> copies = realm.copyFromRealm(items);
    realm.close();

    return Flowable.just(Optional.wrap(copies));
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Test public void shouldPresent_AvailableData_IntoView() throws Exception {

        Flowable<FactAboutNumber> data = Flowable.just(
                FactAboutNumber.of("1", "1 is the first"),
                FactAboutNumber.of("2", "2 is the second")
        );

        when(usecase.fetchTrivia()).thenReturn(data);

        presenter.fetchRandomFacts();

        BehavioursRobot.with(view)
                .showLoadingFirstHideLoadingAfter()
                .disableRefreshFirstAndEnableAfter()
                .shouldNotShowEmptyState()
                .shouldNotShowErrorState()
                .shouldNotReportNetworkingError();

        DataFlowWatcher.with(onNext, onError, onCompleted).shouldReceiveItems(2);

        verify(strategist, oneTimeOnly()).applyStrategy(any());
    }
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Override
public Flowable<Integer> delete(final List<TestModel> items) {
    List<TestModel> output = new ArrayList<>();

    int found = 0;
    for (TestModel tm : models) {
        boolean foundInDeleteList = false;
        for(TestModel model : items) {
            if(tm.getId() == model.getId()) {
                foundInDeleteList = true;
                found++;
                break;
            }
        }

        if(!foundInDeleteList){
            output.add(tm);
        }
    }

    models.clear();
    models.addAll(output);
    return Flowable.just(found);
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
/**
 *
 * @author [email protected]
 * @param sources
 * @return
 */
public static Flowable<int[]> cartesian(List<Flowable<Integer>> sources) {
  if (sources.size() == 0) {
    return Flowable.empty();
  }
  Flowable<int[]> main = Flowable.just(new int[0]);
  for (int i = 0; i < sources.size(); i++) {
    int j = i;
    Flowable<Integer> o = sources.get(i).cache();
    main = main.<int[]> flatMap(v -> o.map(w -> {
      int[] arr = Arrays.copyOf(v, j + 1);
      arr[j] = w;
      return arr;
    }));
  }

  return main;
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
/**
 * Remove only these items
 * @param items
 * @return List of item copied from realm
 */
@Override
public Flowable<Integer> delete(List<T> items) {
    Realm realm = Realm.getDefaultInstance();
    realm.beginTransaction();

    for(T obj : items) {
        if(obj.isManaged()) {
            obj.deleteFromRealm(); // potentially slow
        } else {
            T managedObject = realm.copyToRealmOrUpdate(obj);
            managedObject.deleteFromRealm();
        }
    }

    realm.commitTransaction();
    realm.close();

    return Flowable.just(items.size());
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
/**
 * Creates a Flowable which is true iff all bools provided to the call are also true.
 * This method short circuits and only evaluates until the first false value.
 * @param bools
 * @return A Flowable which emits true iff all bools are true
 */
@SafeVarargs
public static Flowable<Boolean> and(Flowable<Boolean>... bools)
{
    Flowable<Boolean> previousBool = null;

    for (Flowable<Boolean> bool : bools) {
        if (previousBool == null) {
            previousBool = bool;
            continue;
        }

        previousBool = previousBool.switchMap(new AndSwitchMap(bool));
    }

    if (previousBool == null) {
        return Flowable.just(false);
    }

    return previousBool.distinctUntilChanged();
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Test
public void testCreateStream() {
    Publisher<Iterable<Integer>> sourceStream = Flowable.just(VALUES_WITHOUT_NULL);
    doReturn(sourceStream).when(discoveryService).discover(sourceStreamId);
    StreamId<Integer> flattenedStreamId = FlattenedStreamId.flatten(sourceStreamId);
    ErrorStreamPair<Integer> errorStreamPair = flattenedStreamFactory.create(flattenedStreamId, discoveryService);

    errorStreamPair.data().subscribe(testValuesSubscriber);
    errorStreamPair.error().subscribe(testErrorsSubscriber);
    testValuesSubscriber.awaitTerminalEvent(1, TimeUnit.SECONDS);

    testValuesSubscriber.assertComplete();
    testValuesSubscriber.assertValueCount(VALUES_WITHOUT_NULL.size());
    testValuesSubscriber.assertValues(VALUES_WITHOUT_NULL.toArray(new Integer[VALUES_WITHOUT_NULL.size()]));
    testErrorsSubscriber.assertNoValues();
    testErrorsSubscriber.assertNotTerminated();
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Test
public void test_just_Flowable() {

	Flowable<String> observable = Flowable.just("mango", "papaya", "guava");
	TestSubscriber<String> testSubscriber = new TestSubscriber<>();

	observable.subscribe(testSubscriber);

	List<String> items = testSubscriber.values();
	testSubscriber.assertComplete();
	testSubscriber.assertSubscribed();
	testSubscriber.assertNoErrors();
	testSubscriber.assertValueCount(3);
	testSubscriber.assertValues("mango", "papaya", "guava");

}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
/**
 * Creates a Flowable which is true iff at least one bool provided to the call is true.
 * This method short circuits and only evaluates until the first true value.
 * @param bools
 * @return A Flowable which emits true iff at least one bools is true
 */
@SafeVarargs
public static Flowable<Boolean> or(Flowable<Boolean>... bools)
{
    Flowable<Boolean> previousBool = null;

    for (Flowable<Boolean> bool : bools) {
        if (previousBool == null) {
            previousBool = bool;
            continue;
        }

        previousBool = previousBool.switchMap(new OrSwitchMap(bool));
    }

    if (previousBool == null) {
        return Flowable.just(false);
    }

    return previousBool.distinctUntilChanged();
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Override
public Publisher<Boolean> apply(Boolean aBoolean) throws Exception {
    if (!aBoolean) {
        return _bool2;
    }
    return Flowable.just(aBoolean);
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
/**
 * Gets tasks from local data source (sqlite) unless the table is new or empty. In that case it
 * uses the network data source. This is done to simplify the sample.
 */
@Override
public Flowable<Optional<Task>> getTask(@NonNull final String taskId) {
    checkNotNull(taskId);

    final Task cachedTask = getTaskWithId(taskId);

    // Respond immediately with cache if available
    if (cachedTask != null) {
        return Flowable.just(Optional.of(cachedTask));
    }

    // Load from server/persisted if needed.

    // Do in memory cache update to keep the app UI up to date
    if (mCachedTasks == null) {
        mCachedTasks = new LinkedHashMap<>();
    }

    // Is the task in the local data source? If not, query the network.
    Flowable<Optional<Task>> localTask = getTaskWithIdFromLocalRepository(taskId);
    Flowable<Optional<Task>> remoteTask = mTasksRemoteDataSource
            .getTask(taskId)
            .doOnNext(taskOptional -> {
                if (taskOptional.isPresent()) {
                    Task task = taskOptional.get();
                    mTasksLocalDataSource.saveTask(task);
                    mCachedTasks.put(task.getId(), task);
                }
            });

    return Flowable.concat(localTask, remoteTask)
            .firstElement()
            .toFlowable();
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Test
public void testStockPriceSchedulerWithFlowable() throws IOException, InterruptedException {
    Flowable<String> stockNames = Flowable.just("M", "MSFT", "T", "ORCL");
    Flowable<String> urls = stockNames.map(s -> "https://finance.google.com/finance/historical?output=csv&q=" + s);
    urls.parallel(4).runOn(Schedulers.from(executorService)).map(this::getInfoFromURL).flatMap(doc ->
            Flowable.fromArray(doc.split("\n")).skip(1).take(1)).sequential().subscribe(System.out::println);
    Thread.sleep(10000);
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Test
public void manyToMany() {
    RxGreeterGrpc.RxGreeterStub stub = RxGreeterGrpc.newRxStub(channel);
    Flowable<HelloRequest> req = Flowable.just(HelloRequest.getDefaultInstance());
    Flowable<HelloResponse> resp = stub.sayHelloBothStream(req);
    TestSubscriber<HelloResponse> test = resp.test();

    test.awaitTerminalEvent(3, TimeUnit.SECONDS);
    test.assertError(t -> t instanceof StatusRuntimeException);
    test.assertError(t -> ((StatusRuntimeException)t).getStatus().getCode() == Status.Code.CANCELLED);
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Test
public void manyToOne() {
    RxGreeterGrpc.RxGreeterStub stub = RxGreeterGrpc.newRxStub(channel);
    Flowable<String> rxRequest = Flowable.just("A", "B", "C");
    Single<String> rxResponse = stub.sayHelloReqStream(rxRequest.map(this::toRequest)).map(this::fromResponse);

    TestObserver<String> test = rxResponse.test();
    test.awaitTerminalEvent(1, TimeUnit.SECONDS);

    test.assertNoErrors();
    test.assertValue("Hello A and B and C");
}
 

import io.reactivex.Flowable; //导入方法依赖的package包/类
@Test
public void manyToOne() throws Exception {
    RxGreeterGrpc.RxGreeterStub stub = RxGreeterGrpc.newRxStub(channel);
    Flowable<HelloRequest> req = Flowable.just(
            HelloRequest.newBuilder().setName("a").build(),
            HelloRequest.newBuilder().setName("b").build(),
            HelloRequest.newBuilder().setName("c").build());

    Single<HelloResponse> resp = stub.sayHelloReqStream(req);

    TestObserver<String> testObserver = resp.map(HelloResponse::getMessage).test();
    testObserver.awaitTerminalEvent(3, TimeUnit.SECONDS);
    testObserver.assertValue("Hello a and b and c");
}