java判断多个对象是否同时为空，或者都不为空，或者混合存在

package com.nnhx.common.util;

import com.xiaoleilu.hutool.collection.IterUtil;
import com.xiaoleilu.hutool.util.ArrayUtil;
import com.xiaoleilu.hutool.util.MapUtil;
import com.xiaoleilu.hutool.util.StrUtil;

import java.util.*;

/**
 * @ClassName ObjectUtil
 * @Description // 判断多个对象是否同时为空，或者都不为空，或者混合存在
 * @Author WHX
 * @Date 2020/7/28 15:48
 **/
public class ObjectUtil {
   

    public static final int ALL_NOT_EMPTY = 1;
    public static final int ALL_EMPTY = 2;
    public static final int MIXTURE_STATE = 3;

    public static void main(String[] args) {
   
        testUtils();
    }

    /**
     * 全部不为空
     * @param charBlankVerify true: 校验空白字符； false：不校验空白字符
     * @param objs
     * @return
     */
    public static boolean isAllNotEmpty(boolean charBlankVerify, Object... objs){
   
        if(ArrayUtil.isEmpty(objs)){
   
            return false;
        }
        for (Object obj : objs) {
   
            if (isEmpty(charBlankVerify, obj)){
   
                return false;
            }
        }
        return true;
    }

    /**
     * 全部为空
     * @param charBlankVerify true: 校验空白字符； false：不校验空白字符
     * @param objs
     * @return
     */
    public static boolean isAllEmpty(boolean charBlankVerify, Object... objs){
   
        if(ArrayUtil.isEmpty(objs)){
   
            return true;
        }
        for (Object obj : objs) {
   
            if (!isEmpty(charBlankVerify, obj)){
   
                return false;
            }
        }
        return true;
    }

    /**
     * 不全为空，也不全为非空（必须是混合状态）
     * @param charBlankVerify true: 校验空白字符； false：不校验空白字符
     * @param objs
     * @return
     */
    public static boolean isMixtureState(boolean charBlankVerify, Object... objs){
   
        return  !isAllEmpty(charBlankVerify, objs) && !isAllNotEmpty(charBlankVerify, objs);
    }

    /**
     * 获取状态
     * @param charBlankVerify true: 校验空白字符； false：不校验空白字符
     * @param objs
     * @return 1、都不为空；2、都为空；3、不全为空，也不全为非空（混合存在）
     */
    public static int getStatus(boolean charBlankVerify, Object... objs){
   
        return isAllNotEmpty(charBlankVerify, objs) ? ALL_NOT_EMPTY : isAllEmpty(charBlankVerify, objs) ? ALL_EMPTY : MIXTURE_STATE;
    }

    /**
     * 判断指定对象是否为空，支持：（部分引用hutool工具类）
     *
     * <pre>
     * 1. CharSequence      使用isBlank判断
     * 2. Map
     * 3. Iterable
     * 4. Iterator
     * 5. Array
     * </pre>
     *
     * @param charBlankVerify true: 校验空白字符； false：不校验空白字符
     * @param obj 被判断的对象
     * @return 是否为空，如果类型不支持，默认判断 null == obj
     */
    public static boolean isEmpty(boolean charBlankVerify, Object obj) {
   
        if (null == obj) {
   
            return true;
        }

        if (obj instanceof CharSequence) {
   
            return charBlankVerify ? StrUtil.isBlank((CharSequence) obj) : StrUtil.isEmpty((CharSequence) obj);
        } else if (obj instanceof Map) {
   
            return MapUtil.isEmpty((Map) obj);
        } else if (obj instanceof Iterable) {
   
            return IterUtil.isEmpty((Iterable) obj);
        } else if (obj instanceof Iterator) {
   
            return IterUtil.isEmpty((Iterator) obj);
        } else if (ArrayUtil.isArray(obj)) {
   
            return ArrayUtil.isEmpty(obj);
        }else {
   
            return null == obj;
        }
    }

    /**
     * 测试方法
     */
    private static void testUtils() {
   
        List<Object> array1 = null;
        List<Object> array2 = new ArrayList<>();
        List<String> array3 = Arrays.asList("1","2","3");
        List<Integer> array4 = Arrays.asList(1,2,3);

        String str1 = null;
        String str2 = "";
        String str3 = "ss";

        Integer int1 = null;
        Integer int2 = 1;
        Integer int3 = 2;

        Map<Object,Object> map1 = null;
        Map<Object,Object> map2 = new HashMap<>();
        Map<Object,Object> map3 = new HashMap<>();
        map3.put(null,null);

        List<List<?>> lists1 = Arrays.asList(array1, array2,array3,array4);
        List<?> lists2 = Arrays.asList(str1,str2,str3);
        List<?> lists3 = Arrays.asList(int1,int2,int3);
        List<?> lists4 = Arrays.asList(map1,map2,map3);


        // 设置测试数据
        lists1 = lists1.subList(1,2);

        lists1.forEach(w->{
   
            lists2.forEach(y->{
   
                lists4.forEach(z->{
   
                    System.out.println("----------------" + w + "\t\t" + y + "\t\t" + z);
                    // 全部不为空
                    boolean allNoBlank = isAllNotEmpty(true, w,y,z);
                    // 全部为空
                    boolean allBlank = isAllEmpty(true, w,y,z);
                    // 不全部为空（必须是混合状态）
                    boolean noAllBlank = isMixtureState(true, w,y,z);

                    System.out.println("全部不为空：\t" + allNoBlank);
                    System.out.println("全部为空：\t" + allBlank);
                    System.out.println("不全部为空：\t" + noAllBlank);
                });
            });
        });

        System.out.println();
    }
}

        

          
        
        
        

          

          AI 代码解读