CollectionsUtil.java

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * The smarter thing to do would be to use what is Guava, etc...but Guava is a big fat library that
 * will blow the dex count and this is pretty much the only thing we are using out of it.
 *
 * No guarantee that any of these are the best implementation.
 */
public class CollectionsUtil {
    public interface Predicate<T> {
        boolean apply(T object);
    }

    public interface IndexedPredicate<T> {
        boolean apply(int index, T object);
    }

    public static <T> boolean atLeastOneMatches(List<T> list, Predicate<T> predicate) {
        return first(list, predicate) != null;
    }

    public static <T> T first(List<T> list, Predicate<T> predicate) {
        for (T item : list) {
            if (predicate.apply(item)) {
                return item;
            }
        }

        return null;
    }

    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        ArrayList<T> result = new ArrayList<>();
        for (T item : list) {
            if (predicate.apply(item)) {
                result.add(item);
            }
        }
        return result;
    }

    public static <T> List<T> filter(List<T> list, IndexedPredicate<T> predicate) {
        ArrayList<T> result = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            T item = list.get(i);
            if (predicate.apply(i, item)) {
                result.add(item);
            }
        }
        return result;
    }

    public interface Function<F, T> {
        T apply(F from);
    }

    public interface IndexedFunction<F, T> {
        T apply(int index, F from);
    }

    public static <F, T> List<T> transform(List<F> list, Function<F, T> function) {
        ArrayList<T> result = new ArrayList<>();
        if (list == null) {
            return result;
        }

        for (F item : list) {
            result.add(function.apply(item));
        }
        return result;
    }

    public static <F, T> List<T> transform(List<F> list, IndexedFunction<F, T> function) {
        ArrayList<T> result = new ArrayList<>();
        if (list == null) {
            return result;
        }

        for (int i = 0; i < list.size(); i++) {
            F item = list.get(i);
            result.add(function.apply(i, item));
        }

        return result;
    }

    public static <K, V> Map<K,V> toMap(List<V> list, Function<V, K> function) {
        HashMap<K, V> map = new HashMap<>();
        if (list == null) {
            return map;
        }

        for (V item : list) {
            map.put(function.apply(item), item);
        }
        return map;
    }

    public static <T> List<T> concat(List<T> a, List<T> b) {
        ArrayList<T> result = new ArrayList<>();
        result.addAll(a);
        result.addAll(b);
        return result;
    }
}