list工具类

public class ListUtil {
	
    /**
     * @describe 依据某个字段对集合进行排序
     * 
     * @param list
     *            待排序的集合
     * @param fieldName
     *            依据这个字段进行排序
     * @param asc
     *            如果为true，是正序；为false，为倒序
     */
    @SuppressWarnings("unchecked")
    public static <T> void sort(List<T> list, String fieldName, boolean asc) {
        Comparator<?> comparator = ComparableComparator.getInstance();
        comparator = ComparatorUtils.nullLowComparator(comparator); // 允许null
        if (!asc) {
            comparator = ComparatorUtils.reversedComparator(comparator); // 逆序
        }
        Collections.sort(list, new BeanComparator(fieldName, comparator));
    }
    
    /**  
     * <p>Title: partition</p>  
     * <p>Description: 分割list</p>  
     *  
     * @param list 原始list
     * @param size 分割大小
     * @return  
     *
     */
    public static <T> List<List<T>> partition(List<T> list, int size) {
		if (list == null) {
			throw new NullPointerException("List must not be null");
		}
		if (size <= 0) {
			throw new IllegalArgumentException("Size must be greater than 0");
		}
		return new Partition<T>(list, size);
	}
    
    private static class Partition<T> extends AbstractList<List<T>> {
		private final List<T> list;
		private final int size;

		private Partition(List<T> list, int size) {
			this.list = list;
			this.size = size;
		}

		public List<T> get(int index) {
			int listSize = size();
			if (listSize < 0) {
				throw new IllegalArgumentException("negative size: " + listSize);
			}
			if (index < 0) {
				throw new IndexOutOfBoundsException("Index " + index + " must not be negative");
			}
			if (index >= listSize) {
				throw new IndexOutOfBoundsException("Index " + index + " must be less than size " + listSize);
			}

			int start = index * this.size;
			int end = Math.min(start + this.size, this.list.size());
			return this.list.subList(start, end);
		}

		public int size() {
			return ((this.list.size() + this.size - 1) / this.size);
		}

		public boolean isEmpty() {
			return this.list.isEmpty();
		}
	}
    
	
	/**
	 * @see 深度复制list list里对象不再指向同一个地址
	 *
	 * @param src  需要复制的list
	 * @return dest 返回复制后的新List
	 */
	@SuppressWarnings("unchecked")
	public static <T> List<T> deepCopy(List<T> src) {
		try {
			ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
			ObjectOutputStream out = new ObjectOutputStream(byteOut);
			out.writeObject(src);

			ByteArrayInputStream byteIn = new ByteArrayInputStream(
					byteOut.toByteArray());
			ObjectInputStream in = new ObjectInputStream(byteIn);
			List<T> dest = (List<T>) in.readObject();
			return dest;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
}