com.feilong.core.util.CollectionsUtil Maven / Gradle / Ivy
Show all versions of feilong Show documentation
/*
* Copyright (C) 2008 feilong
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.feilong.core.util;
import static com.feilong.core.Validator.isNotNullOrEmpty;
import static com.feilong.core.Validator.isNullOrEmpty;
import static com.feilong.core.bean.ConvertUtil.toArray;
import static com.feilong.core.bean.ConvertUtil.toList;
import static com.feilong.core.util.MapUtil.newLinkedHashMap;
import static java.util.Collections.emptyList;
import static java.util.Collections.emptyMap;
import static java.util.Collections.emptySet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.Transformer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.feilong.core.Validate;
import com.feilong.core.bean.PropertyUtil;
import com.feilong.core.bean.PropertyValueObtainer;
import com.feilong.core.lang.StringUtil;
import com.feilong.core.util.closure.BeanPropertyValueChangeClosure;
import com.feilong.core.util.predicate.BeanPredicateUtil;
import com.feilong.core.util.transformer.BeanTransformer;
import com.feilong.lib.collection4.CollectionUtils;
import com.feilong.lib.collection4.IterableUtils;
import com.feilong.lib.collection4.ListUtils;
import com.feilong.lib.lang3.tuple.Pair;
/**
* {@link Collection} 工具类,是 {@link Collections} 的扩展和补充.
*
* Collections Framework关系图:
*
*
*
* 
*
*
*
* 关于 {@link java.util.Collection}:
*
*
*
*
* 字段
* 说明
*
*
* {@link java.util.Collection Collection}
*
*
* - 一组对象的集合,一般不直接使用
* - 有 {@link Collection#add(Object) add},{@link Collection#size() size},{@link Collection#clear() clear},
* {@link Collection#contains(Object) contains} ,{@link Collection#remove(Object) remove},{@link Collection#removeAll(Collection) removeAll}
* ,{@link Collection#retainAll(Collection) retainAll}, {@link Collection#toArray() toArray}方法
* - 没有get()方法.只能通过iterator()遍历元素
*
*
*
*
*
*
* 关于 {@link java.util.List}:
*
*
*
*
* interface/class
* 说明
*
*
* {@link java.util.List List}
*
*
* - An ordered collection
* - integer index for insert and search.
* - 除了继承Collection接口方法外,有自己的方法定义: get(int) indexOf lastIndexOf listIterator set(int) subList(int,int)
* - optional:可空,可重复
*
*
*
*
* {@link java.util.ArrayList ArrayList}
*
*
* - Resizable-array implementation of the List interface
* - 元素可空
* - 有自己控制容量(数组大小)的方法
*
*
* 扩容:
*
*
*
* - see {@link java.util.ArrayList#ensureCapacity(int)},
* 在jdk1.6里面,int newCapacity = (oldCapacity * 3)/2 + 1 通常是1.5倍
* 在jdk1.7+里面,代码进行了优化
*
*
*
*
*
* {@link java.util.LinkedList LinkedList}
*
*
* - Linked list implementation,双向链表
* - 元素可空
*
*
*
*
* {@link java.util.Vector Vector}
*
*
* - growable array of objects
* - 线程安全的动态数组 synchronized
* - 操作基本和ArrayList相同
*
*
*
*
* {@link java.util.Stack Stack}
*
*
* - last-in-first-out (LIFO) stack of objects
*
*
*
*
*
*
*
*
* 关于 {@link Set }:
*
*
*
*
* interface/class
* 说明
*
*
* {@link java.util.Set Set}
*
*
* - A collection contains no duplicate elements
* - Set和Collection拥有一模一样的接口名称
*
*
*
*
* {@link java.util.HashSet HashSet}
*
*
* - backed by a HashMap instance.
* - makes no guarantees as to the iteration order of the set; 不保证顺序
* - permits the null element.允许空元素
*
*
*
*
* {@link java.util.LinkedHashSet LinkedHashSet}
*
*
* - Hash Map and linked list implementation of the Set interface,
* - with predictable iteration order
*
*
*
*
* {@link java.util.TreeSet TreeSet}
*
*
* - A NavigableSet implementation based on a TreeMap.
* - ordered using their natural ordering, or by a Comparator provided at set creation time
*
*
*
*
* {@link java.util.EnumSet EnumSet}
*
*
* - A specialized Set implementation for use with enum types.
* - Null elements are not permitted.
* - natural order (the order in which the enum constants are declared.
* - abstract class.
* - 以位向量的形式存储,这种存储形式非常紧凑,高效,占用内存很小,运行效率很好.
*
*
*
*
*
*
*
*
* 关于 {@link java.util.Queue Queue}:
*
*
*
*
* interface/class
* 说明
*
*
* {@link java.util.Queue Queue}
*
*
* - Queues typically, but do not necessarily,order elements in a FIFO (first-in-first-out) manner
*
*
*
*
*
*
* SET-MAP现代诗一首
*
*
*
* - 天下人都知道Set,Map不能重复
* - 80%人知道hashCode,equals是判断重复的法则
* - 40%人知道Set添加重复元素时,旧元素不会被覆盖
* - 20%人知道Map添加重复键时,旧键不会被覆盖,而值会覆盖
*
*
*
* guava 实用方法:
*
*
* - com.google.common.collect.Iterables.concat({@code Iterable>})
*
*
*
* @author feilong
* @see java.util.Collections
* @see com.feilong.lib.collection4.ListUtils
* @see com.feilong.lib.collection4.IterableUtils
* @see com.feilong.lib.collection4.CollectionUtils
* @see "org.springframework.util.CollectionUtils"
* @see "com.google.common.collect.Sets"
* @see "com.google.common.collect.Lists"
* @see "com.google.common.collect.Queues"
* @see "com.google.common.collect.Iterators"
* @see "com.google.common.collect.Iterables"
* @since 1.0.2
*
* @since jdk1.5
*/
@SuppressWarnings("squid:S1192") //String literals should not be duplicated
public final class CollectionsUtil{
/** The Constant LOGGER. */
private static final Logger LOGGER = LoggerFactory.getLogger(CollectionsUtil.class);
/** Don't let anyone instantiate this class. */
private CollectionsUtil(){
//AssertionError不是必须的. 但它可以避免不小心在类的内部调用构造器. 保证该类在任何情况下都不会被实例化.
//see 《Effective Java》 2nd
throw new AssertionError("No " + getClass().getName() + " instances for you!");
}
//-----------------------------------------------------------------------
/**
* Returns consecutive {@link List#subList(int, int) sublists} of a
* list, each of the same size (the final list may be smaller). For example,
* partitioning a list containing {@code [a, b, c, d, e]} with a partition
* size of 3 yields {@code [[a, b, c], [d, e]]} -- an outer list containing
* two inner lists of three and two elements, all in the original order.
*
* The outer list is unmodifiable, but reflects the latest state of the
* source list. The inner lists are sublist views of the original list,
* produced on demand using {@link List#subList(int, int)}, and are subject
* to all the usual caveats about modification as explained in that API.
*
* Adapted from http://code.google.com/p/guava-libraries/
*
* @param
* the element type
* @param list
* the list to return consecutive sublists of
* @param size
* the desired size of each sublist (the last may be smaller)
* @return a list of consecutive sublists
* @throws NullPointerException
* if list is null
* @throws IllegalArgumentException
* if size is not strictly positive
* @since 3.0.6
*/
public static List> partition(List list,int size){
return ListUtils.partition(list, size);
}
//---------------------------------------------------------------
/**
* 返回object 元素的大小.
*
*
* 支持object 如下类型:
*
*
*
* - Collection - the collection size
*
- Map - the map size
*
- Array - the array size
*
- Iterator - the number of elements remaining in the iterator
*
- Iterable - the number of elements remaining in the iterator
*
- Enumeration - the number of elements remaining in the enumeration
*
*
* 如果 object 不是上述类型,将抛出异常 {@link IllegalArgumentException}
*
* @param object
* the object to get the size of, may be null
* @return object中包含的元素的数量
* 如果 object 是null 返回 0
* @since 3.0.6
*/
public static int size(final Object object){
return CollectionUtils.size(object);
}
/**
* Shortcut for {@code get(iterator, 0)}.
*
* 返回 iterable {@link Iterator} 里面的第一个元素,如果没有,会抛出 IndexOutOfBoundsException .
*
*
* 如果 {@link Iterable}是个 {@link List}, 会使用 {@link List#get(int)}.
*
*
*
* 示例:
*
*
*
*
*
* CollectionsUtil.first(toList(1, 2, 3)); = 1
*
*
*
*
*
* @param
* the type of object in the {@link Iterable}.
* @param iterable
* the {@link Iterable} to get a value from, may be null
* @return 如果 iterable 是null,抛出 {@link NullPointerException}
* @throws IndexOutOfBoundsException
* if the request is invalid
* @since 3.0.6
*/
public static T first(final Iterable iterable){
return get(iterable, 0);
}
/**
* 返回 iterable {@link Iterator} 里面的最后元素,如果没有,会抛出 IndexOutOfBoundsException .
*
* 如果 {@link Iterable}是个 {@link List}, 会使用 {@link List#get(int)}.
*
*
* 示例:
*
*
*
*
*
* CollectionsUtil.last(toList(1, 2, 3)); = 3
*
*
*
*
*
* @param
* the type of object in the {@link Iterable}.
* @param iterable
* the {@link Iterable} to get a value from, may be null
* @return 如果 iterable 是null,抛出 {@link NullPointerException}
* @throws IndexOutOfBoundsException
* if the request is invalid
* @since 3.5.0
*/
public static T last(final Iterable iterable){
return get(iterable, size(iterable) - 1);
}
/**
* Returns the index-th value in the iterable's {@link Iterator}, throwing
* IndexOutOfBoundsException if there is no such element.
*
* 如果 {@link Iterable}是个 {@link List}, 会使用 {@link List#get(int)}.
*
*
* @param
* the type of object in the {@link Iterable}.
* @param iterable
* the {@link Iterable} to get a value from, may be null
* @param index
* the index to get
* @return 如果 iterable 是null,抛出 {@link NullPointerException}
* @throws IndexOutOfBoundsException
* if the index is invalid
* @since 3.0.6
*/
public static T get(final Iterable iterable,final int index){
Validate.notNull(iterable, "iterable can't be null!");
return IterableUtils.get(iterable, index);
}
/**
* 循环 iterable, 判断元素和参数 element 是否equals, 如果有equals,那么返回true,否则返回false.
*
*
* 使用循环每个元素,然后equals判断
*
*
* 示例:
*
*
*
*
*
* CollectionsUtil.contains(toList("track", "debug"), "debug") = true
*
*
*
*
*
* @param
*
* @param iterable
* the iterable
* @param element
* the element
* @return 如果 iterable 是null或者empty,返回 false
* @see com.feilong.lib.collection4.IterableUtils#contains(Iterable, Object, org.apache.commons.collections4.Equator)
* @see com.feilong.lib.collection4.IterableUtils#contains(Iterable, Object)
* @since 4.0.1
*/
public static boolean contains(final Iterable iterable,final T element){
if (isNullOrEmpty(iterable)){
return false;
}
for (T t : iterable){
if (Objects.equals(t, element)){
return true;
}
}
return false;
}
/**
* 循环 iterable, 判断元素和参数 element 去空且忽视大小写后是否相等, 如果有相等的,那么返回true.
*
* 示例:
*
*
*
*
*
* CollectionsUtil.containsTrimAndIgnoreCase(toList("track", "debug"), " debug") = true
* CollectionsUtil.containsTrimAndIgnoreCase(toList("track", "DEBUG"), " debug") = true
* CollectionsUtil.containsTrimAndIgnoreCase(toList("track", " debug"), " debug") = true
*
*
*
*
*
* 重构:
*
*
*
* 对于以下代码:
*
*
*
* return (StringUtil.trimAndEqualsIgnoreCase(logLevel, "track") //
* || StringUtil.trimAndEqualsIgnoreCase(logLevel, "debug"));
*
*
*
* 可以重构成:
*
*
* return CollectionsUtil.containsTrimAndIgnoreCase(toList("track", "debug"), logLevel);
*
*
*
*
* @param iterable
* the iterable
* @param element
* the element
* @return 如果 iterable 是null或者empty,返回 false
* @since 3.3.4
*/
public static boolean containsTrimAndIgnoreCase(final Iterable iterable,final String element){
if (isNullOrEmpty(iterable)){
return false;
}
for (String string : iterable){
if (StringUtil.trimAndEqualsIgnoreCase(string, element)){
return true;
}
}
return false;
}
//---------------------------------------------------------------
/**
* 循环将beanIterable每个元素的每个指定属性 propertyName的值改成 propertyValue.
*
* 示例:
*
*
*
* 对于以下购物车全选的代码:
*
*
*
* //找到需要处理的对象list
* List{@code } toDoNeedChangeCheckedCommandList = select(
* needChangeCheckedCommandList,
* toggleCheckStatusShoppingCartLinePredicateBuilder.build(shoppingCartLineCommandList, checkStatus));
*
* // 将状态修改成对应状态
* for (ShoppingCartLineCommand shoppingCartLineCommand : toDoNeedChangeCheckedCommandList){
* shoppingCartLineCommand.setSettlementState(1);
* }
*
*
*
* 此时你还可以:
*
*
* //找到需要处理的对象list
* List{@code } toDoNeedChangeCheckedCommandList = select(
* needChangeCheckedCommandList,
* toggleCheckStatusShoppingCartLinePredicateBuilder.build(shoppingCartLineCommandList, checkStatus));
*
* // 将状态修改成对应状态
* CollectionsUtil.forEach(toDoNeedChangeCheckedCommandList, "settlementState", 1);
*
*
*
*
* 说明:
*
*
* - 如果
beanIterable 是null或者empty,什么都不做
* - 如果
beanIterable 中有元素是null,将跳过去
*
*
*
* @param
* the element type
* @param beanIterable
* beanIterable
* @param propertyName
* 泛型O对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @param propertyValue
* 指定属性的属性值
* @throws NullPointerException
* 如果 propertyName 是null
* @throws IllegalArgumentException
* 如果 propertyName 是blank
* @see com.feilong.lib.collection4.IterableUtils#forEach(Iterable, org.apache.commons.collections4.Closure)
* @see BeanPropertyValueChangeClosure
* @since 1.10.2
*/
public static void forEach(final Iterable beanIterable,String propertyName,Object propertyValue){
if (isNotNullOrEmpty(beanIterable)){
IterableUtils.forEach(beanIterable, new BeanPropertyValueChangeClosure(propertyName, propertyValue));
}
}
/**
* 添加所有的{@link Iterable}元素到指定的objectCollection,如果 {@code iterable}是null将忽略.
*
* 示例:
*
*
*
*
*
* List{@code } list = toList("xinge", "feilong1");
* CollectionsUtil.addAllIgnoreNull(list, null); = false
*
*
*
*
* 重构:
*
*
*
* 对于以下代码:
*
*
*
*
* private Set{@code } getItemComboIds(List{@code } lines){
* Set{@code } set = new HashSet{@code <>}();
* if ({@code null != lines && lines.size() > 0}){
* for (ShoppingCartLineCommand line : lines){
* if (line.getComboIds() != null){
* set.addAll(line.getComboIds());
* }
* }
* }
* return set;
* }
*
*
*
* 可以重构成:
*
*
*
* private Set{@code } getItemComboIds(List{@code } lines){
* if (isNullOrEmpty(lines)){
* return Collections.emptySet();
* }
* Set{@code } set = new HashSet{@code <>}();
* for (ShoppingCartLineCommand line : lines){
* CollectionsUtil.addAllIgnoreNull(set, line.getComboIds());
* }
* return set;
* }
*
*
*
* 重构之后,方法的复杂度会更小,阅读性更高
*
*
*
* @param
* the type of object the {@link Collection} contains
* @param objectCollection
* the collection to add to, 不能为null
* @param iterable
* the iterable of elements to add
* @return a boolean 标识 objectCollection 是否改变,如果改变了,返回true.
* 如果 objectCollection 是null,抛出 {@link NullPointerException}
* 如果 iterable 是null,直接返回false
* 否则调用{@link CollectionUtils#addAll(Collection, Iterable)}
* @see com.feilong.lib.collection4.CollectionUtils#addIgnoreNull(Collection, Object)
* @see com.feilong.lib.collection4.CollectionUtils#addAll(Collection, Iterable)
* @see com.feilong.lib.collection4.CollectionUtils#addAll(Collection, Iterator)
* @since 1.6.3
*/
public static boolean addAllIgnoreNull(final Collection objectCollection,final Iterable iterable){
Validate.notNull(objectCollection, "objectCollection can't be null!");
return null != iterable && CollectionUtils.addAll(objectCollection, iterable);
}
/**
* 添加一堆 elements元素到指定的objectCollection,如果其中element null或者 empty元素将忽略.
*
* 重构:
*
*
*
* 对于以下代码:
*
*
*
* List{@code } dataList = new ArrayList{@code <>}();
* for (T bean : iterable){
* Object[] objectArray = toObjectArray(bean, propertyNameList);
* if (isNotNullOrEmpty(objectArray)){
* dataList.add(objectArray);
* }
* }
* return dataList;
*
*
*
* 可以重构成:
*
*
*
* List{@code } dataList = new ArrayList{@code <>}();
* for (T bean : iterable){
* addIgnoreNullOrEmpty(dataList, toObjectArray(bean, propertyNameList));
* }
* return dataList;
*
*
* 重构之后,方法的复杂度会更小,阅读性更高
*
*
*
* 什么情况下元素不是null或者不是empty 但是没有添加进objectCollection:
*
*
* (Returns false if this collection does not permit duplicates and already contains the specified element.)
*
* 如果 objectCollection是个不允许重复元素,并且已经有了要加入的元素, 那么就添加不进去
*
*
*
* Collections that support this operation may place limitations on what elements may be added to this collection. In particular, some
* collections will refuse to add null elements, and others will impose restrictions on the type of elements that may be added.
* Collection classes should clearly specify in their documentation any restrictions on what elements may be added.
*
*
*
* If a collection refuses to add a particular element for any reason other than that it already contains the element, it must throw an
* exception (rather than returning false). This preserves the invariant that a collection always contains the specified element after
* this call returns.
*
*
*
*
* @param
* the generic type
* @param objectCollection
* the collection to add to, 不能为null
* @param elements
* 循环要add 的元素
* @return a boolean 标识 objectCollection 是否改变,如果改变了,返回true.
* 如果 objectCollection 是null,抛出 {@link NullPointerException}
* 如果 elements 是null 或者 empty,直接返回false
* 否则循环调用objectCollection.add(object)
* @see com.feilong.lib.collection4.CollectionUtils#addIgnoreNull(Collection, Object)
* @since 1.8.2
* @since 3.2.1 change to variable argument
*/
public static boolean addIgnoreNullOrEmpty(final Collection objectCollection,final T...elements){
Validate.notNull(objectCollection, "objectCollection can't be null!");
if (isNullOrEmpty(elements)){
return false;
}
//---------------------------------------------------------------
//默认没有改变
boolean result = false;
for (T element : elements){
if (isNullOrEmpty(element)){
continue;
}
if (objectCollection.add(element)){
result = true; //添加进去了 表示改变了
}
}
return result;
}
/**
* 添加 elementIterable里面的元素到指定的objectCollection,如果其中element null或者 empty元素将忽略.
*
* 什么情况下元素不是null或者不是empty 但是没有添加进objectCollection:
*
*
* (Returns false if this collection does not permit duplicates and already contains the specified element.)
*
* 如果 objectCollection是个不允许重复元素,并且已经有了要加入的元素, 那么就添加不进去
*
*
*
* Collections that support this operation may place limitations on what elements may be added to this collection. In particular, some
* collections will refuse to add null elements, and others will impose restrictions on the type of elements that may be added.
* Collection classes should clearly specify in their documentation any restrictions on what elements may be added.
*
*
*
* If a collection refuses to add a particular element for any reason other than that it already contains the element, it must throw an
* exception (rather than returning false). This preserves the invariant that a collection always contains the specified element after
* this call returns.
*
*
*
*
* @param
* the generic type
* @param objectCollection
* the collection to add to, 不能为null
* @param elementIterable
* 循环要add 的元素
* @return a boolean 标识 objectCollection 是否改变,如果改变了,返回true.
* 如果 objectCollection 是null,抛出 {@link NullPointerException}
* 如果 elementIterable 是null 或者 empty,直接返回false
* 否则循环调用objectCollection.add(object)
* @see com.feilong.lib.collection4.CollectionUtils#addIgnoreNull(Collection, Object)
* @since 3.3.9
*/
public static boolean addIgnoreNullOrEmpty(final Collection objectCollection,final Iterable elementIterable){
Validate.notNull(objectCollection, "objectCollection can't be null!");
if (isNullOrEmpty(elementIterable)){
return false;
}
//默认没有改变
boolean result = false;
for (T element : elementIterable){
if (isNullOrEmpty(element)){
continue;
}
if (objectCollection.add(element)){
result = true; //添加进去了 表示改变了
}
}
return result;
}
/**
* 在condition 是true的情况下, 添加 element元素到指定的objectCollection.
*
* 重构:
*
*
*
* 对于以下代码:
*
*
*
* if (lib.getEnableXimaTeach() == 1){
* bookIds.add(ximaTeach);
* }
*
*
*
* 可以重构成:
*
*
*
* addIfCondition(bookIds, ximaTeach, lib.getEnableXimaTeach() == 1);
*
*
* 重构之后,一行可以搞定,代码阅读性更高
*
*
*
* 什么情况下condition是true, 但是没有添加进objectCollection:
*
*
* (Returns false if this collection does not permit duplicates and already contains the specified element.)
*
* 如果 objectCollection是个不允许重复元素,并且已经有了要加入的元素, 那么就添加不进去
*
*
*
* Collections that support this operation may place limitations on what elements may be added to this collection. In particular, some
* collections will refuse to add null elements, and others will impose restrictions on the type of elements that may be added.
* Collection classes should clearly specify in their documentation any restrictions on what elements may be added.
*
*
*
* If a collection refuses to add a particular element for any reason other than that it already contains the element, it must throw an
* exception (rather than returning false). This preserves the invariant that a collection always contains the specified element after
* this call returns.
*
*
*
*
* @param
* the generic type
* @param objectCollection
* the collection to add to, 不能为null
* @param element
* 需要添加的元素
* @param condition
* the condition,仅当条件是true的情况下才会添加
* @return a boolean 标识 objectCollection 是否改变,如果改变了,返回true.
* 如果 objectCollection 是null,抛出 {@link NullPointerException}
* 如果 condition 是false,直接返回false
* 否则调用objectCollection.add(object)
* @see com.feilong.lib.collection4.CollectionUtils#addIgnoreNull(Collection, Object)
* @since 3.3.1
*/
public static boolean addIfCondition(final Collection objectCollection,final T element,boolean condition){
Validate.notNull(objectCollection, "objectCollection can't be null!");
if (!condition){
return false;
}
return objectCollection.add(element);
}
/**
* 在condition 是true的情况下, 设置objectList指定index为 element元素.
*
* 重构:
*
*
*
* 对于以下代码:
*
*
*
* String reason = getCategoryReason(appId, classifyCopyrightStrategyConfig);
* if (isNotNullOrEmpty(reason)){
* result.set(6, reason);
* }
*
*
*
* 可以重构成:
*
*
*
* setIfCondition(result, 6, reason, isNotNullOrEmpty(reason));
*
*
* 重构之后,一行可以搞定,代码阅读性更高
*
*
*
* @param
* the generic type
* @param objectList
* the collection to set, 不能为null
* @param index
* the index
* @param element
* 需要添加的元素
* @param condition
* the condition,仅当条件是true的情况下才会 set
* @since 3.5.1
*/
public static void setIfCondition(final List objectList,int index,final T element,boolean condition){
Validate.notNull(objectList, "objectList can't be null!");
if (!condition){
return;
}
objectList.set(index, element);
}
//---------------------------------------------------------------
/**
* 在list中,查找第一个属性 propertyName 值是指定值 propertyValue 对象的索引位置.
*
* 示例:
*
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User("张飞", 23));
* list.add(new User("关羽", 24));
* list.add(new User("刘备", 25));
*
* CollectionsUtil.indexOf(list, "name", "张飞") = 0
*
* CollectionsUtil.indexOf(null, "age", 24) = -1
* CollectionsUtil.indexOf(new ArrayList{@code }(), "age", 24) = -1
*
*
*
*
* 说明:
*
*
* - 常用于 浏览历史记录,当前的商品id是否在历史记录中第一条位置,如果是,可能就不会操作Cookie,诸如此类的操作
*
*
*
* @param
* the generic type
* @param
* the generic type
* @param list
* the list
* @param propertyName
* 泛型O对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @param propertyValue
* 指定属性的属性值
* @return 如果 list是null 或者 empty,返回 -1
* 如果指定属性propertyName的值 propertyValue在 list 查找不到,返回 -1
* @throws NullPointerException
* 如果 propertyName 是null
* @throws IllegalArgumentException
* 如果 propertyName 是blank
* @see com.feilong.lib.collection4.ListUtils#indexOf(List, Predicate)
* @see BeanPredicateUtil#equalPredicate(String, Object)
* @since 1.5.5
*/
public static int indexOf(List list,String propertyName,V propertyValue){
return ListUtils.indexOf(list, BeanPredicateUtil. equalPredicate(propertyName, propertyValue));
}
//***********************删除****************************************************
/**
* 从 objectCollection中删除所有的 removeCollection (原集合对象不变).
*
* 说明:
*
*
* - 返回剩余的集合 (原集合对象
objectCollection不变),如果你不想修改 objectCollection的话,不能直接调用
* collection.removeAll(remove);,这个方法非常有用.
* - 底层实现是调用的 {@link ListUtils#removeAll(Collection, Collection)},将不是
removeElement的元素加入到新的list返回.
*
*
*
* 示例:
*
*
*
*
* 场景: 从list中删除 "feilong2","feilong1"元素
*
*
*
* List{@code } list = toList("xinge", "feilong1", "feilong2", "feilong2");
* List{@code } removeList = CollectionsUtil.removeAll(list, toList("feilong2", "feilong1"));
*
*
* 返回:
*
*
* ["xinge"]
*
*
*
*
* @param
* the generic type
* @param objectCollection
* the collection from which items are removed (in the returned collection)
* @param removeCollection
* the items to be removed from the returned collection
* @return 从 objectCollection中排除掉 removeCollection 元素的新的 list
* 如果 objectCollection 是null,抛出 {@link NullPointerException}
* 如果 removeCollection 是null,直接返回 objectCollection
* @see ListUtils#removeAll(Collection, Collection)
* @since Commons Collections 4
* @since 1.0.8
* @since 3.3.6 如果 removeCollection 是null,直接返回 objectCollection
*/
public static List removeAll(Collection objectCollection,Collection removeCollection){
Validate.notNull(objectCollection, "objectCollection can't be null!");
if (null == removeCollection){
return toList(objectCollection);
}
return ListUtils.removeAll(objectCollection, removeCollection);
}
/**
* 从 objectCollection中删除所有的 null元素 (原集合对象不变).
*
* 说明:
*
*
*
* - 返回剩余的集合 (原集合对象
objectCollection不变),如果你不想修改 objectCollection的话,不能直接调用
* collection.removeAll(remove);,这个方法非常有用.
* - 底层实现是调用的 {@link ListUtils#removeAll(Collection, Collection)},将不是
removeElement的元素加入到新的list返回.
*
*
*
*
* 示例:
*
*
*
*
* 场景: 从list中删除 null 元素
*
*
*
* List{@code } list = toList("xinge", null, "feilong2", null, "feilong2");
* List{@code } removeList = CollectionsUtil.removeAllNull(list);
*
*
* 返回:
*
*
* "xinge", "feilong2", "feilong2"
*
*
*
*
* @param
* the generic type
* @param objectCollection
* the collection from which items are removed (in the returned collection)
* @return 从 objectCollection中排除掉 null 元素的新的 list
* @throws NullPointerException
* 如果 objectCollection 是null
* @see ListUtils#removeAll(Collection, Collection)
* @since Commons Collections 4
* @since 1.11.0
*/
public static List removeAllNull(Collection objectCollection){
Validate.notNull(objectCollection, "objectCollection can't be null!");
return remove(objectCollection, toArray((O) null));
}
//---------------------------------------------------------------
/**
* 从 objectCollection中 删除removeElements (原集合对象不变).
*
* 说明:
*
*
* - 返回剩余的集合 (原集合对象不变),这个方法非常有用,如果你不想修改
collection的话,不能调用
* collection.remove(removeElements);.
* - 底层实现是调用的 {@link ListUtils#removeAll(Collection, Collection)},将不是
removeElements 的元素加入到新的list返回.
*
*
*
* 示例:
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add("xinge");
* list.add("feilong1");
* list.add("feilong2");
* list.add("feilong2");
*
* LOGGER.info(JsonUtil.format(CollectionsUtil.remove(list, "feilong2")));
*
*
* 返回:
*
*
* ["xinge","feilong1"]
*
*
* 此时,原来的list不变:
*
*
* LOGGER.info(JsonUtil.format(list));
*
*
* 输出 :
*
*
* ["xinge","feilong1","feilong2","feilong2"]
*
*
*
*
* @param
* the generic type
* @param objectCollection
* the object collection
* @param removeElements
* 需要被删除的元素
* @return a List containing all the elements of c except any elements that also occur in remove.
* @throws NullPointerException
* 如果 objectCollection 是null
* @see #removeAll(Collection, Collection)
* @see ListUtils#removeAll(Collection, Collection)
* @since Commons Collections 4
* @since 1.0.8
* @since 1.10.7 change param to Varargs
*/
@SafeVarargs
public static List remove(Collection objectCollection,O...removeElements){
return removeAll(objectCollection, toList(removeElements));
}
//---------------------------------------------------------------
/**
* 去重,返回没有重复元素的新list (原集合对象不变).
*
* 示例:
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add("feilong1");
* list.add("feilong2");
* list.add("feilong2");
* list.add("feilong3");
*
* LOGGER.info(JsonUtil.format(CollectionsUtil.removeDuplicate(list)));
*
*
* 返回:
*
*
* ["feilong1","feilong2","feilong3"]
*
*
*
*
* 注意:
*
*
* - 如果原
objectCollection 是有序的,那么返回的结果参照原 objectCollection元素顺序
* - 原
objectCollection不变
*
*
*
* @param
* the generic type
* @param objectCollection
* the object collection
* @return 如果 objectCollection 是null或者empty,返回 {@link Collections#emptyList()}
* 否则先转换成 {@link LinkedHashSet},再转换成{@link ArrayList}返回
* @see LinkedHashSet#LinkedHashSet(Collection)
* @see com.feilong.core.bean.ConvertUtil#toList(Collection)
* @see "org.apache.commons.collections4.IterableUtils#uniqueIterable(Iterable)"
* @see http://www.oschina.net/code/snippet_117714_2991?p=2#comments
*
*/
public static List removeDuplicate(Collection objectCollection){
return isNullOrEmpty(objectCollection) ? Collections. emptyList() : toList(new LinkedHashSet(objectCollection));
}
/**
* 去重,返回 objectCollection 指定属性 propertyName 没有重复值的新list (原集合对象不变).
*
* 示例:
*
*
* 有以下两个user 对象, id值都是1,这时去重,只保留一个
*
*
*
*
*
* User user1 = new User(1L);
* User user2 = new User(1L);
* List{@code } list = toList(user1, user2);
*
* List{@code } removeDuplicate = CollectionsUtil.removeDuplicate(list, "id");
*
* assertThat(removeDuplicate, contains(user1));
* assertSame(1, removeDuplicate.size());
*
*
*
*
* 注意:
*
*
* - 如果原
objectCollection 是有序的,那么返回的结果参照原 objectCollection元素顺序
* - 出现
propertyName 值重复的话,只保留第一个元素
* - 原
objectCollection不变
*
*
*
* @param
* the generic type
* @param objectCollection
* the object collection
* @param propertyName
* 包含的属性数组名字数组,(can be nested/indexed/mapped/combo),
* 如果是null或者empty,那么直接调用 {@link #removeDuplicate(Collection)}
* @return 如果 propertyName 是null或者empty,那么直接调用 {@link #removeDuplicate(Collection)}
* 如果 objectCollection 是null或者empty,返回 {@link Collections#emptyList()}
* 否则调用 {@link #group(Iterable, String)},将map 的values转成list返回
* @see LinkedHashSet#LinkedHashSet(Collection)
* @see com.feilong.core.bean.ConvertUtil#toList(Collection)
* @see "org.apache.commons.collections4.IterableUtils#uniqueIterable(Iterable)"
* @see http://www.oschina.net/code/snippet_117714_2991?p=2#comments
*
* @since 2.1.0
*/
public static List removeDuplicate(Collection objectCollection,String propertyName){
if (isNullOrEmpty(propertyName)){
return removeDuplicate(objectCollection);
}
if (isNullOrEmpty(objectCollection)){
return Collections. emptyList();
}
//---------------------------------------------------------------
Map map = groupOne(objectCollection, propertyName);
return toList(map.values());
}
/**
* 去重,返回指定属性 propertyNames 组合的值都不重复元素的新list (原集合对象不变).
*
* 示例:
*
*
* 以下3个user id都是1, 年龄分别是 15 ,16,15; 现在要把id以及年龄都一样的数据去重
*
*
*
*
*
* User user1 = new User(1L);
* user1.setUserInfo(new UserInfo(15));
*
* User user2 = new User(1L);
* user2.setUserInfo(new UserInfo(16));
*
* User user3 = new User(1L);
* user3.setUserInfo(new UserInfo(15));
*
* List{@code } list = toList(user1, user2, user3);
*
* List{@code } removeDuplicate = CollectionsUtil.removeDuplicate(list, "id", "userInfo.age");
*
* assertThat(removeDuplicate, contains(user1, user2));
* assertSame(2, removeDuplicate.size());
*
*
*
*
*
* 注意:
*
*
* - 如果原
objectCollection 是有序的,那么返回的结果参照原 objectCollection元素顺序
* - 出现
propertyName 值重复的话,只保留第一个元素
* - 原
objectCollection不变
*
*
*
* @param
* the generic type
* @param objectCollection
* the object collection
* @param propertyNames
* 包含的属性数组名字数组,(can be nested/indexed/mapped/combo),
* 如果是null或者empty,那么直接调用 {@link #removeDuplicate(Collection)}
* @return 如果 propertyNames 是null或者empty,那么直接调用 {@link #removeDuplicate(Collection)}
* 如果 objectCollection 是null或者empty,返回 {@link Collections#emptyList()}
* 如果 propertyNames 只有1个元素,那么调用 {@link #removeDuplicate(Collection, String)} 返回
* @see LinkedHashSet#LinkedHashSet(Collection)
* @see com.feilong.core.bean.ConvertUtil#toList(Collection)
* @see "org.apache.commons.collections4.IterableUtils#uniqueIterable(Iterable)"
* @see http://www.oschina.net/code/snippet_117714_2991?p=2#comments
*
* @since 2.1.0
*/
public static List removeDuplicate(Collection objectCollection,String...propertyNames){
if (isNullOrEmpty(propertyNames)){
return removeDuplicate(objectCollection);
}
if (isNullOrEmpty(objectCollection)){
return Collections. emptyList();
}
//提高性能 since 3.1.0
if (propertyNames.length == 1){
return removeDuplicate(objectCollection, propertyNames[0]);
}
//---------------------------------------------------------------
//用来识别是否重复
List> allValueMapList = newArrayList();
//用来存放返回list
List returnList = new ArrayList<>(size(objectCollection));
//---------------------------------------------------------------
for (O o : objectCollection){
Map propertyNameAndValueMap = PropertyUtil.describe(o, propertyNames);
boolean isNotExist = !isExist(allValueMapList, propertyNameAndValueMap, propertyNames);
if (isNotExist){
returnList.add(o);
allValueMapList.add(propertyNameAndValueMap);
}
}
return returnList;
}
/**
* 分隔集合,将新数据放left , 重复的数据放right.
*
*
* 请自行先进行排序处理
*
*
* 示例:
*
*
*
* 有 User 对象,两个属性 id和age
*
*
*
* User user1 = new User(1L, 15);
* User user2 = new User(1L, 16);
* User user3 = new User(1L, 15); //这条和第一条重复了
* List{@code } list = toList(user1, user2, user3);
*
* Pair{@code , List>} splitDuplicate = CollectionsUtil.splitDuplicate(list, "id", "age");
*
* //left 保存的是不重复的数据
* List{@code } newDuplicate = splitDuplicate.getLeft();
// right 保存的是和left有属性值重复的数据
* List{@code } rightDuplicate = splitDuplicate.getRight();
*
* assertSame(2, newDuplicate.size());
* assertThat(newDuplicate, contains(user1, user2));
*
* assertSame(1, rightDuplicate.size());
* assertThat(rightDuplicate, contains(user3));
*
*
*
*
*
* @param
* @param objectCollection
* the object collection
* @param propertyNames
* 包含的属性数组名字数组,(can be nested/indexed/mapped/combo),
* 如果是null或者empty,那么直接调用 {@link #removeDuplicate(Collection)}
* @return 将新数据放left , 重复的数据放right.
* 如果 propertyNames 是null或者empty,返回 null
* 如果 objectCollection 是null或者empty,返回 null
* @since 4.0.7
*/
public static Pair, List> splitDuplicate(Collection objectCollection,String...propertyNames){
if (isNullOrEmpty(propertyNames)){
return null;
}
if (isNullOrEmpty(objectCollection)){
return null;
}
//---------------------------------------------------------------
//新数据
List newList = new ArrayList<>(size(objectCollection));
//重复
List duplicateList = new ArrayList<>(size(objectCollection));
//---------------------------------------------------------------
//用来识别是否重复
List> allValueMapList = newArrayList();
for (O o : objectCollection){
Map propertyNameAndValueMap = PropertyUtil.describe(o, propertyNames);
boolean isNotExist = !isExist(allValueMapList, propertyNameAndValueMap, propertyNames);
if (isNotExist){
newList.add(o);
allValueMapList.add(propertyNameAndValueMap);
}else{
duplicateList.add(o);
}
}
return Pair.of(newList, duplicateList);
}
/**
* 判断allValueMapList 中,是否含有指定 key-value 的map.
*
* @param allValueMapList
* the map list
* @param propertyNameAndValueMap
* the property name and value map
* @param keys
* the keys
* @return 存在,返回true
* @since 2.1.0
*/
private static boolean isExist(List> allValueMapList,Map propertyNameAndValueMap,String...keys){
for (Map map : allValueMapList){
if (eqauls(map, propertyNameAndValueMap, keys)){
return true;
}
}
return false;
}
/**
* 判断两个map ,提取每个属性 keys 值, 看看是否一致, 如果有不一致的返回false; 如果都一致那么返回true.
*
* @param map
* the map
* @param propertyNameAndValueMap
* the property name and value map
* @param keys
* the property names
* @return true, if successful
* @since 2.1.0
*/
private static boolean eqauls(Map map,Map propertyNameAndValueMap,String...keys){
for (String propertyName : keys){
if (!Objects.equals(map.get(propertyName), propertyNameAndValueMap.get(propertyName))){
return false;
}
}
return true;
}
//----------------------获得 属性值-----------------------------------------
/**
* 循环集合 beanIterable,取到对象指定的属性 propertyName的值,拼成List({@link ArrayList}).
*
* 示例:
*
*
*
*
* 场景: 获取user list每个元素的id属性值,组成新的list返回
*
*
*
*
* List{@code } list = toList(//
* new User(2L),
* new User(5L),
* new User(5L));
*
* List{@code } resultList = CollectionsUtil.getPropertyValueList(list, "id");
* LOGGER.debug(JsonUtil.format(resultList));
*
*
*
* 返回:
*
*
* [2,5,5]
*
*
*
*
* 对于参数 propertyName:
*
*
*
*
* 对于以下的数据结构:
*
*
*
*
* //***************list****************************************
* List{@code } userAddresseList = new ArrayList{@code <>}();
*
* UserAddress userAddress = new UserAddress();
* userAddress.setAddress("中南海");
* userAddresseList.add(userAddress);
*
* //***************map****************************************
* Map{@code } attrMap = new HashMap{@code <>}();
* attrMap.put("蜀国", "赵子龙");
* attrMap.put("魏国", "张文远");
* attrMap.put("吴国", "甘兴霸");
*
* //---------------------------------------------------------------
* UserInfo userInfo1 = new UserInfo();
* userInfo1.setAge(28);
*
* User user1 = new User(2L);
* user1.setLoves(new String[] { "sanguo1", "xiaoshuo1" });
* user1.setUserInfo(userInfo1);
* user1.setAttrMap(attrMap);
* user1.setUserAddresseList(userAddresseList);
*
* //---------------------------------------------------------------
* UserInfo userInfo2 = new UserInfo();
* userInfo2.setAge(null);
*
* User user2 = new User(3L);
* user2.setLoves(new String[] { "sanguo2", "xiaoshuo2" });
* user2.setUserInfo(userInfo2);
* user2.setAttrMap(attrMap);
* user2.setUserAddresseList(userAddresseList);
*
* List{@code } userList = toList(user1,user2);
*
*
*
* 以下情况:
*
*
*
* //数组,取userList 每个元素的 loves属性第2个元素的值
* CollectionsUtil.getPropertyValueList(userList, "loves[1]") = ["xiaoshuo1","xiaoshuo2"]
* //级联对象,取userList 每个元素的 userInfo属性的 age 属性的值
* CollectionsUtil.getPropertyValueList(userList, "userInfo.age") = [28,null]
*
* //Map,取userList 每个元素的 attrMap属性中的key是 "蜀国" 的值
* CollectionsUtil.getPropertyValueList(userList, "attrMap(蜀国)") = ["赵子龙","赵子龙"]
*
* //集合,取userList 每个元素的 userAddresseList属性中的第一个元素
* CollectionsUtil.getPropertyValueList(userList, "userAddresseList[0]") = [{"address": "中南海"},{"address": "中南海"}]
*
*
*
*
* 关于参数 beanIterable
*
* 支持以下类型:
*
* - bean Iterable
* - 诸如List{@code
},Set{@code }等
*
* - map Iterable
* -
* 比如 {@code List
>}
*
* 示例:
*
*
* List{@code >} list = newArrayList();
* list.add(toMap("key", "value1"));
* list.add(toMap("key", "value2"));
* list.add(toMap("key", "value3"));
*
* List{@code } resultList = CollectionsUtil.getPropertyValueList(list, "(key)");
* assertThat(resultList, contains("value1", "value2", "value3"));
*
*
*
*
* - list Iterable
* -
* 比如 {@code List
>}
*
* 示例:
*
*
* List{@code >} list = newArrayList();
* list.add(toList("小明", "18"));
* list.add(toList("小宏", "18"));
* list.add(toList("小振", "18"));
*
* List{@code } resultList = CollectionsUtil.getPropertyValueList(list, "[0]");
* assertThat(resultList, contains("小明", "小宏", "小振"));
*
*
*
*
* - 数组 Iterable
* -
* 比如 {@code List
}
*
* 示例:
*
*
* List{@code } list = newArrayList();
* list.add(toArray("三国", "水浒"));
* list.add(toArray("西游", "金瓶梅"));
*
* List{@code } resultList = CollectionsUtil.getPropertyValueList(list, "[0]");
* assertThat(resultList, contains("三国", "西游"));
*
*
*
*
*
*
*
* @param
* 返回集合类型 generic type
* @param
* 可迭代对象类型 generic type
* @param beanIterable
* 支持
*
*
* - bean Iterable,比如List{@code
},Set{@code }等
* - map Iterable,比如{@code List
>}
* - list Iterable , 比如 {@code List
>}
* - 数组 Iterable ,比如 {@code List
}
*
*
* @param propertyName
* 泛型O对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @return 如果参数 beanIterable是null或者empty,会返回empty ArrayList
* 如果 propertyName 是null,抛出 {@link NullPointerException}
* 如果 propertyName 是blank,抛出 {@link IllegalArgumentException}
* @see PropertyValueObtainer#getPropertyValueCollection(Iterable, String, Collection)
* @since jdk1.5
*/
public static List getPropertyValueList(Iterable beanIterable,String propertyName){
return getPropertyValueList(beanIterable, propertyName, null);
}
/**
* 循环集合 beanIterable,用对象指定的 mapper的值,拼成List({@link ArrayList}).
*
* 示例:
*
*
*
*
* 场景: 获取user list每个元素的id属性值,组成新的list返回
*
*
*
*
* List{@code } list = toList(//
* new User(2L),
* new User(5L),
* new User(5L));
*
* List{@code } resultList = CollectionsUtil.getPropertyValueList(list, User::getId);
* LOGGER.debug(JsonUtil.format(resultList));
*
*
*
* 返回:
*
*
* [2,5,5]
*
*
*
*
* @implSpec
*
* 默认实现:
*
*
*
* {@code
beanIterable.stream()//
.map(mapper)//
.collect(Collectors.toList())
* }
*
*
* @param
* 返回集合类型 generic type
* @param
* 可迭代对象类型 generic type
* @param beanIterable
* the bean iterable
* @param mapper
* the mapper
* @return 如果参数 beanIterable是null或者empty,会返回empty ArrayList
* 如果 mapper 是null,抛出 {@link NullPointerException}
* @since 4.0.0
*
*/
public static List getPropertyValueList(Collection beanIterable,Function mapper){
if (null == beanIterable){
return emptyList();
}
//---------------------------------------------------------------
Validate.notNull(mapper, "mapper can't be null!");
return beanIterable.stream()//
.map(mapper)//
.collect(Collectors.toList());
}
//---------------------------------------------------------------
/**
* 循环集合 beanIterable,取到对象指定的属性 propertyName的值,将值转换成
* returnElementClass类型,拼成List({@link ArrayList}).
*
* 示例:
*
*
*
*
* 场景: 获取user list每个元素的id属性值,转成String类型,组成新的list返回
*
*
*
*
* List{@code } list = toList(//
* new User(2L),
* new User(5L),
* new User(5L));
*
* List{@code } resultList = CollectionsUtil.getPropertyValueList(list, "id",String.class);
* LOGGER.debug(JsonUtil.format(resultList));
*
*
*
* 返回:
*
*
* ["2","5","5"]
*
*
*
*
* 重构:
*
*
*
* 对于以下代码:
*
*
*
*
* List{@code } albumIdList = newArrayList();
* for (SingleBookPo singleBookPo : albums){
* albumIdList.add(singleBookPo.getAlbumId().toString());
* }
*
*
*
* 可以重构成:
*
*
* CollectionsUtil.getPropertyValueList(albums, "albumId", String.class);
*
*
*
*
* 关于参数 beanIterable
*
* 支持以下类型:
*
* - bean Iterable
* - 诸如List{@code
},Set{@code }等
*
* - map Iterable
* -
* 比如 {@code List
>}
*
* 示例:
*
*
* List{@code >} list = newArrayList();
* list.add(toMap("key", "1"));
* list.add(toMap("key", "2"));
* list.add(toMap("key", "3"));
*
* List{@code } resultList = CollectionsUtil.getPropertyValueList(list, "(key)",Integer.class);
* assertThat(resultList, contains(1, 2, 3));
*
*
*
*
* - list Iterable
* -
* 比如 {@code List
>}
*
* 示例:
*
*
* List{@code >} list = newArrayList();
* list.add(toList("小明", "18"));
* list.add(toList("小宏", "19"));
* list.add(toList("小振", "20"));
*
* List{@code } resultList = CollectionsUtil.getPropertyValueList(list, "[1]",Long.class);
* assertThat(resultList, contains(18L, 19L, 20L));
*
*
*
*
* - 数组 Iterable
* -
* 比如 {@code List
}
*
* 示例:
*
*
* List{@code } list = newArrayList();
* list.add(toArray("三国", "水浒"));
* list.add(toArray("西游", "金瓶梅"));
*
* List{@code } resultList = CollectionsUtil.getPropertyValueList(list, "[0]",String.class);
* assertThat(resultList, contains("三国", "西游"));
*
*
*
*
*
*
*
* @param
* 返回集合类型 generic type
* @param
* 可迭代对象类型 generic type
* @param beanIterable
* 支持
*
*
* - bean Iterable,比如List{@code
},Set{@code }等
* - map Iterable,比如{@code List
>}
* - list Iterable , 比如 {@code List
>}
* - 数组 Iterable ,比如 {@code List
}
*
* @param propertyName
* 泛型O对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @param returnElementClass
* 如果 returnElementClass 是null,表示不需要类型转换
* @return 如果参数 beanIterable是null或者empty,会返回empty ArrayList
* 如果 propertyName 是null,抛出 {@link NullPointerException}
* 如果 propertyName 是blank,抛出 {@link IllegalArgumentException}
* 如果 returnElementClass 是null,表示不需要类型转换
* @see PropertyValueObtainer#getPropertyValueCollection(Iterable, String, Collection, Class)
* @since 3.3.1
*/
public static List getPropertyValueList(Iterable beanIterable,String propertyName,Class returnElementClass){
if (isNullOrEmpty(beanIterable)){//避免null point
return emptyList();
}
return PropertyValueObtainer
.getPropertyValueCollection(beanIterable, propertyName, new ArrayList(size(beanIterable)), returnElementClass);
}
/**
* 解析迭代集合 beanIterable ,取到对象指定的属性 propertyName的值,拼成{@link Set}({@link LinkedHashSet}).
*
* 说明:
*
*
* - 返回的是 {@link LinkedHashSet},顺序是参数
beanIterable 元素的顺序
*
*
*
* 示例:
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User(2L));
* list.add(new User(5L));
* list.add(new User(5L));
*
* LOGGER.info(JsonUtil.format(CollectionsUtil.getPropertyValueSet(list, "id")));
*
*
* 返回:
*
*
* [2,5]
*
*
*
*
* @param
* the generic type
* @param
* the generic type
* @param beanIterable
* 支持
*
*
* - bean Iterable,比如List{@code
},Set{@code }等
* - map Iterable,比如{@code List
>}
* - list Iterable , 比如 {@code List
>}
* - 数组 Iterable ,比如 {@code List
}
*
* @param propertyName
* 泛型O对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @return 如果参数 beanIterable是null或者empty,会返回empty {@link LinkedHashSet}
* 如果 propertyName 是null,抛出 {@link NullPointerException}
* 如果 propertyName 是blank,抛出 {@link IllegalArgumentException}
* @see PropertyValueObtainer#getPropertyValueCollection(Iterable, String, Collection)
* @since 1.0.8
*/
public static Set getPropertyValueSet(Iterable beanIterable,String propertyName){
return getPropertyValueSet(beanIterable, propertyName, null);
}
/**
* 解析迭代集合 beanIterable ,取到对象指定的属性 propertyName的值,将值转换成
* returnElementClass类型,拼成{@link Set}({@link LinkedHashSet}).
*
* 说明:
*
*
* - 返回的是 {@link LinkedHashSet},顺序是参数
beanIterable 元素的顺序
*
*
*
* 示例:
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User(2L));
* list.add(new User(5L));
* list.add(new User(5L));
*
* LOGGER.info(JsonUtil.format(CollectionsUtil.getPropertyValueSet(list, "id",String.class)));
*
*
* 返回:
*
*
* ["2","5"]
*
*
*
*
*
* 重构:
*
*
*
* 对于以下代码:
*
*
*
*
* Set{@code } albumIdSet = newHashSet();
* for (SingleBookPo singleBookPo : albums){
* albumIdSet.add(singleBookPo.getAlbumId().toString());
* }
*
*
*
* 可以重构成:
*
*
* CollectionsUtil.getPropertyValueSet(albums, "albumId", String.class);
*
*
*
*
* @param
* the generic type
* @param
* the generic type
* @param beanIterable
* 支持
*
*
* - bean Iterable,比如List{@code
},Set{@code }等
* - map Iterable,比如{@code List
>}
* - list Iterable , 比如 {@code List
>}
* - 数组 Iterable ,比如 {@code List
}
*
* @param propertyName
* 泛型O对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @param returnElementClass
* 如果 returnElementClass 是null,表示不需要类型转换
* @return 如果参数 beanIterable是null或者empty,会返回empty {@link LinkedHashSet}
* 如果 propertyName 是null,抛出 {@link NullPointerException}
* 如果 propertyName 是blank,抛出 {@link IllegalArgumentException}
* 如果 returnElementClass 是null,表示不需要类型转换
* @see PropertyValueObtainer#getPropertyValueCollection(Iterable, String, Collection, Class)
* @since 3.3.1
*/
public static Set getPropertyValueSet(Iterable beanIterable,String propertyName,Class returnElementClass){
if (isNullOrEmpty(beanIterable)){//避免null point
return emptySet();
}
return PropertyValueObtainer.getPropertyValueCollection(
beanIterable,
propertyName,
new LinkedHashSet(size(beanIterable)),
returnElementClass);
}
//----------------------------getPropertyValueMap-----------------------------------
/**
* 循环 beanIterable ,以 keyPropertyName属性值为key, valuePropertyName属性值为value,组成map返回.
*
* 说明:
*
*
* - 返回的是 {@link LinkedHashMap},顺序是参数
beanIterable 元素的顺序
* - 如果有元素
keyPropertyName属性值相同,那么后面的值会覆盖前面的值
*
*
*
* 示例:
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User("张飞", 23));
* list.add(new User("关羽", 24));
* list.add(new User("刘备", 25));
*
* LOGGER.info(JsonUtil.format(CollectionsUtil.getPropertyValueMap(list, "name", "age")));
*
*
* 返回:
*
*
* {
* "张飞": 23,
* "关羽": 24,
* "刘备": 25
* }
*
*
*
*
* 如果有元素 keyPropertyName属性值相同,那么后面的值会覆盖前面的值
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User("张飞", 23));
* list.add(new User("关羽", 24));
* list.add(new User("张飞", 25));
*
* LOGGER.info(JsonUtil.format(CollectionsUtil.getPropertyValueMap(list, "name", "age")));
*
*
* 返回:
*
*
* {
* "张飞": 25,
* "关羽": 24,
* }
*
*
*
*
* @param
* the key type
* @param
* the value type
* @param
* 可迭代对象类型 generic type
* @param beanIterable
* bean Iterable,诸如List{@code },Set{@code }等
* @param keyPropertyName
* 泛型O对象指定的属性名称,取到的值将作为返回的map的key,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @param valuePropertyName
* 泛型O对象指定的属性名称,取到的值将作为返回的map的value,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @return 如果 beanIterable 是null或者empty,返回 {@link Collections#emptyMap()}
* 如果 keyPropertyName 是null,抛出 {@link NullPointerException}
* 如果 keyPropertyName 是blank,抛出 {@link IllegalArgumentException}
* 如果 valuePropertyName 是null,抛出 {@link NullPointerException}
* 如果 valuePropertyName 是blank,抛出 {@link IllegalArgumentException}
* @see com.feilong.core.bean.PropertyUtil#getProperty(Object, String)
*/
public static Map getPropertyValueMap(Iterable beanIterable,String keyPropertyName,String valuePropertyName){
if (isNullOrEmpty(beanIterable)){
return emptyMap();
}
//---------------------------------------------------------------
Validate.notBlank(keyPropertyName, "keyPropertyName can't be null/empty!");
Validate.notBlank(valuePropertyName, "valuePropertyName can't be null/empty!");
Map map = newLinkedHashMap(size(beanIterable));
for (O bean : beanIterable){
map.put(PropertyUtil. getProperty(bean, keyPropertyName), PropertyUtil. getProperty(bean, valuePropertyName));
}
return map;
}
//---------------------------------------------------------------
/**
* 判断iterable中,是否存在 propertyName属性名称值是 propertyValue 的元素.
*
* 示例:
*
*
*
* 场景: list中查找是否存在name是 关羽 的User对象
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User("张飞", 23));
* list.add(new User("关羽", 24));
* list.add(new User("刘备", 25));
* list.add(new User("关羽", 50));
*
* LOGGER.info(CollectionsUtil.exist(list, "name", "关羽"));
*
*
* 返回:
*
*
* true
*
*
*
*
* 重构:
*
*
*
* 对于以下代码:
*
*
*
* Long soundId = singleBookQueryRequest.getSoundId();
* List{@code } soundVoList = soundVoListBuilderFactory
* .querySoundVoByMaterial(libraryPo, materialId, forceSetPaidUrl, doNotCheckNumberLimit, pageIndex);
* boolean isContain = false;
* for (SoundVo soundVo : soundVoList){
* if (soundVo.getSoundId().equals(soundId)){
* isContain = true;
* break;
* }
* }
*
*
*
* 可以重构成:
*
*
* Long soundId = singleBookQueryRequest.getSoundId();
* List{@code } soundVoList = soundVoListBuilderFactory
* .querySoundVoByMaterial(libraryPo, materialId, forceSetPaidUrl, doNotCheckNumberLimit, pageIndex);
* boolean isContain = CollectionsUtil.exist(soundVoList, "soundId", soundId);
*
*
*
*
*
* @param
* the generic type
* @param
* the value type
* @param beanIterable
* bean Iterable,诸如List{@code },Set{@code }等
* @param propertyName
* 泛型O对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @param propertyValue
* 指定的值
* @return 如果 iterable是null, 返回false
* 如果 propertyName 是null,抛出 {@link NullPointerException}
* 如果 propertyName 是blank,抛出 {@link IllegalArgumentException}
* 如果 iterable中没有相关元素的属性propertyName 值是propertyValue,返回false
* @since 3.0.8
*/
public static boolean exist(Iterable beanIterable,String propertyName,V propertyValue){
return null != find(beanIterable, propertyName, propertyValue);
}
/**
* 判断是否存在 iterable中, propertyName属性名称和值是 propertyValue是 propertyNameAndPropertyValueMap 的对应元素.
*
* 示例:
*
*
*
* 场景: 判断list中是否存在 name是 关羽,且年龄是24 的User对象
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User("张飞", 23));
* list.add(new User("关羽", 24));
* list.add(new User("刘备", 25));
* list.add(new User("关羽", 50));
*
* Map{@code } map = toMap("name", "关羽", "age", 24);
* LOGGER.info(JsonUtil.format(CollectionsUtil.exist(list, map)));
*
*
* 返回:
*
*
* true
*
*
*
*
* @param
* the generic type
* @param beanIterable
* bean Iterable,诸如List{@code },Set{@code }等
* @param propertyNameAndPropertyValueMap
* 属性和指定属性值对应的map,其中key是泛型T对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @return 如果 iterable是null, 返回null
* 如果 propertyNameAndPropertyValueMap 是null,抛出 {@link NullPointerException}
* 如果 propertyNameAndPropertyValueMap 是empty,抛出{@link IllegalArgumentException}
* 如果 propertyNameAndPropertyValueMap 中有key是null,抛出{@link NullPointerException}
* 如果 propertyNameAndPropertyValueMap 中有key是blank,抛出{@link IllegalArgumentException}
* 如果 iterable中没有相关元素的属性propertyName 值是propertyValue,返回false
* @since 3.0.8
*/
public static boolean exist(Iterable beanIterable,Map propertyNameAndPropertyValueMap){
return null != find(beanIterable, propertyNameAndPropertyValueMap);
}
/**
* 判断是否存在匹配predicate 的元素.
*
* 示例:
*
*
*
*
* 场景: 从list中查找name是 关羽,并且 age等于30的User对象是否存在
*
*
*
* List{@code } list = toList(//
* new User("张飞", 23),
* new User("关羽", 24),
* new User("刘备", 25),
* new User("关羽", 30));
*
* Map{@code } map = new HashMap{@code <>}();
* map.put("name", "关羽");
* map.put("age", 30);
*
* Predicate{@code } predicate = BeanPredicateUtil.equalPredicate(map);
*
* LOGGER.debug(JsonUtil.format(CollectionsUtil.exist(list, predicate)));
*
*
* 返回:
*
*
* true
*
*
*
*
* @param
* the generic type
* @param iterable
* the iterable to search, may be null
* @param predicate
* the predicate to use, may not be null
* @return 如果 predicate 是 null,将抛出{@link NullPointerException}
* 如果 iterable是null, 返回null
* 如果 iterable中没有相关元素匹配 predicate,返回false
* @since 3.0.8
*/
public static boolean exist(Iterable iterable,Predicate predicate){
return null != find(iterable, predicate);
}
//*************************find****************************************************************
/**
* 找到 iterable中,第一个 propertyName属性名称值是 propertyValue 的对应元素.
*
* 示例:
*
*
*
* 场景: 从list中查找name是 关羽 的User对象
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User("张飞", 23));
* list.add(new User("关羽", 24));
* list.add(new User("刘备", 25));
* list.add(new User("关羽", 50));
*
* LOGGER.info(JsonUtil.format(CollectionsUtil.find(list, "name", "关羽")));
*
*
* 返回:
*
*
* {
* "age": 24,
* "name": "关羽"
* }
*
*
*
*
* 说明:
*
*
* - 返回第一个匹配对象
*
*
*
* @param
* the generic type
* @param
* the value type
* @param beanIterable
* bean Iterable,诸如List{@code },Set{@code }等
* @param propertyName
* 泛型O对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @param propertyValue
* 指定的值
* @return 如果 iterable是null, 返回null
* 如果 propertyName 是null,抛出 {@link NullPointerException}
* 如果 propertyName 是blank,抛出 {@link IllegalArgumentException}
* 如果 iterable中没有相关元素的属性propertyName 值是propertyValue,返回null
* @see #find(Iterable, Predicate)
* @see com.feilong.core.util.predicate.BeanPredicateUtil#equalPredicate(String, Object)
*/
public static O find(Iterable beanIterable,String propertyName,V propertyValue){
return null == beanIterable ? null : find(beanIterable, BeanPredicateUtil. equalPredicate(propertyName, propertyValue));
}
/**
* 找到 iterable中,第一个 propertyName属性名称和值是 propertyValue是 propertyNameAndPropertyValueMap 的对应元素.
*
* 示例:
*
*
*
* 场景: 从list中查找name是 关羽,且年龄是24 的User对象
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User("张飞", 23));
* list.add(new User("关羽", 24));
* list.add(new User("刘备", 25));
* list.add(new User("关羽", 50));
*
* Map{@code } map = toMap("name", "关羽", "age", 24);
* LOGGER.info(JsonUtil.format(CollectionsUtil.find(list, map)));
*
*
* 返回:
*
*
* {
* "age": 24,
* "name": "关羽"
* }
*
*
*
*
* 说明:
*
*
* - 返回第一个匹配对象
*
*
*
* @param
* the generic type
* @param beanIterable
* bean Iterable,诸如List{@code },Set{@code }等
* @param propertyNameAndPropertyValueMap
* 属性和指定属性值对应的map,其中key是泛型T对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @return 如果 iterable是null, 返回null
* 如果 propertyNameAndPropertyValueMap 是null,抛出 {@link NullPointerException}
* 如果 propertyNameAndPropertyValueMap 是empty,抛出{@link IllegalArgumentException}
* 如果 propertyNameAndPropertyValueMap 中有key是null,抛出{@link NullPointerException}
* 如果 propertyNameAndPropertyValueMap 中有key是blank,抛出{@link IllegalArgumentException}
* 如果 iterable中没有相关元素的属性propertyName 值是propertyValue,返回null
* @see #find(Iterable, Predicate)
* @see com.feilong.core.util.predicate.BeanPredicateUtil#equalPredicate(String, Object)
* @since 2.1.0
*/
public static O find(Iterable beanIterable,Map propertyNameAndPropertyValueMap){
return null == beanIterable ? null : find(beanIterable, BeanPredicateUtil. equalPredicate(propertyNameAndPropertyValueMap));
}
/**
* 迭代查找匹配predicate 的第一个元素并返回.
*
* 示例:
*
*
*
*
* 场景: 从list中查找name是 关羽,并且 age等于30的User对象
*
*
*
* List{@code } list = toList(//
* new User("张飞", 23),
* new User("关羽", 24),
* new User("刘备", 25),
* new User("关羽", 30));
*
* Map{@code } map = new HashMap{@code <>}();
* map.put("name", "关羽");
* map.put("age", 30);
*
* Predicate{@code } predicate = BeanPredicateUtil.equalPredicate(map);
*
* User user = CollectionsUtil.find(list, predicate);
* LOGGER.debug(JsonUtil.format(user));
*
*
* 返回:
*
*
* {
* "age": 30,
* "name": "关羽"
* }
*
*
*
*
* 说明:
*
*
* - 返回第一个匹配对象
*
*
*
* @param
* the generic type
* @param iterable
* the iterable to search, may be null
* @param predicate
* the predicate to use, may not be null
* @return 如果 predicate 是 null,将抛出{@link NullPointerException}
* 如果 iterable是null, 返回null
* 如果 iterable中没有相关元素匹配 predicate,返回null
* @see IterableUtils#find(Iterable, Predicate)
* @since 1.5.5
*/
public static O find(Iterable iterable,Predicate predicate){
return IterableUtils.find(iterable, predicate);
}
//**************************select*****************************************************************
/**
* 循环 beanIterable,获得元素 bean的 propertyName的值,判断是否在propertyValues
* 数组中;如果在,将该对象存入list中返回.
*
* 注意:
*
*
*
* 查询的结果的顺序按照原来 beanIterable里面的顺序,和参数 propertyValues 无关,如果你需要结果里面的元素按照指定的propertyValues
* 顺序排序的话,可以将结果再调用{@link SortUtil#sortListByFixedOrderPropertyValueArray(List, String, Object...)}
*
*
*
* 示例:
*
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User("张飞", 23));
* list.add(new User("关羽", 24));
* list.add(new User("刘备", 25));
*
* String[] array = { "刘备", "关羽" };
* LOGGER.info(JsonUtil.format(CollectionsUtil.select(list, "name", array)));
*
*
*
* 返回:
*
*
[{
"age": 24,
"name": "关羽"
},{
"age": 25,
"name": "刘备"
}]
*
*
*
*
* @param
* the generic type
* @param
* the value type
* @param beanIterable
* bean Iterable,诸如List{@code },Set{@code }等
* @param propertyName
* 泛型O对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @param propertyValues
* the values
* @return 如果 beanIterable 是null或者empty,返回 {@link Collections#emptyList()}
* 如果 propertyName 是null,抛出 {@link NullPointerException}
* 如果 propertyName 是blank,抛出 {@link IllegalArgumentException}
* 如果 propertyValues 是null,返回 {@code new ArrayList}
* @see BeanPredicateUtil#containsPredicate(String, Object...)
*/
@SafeVarargs
public static List select(Iterable beanIterable,String propertyName,V...propertyValues){
return isNullOrEmpty(beanIterable) ? Collections. emptyList()
: select(beanIterable, BeanPredicateUtil. containsPredicate(propertyName, propertyValues));
}
/**
* 循环 beanIterable,获得元素 bean 的propertyName的值,判断是否在propertyValueList
* 集合中;如果在,将该对象存入list中返回.
*
* 说明:
*
*
* - 查询的结果的顺序按照原来
beanIterable里面的顺序,和参数 propertyValueList 无关,如果你需要结果里面的元素按照指定的
* propertyValueList顺序排序的话,可以将结果再调用{@link SortUtil#sortListByFixedOrderPropertyValueList(List, String, List)}
* - 和该方法正好相反的是 {@link #selectRejected(Iterable, String, Collection)}
*
*
*
* 示例:
*
*
*
*
* 场景: 查询 name属性是"张飞"或者是"刘备"的 User list
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User("张飞", 23));
* list.add(new User("关羽", 24));
* list.add(new User("刘备", 25));
*
* List{@code } propertyValueList = new ArrayList{@code <>}();
* propertyValueList.add("张飞");
* propertyValueList.add("刘备");
* LOGGER.info(JsonUtil.format(CollectionsUtil.select(list, "name", propertyValueList)));
*
*
* 返回:
*
*
[{
"age": 23,
"name": "张飞"
},{
"age": 25,
"name": "刘备"
}]
*
*
*
*
*
* 重构:
*
*
*
* 对于以下代码:
*
*
*
*
* // 当前店铺 的物流方式Id set
* Set{@code } distributionModeIdSet = new HashSet{@code <>}();
* for (TemeplateDistributionMode tdCmd : temeplateDistributionModeList){
* distributionModeIdSet.add(tdCmd.getDistributionModeId());
* }
*
* // 拿到所有的物流方式 列表
* List{@code } distributionCommandList = freigthMemoryManager.getDistributionList();
*
* // 根据 物流方式ID 找出 支持本商铺的 DistributionCommand
* List{@code } curShopDistributionCommandList = new ArrayList{@code <>}();
*
* for (Long modeId : distributionModeIdSet){
* for (DistributionCommand distributionCmd : distributionCommandList){
* if (modeId.equals(distributionCmd.getDistributionModeId())){
* curShopDistributionCommandList.add(distributionCmd);
* }
* }
* }
*
*
* 可以重构成:
*
*
* // 当前店铺 的物流方式Id set
* Set{@code } distributionModeIdSet = CollectionsUtil.getPropertyValueSet(temeplateDistributionModeList, "distributionModeId");
* // 拿到所有的物流方式 列表
* List{@code } distributionCommandList = freigthMemoryManager.getDistributionList();
*
* // 根据 物流方式ID 找出 支持本商铺的 DistributionCommand
* List{@code } curShopDistributionCommandList = CollectionsUtil.select(distributionCommandList, "distributionModeId", distributionModeIdSet);
*
*
*
*
* @param
* the generic type
* @param
* the value type
* @param beanIterable
* bean Iterable,诸如List{@code },Set{@code }等
* @param propertyName
* 泛型O对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @param propertyValueList
* the values
* @return 如果 beanIterable 是null或者empty,返回 {@link Collections#emptyList()}
* 如果 propertyName 是null,抛出 {@link NullPointerException}
* 如果 propertyName 是blank,抛出 {@link IllegalArgumentException}
* 否则调用 {@link #select(Iterable, Predicate)}
* @see #select(Iterable, Predicate)
* @see BeanPredicateUtil#containsPredicate(String, Collection)
* @since 1.5.0
*/
public static List select(Iterable beanIterable,String propertyName,Collection propertyValueList){
return isNullOrEmpty(beanIterable) ? Collections. emptyList()
: select(beanIterable, BeanPredicateUtil. containsPredicate(propertyName, propertyValueList));
}
/**
* 找到 iterable中,属性和属性值都是propertyNameAndPropertyValueMap的对应元素.
*
* 示例:
*
*
*
* 场景: 从list中查找name是 关羽,且年龄是24 的User对象
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User("张飞", 23));
*
* list.add(new User("关羽", 24));
* list.add(new User("刘备", 25));
* list.add(new User("关羽", 24));
* list.add(new User("关羽", 50));
*
* Map{@code } map = toMap("name", "关羽", "age", 24);
* LOGGER.info(JsonUtil.format(CollectionsUtil.select(list, map)));
*
*
* 返回:
*
*
* [{
* "age": 24,
* "name": "关羽"
* },
* {
* "age": 24,
* "name": "关羽"
* }]
*
*
*
*
* @param
* the generic type
* @param beanIterable
* bean Iterable,诸如List{@code },Set{@code }等
* @param propertyNameAndPropertyValueMap
* 属性和指定属性值对应的map,其中key是泛型T对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @return 如果 beanIterable 是null或者empty,返回 {@link Collections#emptyList()}
* 如果 propertyNameAndPropertyValueMap 是null,抛出 {@link NullPointerException}
* 如果 propertyNameAndPropertyValueMap 是empty,抛出{@link IllegalArgumentException}
* 如果 propertyNameAndPropertyValueMap 中有key是null,抛出{@link NullPointerException}
* 如果 propertyNameAndPropertyValueMap 中有key是blank,抛出{@link IllegalArgumentException}
* 如果 iterable查找不到propertyNameAndPropertyValueMap,返回空集合
* @see #select(Iterable, Predicate)
* @see com.feilong.core.util.predicate.BeanPredicateUtil#equalPredicate(String, Object)
* @since 3.1.1
*/
public static List select(Iterable beanIterable,Map propertyNameAndPropertyValueMap){
return isNullOrEmpty(beanIterable) ? Collections. emptyList()
: select(beanIterable, BeanPredicateUtil. equalPredicate(propertyNameAndPropertyValueMap));
}
/**
* 按照指定的 {@link Predicate},返回查询出来的集合.
*
* 说明:
*
*
* - 和该方法正好相反的是 {@link #selectRejected(Iterable, Predicate)}
*
*
*
* 示例1:
*
*
*
* 场景: 查找等于 1的元素
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(1L);
* list.add(1L);
* list.add(2L);
* list.add(3L);
* LOGGER.info(JsonUtil.format(CollectionsUtil.select(list, new EqualPredicate{@code }(1L))));
*
*
* 返回:
*
*
* [1,1]
*
*
*
*
* 示例2:
*
*
*
* 场景: 查找大于 10的元素
*
*
*
* Comparator{@code } comparator = ComparatorUtils.naturalComparator();
* Predicate{@code } predicate = new ComparatorPredicate{@code }(10, comparator, Criterion.LESS);
*
* List{@code } select = CollectionsUtil.select(toList(1, 5, 10, 30, 55, 88, 1, 12, 3), predicate);
* LOGGER.debug(JsonUtil.format(select, 0, 0));
*
*
* 返回:
*
*
* [30,55,88,12]
*
*
*
*
* @param
* the generic type
* @param beanIterable
* bean Iterable,诸如List{@code },Set{@code }等
* @param predicate
* 接口封装了对输入对象的判断,返回true或者false,可用的实现类有
*
* - {@link com.feilong.lib.collection4.functors.EqualPredicate EqualPredicate}
* - {@link com.feilong.lib.collection4.functors.IdentityPredicate IdentityPredicate}
* - {@link com.feilong.lib.collection4.functors.FalsePredicate FalsePredicate}
* - {@link com.feilong.lib.collection4.functors.TruePredicate TruePredicate}
* - ....
*
* @return 如果 beanIterable 是null或者empty,返回 {@link Collections#emptyList()}
* 否则返回 {@link CollectionUtils#select(Iterable, Predicate)},如果查不到返回空集合
* @see com.feilong.lib.collection4.CollectionUtils#select(Iterable, Predicate)
*/
public static List select(Iterable beanIterable,Predicate predicate){
return isNullOrEmpty(beanIterable) ? Collections. emptyList() : (List) CollectionUtils.select(beanIterable, predicate);
}
//***************************selectRejected*********************************************************************
/**
* 循环 beanIterable,获得元素 bean 的 propertyName 属性值都不在
* propertyValues 时候的list.
*
* 示例:
*
*
*
*
* 场景: 查询name 不是刘备 也不是张飞的 User list元素
*
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User("张飞", 23));
* list.add(new User("关羽", 24));
* list.add(new User("刘备", 25));
*
* List{@code } selectRejected = CollectionsUtil.selectRejected(list, "name", "刘备", "张飞");
* LOGGER.info(JsonUtil.format(selectRejected));
*
*
*
* 返回:
*
*
* [{
* "age": 24,
* "name": "关羽"
* }]
*
*
*
*
* @param
* the generic type
* @param
* the value type
* @param beanIterable
* bean Iterable,诸如List{@code },Set{@code }等
* @param propertyName
* 泛型O对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @param propertyValues
* the values
* @return 如果 beanIterable 是null或者empty,返回 {@link Collections#emptyList()}
* 如果 propertyName 是null,抛出 {@link NullPointerException}
* 如果 propertyName 是blank,抛出 {@link IllegalArgumentException}
* @see BeanPredicateUtil#containsPredicate(String, Object...)
* @see #selectRejected(Iterable, Predicate)
*/
@SafeVarargs
public static List selectRejected(Iterable beanIterable,String propertyName,V...propertyValues){
return isNullOrEmpty(beanIterable) ? Collections. emptyList()
: selectRejected(beanIterable, BeanPredicateUtil. containsPredicate(propertyName, propertyValues));
}
/**
* 循环 beanIterable,获得元素 bean 的 propertyName的值,判断是否不在propertyValueList
* 集合中;如果不在,将该对象存入list中返回.
*
* 示例:
*
*
*
*
* 场景: 查询 name属性是不是"张飞",也不是"刘备"的 User list
*
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User("张飞", 23));
* list.add(new User("关羽", 24));
* list.add(new User("刘备", 25));
*
* List{@code } propertyValueList = new ArrayList{@code <>}();
* propertyValueList.add("张飞");
* propertyValueList.add("刘备");
* LOGGER.info(JsonUtil.format(CollectionsUtil.selectRejected(list, "name", propertyValueList)));
*
*
*
* 返回:
*
*
* [{
* "age": 24,
* "name": "关羽"
* }]
*
*
*
*
* 说明:
*
*
* - 和该方法正好相反的是 {@link #select(Iterable, String, Collection)}
*
*
*
* @param
* the generic type
* @param
* the value type
* @param beanIterable
* bean Iterable,诸如List{@code },Set{@code }等
* @param propertyName
* 泛型O对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @param propertyValueList
* the values
* @return 如果 beanIterable 是null或者empty,返回 {@link Collections#emptyList()}
* 如果 propertyName 是null,抛出 {@link NullPointerException}
* 如果 propertyName 是blank,抛出 {@link IllegalArgumentException}
* @see BeanPredicateUtil#containsPredicate(String, Collection)
* @see #selectRejected(Iterable, Predicate)
* @since 1.5.0
*/
public static List selectRejected(Iterable beanIterable,String propertyName,Collection propertyValueList){
return isNullOrEmpty(beanIterable) ? Collections. emptyList()
: selectRejected(beanIterable, BeanPredicateUtil. containsPredicate(propertyName, propertyValueList));
}
/**
* 找到 iterable中,属性和属性值都不是propertyNameAndPropertyValueMap的对应元素.
*
* 示例:
*
*
*
* 场景: 从list中查找name是 不是关羽,且年龄不是24 的User对象
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add(new User("张飞", 23));
*
* list.add(new User("关羽", 24));
* list.add(new User("刘备", 25));
* list.add(new User("关羽", 24));
* list.add(new User("关羽", 50));
*
* Map{@code } map = toMap("name", "关羽", "age", 24);
* LOGGER.info(JsonUtil.format(CollectionsUtil.selectRejected(list, map)));
*
*
* 返回:
*
*
* [{
* "age": 23,
* "name": "张飞"
* },
* {
* "age": 25,
* "name": "刘备"
* },{
* "age": 50,
* "name": "关羽"
* }]
*
*
*
*
* @param
* the generic type
* @param beanIterable
* bean Iterable,诸如List{@code },Set{@code }等
* @param propertyNameAndPropertyValueMap
* 属性和指定属性值对应的map,其中key是泛型T对象指定的属性名称,Possibly indexed and/or nested name of the property to be modified,参见
* propertyName
* @return 如果 beanIterable 是null或者empty,返回 {@link Collections#emptyList()}
* 如果 propertyNameAndPropertyValueMap 是null,抛出 {@link NullPointerException}
* 如果 propertyNameAndPropertyValueMap 是empty,抛出{@link IllegalArgumentException}
* 如果 propertyNameAndPropertyValueMap 中有key是null,抛出{@link NullPointerException}
* 如果 propertyNameAndPropertyValueMap 中有key是blank,抛出{@link IllegalArgumentException}
* @see #selectRejected(Iterable, Predicate)
* @see com.feilong.core.util.predicate.BeanPredicateUtil#equalPredicate(String, Object)
* @since 3.1.1
*/
public static List selectRejected(Iterable beanIterable,Map propertyNameAndPropertyValueMap){
return isNullOrEmpty(beanIterable) ? Collections. emptyList()
: selectRejected(beanIterable, BeanPredicateUtil. equalPredicate(propertyNameAndPropertyValueMap));
}
/**
* 循环 beanIterable,获得元素 bean,判断是否不匹配predicate,如果不匹配
* ,将该对象存入list中返回.
*
* 说明:
*
*
* - 和该方法正好相反的是 {@link #select(Iterable, Predicate)}
*
*
*
* 示例:
*
*
*
*
* 场景: 从list中查找不等于1的元素
*
*
*
* List{@code } list = toList(1L, 1L, 2L, 3L);
* CollectionsUtil.selectRejected(list, new EqualPredicate{@code }(1L))
*
*
* 返回:
*
*
* 2L, 3L
*
*
*
*
* @param
* the generic type
* @param beanIterable
* bean Iterable,诸如List{@code },Set{@code }等
* @param predicate
* the predicate
* @return 如果 beanIterable 是null或者empty,返回 {@link Collections#emptyMap()}
* @see com.feilong.lib.collection4.CollectionUtils#selectRejected(Iterable, Predicate)
* @since 1.4.0
*/
public static List selectRejected(Iterable beanIterable,Predicate predicate){
return isNullOrEmpty(beanIterable) ? Collections. emptyList()
: (List) CollectionUtils.selectRejected(beanIterable, predicate);
}
//---------------------------------------------------------------
/**
* 循环 inputIterable,将每个元素使用 transformer 转换成新的对象,返回新的list.
*
* 示例:
*
*
*
*
*
* List{@code } list = new ArrayList{@code <>}();
* list.add("xinge");
* list.add("feilong1");
* list.add("feilong2");
* list.add("feilong2");
*
* Transformer{@code } nullTransformer = TransformerUtils.nullTransformer();
* List{@code
*
* 返回:
*
*
* [null,null,null,null]
*
*
*
*
* 更多的,使用这个方法来处理两个不同类型的转换:
*
*
*
* 比如购物车功能,有游客购物车CookieShoppingCartLine以及内存购物车对象
* ShoppingCartLineCommand,两个数据结构部分元素相同,
* 用户登陆需要把cookie中的购物车转成内存购物车ShoppingCartLineCommand list,这时我们可以先创建ToShoppingCartLineCommandTransformer
*
*
*
* 代码示例:
*
*
*
*
* class ToShoppingCartLineCommandTransformer implements Transformer{@code }{
*
* private static final String[] COPY_PROPERTY_NAMES = {"skuId","extentionCode","quantity","createTime","settlementState","lineGroup" };
*
* public ShoppingCartLineCommand transform(CookieShoppingCartLine cookieShoppingCartLine){
* // 将cookie中的购物车 转换为 shoppingCartLineCommand
* ShoppingCartLineCommand shoppingLineCommand = new ShoppingCartLineCommand();
* PropertyUtil.copyProperties(shoppingLineCommand, cookieShoppingCartLine, COPY_PROPERTY_NAMES);
*
* shoppingLineCommand.setId(cookieShoppingCartLine.getId());
* shoppingLineCommand.setGift(null == cookieShoppingCartLine.getIsGift() ? false : cookieShoppingCartLine.getIsGift());
*
* return shoppingLineCommand;
* }
* }
*
*
*
*
* 然后调用:
*
*
*
*
* public List{@code } load(HttpServletRequest request){
* // 获取cookie中的购物车行集合
* List{@code } cookieShoppingCartLineList = getCookieShoppingCartLines(request);
* if (isNullOrEmpty(cookieShoppingCartLineList)){
* return null;
* }
*
* return CollectionsUtil.collect(cookieShoppingCartLineList, new ToShoppingCartLineCommandTransformer());
* }
*
*
*
*
* @param
* the type of object in the input collection
* @param
* the type of object in the output collection
* @param inputIterable
* the inputIterable to get the input from
* @param transformer
* the transformer to use, may be null
* @return 如果 inputIterable 是null,返回 null
* 如果 transformer 是null,返回 empty list
* @see com.feilong.lib.collection4.CollectionUtils#collect(Iterable, Transformer)
* @see com.feilong.lib.collection4.CollectionUtils#transform(Collection, Transformer)
* @since 1.5.5
*/
@SuppressWarnings("unchecked")
public static List collect(final Iterable inputIterable,final Transformer transformer){
return null == inputIterable ? null : (List) CollectionUtils.collect(inputIterable, transformer);
}
/**
* 循环 inputBeanIterable,将每个元素使用转换程成新的 outputListBeanType 类型对象(如有需要只copy传入的includePropertyNames属性)
* 返回新的list.
*
* 示例:
*
*
* 已知有以下两个类 User 和 Customer
*
*
*
* public class User{
*
* // The id.
* private Long id = 0L;
*
* //** The name.
* private String name = "feilong";
*
* //** 年龄.
* private Integer age;
*
* //setter /getter
*
* public User(Long id, String name){
* this.id = id;
* this.name = name;
* }
*
* }
*
*
*
*
*
* public class Customer{
*
* //** The id.
* private long id;
*
* //* The name.
* private String name;
*
* //setter /getter
*
* }
*
*
*
* 此时有以下的 List{@code } 需要转换成List{@code }
*
*