Java BiFunction类代码示例

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    recyclerView = (RecyclerView) findViewById(R.id.recyclerview);

    recyclerView.setLayoutManager(new LinearLayoutManager(getBaseContext()));
    adapter = new Adapter();
    recyclerView.setAdapter(adapter);

    loadWithRetroJsoup();

    Observable.zip(
            Observable.just(""),
            Observable.just("&"),
            new BiFunction<String, String, String>(){

                @Override
                public String apply(@NonNull String s, @NonNull String s2) throws Exception {
                    return null;
                }
            }
    );
}
 

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
@Test
public void reduceWithMultipleItemsThenReturnFunctionResult() {
    boolean result = new Collector<Boolean>(configuration)
            .and(true)
            .and(false)
            .and(true)
            .reduce(new BiFunction<Boolean, Boolean, Boolean>() {

                @Override
                public Boolean apply(@NonNull Boolean itemOne, @NonNull Boolean itemTwo) {
                    return itemOne.equals(itemTwo);
                }
            })
            .call();

    assertFalse(result);
}
 

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
/**
 * Chains another step to be performed after this step completes. If the previous step results in
 * an error and does not emit a new actionable item, future chained onStep calls will not be
 * called.
 *
 * @param func to return the next step when this current step completes. This function will
 *     receive the result of the previous step and the next actionable item to take an action on.
 * @param <TNewValueType> the value type returned by the next step.
 * @param <TNewActionableItem> the actionable item type returned by the next step.
 * @return a {@link Step} to chain more calls to.
 */
public <TNewValueType, TNewActionableItem extends ActionableItem>
    Step<TNewValueType, TNewActionableItem> onStep(
        final BiFunction<T, A, Step<TNewValueType, TNewActionableItem>> func) {
  return new Step<>(
      asObservable()
          .flatMap(
              new Function<
                  Optional<Data<T, A>>,
                  Observable<Optional<Data<TNewValueType, TNewActionableItem>>>>() {
                @Override
                public Observable<Optional<Data<TNewValueType, TNewActionableItem>>> apply(
                    Optional<Data<T, A>> dataOptional) throws Exception {
                  if (dataOptional.isPresent()) {
                    Data<T, A> data = dataOptional.get();
                    return func.apply(data.value, data.actionableItem).asObservable();
                  } else {
                    return Observable.just(
                        Optional.<Data<TNewValueType, TNewActionableItem>>absent());
                  }
                }
              })
          .singleOrError());
}
 

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
private void scanWith(){
    getObservable()
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .scanWith(new Callable<Integer>() {//提供初始值的函数
                @Override
                public Integer call() throws Exception {
                    return 2;
                }
            }, new BiFunction<Integer, Integer, Integer>() {
                @Override
                public Integer apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {
                    return integer + integer2;
                }
            }).subscribe(getObserver());
}
 

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
@Override
public Single<Metadata> generateDefault() {
  final int[] zMinMax = getMaxMin(tileFilenames(directory));
  return FilesystemUtil
      .getTiles(new File(directory, String.valueOf(zMinMax[1])).getAbsolutePath(), 2)
      .map(FilesystemUtil::toZxy).reduce(UNDEFINED_ZXY, new BiFunction<int[], int[], int[]>() {
        @Override
        public int[] apply(int[] aa, int[] bb) throws Exception {
          return aa == UNDEFINED_ZXY ? (bb == UNDEFINED_ZXY ? UNDEFINED_ZXY : bb)
              : new int[] {Math.max(aa[0], bb[0]), Math.max(aa[1], bb[1]),
              Math.max(aa[2], bb[2])};
        }
      }).map(zxy -> {
        if (zxy == UNDEFINED_ZXY) {
          return new Metadata.Builder().build();
        }
        // TODO should be able to translate tile coordinates to
        // bounds shortly!
        return new Metadata.Builder().setMinZoom(zMinMax[0]).setMaxZoom(zMinMax[1]).build();
      }).toObservable().singleOrError();
}
 

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
@NonNull
private BiFunction<UIModel<S>, Result<?>, UIModel<S>> reducer() {
    return (currentUIModel, result) -> {
        String event = result.getEvent();
        S bundle = currentUIModel.getBundle();
        if (result.isLoading()) {
            currentUIModel = loadingState(create(event, bundle));
        } else if (result.isSuccessful()) {
            currentUIModel = successState(create(event,
                    stateReducer().reduce(result.getBundle(), event, bundle)));
        } else {
            currentUIModel = errorState(result.getThrowable(), create(event, bundle));
        }
        return currentUIModel;
    };
}
 

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
DifferentialFlowableList(Flowable<List<T>> list, boolean detectMoves)
{
    _detectMoves = detectMoves;
    _diffTransform = list
            .map(new Function<List<T>, Update<T>>() {
                @Override
                public Update<T> apply(List<T> ts) {
                    return new Update<>(ts, Change.reloaded());
                }
            })
            .scan(new BiFunction<Update<T>, Update<T>, Update<T>>() {
                @Override
                public Update<T> apply(Update<T> previous, Update<T> next) {
                    if (previous == null) {
                        return next;
                    }

                    List<Change> changes = computeDiff(previous.list, next.list);

                    _previousList = next.list;

                    return new Update<>(next.list, changes);
                }
            });
}
 

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
public static <T, R extends Number> FlowableTransformer<T, Pair<T, Statistics>> collectStats(
        final Function<? super T, ? extends R> function) {
    return new FlowableTransformer<T, Pair<T, Statistics>>() {

        @Override
        public Flowable<Pair<T, Statistics>> apply(Flowable<T> source) {
            return source.scan(Pair.create((T) null, Statistics.create()),
                    new BiFunction<Pair<T, Statistics>, T, Pair<T, Statistics>>() {
                        @Override
                        public Pair<T, Statistics> apply(Pair<T, Statistics> pair, T t) throws Exception {
                            return Pair.create(t, pair.b().add(function.apply(t)));
                        }
                    }).skip(1);
        }
    };
}
 

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
@Override
public Observable<?> apply(Observable<? extends Throwable> flowable) throws Exception {
    return flowable.zipWith(Observable.range(1, count + 1), new BiFunction<Throwable, Integer, Wrapper>() {
        @Override
        public Wrapper apply(Throwable throwable, Integer integer) throws Exception {
            return new Wrapper(throwable, integer);
        }
    }).flatMap(wrapper -> {
        if ((wrapper.throwable instanceof ConnectException
                || wrapper.throwable instanceof SocketTimeoutException
                || wrapper.throwable instanceof TimeoutException)
                && wrapper.index < count + 1) {
            return Observable.timer(delay + (wrapper.index - 1) * delay, TimeUnit.MILLISECONDS);
        }
        return Observable.error(wrapper.throwable);
    } );
}
 

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
@Test
public void testElementsList() throws Exception {
    List<TestObject> elements = new ArrayList<>();
    elements.add(new TestObject(1, 9.5, "a"));
    elements.add(new TestObject(2, 6.7, "ab"));
    elements.add(new TestObject(3, 8.2, "abc"));
    elements.add(new TestObject(4, 3.4, "abcd"));
    elements.add(new TestObject(5, 6.5, "abcde"));
    SQLite.get().insert(TestTable.TABLE, elements);

    Observable.zip(RxSQLite.get().query(TestTable.TABLE),
            Observable.just(elements), new BiFunction<List<TestObject>, List<TestObject>, Object>() {
                @Override
                public Object apply(List<TestObject> testElements, List<TestObject> savedElements) throws Exception {
                    assertEquals(testElements.size(), savedElements.size());
                    for (int i = 0; i < testElements.size(); i++) {
                        assertEquals(testElements.size(), savedElements.size());
                    }
                    return null;
                }
            })
            .test();
}
 

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
public static void practice1(){
    final Api api = RetrofitProvider.get().create(Api.class);
    Observable<UserBaseInfoResponse> observable1 =
            api.getUserBaseInfo(new UserBaseInfoRequest()).subscribeOn(Schedulers.io());

    Observable<UserExtraInfoResponse> observable2 =
            api.getUserExtraInfo(new UserExtraInfoRequest()).subscribeOn(Schedulers.io());

    Observable.zip(observable1, observable2,
            new BiFunction<UserBaseInfoResponse, UserExtraInfoResponse, UserInfo>() {
                @Override
                public UserInfo apply(UserBaseInfoResponse baseInfo,
                                      UserExtraInfoResponse extraInfo) throws Exception {
                    return new UserInfo(baseInfo, extraInfo);
                }
            }).observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<UserInfo>() {
                @Override
                public void accept(UserInfo userInfo) throws Exception {
                    //do something;
                }
            });
}
 

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
@Test
public void avgFunction() {
  final double count = 8;
  final Integer sum = Observable.fromIterable(insertSimpleAllValues((int) count))
      .map(new Function<SimpleAllValuesMutable, Integer>() {
        @Override
        public Integer apply(SimpleAllValuesMutable v) {
          return (int) v.primitiveShort;
        }
      })
      .reduce(new BiFunction<Integer, Integer, Integer>() {
        @Override
        public Integer apply(Integer v1, Integer v2) {
          return v1 + v2;
        }
      })
      .blockingGet();

  final Double value = Select
      .column(avg(SIMPLE_ALL_VALUES_MUTABLE.PRIMITIVE_SHORT))
      .from(SIMPLE_ALL_VALUES_MUTABLE)
      .takeFirst()
      .execute();
  assertThat(value).isEqualTo(sum.doubleValue() / count);
}
 

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
private void loadStringArray(final StudyContentDao studyContentDao) {
    String[] titleList = getResources().getStringArray(R.array.study_ui_title);
    String[] descList = getResources().getStringArray(R.array.study_ui_description);
    Observable<String> observableTitle = Observable.fromArray(titleList);
    Observable<String> observableDescList = Observable.fromArray(descList);

    Observable.zip(observableTitle, observableDescList, new BiFunction<String, String, StudyContent>() {
        @Override
        public StudyContent apply(@io.reactivex.annotations.NonNull String s, @io.reactivex.annotations.NonNull String s2) throws Exception {
            StudyContent studyItemModel = new StudyContent();
            studyItemModel.setTitle(s);
            studyItemModel.setDescription(s2);
            studyItemModel.setType(s);
            return studyItemModel;
        }
    }).subscribe(new Consumer<StudyContent>() {
        @Override
        public void accept(@io.reactivex.annotations.NonNull StudyContent studyContent) throws Exception {
            studyContentDao.insertOrReplace(studyContent);
        }
    });
}
 

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
private void findUsersWhoLovesBoth() {
    // here we are using zip operator to combine both request
    Observable.zip(getCricketFansObservable(), getFootballFansObservable(),
            new BiFunction<List<User>, List<User>, List<User>>() {
                @Override
                public List<User> apply(List<User> cricketFans, List<User> footballFans) throws Exception {
                    List<User> userWhoLovesBoth =
                            filterUserWhoLovesBoth(cricketFans, footballFans);
                    return userWhoLovesBoth;
                }
            })
            .subscribeOn(Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Observer<List<User>>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(List<User> users) {
                    // do anything with user who loves both
                    Log.d(TAG, "userList size : " + users.size());
                    for (User user : users) {
                        Log.d(TAG, "user : " + user.toString());
                    }
                }

                @Override
                public void onError(Throwable e) {
                    Utils.logError(TAG, e);
                }

                @Override
                public void onComplete() {
                    Log.d(TAG, "onComplete");
                }
            });
}
 

import io.reactivex.functions.BiFunction; //导入依赖的package包/类
private void doSomeWork() {
    getObservable()
            // Run on a background thread
            .subscribeOn(Schedulers.io())
            // Be notified on the main thread
            .observeOn(AndroidSchedulers.mainThread())
            .scan(new BiFunction<Integer, Integer, Integer>() {
                @Override
                public Integer apply(Integer int1, Integer int2) throws Exception {
                    return int1 + int2;
                }
            })
            .subscribe(getObserver());
}