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

简介: 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();
    }
}
相关文章
|
4天前
|
缓存 前端开发 Java
【前端学java】复习巩固-Java中的对象比较(15)
【8月更文挑战第11天】Java中的对象比较
14 1
【前端学java】复习巩固-Java中的对象比较(15)
|
11天前
|
存储 Java 程序员
Java中对象几种类型的内存分配(JVM对象储存机制)
Java中对象几种类型的内存分配(JVM对象储存机制)
45 5
Java中对象几种类型的内存分配(JVM对象储存机制)
|
3天前
|
Java API 开发者
|
11天前
|
存储 Java 程序员
08 Java面向对象基础(对象与类+实例变量与方法+构造方法+this关键字)
08 Java面向对象基础(对象与类+实例变量与方法+构造方法+this关键字)
33 4
|
15天前
|
存储 安全 Java
揭秘Java序列化神器Serializable:一键解锁对象穿越时空的超能力,你的数据旅行不再受限,震撼登场!
【8月更文挑战第4天】Serializable是Java中的魔术钥匙,开启对象穿越时空的能力。作为序列化的核心,它让复杂对象的复制与传输变得简单。通过实现此接口,对象能被序列化成字节流,实现本地存储或网络传输,再通过反序列化恢复原状。尽管使用方便,但序列化过程耗时且存在安全风险,需谨慎使用。
27 7
|
2天前
|
存储 设计模式 Java
在 Java 中创建多个对象
【8月更文挑战第17天】
6 0
|
5天前
|
Java Spring 容器
Java SpringBoot 中,动态执行 bean 对象中的方法
Java SpringBoot 中,动态执行 bean 对象中的方法
14 0
|
5天前
|
Java
Java Bean 注册对象
Java Bean 注册对象
6 0
|
11天前
|
设计模式 存储 安全
18 Java反射reflect(类加载+获取类对象+通用操作+设计模式+枚举+注解)
18 Java反射reflect(类加载+获取类对象+通用操作+设计模式+枚举+注解)
40 0
|
25天前
|
缓存 Java 应用服务中间件
Java编程问题之重试机制问题之在CGLIB中设置目标对象类并创建代理类如何解决
Java编程问题之重试机制问题之在CGLIB中设置目标对象类并创建代理类如何解决