Java字符串、集合等工具类合集

自己造了一些轮子，由于水平有限，如有错误或缺陷（必定会有的），欢迎大家提出。

项目地址：全球同性交友网站，如对您有些许帮助，帮我点个赞吧~

这里贴上部分工具类代码，完整代码可以点击上面的链接获取

字符串工具类 StringUtil：

1. MD5加密
2. 创建指定长度的随机字符串
3. 字符串和ASCII码互转
4. 字符串判空
...

package com.dengweiping.String;


import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.util.Random;

/**
 * @description:字符串工具类
 * @author: dengweiping
 * @time: 2020/6/1 8:47
 */
public class StringUtil {

    /**
     * MD5加密 生成32位md5码
     *
     * @param inStr 输入字符串
     * @return
     */
    public static String toMD5(String inStr) {
        MessageDigest md5;

        try {
            md5 = MessageDigest.getInstance("MD5");
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

        char[] charArray = inStr.toCharArray();
        byte[] byteArray = new byte[charArray.length];

        for (int i = 0; i < charArray.length; i++) {
            byteArray[i] = (byte) charArray[i];
        }
        byte[] md5Bytes = md5.digest(byteArray);
        StringBuffer hexValue = new StringBuffer();
        for (int i = 0; i < md5Bytes.length; i++) {
            int val = ((int) md5Bytes[i]) & 0xff;
            if (val < 16)
                hexValue.append("0");
            hexValue.append(Integer.toHexString(val));
        }

        return hexValue.toString();
    }

    /**
     * 根据指定字符串创建指定长度的随机码
     *
     * @param strTable
     * @param length
     * @return
     */
    private static String createRandomStr(String strTable, int length) {
        char[] strArr = strTable.toCharArray();
        Random random = new Random();
        StringBuffer result = new StringBuffer(length);
        for (int i = 0; i < length; i++) {
            int num = random.nextInt(strTable.length());
            result.append(strArr[num]);
        }
        return result.toString();
    }

    /**
     * 创建指定数量的随机字符串
     *
     * @param length 指定长度
     * @return
     */
    public static String createRandomStr(int length) {
        String strTable = "abcdefghijkmnpqrstuvwxyz";
        return createRandomStr(strTable, length);
    }

    /**
     * 创建指定数量的随机字符串
     *
     * @param length 指定长度
     * @return
     */
    public static String createRandomStrAndNum(int length) {
        String strTable = "1234567890abcdefghijkmnpqrstuvwxyz";
        return createRandomStr(strTable, length);
    }

    /**
     * 创建指定数量的随机数字
     *
     * @param length 指定长度
     * @return
     */
    public static String createRandomNum(int length) {
        String strTable = "1234567890";
        return createRandomStr(strTable, length);
    }

    /**
     * 字节数组转换为字符串
     *
     * @param bytes 字节数组
     * @return
     */
    public static String byteToStr(byte[] bytes) {
        String strRead = null;
        try {
            strRead = new String(bytes, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return strRead;
    }

    /**
     * 字符串转ASCII
     *
     * @param str 字符串
     * @return
     */
    public static int[] toASCII(String str) {
        byte[] bytes = str.getBytes();
        int[] result = new int[str.length()];
        for (int i = 0; i < bytes.length; i++) {
            result[i] = bytes[i];
        }
        return result;
    }

    /**
     * 字符转ASCII
     *
     * @param c 字符
     * @return
     */
    public static int toASCII(char c) {
        byte b = (byte) c;
        return b;
    }

    /**
     * ASCII转字符
     *
     * @param ASCIINum ASCII码值
     * @return
     */
    public static char ASCIIToChar(int ASCIINum) {
        char strChar = (char) ASCIINum;
        return strChar;
    }

    /**
     * ASCII转字符串
     *
     * @param ASCIINum ASCII码值
     * @return
     */
    public static String ASCIIToStr(int[] ASCIINum) {
        StringBuffer stringBuffer = new StringBuffer();
        for (int num : ASCIINum) {
            char strChar = (char) num;
            stringBuffer.append(strChar);
        }
        return stringBuffer.toString();
    }

    /**
     * 字符串判空
     *
     * @param str
     * @return
     */
    public static boolean isEmpty(String str) {
        if (str == null) {
            return true;
        }
        return str.isEmpty();
    }

    /**
     * 字符串判空，去掉所有空格
     *
     * @param str
     * @return
     */
    public static boolean isBlank(String str) {
        if (str == null) {
            return true;
        }
        str = str.replace(" ", "");
        if (str.indexOf("\t") != -1) {
            str = str.replace("\t", "");
        }
        if (str.indexOf("\n") != -1) {
            str = str.replace("\n", "");
        }
        if (str.indexOf("\r") != -1) {
            str = str.replace("\r", "");
        }
        if (str.indexOf("\f") != -1) {
            str = str.replace("\f", "");
        }
        return isEmpty(str);
    }

}

List 集合工具类：

1. list 集合排序，支持字符串、整形、浮点型、Date类型排序
   …

package com.dengweiping.collection;

import com.dengweiping.domain.Test;

import java.lang.reflect.Field;
import java.util.*;

/**
 * @description 集合工具类
 * @author: dengweiping
 * @time: 2020/6/1 14:49
 */
public class ListUtil {

    /**
     * 根据指定属性升序排序
     *
     * @param list         集合
     * @param propertyName 属性名
     * @param <T>
     * @return
     */
    public static <T> List<T> sortAsc(List<T> list, String propertyName) {
        return sort(list, propertyName, "asc", false);
    }

    /**
     * 根据指定属性升序排序，忽略大小写
     *
     * @param list         集合
     * @param propertyName 属性名
     * @param <T>
     * @return
     */
    public static <T> List<T> sortAscIgnoreCase(List<T> list, String propertyName) {
        return sort(list, propertyName, "asc", true);
    }

    /**
     * 根据指定属性降序排序
     *
     * @param list         集合
     * @param propertyName 属性名
     * @param <T>
     * @return
     */
    public static <T> List<T> sortDesc(List<T> list, String propertyName) {
        return sort(list, propertyName, "desc", false);
    }

    /**
     * 根据指定属性降序排序，忽略大小写
     *
     * @param list         集合
     * @param propertyName 属性名
     * @param <T>
     * @return
     */
    public static <T> List<T> sortDescIgnoreCase(List<T> list, String propertyName) {
        return sort(list, propertyName, "desc", true);
    }

    /**
     * 根据指定方式排序
     *
     * @param list         集合
     * @param propertyName 属性名
     * @param sortType     排序方式 asc：升序 desc：降序
     * @param <T>
     * @return
     */
    private static <T> List<T> sort(List<T> list, String propertyName, String sortType, boolean ignoreCase) {
        Collections.sort(list, (Comparator<Object>) (o1, o2) -> {
            try {
                Field field1 = o1.getClass().getDeclaredField(propertyName);
                Field field2 = o2.getClass().getDeclaredField(propertyName);
                //打开私有访问
                field1.setAccessible(true);
                field2.setAccessible(true);
                String type = field1.getType().getName();
                Object obj1 = field1.get(o1);
                Object obj2 = field2.get(o2);
                if (obj1 == null) {
                    return -1;
                } else if (obj2 == null) {
                    return 1;
                }
                boolean isAsc = "asc".equals(sortType);
                switch (type) {
                    case "int":
                        return isAsc ? ((int) obj1 - (int) obj2) : ((int) obj2 - (int) obj1);
                    case "long":
                    case "java.lang.Long":
                        return (long) obj1 > (long) obj2 ? (isAsc ? 1 : -1) : (isAsc ? -1 : 1);
                    case "double":
                    case "java.lang.double":
                        return (double) obj1 > (double) obj2 ? (isAsc ? 1 : -1) : (isAsc ? -1 : 1);
                    case "float":
                    case "java.lang.Float":
                        return (float) obj1 > (float) obj2 ? (isAsc ? 1 : -1) : (isAsc ? -1 : 1);
                    case "java.lang.String":
                        //循环比较次数以字符串短的为准
                        int length = obj1.toString().length() < obj2.toString().length() ? obj1.toString().length() : obj2.toString().length();
                        //是否忽略大小写
                        char[] charArray1 = ignoreCase ? obj1.toString().toLowerCase().toCharArray() : obj1.toString().toCharArray();
                        char[] charArray2 = ignoreCase ? obj2.toString().toLowerCase().toCharArray() : obj2.toString().toCharArray();
                        //比较字符串的ASCII码值
                        for (int i = 0; i < length; i++) {
                            if ((byte) charArray1[i] > (byte) charArray2[i]) {
                                return isAsc ? 1 : -1;
                            } else if ((byte) charArray1[i] < (byte) charArray2[i]) {
                                return isAsc ? -1 : 1;
                            }
                        }
                        //若相同长度部分的字符串都相等，则根据字符串长度比较
                        return isAsc ? (charArray1.length - charArray2.length) : (charArray2.length - charArray1.length);
                    case "java.util.Date":
                        Date d1 = (Date) obj1;
                        Date d2 = (Date) obj2;
                        return d1.getTime() > d2.getTime() ? (isAsc ? 1 : -1) : (isAsc ? -1 : 1);
                    default:
                        throw new RuntimeException("暂不支持 " + type + " 类型的属性排序");
                }
            } catch (NoSuchFieldException | IllegalAccessException e) {
                e.printStackTrace();
            }
            return 0;
        });

        return list;
    }
}