Java Observable.fromIterable方法代码示例

import io.reactivex.Observable; //导入方法依赖的package包/类
@Test
    public void testReactive() {
        Observable.just("Hello", "World")
                .subscribe(System.out::println);
        List<String> words = Arrays.asList(
                "the",
                "quick",
                "brown",
                "fox",
                "jumps",
                "over",
                "the",
                "lazy",
                "dog"
        );

        Observable<String> wordsObs = Observable.fromIterable(words);
        wordsObs.subscribe(System.out::println);

        Observable<Integer> range = Observable.range(1, Integer.MAX_VALUE);
//        range.subscribe(System.out::println);

        wordsObs.zipWith(range, (word, row) -> String.format("%2d. %s", row, word))
                .subscribe(System.out::println);

        wordsObs.flatMap(word -> Observable.fromArray(word.split("")))
                .sorted()
                .distinct()
                .zipWith(range, (word, row) -> String.format("%2d. %s", row, word))
                .subscribe(System.out::println);
    }
 

import io.reactivex.Observable; //导入方法依赖的package包/类
/**
 * Observable.fromIterable() is another way to create an Observable. It's
 * different than .just() - it is specifically designed to work with
 * Collections. When just is given a collection, it converts it into an
 * Observable that emits each item from the list. Let's understand how the
 * two are different more clearly.
 */
@Test
public void fromIterableShouldCreateAnObservableThatEmitsEachElementFromAnIterable() {
	
	List<String> sandwichIngredients = Arrays.asList("bread (one)", "bread (two)", "cheese", "mayo", "turkey",
			"lettuce", "pickles", "jalapenos", "Sriracha sauce");
	Observable<String> favoriteFoodsObservable = Observable.fromIterable(sandwichIngredients);
	TestObserver<String> testObserverIteratable = null; // TODO create new TestObserver and subscribe to favoriteFoodsObservable

	assertThat(testObserverIteratable.values()).hasSize(____);
	assertThat(testObserverIteratable.values()).containsAll(null);


	TestObserver<List<String>> testObserverForJust = new TestObserver<>();
	// TODO create obseverable for sandwichIngredients with just operator and subscribe testObserverForJust to it
	assertThat(testObserverForJust.values()).hasSize(1);
	assertThat(testObserverForJust.values()).contains(sandwichIngredients);
	/**
	 * ^^ As you can see here, fromIterable() & just() do very different things!
	 */
}
 

import io.reactivex.Observable; //导入方法依赖的package包/类
public Observable<Tuple2<String, Double>> processStock(List<String> stocks, Function<String, String> f) {
    Observable<String> stockNames = Observable.fromIterable(stocks);
    Observable<String> urls = stockNames.map(s -> "https://finance.google.com/finance/historical?output=csv&q=" + s);
    Observable<Optional<String>> optionalObservable = urls
            .subscribeOn(Schedulers.from(executorService))
            .flatMap(s -> {
                try {
                    return Observable.just(Optional.of(f.apply(s)));
                } catch (Throwable t) {
                    return Observable.just(Optional.<String>empty());
                }
            })

            .observeOn(Schedulers.computation())
            .map(opt -> opt.map(doc -> doc.split("\n")[1].split(",")[4]))
            .doOnNext(x -> System.out.println(">>>>" + x));
    return Observable.zip(stockNames, optionalObservable, (name, price) ->
            new Tuple2<>(name, Double.parseDouble(price.orElse("0.0"))));
}
 

import io.reactivex.Observable; //导入方法依赖的package包/类
public static void main(String[] args) {
    List<String> items =
            Arrays.asList("Alpha", "Beta", "Gamma", "Delta", "Epsilon");
    Observable<String> source = Observable.fromIterable(items);
    source.map(String::length).filter(i -> i >= 5)
            .subscribe(s -> System.out.println("RECEIVED: " + s));
}
 

import io.reactivex.Observable; //导入方法依赖的package包/类
public <T> Observable<T> executeSelect(String query, Map<String, Object> arguments, Class<T> returnType) {
    // Add in limit and offset arguments by default. The limit is increased by 1 so that we can see if there is
    // more data for the client to paginate
    //
    // There should be a RequestContext in almost all cases. An exception would be a database call made prior
    // to the request being built like the one made to authenticated the API Token
    if (arguments.get(LIMIT) == null && RequestContextAccessor.get() != null) {
        arguments.put(LIMIT, RequestContextAccessor.get().getLimit() + 1);
    }

    if (arguments.get(OFFSET) == null && RequestContextAccessor.get() != null) {
        arguments.put(OFFSET, RequestContextAccessor.get().getOffset());
    }

    LOG.debug("Running query [{}] with values [{}]", query, arguments);

    List<T> results = namedParameterJdbcTemplate.query(query, arguments, new NestedFieldRowMapper(returnType, beanMapper));

    // If the results filled the limit + 1, there are more results to paginate through.
    if (results.size() == RequestContextAccessor.get().getLimit() + 1) {
        results.remove(results.size() - 1);

        if (RequestContextAccessor.get() != null) {
            RequestContextAccessor.get().setHasAnotherDbPage(Boolean.TRUE);
        }
    }

    return Observable.fromIterable(results);
}
 

