All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • commons.box.util.Collects Maven / Gradle / Ivy

    The newest version!
    package commons.box.util;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Streams;
import com.google.common.primitives.Doubles;
import com.google.common.primitives.Ints;
import com.google.common.primitives.Longs;
import commons.box.app.internal.InternalAutoCloseableIterator;
import org.apache.commons.lang3.StringUtils;

import javax.annotation.Nonnull;
import java.io.Closeable;
import java.util.*;
import java.util.function.Consumer;
import java.util.stream.Stream;

/**
 * 
    创建作者：xingxiuyi 
    
 * 
    版权所属：xingxiuyi 
    
 */
public final class Collects {
    private static final Object[] EMPTY_OBJECTS = new Object[]{};
    private static final List EMPTY_LIST = ImmutableList.of();
    private static final Set EMPTY_SET = ImmutableSet.of();

    @SuppressWarnings("unchecked")
    @Nonnull
    public static  List immlist() {
        return (List) EMPTY_LIST;
    }

    /**
     * 不可变更实例
     *
     * @param 
     * @return
     */
    @SuppressWarnings("unchecked")
    @Nonnull
    public static  List immlist(Collection list) {
        if (list == null || list.isEmpty()) return (List) EMPTY_LIST;
        if (list instanceof List) return Collections.unmodifiableList((List) list);
        else return Collections.unmodifiableList(new ArrayList<>(list));
    }

    @SuppressWarnings("unchecked")
    @Nonnull
    public static  List immlist(T... array) {
        if (array == null) return immlist();
        return immlist(Arrays.asList(array));
    }


    @SuppressWarnings("unchecked")
    public static  Set immset() {
        return (Set) EMPTY_SET;
    }

    /**
     * 不可变更实例
     *
     * @param 
     * @return
     */
    @SuppressWarnings("unchecked")
    @Nonnull
    public static  Set immset(Collection set) {
        if (set == null || set.isEmpty()) return (Set) EMPTY_SET;
        if (set instanceof Set) return Collections.unmodifiableSet((Set) set);
        return Collections.unmodifiableSet(new LinkedHashSet<>(set));
    }


    @SuppressWarnings("unchecked")
    @Nonnull
    public static  Set immset(T... array) {
        if (array == null) return immset();
        return immset(Arrays.asList(array));
    }

    /**
     * 新的 array list
     *
     * @param 
     * @return
     */
    public static  List newlist() {
        return new ArrayList<>();
    }

    /**
     * 新的 array list 其中包含原值
     *
     * @param list
     * @param 
     * @return
     */
    public static  List newlist(Collection list) {
        if (list == null || list.isEmpty()) return new ArrayList<>();
        return new ArrayList<>(list);
    }

    /**
     * 空值安全的操作
     * 
    
     * 
    
     * 如果是空值，返回默认空实例
     * 
    
     * 如果非空则直接返回原始值
     * 
    
     * 本方法用于避免频繁的非空判断
     *
     * @param list
     * @param 
     * @return
     */
    @Nonnull
    @SuppressWarnings("unchecked")
    public static  Collection safe(Collection list) {
        if (list == null) return immlist();
        return list;
    }

    /**
     * 空值安全的操作
     * 
    
     * 
    
     * 如果是空值，返回默认空实例
     * 
    
     * 如果非空则直接返回原始值
     * 
    
     * 本方法用于避免频繁的非空判断
     *
     * @param list
     * @param 
     * @return
     */
    @Nonnull
    @SuppressWarnings("unchecked")
    public static  List safeList(List list) {
        if (list == null) return immlist();
        return list;
    }

    /**
     * 空值安全的操作
     * 
    
     * 
    
     * 如果是空值，返回默认空实例
     * 
    
     * 如果非空则直接返回原始值
     * 
    
     * 本方法用于避免频繁的非空判断
     *
     * @param list
     * @param 
     * @return
     */
    @Nonnull
    @SuppressWarnings("unchecked")
    public static  Set safeSet(Set list) {
        if (list == null) return immset();
        return list;
    }

    /**
     * 判断是否为空.
     */
    public static boolean isEmpty(Collection collection) {
        return (collection == null) || collection.isEmpty();
    }

