Java：通过List转换一些通用集合

我们在平时开发中，会遇到很多转换数据的操作，通常会将数据转换成List集合会方便很多，因为在Java_1.8提供了很多针对List的Stream方法；将一些平时比较容易实用的转换整理了下，希望对大家有帮助：

/**
 * Function:  todo
 *
 * @program: ListUtils
 * @Package: com.kingbal.king.dmp.utils
 * @author: dingcho
 * @date: 2024/06/04
 * @version: 1.0
 * @Copyright: 2024 www.kingbal.com Inc. All rights reserved.
 */
public class ListsUtils {

	/**
	 * 将一组数据平均分成n组
	 *
	 * @param source 要分组的数据源
	 * @param n      平均分成n组
	 * @param 
	 * @return
	 */
	public static  List<List> averageAssign(List source, int n) {
		List<List> result = new ArrayList();
		int remainder = source.size() % n;  //(先计算出余数)
		int number = source.size() / n;  //然后是商
		int offset = 0;//偏移量
		for (int i = 0; i < n; i++) {
			List value = null;
			if (remainder > 0) {
				value = source.subList(i * number + offset, (i + 1) * number + offset + 1);
				remainder--;
				offset++;
			} else {
				value = source.subList(i * number + offset, (i + 1) * number + offset);
			}
			result.add(value);
		}
		return result;
	}

	/**
	 * 将一组数据固定分组，每组n个元素
	 *
	 * @param source 要分组的数据源
	 * @param n      每组n个元素
	 * @param 
	 * @return
	 */
	public static  List<List> fixedGrouping(List source, int n) {
		if (null == source || source.size() == 0 || n <= 0)
			return null;
		List<List> result = new ArrayList();
		int sourceSize = source.size();
		int size = (source.size() / n) + 1;
		for (int i = 0; i < size; i++) {
			List subset = new ArrayList();
			for (int j = i * n; j < (i + 1) * n; j++) {
				if (j < sourceSize) {
					subset.add(source.get(j));
				}
			}
			result.add(subset);
		}
		return result;
	}


	/**
	 * 将一组数据固定分组，每组n个元素
	 *
	 * @param source 要分组的数据源
	 * @param n      每组n个元素
	 * @param 
	 * @return
	 */
	public static  List<List> fixedGrouping2(List source, int n) {
		if (null == source || source.size() == 0 || n <= 0)
			return null;
		List<List> result = new ArrayList();
		int remainder = source.size() % n;
		int size = (source.size() / n);
		for (int i = 0; i < size; i++) {
			List subset = source.subList(i * n, (i + 1) * n);
			result.add(subset);
		}
		if (remainder > 0) {
			List subset = source.subList(size * n, size * n + remainder);
			result.add(subset);
		}
		return result;
	}

	/**
	 * 指定数字转换为集合
	 *
	 * @param number
	 * @return
	 */
	public static List fixedList(int number) {
		List list = Lists.newArrayList();
		for (int i = 1; i <= number; i++) {
			list.add(i);
		}
		return list;
	}

	/**
	 * 指定数字转换为集合
	 * @param minInt
	 * @param maxInt
	 * @return
	 */
	public static List fixedMinMaxList(int minInt, int maxInt) {
		List list = Lists.newArrayList();
		for (int i = minInt; i <= maxInt; i++) {
			list.add(i);
		}
		return list;
	}

	/**
	 * 二维集合
	 *
	 * @param number
	 * @param number2
	 * @return
	 */
	public static List fixedList(int number, int number2) {
		List list = Lists.newArrayList();
		for (int i = 1; i <= number; i++) {
			for (int k = 1; k <= number2; k++) {
				list.add(i + "-" + k);
			}
		}
		return list;
	}

	/**
	 * 获取时间分组
	 *
	 * @return
	 */
	public static Map getTimesGroup() {
		Map map = Maps.newHashMap();
		int table = 10;
		int year = 1990;
		for (int i = 1; i  1 && i <= 8) {
				for (int k = 0; k  8) {
				for (int k = 0; k  9) {
						map.put(year++, 1000 + i);
					} else {
						map.put(year++, 100 + i);
					}
				}
			} else {
				for (int k = 0; k < 10; k++) {
					map.put(year++, 100 + i);
				}
			}
		}
		return map;
	}

	/**
	 * 根据已有数据进行数字分组
	 * @param list
	 * @return
	 */
	public static Map getNumberGroup(List list) {
		Map map = Maps.newHashMap();
		list = list.stream().distinct().collect(Collectors.toList());
		Collections.sort(list);
		List list2 = Lists.newArrayList();
		List list3 = Lists.newArrayList();
		for (int i = 0; i < list.size(); i++) {
			StringBuffer key = new StringBuffer();
			if (i % 2 == 0) {
				list2.add(list.get(i));
			} else {
				list3.add(list.get(i));
			}
		}
		if (list.size() % 2 != 0) {
			list3.add(Collections.max(list));
		}
		for (int i = 0; i < list2.size(); i++) {
			map.put(list2.get(i) + "~" + list3.get(i), 0);
		}
		return map;
	}

	/**
	 * 获取多个list最大的size
	 * @param lists
	 * @return
	 */
	public static Integer getMaxSize(List... lists) {
		if (ObjectUtils.isEmpty(lists)) {
			return 0;
		}
		List maxSizeList = new ArrayList();
		for (List list : lists) {
			maxSizeList.add(ObjectUtils.isEmpty(list) ? 0 : list.size());
		}
		return ObjectUtils.isEmpty(maxSizeList) ? 0 : Collections.max(maxSizeList);
	}

	/**
	 * 填充空值
	 * @param list
	 * @param maxSize
	 * @param 
	 * @return
	 */
	public static  List fillValue(List list, int maxSize) {
		if(list.size() < maxSize){
			for (int i = 0; i < maxSize-list.size() +1; i++) {
				list.add(null);
			}
		}
		return list;
	}

}

根据自己的项目需求选择对应方法，如果有其他方法欢迎留言~~~~~~