com.weicoder.common.lang.Lists Maven / Gradle / Ivy

Go to download
package com.weicoder.common.lang;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

import com.weicoder.common.util.ArrayUtil;
import com.weicoder.common.util.EmptyUtil;

/**
 * List的帮助类
 * @author WD
 * @since JDK7
 * @version 1.0 2009-09-08
 */
public final class Lists {
	/**
	 * 判断是否列表
	 * @param obj 对象
	 * @return 是否列表
	 */
	public static boolean isList(Object obj) {
		return !EmptyUtil.isEmpty(obj) && obj instanceof List;
	}

	/**
	 * 获得List实例 默认初始化大小为10
	 * @return List
	 */
	public static  List getList() {
		return new ArrayList();
	}

	/**
	 * 获得List实例
	 * @param size 初始化大小
	 * @return List
	 */
	public static  List getList(int size) {
		return new ArrayList(size < 1 ? 1 : size);
	}

	/**
	 * 获得List实例
	 * @param es 初始化的数组
	 * @return List
	 */
	@SafeVarargs
	public static  List getList(E... e) {
		return getList(ArrayUtil.toList(e));
	}

	/**
	 * 获得List实例
	 * @param c 初始化的集合
	 * @return List
	 */
	public static  List getList(Collection c) {
		return c == null ? new ArrayList() : new ArrayList(c);
	}

	/**
	 * 获得List实例
	 * @param c 初始化的集合
	 * @return List
	 */
	@SafeVarargs
	public static  List getList(Collection... c) {
		// 获得一个列表
		List list = getList();
		// 循环集合
		for (int i = 0; i < c.length; i++) {
			// 添加到列表中
			if (!EmptyUtil.isEmpty(c[i])) {
				list.addAll(c[i]);
			}
		}
		// 返回列表
		return list;
	}

	/**
	 * 获得List实例 默认初始化大小为10
	 * @return List
	 */
	public static  ArrayList getArrayList() {
		return new ArrayList();
	}

	/**
	 * 获得List实例
	 * @param size 初始化大小
	 * @return List
	 */
	public static  ArrayList getArrayList(int size) {
		return new ArrayList(size < 1 ? 1 : size);
	}

	/**
	 * 获得List实例
	 * @param es 初始化的数组
	 * @return List
	 */
	@SafeVarargs
	public static  ArrayList getArrayList(E... e) {
		return getArrayList(ArrayUtil.toList(e));
	}

	/**
	 * 获得List实例
	 * @param c 初始化的集合
	 * @return List
	 */
	public static  ArrayList getArrayList(Collection c) {
		return c == null ? new ArrayList() : new ArrayList(c);
	}

	/**
	 * 获得并发的List实例 实现类是CopyOnWriteArrayList
	 * @return 同步的List
	 */
	public static  CopyOnWriteArrayList getConcurrenrList() {
		return new CopyOnWriteArrayList();
	}

	/**
	 * 获得并发的List实例 实现类是CopyOnWriteArrayList
	 * @param e 初始化数组
	 * @return 同步的List
	 */
	@SafeVarargs
	public static  CopyOnWriteArrayList getConcurrenrList(E... e) {
		return new CopyOnWriteArrayList(e);
	}

	/**
	 * 获得并发的List实例 实现类是CopyOnWriteArrayList
	 * @param c 初始化的集合
	 * @return 同步的List
	 */
	public static  CopyOnWriteArrayList getConcurrenrList(Collection c) {
		return new CopyOnWriteArrayList(c);
	}

	/**
	 * 获得同步的List实例 实现类是LinkedList
	 * @return 同步的List
	 */
	public static  LinkedList getLinkedList() {
		return new LinkedList();
	}

	/**
	 * 获得同步的List实例 实现类是LinkedList
	 * @param c 初始化的集合
	 * @return 同步的List
	 */
	public static  LinkedList getLinkedList(Collection c) {
		return new LinkedList(c);
	}

	/**
	 * 获得List实例 实现类是LinkedList
	 * @param es 初始化的数组
	 * @return List
	 */
	@SafeVarargs
	public static  List getLinkedList(E... e) {
		return getLinkedList(ArrayUtil.toList(e));
	}

	/**
	 * 返回列表从begin开始返回end个元素
	 * @param list 元素列表
	 * @param begin 开始包含
	 * @param end 结束不包含
	 * @return 返回获得元素列表
	 */
	public static  List subList(List list, int begin, int end) {
		// 如果列表为空返回一个空列表
		if (EmptyUtil.isEmpty(list)) {
			return list;
		}
		// 获得元列表大小
		int size = list.size();
		// 如果开始为小于1 介绍大于列表长度
		if (begin < 1 && end >= size) {
			return list;
		}
		// 判断如果begin大于等于元素列表大小 返回原列表
		if (begin > size) {
			return emptyList();
		}
		// 判断begin
		begin = begin < 0 ? 0 : begin;
		// 如果begin>end
		end = begin > end ? begin + end : end;
		// 判断end
		end = end < 1 || end > size ? size : end;
		// 返回列表
		return list.subList(begin, end);
		// // 获得循环长度
		// int len = begin + end;
		// // 声明一个保存结果的列表
		// List ls = getList(end);
		// // 循环获得元素
		// for (int i = begin; i < len; i++) {
		// // 添加元素
		// ls.add(list.get(i));
		// }
		// // 返回列表
		// return ls;
	}

	/**
	 * 给List排序
	 * @param list 要排序的List
	 * @return 排完序的List
	 */
	public static > List sort(List list) {
		// 排序
		Collections.sort(list);
		// 返回list
		return list;
	}

	/**
	 * 调用每个元素的toString()方法
	 * @param list
	 * @return
	 */
	public static String toString(List list) {
		return ArrayUtil.toString(toArray(list));
	}

	/**
	 * 把一个列表变成数组
	 * @return 一个不可变的空List
	 */
	@SuppressWarnings("unchecked")
	public static  E[] toArray(List list) {
		// 判断列表不为空
		if (EmptyUtil.isEmpty(list)) {
			return ArrayUtil.getArray();
		}
		// 返回数组
		return (E[]) list.toArray(ArrayUtil.getArray(list.get(0).getClass(), list.size()));
	}

	/**
	 * 把一个列表变成数组
	 * @return 一个不可变的空List
	 */
	public static  E[] toArray(List