    /**
     * 判断是否不为空.
     */
    public static boolean isNotEmpty(Collection collection) {
        return (collection != null) && (!collection.isEmpty());
    }


    /**
     * 判断是否为空.
     */
    public static boolean isEmpty(Object[] array) {
        return (array == null) || (array.length < 1);
    }

    /**
     * 判断是否不为空.
     */
    public static boolean isNotEmpty(Object[] array) {
        return (array != null) && (array.length > 0);
    }

    /**
     * 第一个
     *
     * @param array
     * @param 
     * @return
     */
    public static  T first(T[] array) {
        if (array == null || array.length < 1) return null;
        return array[0];
    }

    /**
     * 第一个 非空元素
     *
     * @param array
     * @param 
     * @return
     */
    public static  T firstNonnull(T[] array) {
        if (array == null || array.length < 1) return null;

        for (int i = 0; i < array.length; i++) {
            if (array[i] != null) return array[i];
        }

        return null;
    }

    /**
     * 取得Collection的第一个元素，如果collection为空返回null.
     */
    public static  T first(Collection collection) {
        if (isEmpty(collection)) return null;

        for (T next : collection) {
            if (next != null) return next;
        }

        return null;
    }


    /**
     * 第一个
     *
     * @param array
     * @param 
     * @return
     */
    public static  T last(T[] array) {
        if (array == null || array.length < 1) return null;
        return array[array.length - 1];
    }

    /**
     * 第一个 非空元素
     *
     * @param array
     * @param 
     * @return
     */
    public static  T lastNonnull(T[] array) {
        if (array == null || array.length < 1) return null;

        for (int i = array.length - 1; i >= 0; i--) {
            if (array[i] != null) return array[i];
        }

        return null;
    }

    /**
     * 获取Collection的最后一个元素，如果collection为空返回null.
     */
    public static  T last(Collection collection) {
        if (isEmpty(collection)) return null;

        return Iterables.getLast(collection);
    }

    /**
     * 循环处理
     *
     * @param ern
     * @param cmd
     * @param 
     */
    public static  void iter(Enumeration ern, Consumer cmd) {
        if (ern == null || cmd == null) return;
        while (ern.hasMoreElements()) cmd.accept(ern.nextElement());
    }

    public static  void iter(Iterator iterator, Consumer cmd) {
        if (iterator == null || cmd == null) return;
        while (iterator.hasNext()) cmd.accept(iterator.next());
    }

    /**
     * 空实例
     *
     * @param 
     * @return
     */
    public static  Stream stream() {
        return Stream.empty();
    }

    /**
     * 生成Stream 本方法永远不返回空
     *
     * @param col
     * @param 
     * @return
     */
    public static  Stream stream(Collection col) {
        return stream(col, false);
    }

    /**
     * 生成Stream 本方法永远不返回空
     *
     * @param col
     * @param parallel 使用并行处理机制
     * @param 
     * @return
     */
    @Nonnull
    public static  Stream stream(Collection col, boolean parallel) {
        if (col == null) return Stream.empty();
        return (parallel) ? col.parallelStream() : col.stream();
    }

    /**
     * 生成Stream 本方法永远不返回空
     *
     * @param array
     * @param 
     * @return
     */
    @Nonnull
    public static  Stream stream(T[] array) {
        if (array == null || array.length < 1) return Stream.empty();
        return Arrays.stream(array);
    }

    /**
     * 生成Stream
     *
     * @param iter
     * @param 
     * @return
     */
    @Nonnull
    @SuppressWarnings("UnstableApiUsage")
    public static  Stream stream(Iterable iter) {
        if (iter == null) return Stream.empty();
        return Streams.stream(iter);
    }

    /**
     * 生成Stream
     * 
    
     * 如果 iter 实现了 Closeable 也会响应 Stream.close() 方法，
     * 在调用了 Stream.close 时同时也会级联调用 Iterator  的close方法。
     *
     * @param iter
     * @param 
     * @return
     */
    @Nonnull
    @SuppressWarnings("UnstableApiUsage")
    public static  Stream stream(Iterator iter) {
        if (iter == null) return Stream.empty();
        return stream(iter, (iter instanceof Closeable));
    }