import io.reactivex.Observable; //导入方法依赖的package包/类
private static Observable<Entry> createEntries(int count) {
  List<Entry> entries = new ArrayList<>();
  for (int i = 0; i < count; i++) {
    entries.add(new Entry(22, i, i, "".getBytes()));
  }
  return Observable.fromIterable(entries);
}
 

import io.reactivex.Observable; //导入方法依赖的package包/类
public Observable<PFile> getDirectoryFiles(PFile directory) {
    List<PFile> PFiles = getFilesFromCache(directory);
    if (PFiles == null) {
        return listFiles(directory);
    }
    return Observable.fromIterable(PFiles);
}
 

import io.reactivex.Observable; //导入方法依赖的package包/类
private Function<Collection<T>, Observable<T>> toObservableFromIterable() {
    return new Function<Collection<T>, Observable<T>>() {
        @Override
        public Observable<T> apply(Collection<T> source) {
            return Observable.fromIterable(source);
        }
    };
}
 

import io.reactivex.Observable; //导入方法依赖的package包/类
public static void main(String[] args) {

        List<Beer> beers = loadCellar();  // populate the beer collection

        System.out.println("== Observable creation from an Iterable");

        Observable<Beer> observableBeer = Observable.fromIterable(beers);

        observableBeer.subscribe(
                beer -> System.out.println(beer),
                error -> System.err.println(error),
                () -> System.out.println("Streaming is over")
        );
    }
 

import io.reactivex.Observable; //导入方法依赖的package包/类
public Observable<IdentityProviderUsage> readMyDeviceLocalHistory(RoutingContext routingContext) {
    LOG.debug("Received create IdentityProvider request");

    String globalId = RequestReader.getCookieValue(routingContext, RequestReader.DEVICE_ID);
    Device device = deviceFacade.read(new DeviceQuery().setGlobalId(globalId)).blockingGet();

    return Observable.fromIterable(identityProviderUsageFacade.buildRecentHistory(device));
}
 

import io.reactivex.Observable; //导入方法依赖的package包/类
public static void main(String[] args) {

        List<Beer> beers = loadCellar();  // populate the beer collection

        // === Java 8 Stream
        System.out.println("\n== Iterating over Java 8 Stream");

        beers.stream()
                .skip(1)
                .limit(3)
                .filter(b -> "USA".equals(b.country))
                .map(b -> b.name + ": $" + b.price)
                .forEach(beer -> System.out.println(beer));

        // === RxJava Observable

        Observable<Beer> observableBeer = null;

        System.out.println("\n== Subscribing to Observable ");

        observableBeer = Observable.fromIterable(beers);

        observableBeer
                .skip(1)
                .take(3)
                .filter(b -> "USA".equals(b.country))
                .map(b -> b.name + ": $" + b.price)
                .subscribe(
                        beer -> System.out.println(beer),
                        err ->  System.out.println(err),
                        () ->   System.out.println("Streaming is complete"),
                        disposable -> System.out.println( " !!! Someone just subscribed to the beer stream!!! ")
        );
    }
 

import io.reactivex.Observable; //导入方法依赖的package包/类
private Observable<Long> countStreamForTickFetch(final long endTime) {
    final LongStream counter = LongStream
        .iterate(1, i -> i + 1)
        .map(count -> endTime - count * tickFetchMillis + 1);
    return Observable.fromIterable(counter::iterator);
}
 

import io.reactivex.Observable; //导入方法依赖的package包/类
@Override
public Observable<DeviceAccess> filter(DeviceAccessQuery query) {
    return Observable.fromIterable(deviceAccessList);
}
 

import io.reactivex.Observable; //导入方法依赖的package包/类
@Override
public Observable<Department> getDeptsRx() {
	Observable<Department> depts= Observable.fromIterable(departmentDaoImpl.getDepartments());
	return depts;
}
 

import io.reactivex.Observable; //导入方法依赖的package包/类
@Override
public Observable<Employee> getEmployeesRx() {
	Observable<Employee> publishedEmployees= Observable.fromIterable(employeeDaoImpl.getEmployees());
	return publishedEmployees;
}