Sort a list by a date property (Updateable)
@param collection the collection
@param <T> THE TYPE
@return COLLECTION OF type stored
496932
public static<T> Collection<T> sortByUpdateDate(Collection<T> collection)
   {

       List<T> list = collection instanceof List ? (List<T>) collection : new ArrayList<T>(collection); 

      Collections.sort(list, new UpdateDateComparator());

      return list;

   }
591623
public static <T> ArrayList<T> newArrayList(Collection<T> collection) {
		return (ArrayList<T>) list(false, collection);
	}
914350
public static <T> List<T> sortedCollection(Collection<T> coll) {
	List<T> list = new LinkedList<T>(coll);
	Collections.sort(list, new UComp<T>());
	return list;
    }
665029
public static List<String> getSortedStringList(
            Collection<String> stringCollection) {
        return unmodifiableList(sort(new ArrayList<>(stringCollection)));
    }
89542
public static <T extends Comparable<? super T>> void sort(List<T> list) {
		if (useQuickSort) QuickSort.sort(list);
		else              Collections.sort(list);
	}
376897
public <T extends Comparable<T>> void sort(List<T> list)
    {
        sort(list, defaultComp);
    }
935272
public static <T> List<T> sortByProperty(List<T> list, String property) {
		return sort(list, new PropertyComparator<>(property));
	}
696923
public static <S extends Storable> OrderingList<S> get(Class<S> type, String property) {
        OrderingList<S> list = emptyList();
        if (property != null) {
            list = list.concat(type, property);
        }
        return list;
    }
1258507
public static <T extends HierarchyEntity<T, ?>> Map<T, String> sort(List<T> datas, String property) {
    final Map<T, String> sortedMap = tag(datas, property);
    Collections.sort(datas, new Comparator<HierarchyEntity<T, ?>>() {
      public int compare(HierarchyEntity<T, ?> arg0, HierarchyEntity<T, ?> arg1) {
        String tag0 = sortedMap.get(arg0);
        String tag1 = sortedMap.get(arg1);
        return tag0.compareTo(tag1);
      }
    });
    return sortedMap;
  }
80730
public OrderingList<S> concat(Class<S> type, String property) {
        OrderingList<S> newList = this;
        if (newList == EMPTY_LIST) {
            // Cannot concat from singleton EMPTY_LIST.
            newList = getListHead(type);
        }
        return newList.nextNode(type, property);
    }
961461
public static <T> void sort(List<T> list, Comparator<? super T> comparator) {
		if (list instanceof RandomAccess) {
			quicksort(list, comparator);
		} else {
			List<T> copy = new ArrayList<>(list);
			quicksort(copy, comparator);
			list.clear();
			list.addAll(copy);
		}
	}
389703
public static <E extends Comparable<? super E>> E min(final Collection<E> collection) {
        return Collections.min(collection);
    }
1319419
public static <T> List<T> getReversed(Collection<T> collection) {
        List<T> reversedList = new ArrayList<>(collection);
        Collections.reverse(reversedList);
        return reversedList;
    }
887377
public static <T extends CharSequence> Collection<T> removeBlank(Collection<T> collection) {
		return filter(collection, new Filter<T>() {
			@Override
			public boolean accept(T t) {
				return false == StrUtil.isBlank(t);
			}
		});
	}
967744
public static <T> ArrayList<T> sortThis(ArrayList<T> list, Comparator<? super T> comparator)
    {
        int size = list.size();
        if (ArrayListIterate.canAccessInternalArray(list))
        {
            Arrays.sort(ArrayListIterate.getInternalArray(list), 0, size, comparator);
        }
        else
        {
            Collections.sort(list, comparator);
        }
        return list;
    }
1146033
public static <T extends Comparable<T>> List<T> sorted(Iterable<T> items) {
    List<T> result = toList(items);
    Collections.sort(result);
    return result;
  }
255835
public static <K, V> LinkedHashMap<K, V> sortToMap(Collection<Map.Entry<K, V>> entryCollection, Comparator<Map.Entry<K, V>> comparator) {
		List<Map.Entry<K, V>> list = new LinkedList<>(entryCollection);
		Collections.sort(list, comparator);

		LinkedHashMap<K, V> result = new LinkedHashMap<>();
		for (Map.Entry<K, V> entry : list) {
			result.put(entry.getKey(), entry.getValue());
		}
		return result;
	}