001 /*
002 * Created on Apr 29, 2007
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
005 * the License. You may obtain a copy of the License at
006 *
007 * http://www.apache.org/licenses/LICENSE-2.0
008 *
009 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
010 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
011 * specific language governing permissions and limitations under the License.
012 *
013 * Copyright @2007-2011 the original author or authors.
014 */
015 package org.fest.util;
016
017 import static java.util.Collections.*;
018
019 import static org.fest.util.ToString.toStringOf;
020
021 import java.util.ArrayList;
022 import java.util.Collection;
023 import java.util.HashSet;
024 import java.util.Iterator;
025 import java.util.LinkedHashSet;
026 import java.util.List;
027 import java.util.Set;
028
029 /**
030 * Utility methods related to collections.
031 *
032 * @author Yvonne Wang
033 * @author Alex Ruiz
034 * @author Joel Costigliola
035 */
036 public final class Collections {
037
038 /**
039 * Creates a list containing the given elements.
040 * @param <T> the type of elements of the list to create.
041 * @param elements the elements to store in the list.
042 * @return the created list.
043 */
044 public static <T> List<T> list(T... elements) {
045 if (elements == null) return null;
046 List<T> list = new ArrayList<T>();
047 for (T e : elements)
048 list.add(e);
049 return list;
050 }
051
052 /**
053 * Creates a set containing the given elements.
054 * @param <T> the type of elements of the set to create.
055 * @param elements the elements to store in the set.
056 * @return the created set.
057 * @since 1.1.5
058 */
059 public static <T> Set<T> set(T... elements) {
060 if (elements == null) return null;
061 Set<T> set = new LinkedHashSet<T>();
062 for (T e : elements)
063 set.add(e);
064 return set;
065 }
066
067 /**
068 * Returns any duplicate elements from the given collection.
069 * @param <T> the generic type of the given collection.
070 * @param c the given collection that might have duplicate elements.
071 * @return a collection containing the duplicate elements of the given one. If no duplicates are found, an empty
072 * collection is returned.
073 */
074 public static <T> Collection<T> duplicatesFrom(Collection<T> c) {
075 Set<T> duplicates = new HashSet<T>();
076 if (isEmpty(c)) return duplicates;
077 Set<T> noDuplicates = new HashSet<T>();
078 for (T e : c) {
079 if (noDuplicates.contains(e)) {
080 duplicates.add(e);
081 continue;
082 }
083 noDuplicates.add(e);
084 }
085 return duplicates;
086 }
087
088 /**
089 * Returns {@code true} if the given {@link Iterable} is {@code null} or empty.
090 * @param iterable the {@link Iterable} to check.
091 * @return {@code true} if the given {@link Iterable} is {@code null} or empty, otherwise {@code false}.
092 */
093 public static boolean isEmpty(Iterable<?> iterable) {
094 return iterable == null || !iterable.iterator().hasNext();
095 }
096
097 /**
098 * Returns the size of the given {@link Iterable}.
099 * @param iterable the {@link Iterable} to get size.
100 * @return the size of the given {@link Iterable}..
101 * @throws IllegalArgumentException if given {@link Iterable} is null.
102 */
103 public static int sizeOf(Iterable<?> iterable) {
104 if (iterable == null) throw new IllegalArgumentException("iterable parameter must not be null");
105 int size = 0;
106 for (@SuppressWarnings("unused") Object object : iterable) {
107 size++;
108 }
109 return size;
110 }
111
112 public static <T> List<T> filter(Collection<?> target, CollectionFilter<T> filter) {
113 return filter.filter(target);
114 }
115
116 /**
117 * Returns the {@code String} representation of the given collection, or {@code null} if the given collection is
118 * {@code null}.
119 * @param c the collection to format.
120 * @return the {@code String} representation of the given collection.
121 */
122 public static String format(Collection<?> c) {
123 if (c == null) return null;
124 Iterator<?> i = c.iterator();
125 if (!i.hasNext()) return "[]";
126 StringBuilder b = new StringBuilder();
127 b.append('[');
128 for (;;) {
129 Object e = i.next();
130 b.append(e == c ? "(this Collection)" : toStringOf(e));
131 if (!i.hasNext()) return b.append(']').toString();
132 b.append(", ");
133 }
134 }
135
136 /**
137 * Returns a new unmodifiable collection containing the non-null elements of the given collection. This method returns
138 * an empty unmodifiable collection if the given collection has only {@code null} elements or if it is empty. This
139 * method returns {@code null} if the given collection is {@code null}.
140 * @param <T> the type of elements of the collection.
141 * @param c the collection we want to extract non null elements from.
142 * @return a new unmodifiable collection containing the non-null elements of the given collection, or {@code null} if
143 * the given collection is {@code null}.
144 * @since 1.1.3
145 */
146 public static <T> Collection<T> nonNullElements(Collection<T> c) {
147 if (c == null) return null;
148 Collection<T> nonNullElements = new ArrayList<T>();
149 for (T o : c)
150 if (o != null) nonNullElements.add(o);
151 return unmodifiableCollection(nonNullElements);
152 }
153
154 /**
155 * Returns a new unmodifiable list containing the non-null elements of the given list. This method returns an empty
156 * unmodifiable list if the given list has only {@code null} elements or if it is empty. This method returns
157 * {@code null} if the given list is {@code null}.
158 * @param <T> the type of elements of the list.
159 * @param l the list we want to extract non null elements from.
160 * @return a new unmodifiable list containing the non-null elements of the given list, or {@code null} if the given
161 * list is {@code null}.
162 * @since 1.1.3
163 */
164 public static <T> List<T> nonNullElements(List<T> l) {
165 Collection<T> nonNullElements = nonNullElements((Collection<T>) l);
166 if (nonNullElements == null) return null;
167 return unmodifiableList(new ArrayList<T>(nonNullElements));
168 }
169
170 /**
171 * Returns {@code true} if the given {@link Iterable} has only {@code null} elements, {@code false} otherwise. If given
172 * {@link Iterable} is empty, this method returns {@code true}.
173 * @param iterable the given iterable. <b>It must not be null</b>.
174 * @return {@code true} if the given iterable has only {@code null} elements or is empty, {@code false} otherwise.
175 * @throws NullPointerException if the given iterable is {@code null}.
176 * @since 1.1.3
177 */
178 public static boolean hasOnlyNullElements(Iterable<?> iterable) {
179 if (iterable == null) throw new NullPointerException("The iterable to check should not be null");
180 if (isEmpty(iterable)) return false;
181 for (Object element : iterable)
182 if (element != null) return false;
183 return true;
184 }
185
186 /**
187 * Creates a list containing the given {@link Iterable} elements.
188 * @param <T> the type of elements of the list to create.
189 * @param iterable the {@link Iterable} to get elements from to store in the list.
190 * @return the created list.
191 */
192 public static <T> List<T> list(Iterable<T> iterable) {
193 if (iterable == null) return null;
194 List<T> list = new ArrayList<T>();
195 for (T e : iterable)
196 list.add(e);
197 return list;
198 }
199
200 private Collections() {}
201 }