java常用工具類（從開源專案smartframework專案copy過來備用）

阿新 • • 發佈：2018-11-15

1.陣列操作工具類

package org.smart4j.framework.util;

import org.apache.commons.lang.ArrayUtils;

/**
 * 陣列操作工具類
 *
 * @author huangyong
 * @since 1.0
 */
public class ArrayUtil {

    /**
     * 判斷陣列是否非空
     */
    public static boolean isNotEmpty(Object[] array) {
        return !ArrayUtils.isEmpty(array);
    }

     
/**
     * 判斷陣列是否為空
     */
    public static boolean isEmpty(Object[] array) {
        return ArrayUtils.isEmpty(array);
    }

    /**
     * 連線陣列
     */
    public static Object[] concat(Object[] array1, Object[] array2) {
        return ArrayUtils.addAll(array1, array2);
    }

    /**
     * 判斷物件是否在陣列中
      
*/
    public static <T> boolean contains(T[] array, T obj) {
        return ArrayUtils.contains(array, obj);
    }
}

2. 轉型操作工具類

package org.smart4j.framework.util;

/**
 * 轉型操作工具類
 *
 * @author huangyong
 * @since 1.0
 */
public class CastUtil {

    /**
     * 轉為 String 型
     */
    public 
 static String castString(Object obj) {
        return CastUtil.castString(obj, "");
    }

    /**
     * 轉為 String 型（提供預設值）
     */
    public static String castString(Object obj, String defaultValue) {
        return obj != null ? String.valueOf(obj) : defaultValue;
    }

    /**
     * 轉為 double 型
     */
    public static double castDouble(Object obj) {
        return CastUtil.castDouble(obj, 0);
    }

    /**
     * 轉為 double 型（提供預設值）
     */
    public static double castDouble(Object obj, double defaultValue) {
        double doubleValue = defaultValue;
        if (obj != null) {
            String strValue = castString(obj);
            if (StringUtil.isNotEmpty(strValue)) {
                try {
                    doubleValue = Double.parseDouble(strValue);
                } catch (NumberFormatException e) {
                    doubleValue = defaultValue;
                }
            }
        }
        return doubleValue;
    }

    /**
     * 轉為 long 型
     */
    public static long castLong(Object obj) {
        return CastUtil.castLong(obj, 0);
    }

    /**
     * 轉為 long 型（提供預設值）
     */
    public static long castLong(Object obj, long defaultValue) {
        long longValue = defaultValue;
        if (obj != null) {
            String strValue = castString(obj);
            if (StringUtil.isNotEmpty(strValue)) {
                try {
                    longValue = Long.parseLong(strValue);
                } catch (NumberFormatException e) {
                    longValue = defaultValue;
                }
            }
        }
        return longValue;
    }

    /**
     * 轉為 int 型
     */
    public static int castInt(Object obj) {
        return CastUtil.castInt(obj, 0);
    }

    /**
     * 轉為 int 型（提供預設值）
     */
    public static int castInt(Object obj, int defaultValue) {
        int intValue = defaultValue;
        if (obj != null) {
            String strValue = castString(obj);
            if (StringUtil.isNotEmpty(strValue)) {
                try {
                    intValue = Integer.parseInt(strValue);
                } catch (NumberFormatException e) {
                    intValue = defaultValue;
                }
            }
        }
        return intValue;
    }

    /**
     * 轉為 boolean 型
     */
    public static boolean castBoolean(Object obj) {
        return CastUtil.castBoolean(obj, false);
    }

    /**
     * 轉為 boolean 型（提供預設值）
     */
    public static boolean castBoolean(Object obj, boolean defaultValue) {
        boolean booleanValue = defaultValue;
        if (obj != null) {
            booleanValue = Boolean.parseBoolean(castString(obj));
        }
        return booleanValue;
    }

    /**
     * 轉為 String[] 型
     */
    public static String[] castStringArray(Object[] objArray) {
        if (objArray == null) {
            objArray = new Object[0];
        }
        String[] strArray = new String[objArray.length];
        if (ArrayUtil.isNotEmpty(objArray)) {
            for (int i = 0; i < objArray.length; i++) {
                strArray[i] = castString(objArray[i]);
            }
        }
        return strArray;
    }

    /**
     * 轉為 double[] 型
     */
    public static double[] castDoubleArray(Object[] objArray) {
        if (objArray == null) {
            objArray = new Object[0];
        }
        double[] doubleArray = new double[objArray.length];
        if (!ArrayUtil.isEmpty(objArray)) {
            for (int i = 0; i < objArray.length; i++) {
                doubleArray[i] = castDouble(objArray[i]);
            }
        }
        return doubleArray;
    }

    /**
     * 轉為 long[] 型
     */
    public static long[] castLongArray(Object[] objArray) {
        if (objArray == null) {
            objArray = new Object[0];
        }
        long[] longArray = new long[objArray.length];
        if (!ArrayUtil.isEmpty(objArray)) {
            for (int i = 0; i < objArray.length; i++) {
                longArray[i] = castLong(objArray[i]);
            }
        }
        return longArray;
    }

    /**
     * 轉為 int[] 型
     */
    public static int[] castIntArray(Object[] objArray) {
        if (objArray == null) {
            objArray = new Object[0];
        }
        int[] intArray = new int[objArray.length];
        if (!ArrayUtil.isEmpty(objArray)) {
            for (int i = 0; i < objArray.length; i++) {
                intArray[i] = castInt(objArray[i]);
            }
        }
        return intArray;
    }

    /**
     * 轉為 boolean[] 型
     */
    public static boolean[] castBooleanArray(Object[] objArray) {
        if (objArray == null) {
            objArray = new Object[0];
        }
        boolean[] booleanArray = new boolean[objArray.length];
        if (!ArrayUtil.isEmpty(objArray)) {
            for (int i = 0; i < objArray.length; i++) {
                booleanArray[i] = castBoolean(objArray[i]);
            }
        }
        return booleanArray;
    }
}

3. 類操作工具類

package org.smart4j.framework.util;

import java.net.URL;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 類操作工具類
 *
 * @author huangyong
 * @since 1.0
 */
public class ClassUtil {

    private static final Logger logger = LoggerFactory.getLogger(ClassUtil.class);

    /**
     * 獲取類載入器
     */
    public static ClassLoader getClassLoader() {
        return Thread.currentThread().getContextClassLoader();
    }

    /**
     * 獲取類路徑
     */
    public static String getClassPath() {
        String classpath = "";
        URL resource = getClassLoader().getResource("");
        if (resource != null) {
            classpath = resource.getPath();
        }
        return classpath;
    }

    /**
     * 載入類（將自動初始化）
     */
    public static Class<?> loadClass(String className) {
        return loadClass(className, true);
    }

    /**
     * 載入類
     */
    public static Class<?> loadClass(String className, boolean isInitialized) {
        Class<?> cls;
        try {
            cls = Class.forName(className, isInitialized, getClassLoader());
        } catch (ClassNotFoundException e) {
            logger.error("載入類出錯！", e);
            throw new RuntimeException(e);
        }
        return cls;
    }

    /**
     * 是否為 int 型別（包括 Integer 型別）
     */
    public static boolean isInt(Class<?> type) {
        return type.equals(int.class) || type.equals(Integer.class);
    }

    /**
     * 是否為 long 型別（包括 Long 型別）
     */
    public static boolean isLong(Class<?> type) {
        return type.equals(long.class) || type.equals(Long.class);
    }

    /**
     * 是否為 double 型別（包括 Double 型別）
     */
    public static boolean isDouble(Class<?> type) {
        return type.equals(double.class) || type.equals(Double.class);
    }

    /**
     * 是否為 String 型別
     */
    public static boolean isString(Class<?> type) {
        return type.equals(String.class);
    }
}

4. 編碼與解碼操作工具類

package org.smart4j.framework.util;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.UUID;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang.RandomStringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.smart4j.framework.FrameworkConstant;

/**
 * 編碼與解碼操作工具類
 *
 * @author huangyong
 * @since 1.0
 */
public class CodecUtil {

    private static final Logger logger = LoggerFactory.getLogger(CodecUtil.class);

    /**
     * 將 URL 編碼
     */
    public static String encodeURL(String str) {
        String target;
        try {
            target = URLEncoder.encode(str, FrameworkConstant.UTF_8);
        } catch (Exception e) {
            logger.error("編碼出錯！", e);
            throw new RuntimeException(e);
        }
        return target;
    }

    /**
     * 將 URL 解碼
     */
    public static String decodeURL(String str) {
        String target;
        try {
            target = URLDecoder.decode(str, FrameworkConstant.UTF_8);
        } catch (Exception e) {
            logger.error("解碼出錯！", e);
            throw new RuntimeException(e);
        }
        return target;
    }

    /**
     * 將字串 Base64 編碼
     */
    public static String encodeBASE64(String str) {
        String target;
        try {
            target = Base64.encodeBase64URLSafeString(str.getBytes(FrameworkConstant.UTF_8));
        } catch (UnsupportedEncodingException e) {
            logger.error("編碼出錯！", e);
            throw new RuntimeException(e);
        }
        return target;
    }