    /**
     * 生成Stream 如果 autoCloseable=true 将使用自动关闭的 Iterator （到达记录尾端时自动调用 close 方法）
     * 
    
     * 同时如果声明了 autoCloseable=true ，也会响应 Stream.close() 方法，
     * 在调用了 Stream.close 时同时也会级联调用 Iterator  的close方法。
     *
     * @param iter
     * @param autoCloseable
     * @param 
     * @return
     */
    @Nonnull
    @SuppressWarnings("UnstableApiUsage")
    public static  Stream stream(Iterator iter, boolean autoCloseable) {
        if (iter == null) return Stream.empty();
        if (autoCloseable) {
            InternalAutoCloseableIterator aciter = InternalAutoCloseableIterator.from(iter);
            return Streams.stream(aciter).onClose(() -> IOs.close(aciter));
        } else {
            return Streams.stream(iter);
        }
    }

    /**
     * 向 source 中增加元素
     *
     * @param source
     * @param b
     * @param 
     */
    public static  void addAll(final Collection source, final Collection b) {
        if (source == null) return;
        if (b != null && !b.isEmpty()) source.addAll(b);
    }

    /**
     * 向 source 中增加元素
     *
     * @param source
     * @param b
     * @param 
     */
    public static  void addAll(final Collection source, final T[] b) {
        if (source == null) return;
        if (b != null && b.length > 0) source.addAll(Arrays.asList(b));
    }


    /**
     * 返回a+b的新List.
     */
    @Nonnull
    public static  List union(final Collection a, final Collection b) {
        if (a == null && b == null) return new ArrayList<>();
        else if (a == null) return new ArrayList<>(b);
        else if (b == null) return new ArrayList<>(a);

        List result = new ArrayList<>(a);
        result.addAll(b);

        return result;
    }

    /**
     * 返回a-b的新List.
     */
    @Nonnull
    public static  List subtract(final Collection a, final Collection b) {
        List list = new ArrayList<>(a);
        for (T element : b) {
            list.remove(element);
        }

        return list;
    }

    /**
     * 返回a与b的交集的新List.
     */
    @Nonnull
    public static  List intersection(Collection a, Collection b) {
        List list = new ArrayList<>();

        for (T element : a) {
            if (b.contains(element)) {
                list.add(element);
            }
        }
        return list;
    }

    /**
     * 逆序
     *
     * @param source
     * @param 
     * @return
     */
    public static  List reverse(Collection source) {
        if (isEmpty(source)) return new ArrayList<>();
        List results = new ArrayList<>(source);
        Collections.reverse(results);
        return results;
    }

    /**
     * 由数组生成List
     *
     * @param objs
     * @param 
     * @return
     */
    @SuppressWarnings("unchecked")
    @Nonnull
    public static  List asList(T... objs) {
        if (objs == null || objs.length < 1) return (List) EMPTY_LIST;
        return Arrays.asList(objs);
    }

    // TODO NO_NULL SAFE
    @SafeVarargs
    @Nonnull
    public static  Iterable concat(Iterable... inputs) {
        if (inputs == null || inputs.length < 1) return new ArrayList<>();
        return Iterables.concat(inputs);
    }

    /**
     * 返回一个底层由原始类型long保存的List, 与保存Long相比节约空间.
     */
    public static List asListLong(long... backingArray) {
        return Longs.asList(backingArray);
    }

    /**
     * 返回一个底层由原始类型int保存的List, 与保存Integer相比节约空间.
     */
    public static List asListInt(int... backingArray) {
        return Ints.asList(backingArray);
    }

    /**
     * 返回一个底层由原始类型double保存的Double, 与保存Double相比节约空间.
     */
    public static List asListDouble(double... backingArray) {
        return Doubles.asList(backingArray);
    }


    /**
     * 转换Collection所有元素(通过toString())为String, 中间以 separator分隔。
     */
    public static String convertToString(final Collection collection, final String separator) {
        return StringUtils.join(collection, separator);
    }

    /**
     * 转换Collection所有元素(通过toString())为String, 每个元素的前面加入prefix，后面加入postfix，如
    mymessage
    。
     */
    public static String convertToString(final Collection collection, final String prefix, final String postfix) {
        StringBuilder builder = new StringBuilder();
        for (Object o : collection) builder.append(prefix).append(o).append(postfix);
        return builder.toString();
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy