Java Function.apply方法代码示例

import com.annimon.stream.function.Function; //导入方法依赖的package包/类
/**
 * Returns a comparator that uses a function that extracts a sort key
 * to be compared with the specified comparator.
 *
 * @param <T> the type of the objects compared by the comparator
 * @param <U> the type of the sort key
 * @param keyExtractor  the function that extracts the sort key
 * @param keyComparator  the comparator used to compare the sort key
 * @return a comparator
 * @throws NullPointerException if {@code keyExtractor} or {@code keyComparator} is null
 */
public static <T, U> ComparatorCompat<T> comparing(
        final Function<? super T, ? extends U> keyExtractor,
        final Comparator<? super U> keyComparator) {
    Objects.requireNonNull(keyExtractor);
    Objects.requireNonNull(keyComparator);
    return new ComparatorCompat<T>(new Comparator<T>() {

        @Override
        public int compare(T t1, T t2) {
            final U u1 = keyExtractor.apply(t1);
            final U u2 = keyExtractor.apply(t2);
            return keyComparator.compare(u1, u2);
        }
    });
}
 

import com.annimon.stream.function.Function; //导入方法依赖的package包/类
@NonNull
static String encode(@NonNull Function<Integer, Character> lookup, int number) {
	int loopCounter = 0;
	boolean done = false;

	String str = "";

	while(!done) {
		str = str + lookup.apply(((number >> (4 * loopCounter)) & 0x0f) | randomByte());
		done = number < (Math.pow(16, loopCounter + 1));
		loopCounter++;
	}

	return str;
}
 

import com.annimon.stream.function.Function; //导入方法依赖的package包/类
/**
 * Function to find a view and act on it
 *
 * @param view      - The root view
 * @param resId     - The view resource ID to find
 * @param consumer - The method to act with
 * @return T - Instance of the view found, null if not found.
 */
public static <T> T findView(View view, int resId, Function<View, T> caster, Consumer<T> consumer) {
    View child = view.findViewById(resId);
    if (CommonUtils.isNull(child))
        return null;

    T casted = caster.apply(child);
    consumer.accept(casted);
    return casted;
}
 

import com.annimon.stream.function.Function; //导入方法依赖的package包/类
private void initPokemonGOApi(final Function<Object, Object> callback){
        final String authJson = pref.getString("auth", "");

        if(TextUtils.isEmpty(authJson)){
            askLogin();
            return;
        }

        AsyncTask at = new AsyncTask() {

            @Override
            protected void onPreExecute() {
                super.onPreExecute();
//                mSignin.setEnabled(false);
                mSignin.setText(R.string.loading_);
            }

            @Override
            protected Object doInBackground(Object[] objects) {

                try {
                    if(!TextUtils.isEmpty(authJson)){
                        Gson gson = new Gson();

                        final RequestEnvelopeOuterClass.RequestEnvelope.AuthInfo auth =
                                gson.fromJson(authJson, RequestEnvelopeOuterClass.RequestEnvelope.AuthInfo.class);
                        pokemonGo = new PokemonGo(new CredentialProviderAdapter(auth), http);
                        PlayerProfile profile = pokemonGo.getPlayerProfile();
                        return profile;
                    }
                }catch (Exception e){
                    e.printStackTrace();
//                    final String error = e.getMessage();
//                    runOnUiThread(new Runnable() {
//                        @Override
//                        public void run() {
//                            showMessage(error);
//                        }
//                    });
                }
                return null;
            }

            @Override
            protected void onPostExecute(Object o) {
                super.onPostExecute(o);
//                mSignin.setEnabled(false);
                mSignin.setText(R.string.sign_in);
                if(o instanceof  PlayerProfile){
                    PlayerProfile playerProfile = (PlayerProfile)o;
                    renderProfile(playerProfile);
                }else{
                    setProfile("", "", Collections.<String, String>emptyMap());
                }

                if(callback != null){
                    callback.apply(o);
                }

            }
        };
        at.execute();
    }
 

import com.annimon.stream.function.Function; //导入方法依赖的package包/类
/**
 * Applies custom operator on {@code Exceptional}.
 *
 * @param <R> the type of the result
 * @param function  a transforming function
 * @return a result of the transforming function
 * @throws NullPointerException if {@code function} is null
 * @since 1.1.9
 */
public <R> R custom(Function<Exceptional<T>, R> function) {
    Objects.requireNonNull(function);
    return function.apply(this);
}
 

import com.annimon.stream.function.Function; //导入方法依赖的package包/类
/**
 * Applies custom operator on {@code OptionalDouble}.
 *
 * @param <R> the type of the result
 * @param function  a transforming function
 * @return a result of the transforming function
 * @throws NullPointerException if {@code function} is null
 * @since 1.1.9
 */
public <R> R custom(Function<OptionalDouble, R> function) {
    Objects.requireNonNull(function);
    return function.apply(this);
}
 

import com.annimon.stream.function.Function; //导入方法依赖的package包/类
/**
 * Applies custom operator on {@code OptionalBoolean}.
 *
 * @param <R> the type of the result
 * @param function  a transforming function
 * @return a result of the transforming function
 * @throws NullPointerException if {@code function} is null
 * @since 1.1.9
 */
public <R> R custom(Function<OptionalBoolean, R> function) {
    Objects.requireNonNull(function);
    return function.apply(this);
}
 

import com.annimon.stream.function.Function; //导入方法依赖的package包/类
/**
 * Applies custom operator on {@code OptionalInt}.
 *
 * @param <R> the type of the result
 * @param function  a transforming function
 * @return a result of the transforming function
 * @throws NullPointerException if {@code function} is null
 * @since 1.1.9
 */
public <R> R custom(Function<OptionalInt, R> function) {
    Objects.requireNonNull(function);
    return function.apply(this);
}
 

import com.annimon.stream.function.Function; //导入方法依赖的package包/类
/**
 * Applies custom operator on {@code OptionalLong}.
 *
 * @param <R> the type of the result
 * @param function  a transforming function
 * @return a result of the transforming function
 * @throws NullPointerException if {@code function} is null
 * @since 1.1.9
 */
public <R> R custom(Function<OptionalLong, R> function) {
    Objects.requireNonNull(function);
    return function.apply(this);
}
 

import com.annimon.stream.function.Function; //导入方法依赖的package包/类
/**
 * Applies custom operator on {@code Optional}.
 *
 * @param <R> the type of the result
 * @param function  a transforming function
 * @return a result of the transforming function
 * @throws NullPointerException if {@code function} is null
 * @since 1.1.9
 */
public <R> R custom(Function<Optional<T>, R> function) {
    Objects.requireNonNull(function);
    return function.apply(this);
}