    /**
     * 將字串 Base64 解碼
     */
    public static String decodeBASE64(String str) {
        String target;
        try {
            target = new String(Base64.decodeBase64(str), FrameworkConstant.UTF_8);
        } catch (UnsupportedEncodingException e) {
            logger.error("解碼出錯！", e);
            throw new RuntimeException(e);
        }
        return target;
    }

    /**
     * 將字串 MD5 加密
     */
    public static String encryptMD5(String str) {
        return DigestUtils.md5Hex(str);
    }

    /**
     * 將字串 SHA 加密
     */
    public static String encryptSHA(String str) {
        return DigestUtils.sha1Hex(str);
    }

    /**
     * 建立隨機數
     */
    public static String createRandom(int count) {
        return RandomStringUtils.randomNumeric(count);
    }

    /**
     * 獲取 UUID（32位）
     */
    public static String createUUID() {
        return UUID.randomUUID().toString().replaceAll("-", "");
    }
}

View Code

5. 集合操作工具類

package org.smart4j.framework.util;

import java.util.Collection;
import org.apache.commons.collections.CollectionUtils;

/**
 * 集合操作工具類
 *
 * @author huangyong
 * @since 1.0
 */
public class CollectionUtil {

    /**
     * 判斷集合是否非空
     */
    public static boolean isNotEmpty(Collection<?> collection) {
        return CollectionUtils.isNotEmpty(collection);
    }

    /**
     * 判斷集合是否為空
     */
    public static boolean isEmpty(Collection<?> collection) {
        return CollectionUtils.isEmpty(collection);
    }
}

View Code

6. 日期操作工具類

package org.smart4j.framework.util;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 日期操作工具類
 *
 * @author huangyong
 * @since 1.0
 */
public class DateUtil {

    private static final Logger logger = LoggerFactory.getLogger(DateUtil.class);

    private static final SimpleDateFormat datetimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
    private static final SimpleDateFormat timeFormat = new SimpleDateFormat("HH:mm:ss");

    /**
     * 格式化日期與時間
     */
    public static String formatDatetime(long timestamp) {
        return datetimeFormat.format(new Date(timestamp));
    }

    /**
     * 格式化日期
     */
    public static String formatDate(long timestamp) {
        return dateFormat.format(new Date(timestamp));
    }

    /**
     * 格式化時間
     */
    public static String formatTime(long timestamp) {
        return timeFormat.format(new Date(timestamp));
    }

    /**
     * 獲取當前日期與時間
     */
    public static String getCurrentDatetime() {
        return datetimeFormat.format(new Date());
    }

    /**
     * 獲取當前日期
     */
    public static String getCurrentDate() {
        return dateFormat.format(new Date());
    }

    /**
     * 獲取當前時間
     */
    public static String getCurrentTime() {
        return timeFormat.format(new Date());
    }

    /**
     * 解析日期與時間
     */
    public static Date parseDatetime(String str) {
        Date date = null;
        try {
            date = datetimeFormat.parse(str);
        } catch (ParseException e) {
            logger.error("解析日期字串出錯！格式：yyyy-MM-dd HH:mm:ss", e);
        }
        return date;
    }

    /**
     * 解析日期
     */
    public static Date parseDate(String str) {
        Date date = null;
        try {
            date = dateFormat.parse(str);
        } catch (ParseException e) {
            logger.error("解析日期字串出錯！格式：yyyy-MM-dd", e);
        }
        return date;
    }

    /**
     * 解析時間
     */
    public static Date parseTime(String str) {
        Date date = null;
        try {
            date = timeFormat.parse(str);
        } catch (ParseException e) {
            logger.error("解析日期字串出錯！格式：HH:mm:ss", e);
        }
        return date;
    }
}

7. 檔案操作工具類

package org.smart4j.framework.util;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.smart4j.framework.FrameworkConstant;

/**
 * 檔案操作工具類
 *
 * @author huangyong
 * @since 1.0
 */
public class FileUtil {

    private static final Logger logger = LoggerFactory.getLogger(FileUtil.class);

    /**
     * 建立目錄
     */
    public static File createDir(String dirPath) {
        File dir;
        try {
            dir = new File(dirPath);
            if (!dir.exists()) {
                FileUtils.forceMkdir(dir);
            }
        } catch (Exception e) {
            logger.error("建立目錄出錯！", e);
            throw new RuntimeException(e);
        }
        return dir;
    }

    /**
     * 建立檔案
     */
    public static File createFile(String filePath) {
        File file;
        try {
            file = new File(filePath);
            File parentDir = file.getParentFile();
            if (!parentDir.exists()) {
                FileUtils.forceMkdir(parentDir);
            }
        } catch (Exception e) {
            logger.error("建立檔案出錯！", e);
            throw new RuntimeException(e);
        }
        return file;
    }

