import android.arch.core.util.Function; //导入依赖的package包/类
private void subscribeToDbChanges() {
    LiveData<List<LoanWithUserAndBook>> loans
            = mDb.loanModel().findLoansByNameAfter("Mike", getYesterdayDate());

    // Instead of exposing the list of Loans, we can apply a transformation and expose Strings.
    mLoansResult = Transformations.map(loans,
            new Function<List<LoanWithUserAndBook>, String>() {
        @Override
        public String apply(List<LoanWithUserAndBook> loansWithUserAndBook) {
            StringBuilder sb = new StringBuilder();
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm",
                    Locale.US);

            for (LoanWithUserAndBook loan : loansWithUserAndBook) {
                sb.append(String.format("%s\n  (Returned: %s)\n",
                        loan.bookTitle,
                        simpleDateFormat.format(loan.endTime)));
            }
            return sb.toString();
        }
    });
}
 

import android.arch.core.util.Function; //导入依赖的package包/类
private void subscribeToDbChanges() {
    // TODO: Modify this query to show only recent loans from specific user
    LiveData<List<LoanWithUserAndBook>> loans
            = mDb.loanModel().findAllWithUserAndBook();

    // Instead of exposing the list of Loans, we can apply a transformation and expose Strings.
    mLoansResult = Transformations.map(loans,
            new Function<List<LoanWithUserAndBook>, String>() {
        @Override
        public String apply(List<LoanWithUserAndBook> loansWithUserAndBook) {
            StringBuilder sb = new StringBuilder();
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm",
                    Locale.US);

            for (LoanWithUserAndBook loan : loansWithUserAndBook) {
                sb.append(String.format("%s\n  (Returned: %s)\n",
                        loan.bookTitle,
                        simpleDateFormat.format(loan.endTime)));
            }
            return sb.toString();
        }
    });
}
 

import android.arch.core.util.Function; //导入依赖的package包/类
/**
 * Default constructor.
 * @param application
 */
public DocListViewModel(Application application) {
    super(application);

    // transform database created flag to live data.
    // if it is not created, it will return ABSENT field.
    // if it is created, it will return room live data.
    final DatabaseManager databaseManager = DatabaseManager.getInstance(application);
    LiveData<Boolean> databaseCreated = databaseManager.isDatabaseCreated();
    mObservableDocuments = Transformations.switchMap(databaseCreated,
            new Function<Boolean, LiveData<List<DocumentMetadata>>>() {
                @Override
                public LiveData<List<DocumentMetadata>> apply(Boolean isDbCreated) {
                    if (!Boolean.TRUE.equals(isDbCreated)) {
                        return ABSENT;
                    } else {
                        return databaseManager.getDatabase().documentDao().loadAllDocumentsMetadata();
                    }
                }
            });

    databaseManager.initDbAsync(this.getApplication());
}
 

import android.arch.core.util.Function; //导入依赖的package包/类
PostsListViewModel(@NonNull Application application, String slug, int postCount, Retrofit retrofit) {
    super(application);
    mSlug = slug;
    mPostCount = postCount;
    mRetrofit = retrofit;

    mIsLoading.setValue(true);
    mOffset.setValue(0);

    // 当 mOffset 的值发生改变，就会执行 apply
    mListLiveData = Transformations.switchMap(mOffset, new Function<Integer, LiveData<List<PostsListBean>>>() {
        @Override
        public LiveData<List<PostsListBean>> apply(Integer input) {
            return handleData(input);
        }
    });
}
 

import android.arch.core.util.Function; //导入依赖的package包/类
public FlexibleViewModel() {
    identifier = new MutableLiveData<>();
    liveItems = Transformations.switchMap(identifier, new Function<Identifier, LiveData<List<AdapterItem>>>() {
        @Override
        public LiveData<List<AdapterItem>> apply(Identifier input) {
            return Transformations.map(getSource(input), new Function<Source, List<AdapterItem>>() {
                @Override
                public List<AdapterItem> apply(Source source) {
                    if (isSourceValid(source)) {
                        return map(source);
                    } else {
                        return liveItems.getValue();
                    }
                }
            });
        }
    });
}
 

import android.arch.core.util.Function; //导入依赖的package包/类
public static <E, R> List<R> map(List<E> list, Function<E, R> mapper) {
    final List<R> newList = new ArrayList<>(list.size());
    for (E el : list) {
        newList.add(mapper.apply(el));
    }
    return newList;
}
 

import android.arch.core.util.Function; //导入依赖的package包/类
@Inject
public VideosViewModel(Application application, VideosRepository repository) {
    super(application);

    mRepository = repository;

    mAllCategories = mRepository.getAllCategories();

    mSearchResults = Transformations.switchMap(
            mQuery, new Function<String, LiveData<List<VideoEntity>>>() {
                @Override
                public LiveData<List<VideoEntity>> apply(final String queryMessage) {
                    return mRepository.getSearchResult(queryMessage);
                }
            });


    mVideoById = Transformations.switchMap(
            mVideoId, new Function<Long, LiveData<VideoEntity>>() {
                @Override
                public LiveData<VideoEntity> apply(final Long videoId) {
                    return mRepository.getVideoById(videoId);
                }
            });

    /**
     * Using switch map function to react to the change of observed variable, the benefits of
     * this mapping method is we don't have to re-create the live data every time.
     */
    mAllVideosByCategory = Transformations.switchMap(mVideoCategory, new Function<String, LiveData<List<VideoEntity>>>() {
        @Override
        public LiveData<List<VideoEntity>> apply(String category) {
            return mRepository.getVideosInSameCategoryLiveData(category);
        }
    });
}
 

import android.arch.core.util.Function; //导入依赖的package包/类
/**
 * Construct new paired list. Main and supplementary lists will be empty.
 * @param mapper Function, which will be used to translate items from the main list to the
 *               supplementary one.
 */
public PairedList(Function<T, ? extends V> mapper) {
    this.mapper = mapper;
}