com.star.clazz.ClassUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of utils Show documentation
some utility class for java develop
The newest version!
package com.star.clazz;

import com.star.collection.array.ArrayUtil;
import com.star.collection.map.MapUtil;
import com.star.exception.ToolException;
import com.star.io.resource.ResourceUtil;
import com.star.reflect.ConstructorUtil;
import com.star.string.StringUtil;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;

/**
 * 类工具类
 * 
 * Created by win7 on 2017/6/18.
 */
public final class ClassUtil {

    /**
     * 默认值缓存
     */
    private static final Map, Object> CACHE = MapUtil.newHashMap(8);

    static {
        CACHE.put(long.class, 0L);
        CACHE.put(int.class, 0);
        CACHE.put(short.class, (short) 0);
        CACHE.put(char.class, (char) 0);
        CACHE.put(byte.class, (byte) 0);
        CACHE.put(double.class, 0D);
        CACHE.put(float.class, 0f);
        CACHE.put(boolean.class, false);
    }

    private ClassUtil() {
    }

    /**
     * 获取对象类型
     *
     * @param obj 对象
     * @param  泛型
     * @return 类型
     */
    @SuppressWarnings("unchecked")
    public static  Optional> getClass(final T obj) {
        return Objects.isNull(obj) ? Optional.empty() : Optional.of((Class) obj.getClass());
    }

    /**
     * 获取类名
     *
     * @param clazz    类
     * @param isSimple 是否全路径
     * @return 类名
     */
    public static String getClassName(final Class clazz, final boolean isSimple) {
        return Objects.isNull(clazz) ? StringUtil.EMPTY : isSimple ? clazz.getSimpleName() : clazz.getName();
    }

    /**
     * 获得对象数组的类数组
     *
     * @param objects 实例数组
     * @return 对象数据
     */
    public static Class[] getClasses(final Object... objects) {
        Class[] clazzs = new Class[objects.length];
        for (int i = 0; i < objects.length; i++) {
            clazzs[i] = getClass(objects[i]).orElse(Object.class);
        }
        return clazzs;
    }

    /**
     * 获得ClassPath
     *
     * @return ClassPath集合
     */
    public static Set getClassPathResources() {
        return getClassPaths(StringUtil.EMPTY);
    }

    /**
     * 获得ClassPath
     *
     * @param packageName 包名
     * @return ClassPath路径字符串集合
     */
    public static Set getClassPaths(final String packageName) {
        final String packagePath = packageName.replace(StringUtil.DOT, StringUtil.SLASH);
        Enumeration resources;
        try {
            resources = ClassLoaderUtil.getClassLoader().getResources(packagePath);
        } catch (IOException e) {
            throw new ToolException(StringUtil.format("Loading classPath [{}] error!", packagePath), e);
        }
        final Set paths = new HashSet<>();
        while (resources.hasMoreElements()) {
            paths.add(resources.nextElement().getPath());
        }
        return paths;
    }

    /**
     * 获得ClassPath
     *
     * @return ClassPath
     */
    public static String getClassPath() {
        return getClassPathURL().getPath();
    }

    /**
     * 获得ClassPath URL
     *
     * @return ClassPath URL
     */
    public static URL getClassPathURL() {
        return ResourceUtil.getResource(StringUtil.EMPTY);
    }

    /**
     * @return 获得Java ClassPath路径，不包括 jre
     */
    public static String[] getJavaClassPaths() {
        return System.getProperty("java.class.path").split(System.getProperty("path.separator"));
    }

    /**
     * 实例化对象
     *
     * @param    对象类型
     * @param clazz 类名
     * @return 对象
     */
    @SuppressWarnings("unchecked")
    public static  T newInstance(final String clazz) {
        try {
            return (T) Class.forName(clazz).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            throw new ToolException(StringUtil.format("instance class {} failure,the reason is: {}", clazz, e.getMessage()),
                    e);
        }
    }

    /**
     * 实例化对象
     *
     * @param     对象类型
     * @param clazz  类
     * @param params 构造函数参数
     * @return 对象
     */
    public static  T newInstance(final Class clazz, final Object... params) {
        try {
            return ArrayUtil.isEmpty(params) ? clazz.newInstance() : ConstructorUtil.getConstructor(clazz, getClasses(params)).orElseThrow
                    (NullPointerException::new).newInstance(params);
        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
                | SecurityException e) {
            throw new ToolException(
                    StringUtil.format("instance class {} failure,the reason is: {}", clazz.getSimpleName(), e.getMessage()),
                    e);
        }
    }

    /**
     * 获得给定类所在包的名称
     *
     * @param clazz 类
     * @return 包名
     */
    public static String getPackage(final Class clazz) {
        final String name = getClassName(clazz, false);
        final int packageEndIndex = name.lastIndexOf(StringUtil.C_DOT);
        return packageEndIndex == -1 ? name : StringUtil.sub(name, 0, packageEndIndex);
    }

    /**
     * 获得给定类所在包的路径
     *
     * @param clazz 类
     * @return 包名
     */
    public static String getPackagePath(final Class clazz) {
        return getPackage(clazz).replace(StringUtil.C_DOT, StringUtil.C_SLASH);
    }


    /**
     * 获取指定类型分的默认值
     *
     * @param clazz 类
     * @return 默认值
     */
    public static Optional