/* * Copyright 2011 Eric F. Savage, code@efsavage.com * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Copyright 2011 Eric F. Savage, code@efsavage.com * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.ajah.util; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Map; /** * Utilities for dealing with members of the Collections API. * * @author <a href="http://efsavage.com">Eric F. Savage</a>, * <a href="mailto:code@efsavage.com">code@efsavage.com</a>. */ public class CollectionUtils { /** * Checks to see if a collection is null or empty. * * @param collection * Collection to test, may be null. * @return true if the collection is null or empty, otherwise false. */ public static boolean isEmpty(final Collection<?> collection) { return collection == null || collection.size() < 1; } /** * Returns null if the supplied collection is empty. * * @param collection * The collection to test. * @return The original collection if not empty, otherwise null. */ public static <T, C extends Collection<T>> C nullIfEmpty(final C collection) { if (isEmpty(collection)) { return null; } return collection; } /** * Shorthand method for adding an item to a list, and creating that list if * necessary. * * @param list * The list to add to. * @param item * The item to add. * @return The original list that was passed in, or a new list. */ private static <T> List<T> safeAdd(final List<T> list, final T item) { List<T> retVal = list; if (retVal == null) { retVal = new ArrayList<>(); } retVal.add(item); return retVal; } /** * Returns an element of a list, or null if the list is null or does not * have that index. * * @param list * The list to get from, may be null. * @param index * The index to get, must be >=0. * @return The size of the collection, zero if the collection is null. */ public static <T> T safeGet(final List<T> list, final int index) { if (list == null || list.size() <= index) { return null; } return list.get(index); } /** * Returns the size of a collection, or zero if the collection is null. * * @param collection * The collection to inspect, may be null. * @return The size of the collection, zero if the collection is null. */ public static int safeSize(final Collection<?> collection) { if (collection == null) { return 0; } return collection.size(); } /** * Removes the entries of a map that have null values. * * @param map * The map to strip. * @return The map that was passed in. */ public static <K, V> Map<K, V> stripNulls(final Map<K, V> map) { List<Object> toRemove = null; for (final Object key : map.keySet()) { if (map.get(key) == null) { toRemove = safeAdd(toRemove, key); } } if (toRemove != null) { for (final Object key : toRemove) { map.remove(key); } } return map; } /** * Returns an empty list if the supplied list is null. Useful for avoiding * NPEs in for loops. * * @param collection * The collection to test. * @return The collection or an empty list. */ public static <T> List<T> emptyIfNull(List<T> collection) { if (collection == null) { return Collections.emptyList(); } return collection; } /** * A shortcut to do sorting inline since the {@link Collections#sort(List)} * and {@link List#sort(java.util.Comparator)} methods returns void. * * @See {@link Collections#sort(List)} * @param collection * The collection to sort. * @return The sorted collection. */ public static <T extends Comparable<? super T>> List<T> sort(List<T> collection) { Collections.sort(collection); return collection; } }