APP
簡單工具類
寫作初衷:由于日常開發(fā)經(jīng)常需要用到很多工具類,經(jīng)常根據(jù)需求自己寫也比較麻煩
網(wǎng)上好了一些工具類例如commom.lang3或者hutool或者Jodd這樣的開源工具,但是
發(fā)現(xiàn)他們之中雖然設(shè)計不錯,但是如果我想要使用,就必須要引入依賴并且去維護依賴,有些
甚至會有存在版本編譯不通過問題,故此想要寫作一個每個類都可以作為獨立工具類使用
每個使用者只需要復(fù)制該類,到任何項目當中都可以使用,所以需要尊從以下兩個原則才能
做到.在此誠邀各位大佬參與.可以把各自用過的工具,整合成只依賴JDK,每個類都能夠單獨
使用的工具.每個人當遇到業(yè)務(wù)需求需要使用的時候,只需要到這里單獨拷貝一個即可使用.
拋棄傳統(tǒng)的需要引入依賴的煩惱.讓大家一起來解決你所面臨的業(yè)務(wù)問題吧!
介紹
遵從兩大原則
- 1.絕不依賴JDK以外的源碼
- 2.犧牲代碼復(fù)用性,每個類都必須是單獨的組件,絕不互相引用,做到完全解耦
package com.simple.util.base;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* @program: simple_tools
* @description:
* @author: ChenWenLong
* @create: 2019-05-31 10:43
**/
public class ClassUtils {
public ClassUtils() {
super();
}
//包分割符
public static final char PACKAGE_SEPARATOR_CHAR = '.';
//字符串類型的包分隔符
public static final String PACKAGE_SEPARATOR = String.valueOf(PACKAGE_SEPARATOR_CHAR);
//內(nèi)部類分割符
public static final char INNER_CLASS_SEPARATOR_CHAR = '$';
//字符串類型內(nèi)部類分隔符
public static final String INNER_CLASS_SEPARATOR = String.valueOf(INNER_CLASS_SEPARATOR_CHAR);
//基本類型的Map集合
private static Map primitiveWrapperMap = new HashMap();
static {
primitiveWrapperMap.put(Boolean.TYPE, Boolean.class);
primitiveWrapperMap.put(Byte.TYPE, Byte.class);
primitiveWrapperMap.put(Character.TYPE, Character.class);
primitiveWrapperMap.put(Short.TYPE, Short.class);
primitiveWrapperMap.put(Integer.TYPE, Integer.class);
primitiveWrapperMap.put(Long.TYPE, Long.class);
primitiveWrapperMap.put(Double.TYPE, Double.class);
primitiveWrapperMap.put(Float.TYPE, Float.class);
primitiveWrapperMap.put(Void.TYPE, Void.TYPE);
}
//用于交換的Map類型集合
private static Map wrapperPrimitiveMap = new HashMap();
static {
for (Iterator it = primitiveWrapperMap.keySet().iterator(); it.hasNext();) {
Class primitiveClass = (Class) it.next();
Class wrapperClass = (Class) primitiveWrapperMap.get(primitiveClass);
if (!primitiveClass.equals(wrapperClass)) {
wrapperPrimitiveMap.put(wrapperClass, primitiveClass);
}
}
}
//用于存儲類型名稱簡寫的Map
private static Map abbreviationMap = new HashMap();
//類名縮寫的替換Map集合
private static Map reverseAbbreviationMap = new HashMap();
/**
* 功能描述:
* 〈基本類型的類名縮寫添加到Map當中〉
*
* @params : [primitive, abbreviation]
* @return : void
* @author : cwl
* @date : 2019/5/31 15:22
*/
private static void addAbbreviation(String primitive, String abbreviation) {
abbreviationMap.put(primitive, abbreviation);
reverseAbbreviationMap.put(abbreviation, primitive);
}
/**
* 功能描述:
* 〈將類型縮寫對應(yīng)的添加到Map當中〉
*
* @params :
* @return :
* @author : cwl
* @date : 2019/5/31 15:23
*/
static {
addAbbreviation("int", "I");
addAbbreviation("boolean", "Z");
addAbbreviation("float", "F");
addAbbreviation("long", "J");
addAbbreviation("short", "S");
addAbbreviation("byte", "B");
addAbbreviation("double", "D");
addAbbreviation("char", "C");
}
/**
* 功能描述:
* 〈獲取object的名臣簡寫,valueIfNull為當object==null時返回的默認參數(shù)〉
*
* @params : [object, valueIfNull]
* @return : java.lang.String
* @author : cwl
* @date : 2019/5/31 15:27
*/
public static String getShortClassName(Object object, String valueIfNull) {
if (object == null) {
return valueIfNull;
}
return getShortClassName(object.getClass().getName());
}
/**
* 功能描述:
* 〈根據(jù)cls對象獲取它的簡單類型名稱〉
*
* @params : [cls]
* @return : java.lang.String
* @author : cwl
* @date : 2019/5/31 15:32
*/
public static String getShortClassName(Class cls) {
if (cls == null) {
return "";
}
return getShortClassName(cls.getName());
}
/**
* 功能描述:
* 〈依據(jù)字符串className名稱獲取它的簡寫字符名稱〉
*
* @params : [className]
* @return : java.lang.String
* @author : cwl
* @date : 2019/5/31 15:33
*/
private static String getShortClassName(String className) {
if (className == null) {
return "";
}
if (className.length() == 0) {
return "";
}
int lastDotIdx = className.lastIndexOf(PACKAGE_SEPARATOR_CHAR);
int innerIdx = className.indexOf(
INNER_CLASS_SEPARATOR_CHAR, lastDotIdx == -1 ? 0 : lastDotIdx + 1);
String out = className.substring(lastDotIdx + 1);
if (innerIdx != -1) {
out = out.replace(INNER_CLASS_SEPARATOR_CHAR, PACKAGE_SEPARATOR_CHAR);
}
return out;
}
/**
* 功能描述:
* 〈獲取object對象所在的包名稱,valueIfNull是當object為null時返回的默認值〉
*
* @params : [object, valueIfNull]
* @return : java.lang.String
* @author : cwl
* @date : 2019/5/31 15:34
*/
public static String getPackageName(Object object, String valueIfNull) {
if (object == null) {
return valueIfNull;
}
return getPackageName(object.getClass().getName());
}
/**
* 功能描述:
* 〈根據(jù)字節(jié)碼對象cls獲取該對象所在包名稱〉
*
* @params : [cls]
* @return : java.lang.String
* @author : cwl
* @date : 2019/5/31 15:35
*/
public static String getPackageName(Class cls) {
if (cls == null) {
return "";
}
return getPackageName(cls.getName());
}
/**
* 功能描述:
* 〈根據(jù)className獲得它所在的報名〉
*
* @params : [className]
* @return : java.lang.String
* @author : cwl
* @date : 2019/5/31 15:36
*/
private static String getPackageName(String className) {
if (className == null) {
return "";
}
int i = className.lastIndexOf(PACKAGE_SEPARATOR_CHAR);
if (i == -1) {
return "";
}
return className.substring(0, i);
}
/**
* 功能描述:
* 〈獲取cls所有的父類對象〉
*
* @params : [cls]
* @return : java.util.List
* @author : cwl
* @date : 2019/5/31 15:38
*/
public static List getAllSuperclasses(Class cls) {
if (cls == null) {
return null;
}
List classes = new ArrayList();
Class superclass = cls.getSuperclass();
while (superclass != null) {
classes.add(superclass);
superclass = superclass.getSuperclass();
}
return classes;
}
/**
* 功能描述:
* 〈獲取cls對象所有實現(xiàn)的接口〉
*
* @params : [cls]
* @return : java.util.List
* @author : cwl
* @date : 2019/5/31 15:39
*/
public static List getAllInterfaces(Class cls) {
if (cls == null) {
return null;
}
List list = new ArrayList();
while (cls != null) {
Class[] interfaces = cls.getInterfaces();
for (int i = 0; i < interfaces.length; i++) {
if (list.contains(interfaces[i]) == false) {
list.add(interfaces[i]);
}
List superInterfaces = getAllInterfaces(interfaces[i]);
for (Iterator it = superInterfaces.iterator(); it.hasNext();) {
Class intface = (Class) it.next();
if (list.contains(intface) == false) {
list.add(intface);
}
}
}
cls = cls.getSuperclass();
}
return list;
}
/**
* 功能描述:
* 〈將類名轉(zhuǎn)換成為Class對象,貌似也沒啥用處〉
*
* @params : [classNames]
* @return : java.util.List<java.lang.Class>
* @author : cwl
* @date : 2019/5/31 15:52
*/
public static List convertClassNamesToClasses(List<String> classNames) {
if (classNames == null) {
return null;
}
List classes = new ArrayList(classNames.size());
for (Iterator it = classNames.iterator(); it.hasNext();) {
String className = (String) it.next();
try {
classes.add(Class.forName(className));
} catch (Exception ex) {
classes.add(null);
}
}
return classes;
}
/**
* 功能描述:
* 〈classes集合轉(zhuǎn)換成為全限定類名的集合〉
*
* @params : [classes]
* @return : java.util.List
* @author : cwl
* @date : 2019/5/31 16:01
*/
public static List convertClassesToClassNames(List classes) {
if (classes == null) {
return null;
}
List classNames = new ArrayList(classes.size());
for (Iterator it = classes.iterator(); it.hasNext();) {
Class cls = (Class) it.next();
if (cls == null) {
classNames.add(null);
} else {
classNames.add(cls.getName());
}
}
return classNames;
}
/**
* 功能描述:
* 〈判斷classArray數(shù)組能否轉(zhuǎn)換為toClassArray〉
*
* @params : [classArray, toClassArray]
* @return : boolean
* @author : cwl
* @date : 2019/5/31 16:58
*/
public static boolean isAssignable(Class[] classArray, Class[] toClassArray) {
if ((classArray == null && toClassArray != null && toClassArray.length > 0) ||
(toClassArray == null && classArray != null && classArray.length > 0) ||
(classArray != null && toClassArray != null && classArray.length != toClassArray.length)) {
return false;
}
if (classArray == null) {
classArray = new Class[0];
}
if (toClassArray == null) {
toClassArray = new Class[0];
}
for (int i = 0; i < classArray.length; i++) {
if (isAssignable(classArray[i], toClassArray[i]) == false) {
return false;
}
}
return true;
}
/**
* 功能描述:
* 〈判斷cls能否轉(zhuǎn)換為toClass〉
*
* @params : [cls, toClass]
* @return : boolean
* @author : cwl
* @date : 2019/5/31 16:59
*/
public static boolean isAssignable(Class cls, Class toClass) {
if (toClass == null) {
return false;
}
// have to check for null, as isAssignableFrom doesn't
if (cls == null) {
return !(toClass.isPrimitive());
}
if (cls.equals(toClass)) {
return true;
}
if (cls.isPrimitive()) {
if (toClass.isPrimitive() == false) {
return false;
}
if (Integer.TYPE.equals(cls)) {
return Long.TYPE.equals(toClass)
|| Float.TYPE.equals(toClass)
|| Double.TYPE.equals(toClass);
}
if (Long.TYPE.equals(cls)) {
return Float.TYPE.equals(toClass)
|| Double.TYPE.equals(toClass);
}
if (Boolean.TYPE.equals(cls)) {
return false;
}
if (Double.TYPE.equals(cls)) {
return false;
}
if (Float.TYPE.equals(cls)) {
return Double.TYPE.equals(toClass);
}
if (Character.TYPE.equals(cls)) {
return Integer.TYPE.equals(toClass)
|| Long.TYPE.equals(toClass)
|| Float.TYPE.equals(toClass)
|| Double.TYPE.equals(toClass);
}
if (Short.TYPE.equals(cls)) {
return Integer.TYPE.equals(toClass)
|| Long.TYPE.equals(toClass)
|| Float.TYPE.equals(toClass)
|| Double.TYPE.equals(toClass);
}
if (Byte.TYPE.equals(cls)) {
return Short.TYPE.equals(toClass)
|| Integer.TYPE.equals(toClass)
|| Long.TYPE.equals(toClass)
|| Float.TYPE.equals(toClass)
|| Double.TYPE.equals(toClass);
}
// should never get here
return false;
}
return toClass.isAssignableFrom(cls);
}
/**
* 功能描述:
* 〈類名轉(zhuǎn)全限定類名〉
*
* @params : [cls]
* @return : java.lang.Class
* @author : cwl
* @date : 2019/5/31 17:07
*/
public static Class primitiveToWrapper(Class cls) {
Class convertedClass = cls;
if (cls != null && cls.isPrimitive()) {
convertedClass = (Class) primitiveWrapperMap.get(cls);
}
return convertedClass;
}
/**
* 功能描述:
* 〈類名數(shù)組轉(zhuǎn)全限定類名數(shù)組〉
*
* @params : [classes]
* @return : java.lang.Class[]
* @author : cwl
* @date : 2019/5/31 17:08
*/
public static Class[] primitivesToWrappers(Class[] classes) {
if (classes == null) {
return null;
}
if (classes.length == 0) {
return classes;
}
Class[] convertedClasses = new Class[classes.length];
for (int i=0; i < classes.length; i++) {
convertedClasses[i] = primitiveToWrapper( classes[i] );
}
return convertedClasses;
}
/**
* 功能描述:
* 〈全限定類名轉(zhuǎn)類名〉
*
* @params : [cls]
* @return : java.lang.Class
* @author : cwl
* @date : 2019/5/31 17:45
*/
public static Class wrapperToPrimitive(Class cls) {
return (Class) wrapperPrimitiveMap.get(cls);
}
/**
* 功能描述:
* 〈全限定類名數(shù)組轉(zhuǎn)類名數(shù)組〉
*
* @params : [classes]
* @return : java.lang.Class[]
* @author : cwl
* @date : 2019/5/31 17:45
*/
public static Class[] wrappersToPrimitives(Class[] classes) {
if (classes == null) {
return null;
}
if (classes.length == 0) {
return classes;
}
Class[] convertedClasses = new Class[classes.length];
for (int i=0; i < classes.length; i++) {
convertedClasses[i] = wrapperToPrimitive( classes[i] );
}
return convertedClasses;
}
/**
* 功能描述:
* 〈是否是內(nèi)部類〉
*
* @params : [cls]
* @return : boolean
* @author : cwl
* @date : 2019/5/31 17:45
*/
public static boolean isInnerClass(Class cls) {
if (cls == null) {
return false;
}
return cls.getName().indexOf(INNER_CLASS_SEPARATOR_CHAR) >= 0;
}
/**
* 功能描述:
* 〈從類加載器當中獲取字節(jié)碼對象〉
*
* @params : [classLoader, className, initialize]
* @return : java.lang.Class
* @author : cwl
* @date : 2019/5/31 17:46
*/
public static Class getClass(
ClassLoader classLoader, String className, boolean initialize) throws ClassNotFoundException {
Class clazz;
if (abbreviationMap.containsKey(className)) {
String clsName = "[" + abbreviationMap.get(className);
clazz = Class.forName(clsName, initialize, classLoader).getComponentType();
} else {
clazz = Class.forName(toCanonicalName(className), initialize, classLoader);
}
return clazz;
}
/**
* 功能描述:
* 〈從類加載器當中獲取字節(jié)碼對象〉
*
* @params : [classLoader, className]
* @return : java.lang.Class
* @author : cwl
* @date : 2019/5/31 17:47
*/
public static Class getClass(ClassLoader classLoader, String className) throws ClassNotFoundException {
return getClass(classLoader, className, true);
}
/**
* 功能描述:
* 〈根據(jù)className獲取字節(jié)碼對象〉
*
* @params : [className]
* @return : java.lang.Class
* @author : cwl
* @date : 2019/5/31 17:47
*/
private static Class getClass(String className) throws ClassNotFoundException {
return getClass(className, true);
}
/**
* 功能描述:
* 〈根據(jù)className獲取字節(jié)碼對象〉
*
* @params : [className, initialize]
* @return : java.lang.Class
* @author : cwl
* @date : 2019/5/31 17:48
*/
private static Class getClass(String className, boolean initialize) throws ClassNotFoundException {
ClassLoader contextCL = Thread.currentThread().getContextClassLoader();
ClassLoader loader = contextCL == null ? ClassUtils.class.getClassLoader() : contextCL;
return getClass(loader, className, initialize );
}
/**
* 功能描述:
* 〈獲取cls的公共方法〉
*
* @params : [cls, methodName, parameterTypes]
* @return : java.lang.reflect.Method
* @author : cwl
* @date : 2019/5/31 17:49
*/
public static Method getPublicMethod(Class cls, String methodName, Class parameterTypes[])
throws SecurityException, NoSuchMethodException {
Method declaredMethod = cls.getMethod(methodName, parameterTypes);
if (Modifier.isPublic(declaredMethod.getDeclaringClass().getModifiers())) {
return declaredMethod;
}
List candidateClasses = new ArrayList();
candidateClasses.addAll(getAllInterfaces(cls));
candidateClasses.addAll(getAllSuperclasses(cls));
for (Iterator it = candidateClasses.iterator(); it.hasNext(); ) {
Class candidateClass = (Class) it.next();
if (!Modifier.isPublic(candidateClass.getModifiers())) {
continue;
}
Method candidateMethod;
try {
candidateMethod = candidateClass.getMethod(methodName, parameterTypes);
} catch (NoSuchMethodException ex) {
continue;
}
if (Modifier.isPublic(candidateMethod.getDeclaringClass().getModifiers())) {
return candidateMethod;
}
}
throw new NoSuchMethodException("Can't find a public method for " +
methodName);
}
/**
* 功能描述:
* 〈轉(zhuǎn)換成JSL規(guī)范的類名〉
*
* @params : [className]
* @return : java.lang.String
* @author : cwl
* @date : 2019/5/31 17:52
*/
private static String toCanonicalName(String className) {
className = StringUtils.deleteWhitespace(className);
if (className == null) {
throw new NullPointerException("className is null");
} else if (className.endsWith("[]")) {
StringBuffer classNameBuffer = new StringBuffer();
while (className.endsWith("[]")) {
className = className.substring(0, className.length() - 2);
classNameBuffer.append("[");
}
String abbreviation = (String) abbreviationMap.get(className);
if (abbreviation != null) {
classNameBuffer.append(abbreviation);
} else {
classNameBuffer.append("L").append(className).append(";");
}
className = classNameBuffer.toString();
}
return className;
}
/**
* 功能描述:
* 〈Object類型的數(shù)組array轉(zhuǎn)換成它對應(yīng)的字節(jié)碼對象〉
*
* @params : [array]
* @return : java.lang.Class[]
* @author : cwl
* @date : 2019/5/31 17:53
*/
public static Class[] toClass(Object[] array)
{
if (array == null) {
return null;
} else if (array.length == 0) {
return new Class[0];
}
Class[] classes = new Class[array.length];
for (int i = 0; i < array.length; i++) {
classes[i] = array[i].getClass();
}
return classes;
}
/**
* 功能描述:
* 〈獲取object對象的簡稱,valueIfNull為當object為null時的返回值〉
*
* @params : [object, valueIfNull]
* @return : java.lang.String
* @author : cwl
* @date : 2019/5/31 17:53
*/
public static String getShortCanonicalName(Object object, String valueIfNull) {
if (object == null) {
return valueIfNull;
}
return getShortCanonicalName(object.getClass().getName());
}
/**
* 功能描述:
* 〈獲取cls字節(jié)碼對象的簡稱〉
*
* @params : [cls]
* @return : java.lang.String
* @author : cwl
* @date : 2019/5/31 17:55
*/
public static String getShortCanonicalName(Class cls) {
if (cls == null) {
return "";
}
return getShortCanonicalName(cls.getName());
}
/**
* 功能描述:
* 〈獲取canonicalName的簡稱〉
*
* @params : [canonicalName]
* @return : java.lang.String
* @author : cwl
* @date : 2019/5/31 17:55
*/
public static String getShortCanonicalName(String canonicalName) {
return ClassUtils.getShortClassName(getCanonicalName(canonicalName));
}
/**
* 功能描述:
* 〈獲取canonicalName的簡稱〉
*
* @params : [className]
* @return : java.lang.String
* @author : cwl
* @date : 2019/5/31 17:58
*/
private static String getCanonicalName(String className) {
className = StringUtils.deleteWhitespace(className);
if (className == null) {
return null;
} else {
int dim = 0;
while(className.startsWith("[")) {
dim++;
className = className.substring(1);
}
if(dim < 1) {
return className;
} else {
if(className.startsWith("L")) {
className = className.substring(
1,
className.endsWith(";")
? className.length() - 1
: className.length());
} else {
if(className.length() > 0) {
className = (String) reverseAbbreviationMap.get(
className.substring(0, 1));
}
}
StringBuffer canonicalClassNameBuffer = new StringBuffer(className);
for(int i = 0; i < dim; i++) {
canonicalClassNameBuffer.append("[]");
}
return canonicalClassNameBuffer.toString();
}
}
}
}
本文摘自 ：https://blog.51cto.com/u
