devutility.internal.util.ListHelper Maven / Gradle / Ivy

Go to download
package devutility.internal.util;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import devutility.internal.data.BeanUtils;
import devutility.internal.lang.ClassHelper;
import devutility.internal.lang.models.EntityField;
import devutility.internal.system.SystemHelper;
import devutility.internal.util.concurrent.ConcurrentExecutor;

public class ListHelper {
	// region empty or not

	public static  boolean isEmpty(List list) {
		return list == null || list.size() == 0;
	}

	public static  boolean isNotEmpty(List list) {
		return list != null && list.size() > 0;
	}

	// endregion

	// region exist

	public static  boolean exist(List list, Predicate predicate) {
		return count(list, predicate) > 0;
	}

	// endregion

	// region find

	public static  T find(List list, Predicate predicate) {
		Optional optional = list.stream().filter(predicate).findAny();

		if (optional.isPresent()) {
			return optional.get();
		}

		return null;
	}

	public static  Optional parallelFindOptional(List list, Predicate predicate) {
		return list.stream().parallel().filter(predicate).findAny();
	}

	public static  T parallelFind(List list, Predicate predicate) {
		Optional optional = parallelFindOptional(list, predicate);

		if (optional.isPresent()) {
			return optional.get();
		}

		return null;
	}

	// endregion

	// region query

	public static  Stream query(List list, Predicate predicate) {
		return list.stream().filter(predicate);
	}

	public static  Stream parallelQuery(List list, Predicate predicate) {
		return list.stream().parallel().filter(predicate);
	}

	// endregion

	// region list

	public static  List list(List list, Predicate predicate) {
		return query(list, predicate).collect(Collectors.toList());
	}

	public static  List parallelList(List list, Predicate predicate) {
		return parallelQuery(list, predicate).collect(Collectors.toList());
	}

	// endregion

	// region count

	public static  int count(List list, Predicate predicate) {
		return (int) list.stream().filter(predicate).count();
	}

	// endregion

	// region map

	public static  List map(List list, Predicate predicate, Function mapper) {
		return query(list, predicate).map(mapper).collect(Collectors.toList());
	}

	public static  List map(List list, Function mapper) {
		return list.stream().map(mapper).collect(Collectors.toList());
	}

	public static  List mapAndDistinct(List list, Predicate predicate, Function mapper) {
		return query(list, predicate).map(mapper).distinct().collect(Collectors.toList());
	}

	public static  List mapAndDistinct(List list, Function mapper) {
		return list.stream().map(mapper).distinct().collect(Collectors.toList());
	}

	public static  List mapMany(List list, Function> mapper) {
		List result = new ArrayList();

		list.stream().map(mapper).forEach(i -> {
			result.addAll(i.collect(Collectors.toList()));
		});

		return result;
	}

	public static  Stream parallelMapToStream(List list, Function mapper) {
		return list.stream().parallel().map(mapper);
	}

	public static  List parallelMap(List list, Function mapper) {
		return parallelMapToStream(list, mapper).collect(Collectors.toList());
	}

	public static  List parallelMapAndDistinct(List list, Function mapper) {
		return parallelMapToStream(list, mapper).distinct().collect(Collectors.toList());
	}

	public static  List parallelMapAndDistinct(List list, Predicate predicate, Function mapper) {
		return parallelQuery(list, predicate).map(mapper).distinct().collect(Collectors.toList());
	}

	/**
	 * Concurrent map
	 * @param list: List need map
	 * @param mapper: Mapper expression
	 * @return {@code List}
	 * @throws InterruptedException
	 * @throws ExecutionException
	 */
	public static  List concurrentMap(List list, Function mapper) throws InterruptedException, ExecutionException {
		List results = new ArrayList<>();
		int processorsCount = SystemHelper.getProcessorsCount();
		List>> callables = new ArrayList<>(processorsCount);
		int pageSize = list.size() / processorsCount + list.size() % processorsCount;

		for (int i = 0; i < processorsCount; i++) {
			int start = i * pageSize;
			int targetEnd = start + pageSize;
			int end = targetEnd > list.size() ? list.size() : targetEnd;

			callables.add(() -> {
				return list.subList(start, end).stream().map(mapper).collect(Collectors.toList());
			});
		}

		List> futureResults = ConcurrentExecutor.runAndGet(callables);

		for (List futureResult : futureResults) {
			results.addAll(futureResult);
		}

		return results;
	}