    /**
     * 複製目錄（不會複製空目錄）
     */
    public static void copyDir(String srcPath, String destPath) {
        try {
            File srcDir = new File(srcPath);
            File destDir = new File(destPath);
            if (srcDir.exists() && srcDir.isDirectory()) {
                FileUtils.copyDirectoryToDirectory(srcDir, destDir);
            }
        } catch (Exception e) {
            logger.error("複製目錄出錯！", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 複製檔案
     */
    public static void copyFile(String srcPath, String destPath) {
        try {
            File srcFile = new File(srcPath);
            File destDir = new File(destPath);
            if (srcFile.exists() && srcFile.isFile()) {
                FileUtils.copyFileToDirectory(srcFile, destDir);
            }
        } catch (Exception e) {
            logger.error("複製檔案出錯！", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 刪除目錄
     */
    public static void deleteDir(String dirPath) {
        try {
            File dir = new File(dirPath);
            if (dir.exists() && dir.isDirectory()) {
                FileUtils.deleteDirectory(dir);
            }
        } catch (Exception e) {
            logger.error("刪除目錄出錯！", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 刪除檔案
     */
    public static void deleteFile(String filePath) {
        try {
            File file = new File(filePath);
            if (file.exists() && file.isFile()) {
                FileUtils.forceDelete(file);
            }
        } catch (Exception e) {
            logger.error("刪除檔案出錯！", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 重新命名檔案
     */
    public static void renameFile(String srcPath, String destPath) {
        File srcFile = new File(srcPath);
        if (srcFile.exists()) {
            File newFile = new File(destPath);
            boolean result = srcFile.renameTo(newFile);
            if (!result) {
                throw new RuntimeException("重新命名檔案出錯！" + newFile);
            }
        }
    }

    /**
     * 將字串寫入檔案
     */
    public static void writeFile(String filePath, String fileContent) {
        OutputStream os = null;
        Writer w = null;
        try {
            FileUtil.createFile(filePath);
            os = new BufferedOutputStream(new FileOutputStream(filePath));
            w = new OutputStreamWriter(os, FrameworkConstant.UTF_8);
            w.write(fileContent);
            w.flush();
        } catch (Exception e) {
            logger.error("寫入檔案出錯！", e);
            throw new RuntimeException(e);
        } finally {
            try {
                if (os != null) {
                    os.close();
                }
                if (w != null) {
                    w.close();
                }
            } catch (Exception e) {
                logger.error("釋放資源出錯！", e);
            }
        }
    }

    /**
     * 獲取真實檔名（去掉檔案路徑）
     */
    public static String getRealFileName(String fileName) {
        return FilenameUtils.getName(fileName);
    }

    /**
     * 判斷檔案是否存在
     */
    public static boolean checkFileExists(String filePath) {
        return new File(filePath).exists();
    }
}

8. JSON 操作工具類

package org.smart4j.framework.util;

import org.codehaus.jackson.map.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * JSON 操作工具類
 *
 * @author huangyong
 * @since 1.0
 */
public class JsonUtil {

    private static final Logger logger = LoggerFactory.getLogger(JsonUtil.class);

    private static final ObjectMapper objectMapper = new ObjectMapper();

    /**
     * 將 Java 物件轉為 JSON 字串
     */
    public static <T> String toJSON(T obj) {
        String jsonStr;
        try {
            jsonStr = objectMapper.writeValueAsString(obj);
        } catch (Exception e) {
            logger.error("Java 轉 JSON 出錯！", e);
            throw new RuntimeException(e);
        }
        return jsonStr;
    }

    /**
     * 將 JSON 字串轉為 Java 物件
     */
    public static <T> T fromJSON(String json, Class<T> type) {
        T obj;
        try {
            obj = objectMapper.readValue(json, type);
        } catch (Exception e) {
            logger.error("JSON 轉 Java 出錯！", e);
            throw new RuntimeException(e);
        }
        return obj;
    }
}

View Code

9. 對映操作工具類

package org.smart4j.framework.util;

import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.commons.collections.MapUtils;

/**
 * 對映操作工具類
 *
 * @author huangyong
 * @since 1.0
 */
public class MapUtil {

    /**
     * 判斷 Map 是否非空
     */
    public static boolean isNotEmpty(Map<?, ?> map) {
        return MapUtils.isNotEmpty(map);
    }

    /**
     * 判斷 Map 是否為空
     */
    public static boolean isEmpty(Map<?, ?> map) {
        return MapUtils.isEmpty(map);
    }

    /**
     * 轉置 Map
     */
    public static <K, V> Map<V, K> invert(Map<K, V> source) {
        Map<V, K> target = null;
        if (isNotEmpty(source)) {
            target = new LinkedHashMap<V, K>(source.size());
            for (Map.Entry<K, V> entry : source.entrySet()) {
                target.put(entry.getValue(), entry.getKey());
            }
        }
        return target;
    }
}

View Code

10. 物件操作工具類

package org.smart4j.framework.util;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.commons.beanutils.PropertyUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 物件操作工具類
 *
 * @author huangyong
 * @since 1.0
 */
public class ObjectUtil {

    private static final Logger logger = LoggerFactory.getLogger(ObjectUtil.class);

    /**
     * 設定成員變數
     */
    public static void setField(Object obj, String fieldName, Object fieldValue) {
        try {
            if (PropertyUtils.isWriteable(obj, fieldName)) {
                PropertyUtils.setProperty(obj, fieldName, fieldValue);
            }
        } catch (Exception e) {
            logger.error("設定成員變量出錯！", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 獲取成員變數
     */
    public static Object getFieldValue(Object obj, String fieldName) {
        Object propertyValue = null;
        try {
            if (PropertyUtils.isReadable(obj, fieldName)) {
                propertyValue = PropertyUtils.getProperty(obj, fieldName);
            }
        } catch (Exception e) {
            logger.error("獲取成員變量出錯！", e);
            throw new RuntimeException(e);
        }
        return propertyValue;
    }

    /**
     * 複製所有成員變數
     */
    public static void copyFields(Object source, Object target) {
        try {
            for (Field field : source.getClass().getDeclaredFields()) {
                // 若不為 static 成員變數，則進行復制操作
                if (!Modifier.isStatic(field.getModifiers())) {
                    field.setAccessible(true); // 可操作私有成員變數
                    field.set(target, field.get(source));
                }
            }
        } catch (Exception e) {
            logger.error("複製成員變量出錯！", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 通過反射建立例項
     */
    @SuppressWarnings("unchecked")
    public static <T> T newInstance(String className) {
        T instance;
        try {
            Class<?> commandClass = ClassUtil.loadClass(className);
            instance = (T) commandClass.newInstance();
        } catch (Exception e) {
            logger.error("建立例項出錯！", e);
            throw new RuntimeException(e);
        }
        return instance;
    }

    /**
     * 獲取物件的欄位對映（欄位名 => 欄位值），忽略 static 欄位
     */
    public static Map<String, Object> getFieldMap(Object obj) {
        return getFieldMap(obj, true);
    }

    /**
     * 獲取物件的欄位對映（欄位名 => 欄位值）
     */
    public static Map<String, Object> getFieldMap(Object obj, boolean isStaticIgnored) {
        Map<String, Object> fieldMap = new LinkedHashMap<String, Object>();
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (isStaticIgnored && Modifier.isStatic(field.getModifiers())) {
                continue;
            }
            String fieldName = field.getName();
            Object fieldValue = ObjectUtil.getFieldValue(obj, fieldName);
            fieldMap.put(fieldName, fieldValue);
        }
        return fieldMap;
    }
}

View Code

11. 屬性檔案操作工具類

package org.smart4j.framework.util;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 屬性檔案操作工具類
 *
 * @author huangyong
 * @since 1.0
 */
public class PropsUtil {

    private static final Logger logger = LoggerFactory.getLogger(PropsUtil.class);

    /**
     * 載入屬性檔案
     */
    public static Properties loadProps(String propsPath) {
        Properties props = new Properties();
        InputStream is = null;
        try {
            if (StringUtil.isEmpty(propsPath)) {
                throw new IllegalArgumentException();
            }
            String suffix = ".properties";
            if (propsPath.lastIndexOf(suffix) == -1) {
                propsPath += suffix;
            }
            is = ClassUtil.getClassLoader().getResourceAsStream(propsPath);
            if (is != null) {
                props.load(is);
            }
        } catch (Exception e) {
            logger.error("載入屬性檔案出錯！", e);
            throw new RuntimeException(e);
        } finally {
            try {
                if (is != null) {
                    is.close();
                }
            } catch (IOException e) {
                logger.error("釋放資源出錯！", e);
            }
        }
        return props;
    }

    /**
     * 載入屬性檔案，並轉為 Map
     */
    public static Map<String, String> loadPropsToMap(String propsPath) {
        Map<String, String> map = new HashMap<String, String>();
        Properties props = loadProps(propsPath);
        for (String key : props.stringPropertyNames()) {
            map.put(key, props.getProperty(key));
        }
        return map;
    }

    /**
     * 獲取字元型屬性
     */
    public static String getString(Properties props, String key) {
        String value = "";
        if (props.containsKey(key)) {
            value = props.getProperty(key);
        }
        return value;
    }

    /**
     * 獲取字元型屬性（帶有預設值）
     */
    public static String getString(Properties props, String key, String defalutValue) {
        String value = defalutValue;
        if (props.containsKey(key)) {
            value = props.getProperty(key);
        }
        return value;
    }

    /**
     * 獲取數值型屬性
     */
    public static int getNumber(Properties props, String key) {
        int value = 0;
        if (props.containsKey(key)) {
            value = CastUtil.castInt(props.getProperty(key));
        }
        return value;
    }

    // 獲取數值型屬性（帶有預設值）
    public static int getNumber(Properties props, String key, int defaultValue) {
        int value = defaultValue;
        if (props.containsKey(key)) {
            value = CastUtil.castInt(props.getProperty(key));
        }
        return value;
    }

    /**
     * 獲取布林型屬性
     */
    public static boolean getBoolean(Properties props, String key) {
        return getBoolean(props, key, false);
    }

    /**
     * 獲取布林型屬性（帶有預設值）
     */
    public static boolean getBoolean(Properties props, String key, boolean defalutValue) {
        boolean value = defalutValue;
        if (props.containsKey(key)) {
            value = CastUtil.castBoolean(props.getProperty(key));
        }
        return value;
    }

    /**
     * 獲取指定字首的相關屬性
     */
    public static Map<String, Object> getMap(Properties props, String prefix) {
        Map<String, Object> kvMap = new LinkedHashMap<String, Object>();
        Set<String> keySet = props.stringPropertyNames();
        if (CollectionUtil.isNotEmpty(keySet)) {
            for (String key : keySet) {
                if (key.startsWith(prefix)) {
                    String value = props.getProperty(key);
                    kvMap.put(key, value);
                }
            }
        }
        return kvMap;
    }
}

View Code

12. 流操作工具類

package org.smart4j.framework.util;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 流操作工具類
 *
 * @author huangyong
 * @since 1.0
 */
public class StreamUtil {

    private static final Logger logger = LoggerFactory.getLogger(StreamUtil.class);

    /**
     * 將輸入流複製到輸出流
     */
    public static void copyStream(InputStream inputStream, OutputStream outputStream) {
        try {
            int length;
            byte[] buffer = new byte[4 * 1024];
            while ((length = inputStream.read(buffer, 0, buffer.length)) != -1) {
                outputStream.write(buffer, 0, length);
            }
            outputStream.flush();
        } catch (Exception e) {
            logger.error("複製流出錯！", e);
            throw new RuntimeException(e);
        } finally {
            try {
                inputStream.close();
                outputStream.close();
            } catch (Exception e) {
                logger.error("釋放資源出錯！", e);
            }
        }
    }

    /**
     * 從輸入流中獲取字串
     */
    public static String getString(InputStream is) {
        StringBuilder sb = new StringBuilder();
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(is));
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (Exception e) {
            logger.error("Stream 轉 String 出錯！", e);
            throw new RuntimeException(e);
        }
        return sb.toString();
    }
}

View Code

13. 字串操作工具類

package org.smart4j.framework.util;

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.NumberUtils;

/**
 * 字串操作工具類
 *
 * @author huangyong
 * @since 1.0
 */
public class StringUtil {

    /**
     * 字串分隔符
     */
    public static final String SEPARATOR = String.valueOf((char) 29);

    /**
     * 判斷字串是否非空
     */
    public static boolean isNotEmpty(String str) {
        return StringUtils.isNotEmpty(str);
    }

    /**
     * 判斷字串是否為空
     */
    public static boolean isEmpty(String str) {
        return StringUtils.isEmpty(str);
    }

    /**
     * 若字串為空，則取預設值
     */
    public static String defaultIfEmpty(String str, String defaultValue) {
        return StringUtils.defaultIfEmpty(str, defaultValue);
    }

    /**
     * 替換固定格式的字串（支援正則表示式）
     */
    public static String replaceAll(String str, String regex, String replacement) {
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(str);
        StringBuffer sb = new StringBuffer();
        while (m.find()) {
            m.appendReplacement(sb, replacement);
        }
        m.appendTail(sb);
        return sb.toString();
    }

    /**
     * 是否為數字（整數或小數）
     */
    public static boolean isNumber(String str) {
        return NumberUtils.isNumber(str);
    }

    /**
     * 是否為十進位制數（整數）
     */
    public static boolean isDigits(String str) {
        return NumberUtils.isDigits(str);
    }

    /**
     * 將駝峰風格替換為下劃線風格
     */
    public static String camelhumpToUnderline(String str) {
        Matcher matcher = Pattern.compile("[A-Z]").matcher(str);
        StringBuilder builder = new StringBuilder(str);
        for (int i = 0; matcher.find(); i++) {
            builder.replace(matcher.start() + i, matcher.end() + i, "_" + matcher.group().toLowerCase());
        }
        if (builder.charAt(0) == '_') {
            builder.deleteCharAt(0);
        }
        return builder.toString();
    }

    /**
     * 將下劃線風格替換為駝峰風格
     */
    public static String underlineToCamelhump(String str) {
        Matcher matcher = Pattern.compile("_[a-z]").matcher(str);
        StringBuilder builder = new StringBuilder(str);
        for (int i = 0; matcher.find(); i++) {
            builder.replace(matcher.start() - i, matcher.end() - i, matcher.group().substring(1).toUpperCase());
        }
        if (Character.isUpperCase(builder.charAt(0))) {
            builder.replace(0, 1, String.valueOf(Character.toLowerCase(builder.charAt(0))));
        }
        return builder.toString();
    }

    /**
     * 分割固定格式的字串
     */
    public static String[] splitString(String str, String separator) {
        return StringUtils.splitByWholeSeparator(str, separator);
    }

    /**
     * 將字串首字母大寫
     */
    public static String firstToUpper(String str) {
        return Character.toUpperCase(str.charAt(0)) + str.substring(1);
    }

    /**
     * 將字串首字母小寫
     */
    public static String firstToLower(String str) {
        return Character.toLowerCase(str.charAt(0)) + str.substring(1);
    }

    /**
     * 轉為帕斯卡命名方式（如：FooBar）
     */
    public static String toPascalStyle(String str, String seperator) {
        return StringUtil.firstToUpper(toCamelhumpStyle(str, seperator));
    }

    /**
     * 轉為駝峰命令方式（如：fooBar）
     */
    public static String toCamelhumpStyle(String str, String seperator) {
        return StringUtil.underlineToCamelhump(toUnderlineStyle(str, seperator));
    }

    /**
     * 轉為下劃線命名方式（如：foo_bar）
     */
    public static String toUnderlineStyle(String str, String seperator) {
        str = str.trim().toLowerCase();
        if (str.contains(seperator)) {
            str = str.replace(seperator, "_");
        }
        return str;
    }

    /**
     * 轉為顯示命名方式（如：Foo Bar）
     */
    public static String toDisplayStyle(String str, String seperator) {
        String displayName = "";
        str = str.trim().toLowerCase();
        if (str.contains(seperator)) {
            String[] words = StringUtil.splitString(str, seperator);
            for (String word : words) {
                displayName += StringUtil.firstToUpper(word) + " ";
            }
            displayName = displayName.trim();
        } else {
            displayName = StringUtil.firstToUpper(str);
        }
        return displayName;
    }
}

14. Web 操作工具類

package org.smart4j.framework.util;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Random;
import javax.imageio.ImageIO;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.io.FilenameUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.smart4j.framework.FrameworkConstant;

/**
 * Web 操作工具類
 *
 * @author huangyong
 * @since 1.0
 */
public class WebUtil {

    private static final Logger logger = LoggerFactory.getLogger(WebUtil.class);

    /**
     * 將資料以 JSON 格式寫入響應中
     */
    public static void writeJSON(HttpServletResponse response, Object data) {
        try {
            // 設定響應頭
            response.setContentType("application/json"); // 指定內容型別為 JSON 格式
            response.setCharacterEncoding(FrameworkConstant.UTF_8); // 防止中文亂碼
            // 向響應中寫入資料
            PrintWriter writer = response.getWriter();
            writer.write(JsonUtil.toJSON(data)); // 轉為 JSON 字串
            writer.flush();
            writer.close();
        } catch (Exception e) {
            logger.error("在響應中寫資料出錯！", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 將資料以 HTML 格式寫入響應中（在 JS 中獲取的是 JSON 字串，而不是 JSON 物件）
     */
    public static void writeHTML(HttpServletResponse response, Object data) {
        try {
            // 設定響應頭
            response.setContentType("text/html"); // 指定內容型別為 HTML 格式
            response.setCharacterEncoding(FrameworkConstant.UTF_8); // 防止中文亂碼
            // 向響應中寫入資料
            PrintWriter writer = response.getWriter();
            writer.write(JsonUtil.toJSON(data)); // 轉為 JSON 字串
            writer.flush();
            writer.close();
        } catch (Exception e) {
            logger.error("在響應中寫資料出錯！", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 從請求中獲取所有引數（當引

java常用工具類（從開源專案smartframework專案copy過來備用）

1.陣列操作工具類 package org.smart4j.framework.util; import org.apache.commons.lang.ArrayUtils; /** * 陣列操作工具類 * * @author huangyong * @since 1.0 */ pub

java常用工具類（一）—— Map 與 Bean 之間的互相轉換

import net.bytebuddy.implementation.bytecode.Throw; import org.springframework.cglib.beans.BeanMap; import java.beans.PropertyDescriptor; import java.lang

java常用工具類（二）—— JSON處理工具類

tor ast val simple sta 轉換 local pass password package com.springboot.commons.utils; import com.springboot.commons.scan.JacksonObjectMapp

java常用工具類（三）—— 檔案讀取的操作類

定義常用的檔案型別 public class FileType { /** * 檔案頭型別 */ public static final String XML_FILE = "text/xml;charset=UTF-8"; public static

java常用工具類（三）—— Excel 操作工具

import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.ss.usermodel.*; import org.apache.poi.xssf.usermodel.XSSFWorkbook; import java.io

java常用工具類（三）—— 文件讀取的操作類

() utf-8 cati 解壓縮操作 char ringbuf 路徑 except 定義常用的文件類型 public class FileType { /** * 文件頭類型 */ public static final Stri

JAVA常用工具類（一）--------------RedisConfig工具類

Redis快取用的越來越多，那麼我們是如何使用的Redis？一，redis的視覺化app 這個是目前比較流行的redis視覺化app。這是執行狀態的redis，一共擁有16個數據庫，預設儲存在db0裡面。具體儲存的格式，我在 Redis實用教程-----

java 加密工具類（MD5、RSA、AES等加密方式）

MD5加密 import org.apache.commons.codec.digest.DigestUtils; /** * MD5加密元件 * * @version 1.0 * @since 1.0 */ public abstract class M

JavaEE程式設計實驗實驗1 Java常用工具類程式設計（未完成）

1.使用String類分割split將字串“Solutions to selected exercises can be found in the electronic document The Thinking in Java Annotated Solution Guide,available for a

專案經驗分享——Java常用工具類集合

寫在前面本文涉及的工具類部分是自己編寫，另一部分是在專案裡收集的。工具類涉及資料庫連線、格式轉換、檔案操作、傳送郵件等等。提高開發效率，歡迎收藏與轉載。資料庫連線工具類資料庫連線工具類——僅僅獲得連線物件 ConnDB.javapackage com.util;import j

java 微信開發常用工具類（xml傳輸和解析 json轉換物件）

與微信通訊常用工具（xml傳輸和解析） package com.lownsun.wechatOauth.utl; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; impo

Java 常用工具類整理

一、org.apache.commons.io.IOUtils closeQuietly 關閉一個IO流、socket、或者selector且不丟擲異常。通常放在finally塊。 toString 轉換IO流、 Uri、 byte[]為String。

Java 常用工具類

PageBaen 分頁工具類 package com.strurts.utli; import java.util.Map; import javax.servlet.http.HttpServletRequest; public class PageBean {

JAVA常用工具類(二) ArrayUtils類

該工具類主要運算元組。以下陣列的型別使用T代替，同一函式中T代表相同型別。T可包含的型別有：Object、boolean、int、byte、char、double、float、long、short。陣列判斷函式： 1.判斷是否存在，返回boolean： ArrayUtils.co

JAVA常用工具類(一) StringUtils類

該工具類是用於操作Java.lang.String類的。 StringUtils類與String類的區別在於：此類是null安全的，即如果輸入引數String為null，則不會丟擲NullPointerException異常，程式碼更健壯。以函式isEmpty為例子：存在字串stri

Java 常用工具類---- 各種字符集編碼判斷與轉換

import java.io.UnsupportedEncodingException; /** * 判斷字元編碼 * * @author guyinyihun */ public class CharacterCodingUtil { private final static

常用工具類（三）：獲取介面引數與統一返回結果

public class ParamUtils { private static Logger logger = LoggerFactory.getLogger(ParamUtils.class); private static Gson gson = new Gson();

常用工具類（二）：HttpUtil 傳送HTTP請求

常用工具類（二）：HttpUtil 傳送HTTP請求 public class HttpUtil { private static Logger logger = LoggerFactory.getLogger(HttpUtil.class); /** *

常用工具類（一）：FileUtile 檔案相關操作

常用工具類（一）：FileUtile 檔案相關操作 public class FileUtil { private static final Logger logger = LoggerFactory.getLogger(FileUtils.class); //讀取檔案

JAVA常用工具類(三) SystemUtils類

常用的函式操作，基於commons-lang-2.5。 1.獲取Java Home目錄，返回File SystemUtils.getJavaHome() 2.獲取Java IO臨時目錄檔案，返回File

java常用工具類（從開源專案smartframework專案copy過來備用）

相關推薦