在Java开发中，合理利用工具类能够显著提升编码效率和代码质量。本文将介绍几个Java程序员不可或缺的常用工具类，涵盖日期处理、字符串操作、集合处理、文件操作等方面，旨在为你的日常开发工作提供实用的参考。废话不多说，上代码！
1. DateUtils - 日期处理工具类
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateUtils {
private static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
/**
* 将日期格式化为字符串
* @param date 日期对象
* @param format 日期格式，默认为"yyyy-MM-dd HH:mm:ss"
* @return 格式化后的日期字符串
*/
public static String format(Date date, String format) {
if (date == null) {
return "";
}
SimpleDateFormat sdf = new SimpleDateFormat(format);
return sdf.format(date);
}
/**
* 将字符串解析为日期
* @param dateStr 日期字符串
* @param format 字符串格式，默认为"yyyy-MM-dd HH:mm:ss"
* @return 解析后的日期对象
* @throws ParseException 解析异常
*/
public static Date parse(String dateStr, String format) throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat(format);
return sdf.parse(dateStr);
}
/**
* 默认格式将日期字符串转换为日期对象
* @param dateStr 日期字符串
* @return 解析后的日期对象
* @throws ParseException 解析异常
*/
public static Date parseDefault(String dateStr) throws ParseException {
return parse(dateStr, DEFAULT_DATE_FORMAT);
}
// 新增：获取当前日期时间字符串
public static String getCurrentDateTimeStr() {
return format(new Date(), DEFAULT_DATE_FORMAT);
}
// 新增：计算两个日期之间的天数差
public static long daysBetween(Date startDate, Date endDate) {
return ChronoUnit.DAYS.between(startDate.toInstant(), endDate.toInstant());
}
}2. StringUtils - 扩展的字符串操作工具类
public class StringUtils {
/**
* 判断字符串是否为空或空白字符串
* @param str 待检查的字符串
* @return 如果字符串为null或仅包含空白字符，则返回true
*/
public static boolean isBlank(String str) {
return str == null || str.trim().isEmpty();
}
/**
* 安全地获取字符串长度，如果字符串为null，则返回0
* @param str 字符串
* @return 字符串长度或0
*/
public static int safeLength(String str) {
return str != null ? str.length() : 0;
}
/**
* 连接字符串数组，忽略null值
* @param strs 字符串数组
* @param delimiter 分隔符
* @return 连接后的字符串
*/
public static String joinIgnoreNull(String[] strs, String delimiter) {
StringBuilder sb = new StringBuilder();
for (String str : strs) {
if (str != null) {
if (sb.length() > 0) {
sb.append(delimiter);
}
sb.append(str);
}
}
return sb.toString();
}
// 新增：重复字符串N次
public static String repeat(String str, int times) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < times; i++) {
sb.append(str);
}
return sb.toString();
}
// 新增：判断字符串是否包含指定字符集合中的任意字符
public static boolean containsAnyChar(String str, char... chars) {
for (char c : chars) {
if (str.indexOf(c) >= 0) {
return true;
}
}
return false;
}
}3. CollectionUtils - 简化的集合操作工具类
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.Set;
public class CollectionUtils {
/**
* 安全地转换集合为列表，如果原集合为null，则返回一个空列表
* @param collection 原集合
* @param <T> 泛型标记
* @return 转换后的列表
*/
public static <T> List<T> toSafeList(Collection<T> collection) {
return collection != null ? new ArrayList<>(collection) : new ArrayList<>();
}
/**
* 检查Map是否为空或大小为0
* @param map 待检查的Map
* @return 如果Map为null或大小为0，则返回true
*/
public static boolean isEmpty(Map<?, ?> map) {
return map == null || map.isEmpty();
}
/**
* 获取集合的第一个元素，如果集合为空则返回null
* @param collection 集合
* @param <T> 泛型标记
* @return 集合的第一个元素或null
*/
public static <T> T getFirst(Collection<T> collection) {
if (collection != null && !collection.isEmpty()) {
return collection.iterator().next();
}
return null;
}
/**
* 新增：安全获取Map中的值，如果不存在则返回默认值
*/
public static <K, V> V getOrDefault(Map<K, V> map, K key, V defaultValue) {
return map != null ? map.getOrDefault(key, defaultValue) : defaultValue;
}
/**
* 新增：合并两个集合，自动去除重复项
*/
public static <T> List<T> mergeDistinct(List<T> list1, List<T> list2) {
Set<T> set = new HashSet<>(list1);
set.addAll(list2);
return new ArrayList<>(set);
}
}4. MathUtils - 数学运算工具类
public class MathUtils {
/**
* 安全的除法运算，避免除以零异常
* @param dividend 被除数
* @param divisor 除数
* @return 结果或Double.NaN（如果除数为0）
*/
public static double safeDivide(double dividend, double divisor) {
if (divisor == 0) {
return Double.NaN;
}
return dividend / divisor;
}
/**
* 计算平均值，忽略null或非数字值
* @param numbers 数字数组
* @return 平均值或Double.NaN（如果数组为空或所有元素都是无效值）
*/
public static double average(Double... numbers) {
if (numbers == null || numbers.length == 0) {
return Double.NaN;
}
double sum = 0;
int count = 0;
for (Double num : numbers) {
if (num != null) {
sum += num;
count++;
}
}
return count > 0 ? sum / count : Double.NaN;
}
}5. FileUtil - 文件操作工具类
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.charset.StandardCharsets;
public class FileUtil {
/**
* 读取文件内容为字符串
* @param filePath 文件路径
* @return 文件内容或null（如果文件不存在或读取失败）
*/
public static String readFileAsString(String filePath) {
try {
return new String(Files.readAllBytes(Paths.get(filePath)), StandardCharsets.UTF_8);
} catch (IOException e) {
return null;
}
}
/**
* 写入字符串到文件
* @param content 字符串内容
* @param filePath 文件路径
* @return 是否写入成功
*/
public static boolean writeFileFromString(String content, String filePath) {
try {
Files.write(Paths.get(filePath), content.getBytes(StandardCharsets.UTF_8));
return true;
} catch (IOException e) {
return false;
}
}
}6. NetworkUtils - 简单的网络请求工具类
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
public class NetworkUtils {
private static final String USER_AGENT = "Mozilla/5.0";
/**
* 发送GET请求
* @param urlStr 请求的URL
* @return 响应内容或null（如果发生错误）
*/
public static String sendGetRequest(String urlStr) {
return sendHttpRequest("GET", urlStr, null, null);
}
/**
* 发送POST请求
* @param urlStr 请求的URL
* @param postData POST数据，格式如"name=value&another=value"
* @return 响应内容或null（如果发生错误）
*/
public static String sendPostRequest(String urlStr, String postData) {
return sendHttpRequest("POST", urlStr, postData, null);
}
/**
* 发送带有自定义头的HTTP请求
* @param method 请求方法（GET, POST等）
* @param urlStr 请求的URL
* @param postData POST数据，若method为GET则忽略
* @param headers 自定义请求头
* @return 响应内容或null（如果发生错误）
*/
public static String sendHttpRequest(String method, String urlStr, String postData, Map<String, String> headers) {
try {
URL url = new URL(urlStr);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod(method);
connection.setRequestProperty("User-Agent", USER_AGENT);
if (headers != null) {
for (Map.Entry<String, String> entry : headers.entrySet()) {
connection.setRequestProperty(entry.getKey(), entry.getValue());
}
}
if ("POST".equalsIgnoreCase(method)) {
connection.setDoOutput(true);
try (OutputStream os = connection.getOutputStream()) {
byte[] input = postData.getBytes(StandardCharsets.UTF_8);
os.write(input, 0, input.length);
}
}
int responseCode = connection.getResponseCode();
if (responseCode == HttpURLConnection.HTTP_OK) {
return readResponse(connection);
} else {
System.out.println("HTTP Error Code : " + responseCode);
return "Request failed with HTTP error code: " + responseCode;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
private static String readResponse(HttpURLConnection connection) throws IOException {
StringBuilder response = new StringBuilder();
try (BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
String inputLine;
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
}
return response.toString();
}
// 示例：如何设置请求头
public static void exampleSetHeaders() {
Map<String, String> headers = new HashMap<>();
headers.put("Content-Type", "application/json");
headers.put("Authorization", "Bearer your_token_here");
String response = sendHttpRequest("GET", "http://example.com/api/data", null, headers);
System.out.println(response);
}
}7. JsonUtils - JSON处理工具类
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
public class JsonUtils {
private static final Gson gson = new GsonBuilder().create();
/**
* 将Java对象转换为JSON字符串
* @param obj 对象实例
* @return JSON字符串
*/
public static String toJson(Object obj) {
return gson.toJson(obj);
}
/**
* 将JSON字符串转换为指定类型的Java对象
* @param json JSON字符串
* @param clazz 目标类型
* @param <T> 泛型标记
* @return 转换后的对象实例
*/
public static <T> T fromJson(String json, Class<T> clazz) {
return gson.fromJson(json, clazz);
}
/**
* 解析JSON字符串为JsonElement
* @param jsonString JSON字符串
* @return JsonElement
*/
public static JsonElement parseToJsonElement(String jsonString) {
return JsonParser.parseString(jsonString);
}
}8. ThreadPoolUtils - 简易线程池管理工具类
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
public class ThreadPoolUtils {
private static ExecutorService executor;
private ThreadPoolUtils() {}
/**
* 初始化固定大小的线程池
* @param poolSize 线程池大小
*/
public static synchronized void initThreadPool(int poolSize) {
if (executor == null) {
executor = Executors.newFixedThreadPool(poolSize);
}
}
/**
* 提交任务到线程池执行
* @param task 任务
*/
public static void execute(Runnable task) {
if (executor != null && !executor.isShutdown()) {
executor.execute(task);
} else {
throw new IllegalStateException("ThreadPool not initialized or shut down.");
}
}
/**
* 关闭线程池
*/
public static void shutdownThreadPool() {
if (executor != null && !executor.isShutdown()) {
((ThreadPoolExecutor) executor).shutdown();
}
}
}9. LogUtils - 日志记录工具类
import java.text.SimpleDateFormat;
import java.util.Date;
public class LogUtils {
private static final String LOG_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss.SSS";
private LogUtils() {}
public static void info(String message) {
log("INFO", message);
}
public static void debug(String message) {
log("DEBUG", message);
}
public static void warn(String message) {
log("WARN", message);
}
public static void error(String message) {
log("ERROR", message);
}
public static void fatal(String message) {
log("FATAL", message);
}
private static void log(String level, String message) {
SimpleDateFormat sdf = new SimpleDateFormat(LOG_DATE_FORMAT);
String timestamp = sdf.format(new Date());
System.out.printf("[%s] [%s] %s%n", timestamp, level, message);
}
}10. CryptoUtils - 加密解密工具类
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.util.Base64;
public class CryptoUtils {
private static final String ALGORITHM = "AES";
private static final byte[] keyValue =
new byte[]{'T', 'h', 'i', 's', 'I', 's', 'A', 'S', 'e', 'c', 'r', 'e', 't', 'K', 'e', 'y'};
/**
* 使用AES算法对给定的字符串进行加密，并返回Base64编码的加密结果字符串
*/
public static String encrypt(String valueToEnc) throws Exception {
Key key = generateKey();
Cipher c = Cipher.getInstance(ALGORITHM);
c.init(Cipher.ENCRYPT_MODE, key);
byte[] encValue = c.doFinal(valueToEnc.getBytes());
return Base64.getEncoder().encodeToString(encValue);
}
/**
* 接受一个Base64编码的加密字符串，使用AES算法解密并返回原始字符串
*/
public static String decrypt(String encryptedValue) throws Exception {
Key key = generateKey();
Cipher c = Cipher.getInstance(ALGORITHM);
c.init(Cipher.DECRYPT_MODE, key);
byte[] decordedValue = Base64.getDecoder().decode(encryptedValue);
byte[] decValue = c.doFinal(decordedValue);
return new String(decValue);
}
/**
* 生成AES加密所需的密钥
*/
private static Key generateKey() throws Exception {
return new SecretKeySpec(keyValue, ALGORITHM);
}
/**
* 将十六进制字符串转换为字节数组
*/
public static byte[] hexStringToByteArray(String s) {
int len = s.length();
byte[] data = new byte[len / 2];
for (int i = 0; i < len; i += 2) {
data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
+ Character.digit(s.charAt(i+1), 16));
}
return data;
}
/**
* 将字节数组转换为十六进制字符串
*/
public static String byteArrayToHexString(byte[] bytes) {
StringBuilder sb = new StringBuilder();
for (byte b : bytes) {
sb.append(String.format("%02x", b));
}
return sb.toString();
}
}11. SysPropUtils - 系统属性操作工具类
public class SysPropUtils {
/**
* 获取指定名称的系统属性值
*/
public static String getProperty(String propName) {
return System.getProperty(propName);
}
/**
* 设置或修改系统属性值
*/
public static void setProperty(String propName, String propValue) {
System.setProperty(propName, propValue);
}
/**
* 检查是否存在指定名称的系统属性
*/
public static boolean hasProperty(String propName) {
return System.getProperties().containsKey(propName);
}
/**
* 移除指定名称的系统属性
*/
public static void removeProperty(String propName) {
System.clearProperty(propName);
}
/**
* 获取所有系统属性的映射
*/
public static Map<String, String> getAllProperties() {
return System.getProperties().entrySet().stream()
.collect(Collectors.toMap(
e -> e.getKey().toString(),
e -> e.getValue().toString()));
}
}12. ReflectionUtils - 反射操作工具类
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
public class ReflectionUtils {
/**
* 通过反射获取对象中指定字段的值
*/
public static Object getField(Object obj, String fieldName) throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
return field.get(obj);
}
/**
* 通过反射设置对象中指定字段的值
*/
public static void setField(Object obj, String fieldName, Object fieldValue) throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(obj, fieldValue);
}
/**
* 通过反射获取类中指定方法的方法对象
*/
public static Method getMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) throws NoSuchMethodException {
return clazz.getMethod(methodName, parameterTypes);
}
/**
* 通过反射调用对象上的方法，并传递参数
*/
public static Object invokeMethod(Object obj, String methodName, Object... args) throws Exception {
Class<?>[] argTypes = Arrays.stream(args).map(Object::getClass).toArray(Class<?>[]::new);
Method method = obj.getClass().getMethod(methodName, argTypes);
return method.invoke(obj, args);
}
/**
* 根据类名字符串加载对应的Class对象
*/
public static Class<?> getClassByName(String className) throws ClassNotFoundException {
return Class.forName(className);
}
}以上示例涵盖了工作中常见的工具类，可以直接在项目中引用，根据需要进行调用，以提高开发效率并保证代码的健壮性。希望对你有帮助！
扫一扫
1417
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