	// endregion

	// region min

	public static  T min(List list, Comparator comparator) {
		Optional optional = list.stream().min(comparator);

		if (optional.isPresent()) {
			return optional.get();
		}

		return null;
	}

	public static int minInt(List list) {
		Integer value = min(list, Comparator.comparingInt(i -> i));

		if (value == null) {
			return 0;
		}

		return value;
	}

	// endregion

	// region max

	public static  T max(List list, Comparator comparator) {
		Optional optional = list.stream().max(comparator);

		if (optional.isPresent()) {
			return optional.get();
		}

		return null;
	}

	public static int maxInt(List list) {
		Integer value = max(list, Comparator.comparingInt(i -> i));

		if (value == null) {
			return 0;
		}

		return value;
	}

	// endregion

	// region paging

	public static  List paging(List list, int pageIndex, int pageSize) {
		if (list == null || pageIndex < 1) {
			return new ArrayList();
		}

		int skip = (pageIndex - 1) * pageSize;

		if (skip < 0 || skip >= list.size()) {
			return new ArrayList();
		}

		return list.stream().skip(skip).limit(pageSize).collect(Collectors.toList());
	}

	// endregion

	// region top

	public static  List top(List list, int count) {
		if (list == null || count < 1) {
			return new ArrayList();
		}

		return list.stream().limit(count).collect(Collectors.toList());
	}

	// endregion

	// region group

	public static  Map> groupToMap(List list, Function classifier) {
		return list.stream().collect(Collectors.groupingBy(classifier));
	}

	public static  Map> groupToMap(List list, Predicate predicate, Function classifier) {
		return query(list, predicate).collect(Collectors.groupingBy(classifier));
	}

	public static  List group(List list, Function classifier) {
		Map> map = groupToMap(list, classifier);
		return map.keySet().stream().collect(Collectors.toList());
	}

	public static  Map> parallelGroupToMap(List list, Function classifier) {
		return list.stream().parallel().collect(Collectors.groupingBy(classifier));
	}

	// endregion

	/**
	 * List to arrays
	 * @param list: Bean list
	 * @param clazz: Class object of bean.
	 * @return String[][]
	 * @throws IllegalArgumentException
	 * @throws IllegalAccessException
	 * @throws InvocationTargetException
	 */
	public static  String[][] toArrays(List list, Class clazz) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
		List entityFields = ClassHelper.getEntityFields(clazz);
		return toArrays(list, entityFields);
	}

	/**
	 * List to arrays
	 * @param list: Bean list.
	 * @param entityFields: EntityFields of {@code T}
	 * @return String[][]
	 * @throws IllegalArgumentException
	 * @throws IllegalAccessException
	 * @throws InvocationTargetException
	 */
	public static  String[][] toArrays(List list, List entityFields) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		if (list.size() == 0 || entityFields.size() == 0) {
			return new String[0][];
		}

		String[][] arrays = new String[list.size()][];

		for (int i = 0; i < list.size(); i++) {
			T entity = list.get(i);
			String[] array = BeanUtils.toArray(entity, entityFields);

			if (array != null) {
				arrays[i] = array;
			}
		}

		return arrays;
	}

	/**
	 * Arrays to entities list
	 * @param arrays: Arrays
	 * @param clazz: Class object of bean.
	 * @return {@code List}
	 * @throws IllegalAccessException
	 * @throws IllegalArgumentException
	 * @throws InvocationTargetException
	 */
	public static  List toEntities(String[][] arrays, Class clazz) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		List entityFields = ClassHelper.getEntityFields(clazz);
		return toEntities(arrays, clazz, entityFields);
	}

	/**
	 * Arrays to entities list
	 * @param arrays: Arrays
	 * @param clazz: Class object of bean.
	 * @param entityFields: EntityFields of {@code T}
	 * @return {@code List}
	 * @throws IllegalAccessException
	 * @throws IllegalArgumentException
	 * @throws InvocationTargetException
	 */
	public static  List toEntities(String[][] arrays, Class clazz, List entityFields) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		if (arrays == null || arrays.length == 0 || entityFields == null || entityFields.size() == 0) {
			return new ArrayList<>();
		}

		List list = new ArrayList<>(arrays.length);

		for (int i = 0; i < arrays.length; i++) {
			T entity = BeanUtils.toEntity(arrays[i], entityFields, clazz);

			if (entity != null) {
				list.add(entity);
			}
		}

		return list;
	}
}