有用的工具类（Java）
IP地址获取
public class IPUtil {
private static final String UNKNOWN = "unknown";
protected IPUtil(){
}
/**
* 获取 IP地址
* 使用 Nginx等反向代理软件， 则不能通过 request.getRemoteAddr()获取 IP地址
* 如果使用了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP地址，
* X-Forwarded-For中第一个非 unknown的有效IP字符串，则为真实IP地址
*/
public static String getIpAddr(HttpServletRequest request) {
String ip = request.getHeader("x-forwarded-for");
if (StringUtils.isNotEmpty(ip)) {
ip = ip.split(", ")[0];
}
if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
ip = request.getHeader("Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
ip = request.getHeader("WL-Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
}
return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
}
}
获取上个月月份字符串
public static final String getLastMonth() {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
Date date = new Date();
Calendar calendar = Calendar.getInstance();
// 设置为当前时间
calendar.setTime(date);
// 设置为上一个月
calendar.add(Calendar.MONTH,-1);
date = calendar.getTime();
return format.format(date);
}
日期工具类
/**
* 日期工具类
*
*/
@UtilityClass
public class DateUtil { public static final String PATTERN_DATETIME = "yyyy-MM-dd HH:mm:ss";
public static final String PATTERN_DATETIME_MINI = "yyyyMMddHHmmss";
public static final String PATTERN_DATE = "yyyy-MM-dd";
public static final String PATTERN_TIME = "HH:mm:ss";
/**
* 老 date 格式化
*/
public static final ConcurrentDateFormat DATETIME_FORMAT = ConcurrentDateFormat.of(PATTERN_DATETIME);
public static final ConcurrentDateFormat DATETIME_MINI_FORMAT = ConcurrentDateFormat.of(PATTERN_DATETIME_MINI);
public static final ConcurrentDateFormat DATE_FORMAT = ConcurrentDateFormat.of(PATTERN_DATE);
public static final ConcurrentDateFormat TIME_FORMAT = ConcurrentDateFormat.of(PATTERN_TIME);
/**
* java 8 时间格式化
*/
public static final DateTimeFormatter DATETIME_FORMATTER = DateTimeFormatter.ofPattern(DateUtil.PATTERN_DATETIME);
public static final DateTimeFormatter DATETIME_MINI_FORMATTER = DateTimeFormatter.ofPattern(DateUtil.PATTERN_DATETIME_MINI);
public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern(DateUtil.PATTERN_DATE);
public static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern(DateUtil.PATTERN_TIME); /**
* 获取当前日期
*
* @return 当前日期
*/
public static Date now() {
return new Date();
} /**
* 添加年
*
* @param date 时间
* @param yearsToAdd 添加的年数
* @return 设置后的时间
*/
public static Date plusYears(Date date, int yearsToAdd) {
return DateUtil.set(date, Calendar.YEAR, yearsToAdd);
} /**
* 添加月
*
* @param date 时间
* @param monthsToAdd 添加的月数
* @return 设置后的时间
*/
public static Date plusMonths(Date date, int monthsToAdd) {
return DateUtil.set(date, Calendar.MONTH, monthsToAdd);
} /**
* 添加周
*
* @param date 时间
* @param weeksToAdd 添加的周数
* @return 设置后的时间
*/
public static Date plusWeeks(Date date, int weeksToAdd) {
return DateUtil.plus(date, Period.ofWeeks(weeksToAdd));
} /**
* 添加天
*
* @param date 时间
* @param daysToAdd 添加的天数
* @return 设置后的时间
*/
public static Date plusDays(Date date, long daysToAdd) {
return DateUtil.plus(date, Duration.ofDays(daysToAdd));
} /**
* 添加小时
*
* @param date 时间
* @param hoursToAdd 添加的小时数
* @return 设置后的时间
*/
public static Date plusHours(Date date, long hoursToAdd) {
return DateUtil.plus(date, Duration.ofHours(hoursToAdd));
} /**
* 添加分钟
*
* @param date 时间
* @param minutesToAdd 添加的分钟数
* @return 设置后的时间
*/
public static Date plusMinutes(Date date, long minutesToAdd) {
return DateUtil.plus(date, Duration.ofMinutes(minutesToAdd));
} /**
* 添加秒
*
* @param date 时间
* @param secondsToAdd 添加的秒数
* @return 设置后的时间
*/
public static Date plusSeconds(Date date, long secondsToAdd) {
return DateUtil.plus(date, Duration.ofSeconds(secondsToAdd));
} /**
* 添加毫秒
*
* @param date 时间
* @param millisToAdd 添加的毫秒数
* @return 设置后的时间
*/
public static Date plusMillis(Date date, long millisToAdd) {
return DateUtil.plus(date, Duration.ofMillis(millisToAdd));
} /**
* 添加纳秒
*
* @param date 时间
* @param nanosToAdd 添加的纳秒数
* @return 设置后的时间
*/
public static Date plusNanos(Date date, long nanosToAdd) {
return DateUtil.plus(date, Duration.ofNanos(nanosToAdd));
} /**
* 日期添加时间量
*
* @param date 时间
* @param amount 时间量
* @return 设置后的时间
*/
public static Date plus(Date date, TemporalAmount amount) {
Instant instant = date.toInstant();
return Date.from(instant.plus(amount));
} /**
* 减少年
*
* @param date 时间
* @param years 减少的年数
* @return 设置后的时间
*/
public static Date minusYears(Date date, int years) {
return DateUtil.set(date, Calendar.YEAR, -years);
} /**
* 减少月
*
* @param date 时间
* @param months 减少的月数
* @return 设置后的时间
*/
public static Date minusMonths(Date date, int months) {
return DateUtil.set(date, Calendar.MONTH, -months);
} /**
* 减少周
*
* @param date 时间
* @param weeks 减少的周数
* @return 设置后的时间
*/
public static Date minusWeeks(Date date, int weeks) {
return DateUtil.minus(date, Period.ofWeeks(weeks));
} /**
* 减少天
*
* @param date 时间
* @param days 减少的天数
* @return 设置后的时间
*/
public static Date minusDays(Date date, long days) {
return DateUtil.minus(date, Duration.ofDays(days));
} /**
* 减少小时
*
* @param date 时间
* @param hours 减少的小时数
* @return 设置后的时间
*/
public static Date minusHours(Date date, long hours) {
return DateUtil.minus(date, Duration.ofHours(hours));
} /**
* 减少分钟
*
* @param date 时间
* @param minutes 减少的分钟数
* @return 设置后的时间
*/
public static Date minusMinutes(Date date, long minutes) {
return DateUtil.minus(date, Duration.ofMinutes(minutes));
} /**
* 减少秒
*
* @param date 时间
* @param seconds 减少的秒数
* @return 设置后的时间
*/
public static Date minusSeconds(Date date, long seconds) {
return DateUtil.minus(date, Duration.ofSeconds(seconds));
} /**
* 减少毫秒
*
* @param date 时间
* @param millis 减少的毫秒数
* @return 设置后的时间
*/
public static Date minusMillis(Date date, long millis) {
return DateUtil.minus(date, Duration.ofMillis(millis));
} /**
* 减少纳秒
*
* @param date 时间
* @param nanos 减少的纳秒数
* @return 设置后的时间
*/
public static Date minusNanos(Date date, long nanos) {
return DateUtil.minus(date, Duration.ofNanos(nanos));
} /**
* 日期减少时间量
*
* @param date 时间
* @param amount 时间量
* @return 设置后的时间
*/
public static Date minus(Date date, TemporalAmount amount) {
Instant instant = date.toInstant();
return Date.from(instant.minus(amount));
} /**
* 设置日期属性
*
* @param date 时间
* @param calendarField 更改的属性
* @param amount 更改数，-1表示减少
* @return 设置后的时间
*/
private static Date set(Date date, int calendarField, int amount) {
Assert.notNull(date, "The date must not be null");
Calendar c = Calendar.getInstance();
c.setLenient(false);
c.setTime(date);
c.add(calendarField, amount);
return c.getTime();
} /**
* 日期时间格式化
*
* @param date 时间
* @return 格式化后的时间
*/
public static String formatDateTime(Date date) {
return DATETIME_FORMAT.format(date);
} /**
* 日期时间格式化
*
* @param date 时间
* @return 格式化后的时间
*/
public static String formatDateTimeMini(Date date) {
return DATETIME_MINI_FORMAT.format(date);
} /**
* 日期格式化
*
* @param date 时间
* @return 格式化后的时间
*/
public static String formatDate(Date date) {
return DATE_FORMAT.format(date);
} /**
* 时间格式化
*
* @param date 时间
* @return 格式化后的时间
*/
public static String formatTime(Date date) {
return TIME_FORMAT.format(date);
} /**
* 日期格式化
*
* @param date 时间
* @param pattern 表达式
* @return 格式化后的时间
*/
public static String format(Date date, String pattern) {
return ConcurrentDateFormat.of(pattern).format(date);
} /**
* java8 日期时间格式化
*
* @param temporal 时间
* @return 格式化后的时间
*/
public static String formatDateTime(TemporalAccessor temporal) {
return DATETIME_FORMATTER.format(temporal);
} /**
* java8 日期时间格式化
*
* @param temporal 时间
* @return 格式化后的时间
*/
public static String formatDateTimeMini(TemporalAccessor temporal) {
return DATETIME_MINI_FORMATTER.format(temporal);
} /**
* java8 日期时间格式化
*
* @param temporal 时间
* @return 格式化后的时间
*/
public static String formatDate(TemporalAccessor temporal) {
return DATE_FORMATTER.format(temporal);
} /**
* java8 时间格式化
*
* @param temporal 时间
* @return 格式化后的时间
*/
public static String formatTime(TemporalAccessor temporal) {
return TIME_FORMATTER.format(temporal);
} /**
* java8 日期格式化
*
* @param temporal 时间
* @param pattern 表达式
* @return 格式化后的时间
*/
public static String format(TemporalAccessor temporal, String pattern) {
return DateTimeFormatter.ofPattern(pattern).format(temporal);
} /**
* 将字符串转换为时间
*
* @param dateStr 时间字符串
* @param pattern 表达式
* @return 时间
*/
public static Date parse(String dateStr, String pattern) {
ConcurrentDateFormat format = ConcurrentDateFormat.of(pattern);
try {
return format.parse(dateStr);
} catch (ParseException e) {
throw Exceptions.unchecked(e);
}
} /**
* 将字符串转换为时间
*
* @param dateStr 时间字符串
* @param format ConcurrentDateFormat
* @return 时间
*/
public static Date parse(String dateStr, ConcurrentDateFormat format) {
try {
return format.parse(dateStr);
} catch (ParseException e) {
throw Exceptions.unchecked(e);
}
} /**
* 将字符串转换为时间
*
* @param dateStr 时间字符串
* @param pattern 表达式
* @return 时间
*/
public static <T> T parse(String dateStr, String pattern, TemporalQuery<T> query) {
return DateTimeFormatter.ofPattern(pattern).parse(dateStr, query);
} /**
* 时间转 Instant
*
* @param dateTime 时间
* @return Instant
*/
public static Instant toInstant(LocalDateTime dateTime) {
return dateTime.atZone(ZoneId.systemDefault()).toInstant();
} /**
* Instant 转 时间
*
* @param instant Instant
* @return Instant
*/
public static LocalDateTime toDateTime(Instant instant) {
return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
} /**
* 转换成 date
*
* @param dateTime LocalDateTime
* @return Date
*/
public static Date toDate(LocalDateTime dateTime) {
return Date.from(DateUtil.toInstant(dateTime));
} /**
* 转换成 date
*
* @param localDate LocalDate
* @return Date
*/
public static Date toDate(final LocalDate localDate) {
return Date.from(localDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
} /**
* Converts local date time to Calendar.
*/
public static Calendar toCalendar(final LocalDateTime localDateTime) {
return GregorianCalendar.from(ZonedDateTime.of(localDateTime, ZoneId.systemDefault()));
} /**
* localDateTime 转换成毫秒数
*
* @param localDateTime LocalDateTime
* @return long
*/
public static long toMilliseconds(final LocalDateTime localDateTime) {
return localDateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
} /**
* localDate 转换成毫秒数
*
* @param localDate LocalDate
* @return long
*/
public static long toMilliseconds(LocalDate localDate) {
return toMilliseconds(localDate.atStartOfDay());
} /**
* 转换成java8 时间
*
* @param calendar 日历
* @return LocalDateTime
*/
public static LocalDateTime fromCalendar(final Calendar calendar) {
TimeZone tz = calendar.getTimeZone();
ZoneId zid = tz == null ? ZoneId.systemDefault() : tz.toZoneId();
return LocalDateTime.ofInstant(calendar.toInstant(), zid);
} /**
* 转换成java8 时间
*
* @param instant Instant
* @return LocalDateTime
*/
public static LocalDateTime fromInstant(final Instant instant) {
return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
} /**
* 转换成java8 时间
*
* @param date Date
* @return LocalDateTime
*/
public static LocalDateTime fromDate(final Date date) {
return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
} /**
* 转换成java8 时间
*
* @param milliseconds 毫秒数
* @return LocalDateTime
*/
public static LocalDateTime fromMilliseconds(final long milliseconds) {
return LocalDateTime.ofInstant(Instant.ofEpochMilli(milliseconds), ZoneId.systemDefault());
} /**
* 比较2个时间差，跨度比较小
*
* @param startInclusive 开始时间
* @param endExclusive 结束时间
* @return 时间间隔
*/
public static Duration between(Temporal startInclusive, Temporal endExclusive) {
return Duration.between(startInclusive, endExclusive);
} /**
* 比较2个时间差，跨度比较大，年月日为单位
*
* @param startDate 开始时间
* @param endDate 结束时间
* @return 时间间隔
*/
public static Period between(LocalDate startDate, LocalDate endDate) {
return Period.between(startDate, endDate);
} /**
* 比较2个 时间差
*
* @param startDate 开始时间
* @param endDate 结束时间
* @return 时间间隔
*/
public static Duration between(Date startDate, Date endDate) {
return Duration.between(startDate.toInstant(), endDate.toInstant());
} /**
* 获取今天的日期
*
* @return 时间
*/
public static String today() {
return format(new Date(), "yyyyMMdd");
} /**
* 获取今天的时间
*
* @return 时间
*/
public static String time() {
return format(new Date(), PATTERN_DATETIME_MINI);
} /**
* 获取指定年月的第一天
* @param year
* @param month
* @return
*/
public static String getFirstDayOfMonth(int year, int month) {
Calendar cal = Calendar.getInstance();
//设置年份
cal.set(Calendar.YEAR, year);
//设置月份
cal.set(Calendar.MONTH, month-1);
//获取某月最小天数
int firstDay = cal.getMinimum(Calendar.DATE);
//设置日历中月份的最小天数
cal.set(Calendar.DAY_OF_MONTH,firstDay);
//格式化日期
return DATE_FORMAT.format(cal.getTime());
} /**
* 获取指定年月的最后一天
* @param year
* @param month
* @return
*/
public static String getLastDayOfMonth(int year, int month) {
Calendar cal = Calendar.getInstance();
//设置年份
cal.set(Calendar.YEAR, year);
//设置月份
cal.set(Calendar.MONTH, month-1);
//获取某月最大天数
int lastDay = cal.getActualMaximum(Calendar.DATE);
//设置日历中月份的最大天数
cal.set(Calendar.DAY_OF_MONTH, lastDay);
//格式化日期
return DATE_FORMAT.format(cal.getTime());
} /**
* 获取指定年月的下个月第一天
* @param year
* @param month
* @return
*/
public static String getFirstDayOfNextMonth(int year, int month) {
Calendar cal = Calendar.getInstance();
//设置年份
cal.set(Calendar.YEAR, year);
//设置月份
cal.set(Calendar.MONTH, month);
//获取某月最小天数
int firstDay = cal.getMinimum(Calendar.DATE);
//设置日历中月份的最小天数
cal.set(Calendar.DAY_OF_MONTH,firstDay);
//格式化日期
return DATE_FORMAT.format(cal.getTime());
}
}
BigDecimal运算工具类
import java.math.BigDecimal; /**
* 用于高精确处理常用的数学运算
*/
public class ArithmeticUtils {
//默认除法运算精度
private static final int DEF_DIV_SCALE = 10; /**
* 提供精确的加法运算
*
* @param v1 被加数
* @param v2 加数
* @return 两个参数的和
*/ public static double add(double v1, double v2) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
} /**
* 提供精确的加法运算
*
* @param v1 被加数
* @param v2 加数
* @return 两个参数的和
*/
public static BigDecimal add(String v1, String v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.add(b2);
} /**
* 提供精确的加法运算
*
* @param v1 被加数
* @param v2 加数
* @param scale 保留scale 位小数
* @return 两个参数的和
*/
public static String add(String v1, String v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
} /**
* 提供精确的减法运算
*
* @param v1 被减数
* @param v2 减数
* @return 两个参数的差
*/
public static double sub(double v1, double v2) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
} /**
* 提供精确的减法运算。
*
* @param v1 被减数
* @param v2 减数
* @return 两个参数的差
*/
public static BigDecimal sub(String v1, String v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.subtract(b2);
} /**
* 提供精确的减法运算
*
* @param v1 被减数
* @param v2 减数
* @param scale 保留scale 位小数
* @return 两个参数的差
*/
public static String sub(String v1, String v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
} /**
* 提供精确的乘法运算
*
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/
public static double mul(double v1, double v2) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
} /**
* 提供精确的乘法运算
*
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/
public static BigDecimal mul(String v1, String v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.multiply(b2);
} /**
* 提供精确的乘法运算
*
* @param v1 被乘数
* @param v2 乘数
* @param scale 保留scale 位小数
* @return 两个参数的积
*/
public static double mul(double v1, double v2, int scale) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return round(b1.multiply(b2).doubleValue(), scale);
} /**
* 提供精确的乘法运算
*
* @param v1 被乘数
* @param v2 乘数
* @param scale 保留scale 位小数
* @return 两个参数的积
*/
public static String mul(String v1, String v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
} /**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
* 小数点以后10位，以后的数字四舍五入
*
* @param v1 被除数
* @param v2 除数
* @return 两个参数的商
*/ public static double div(double v1, double v2) {
return div(v1, v2, DEF_DIV_SCALE);
} /**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入
*
* @param v1 被除数
* @param v2 除数
* @param scale 表示表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static double div(double v1, double v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
} /**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入
*
* @param v1 被除数
* @param v2 除数
* @param scale 表示需要精确到小数点以后几位
* @return 两个参数的商
*/
public static String div(String v1, String v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v1);
return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
} /**
* 提供精确的小数位四舍五入处理
*
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果
*/
public static double round(double v, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(Double.toString(v));
return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
} /**
* 提供精确的小数位四舍五入处理
*
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果
*/
public static String round(String v, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(v);
return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
} /**
* 取余数
*
* @param v1 被除数
* @param v2 除数
* @param scale 小数点后保留几位
* @return 余数
*/
public static String remainder(String v1, String v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
} /**
* 取余数 BigDecimal
*
* @param v1 被除数
* @param v2 除数
* @param scale 小数点后保留几位
* @return 余数
*/
public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
} /**
* 比较大小
*
* @param v1 被比较数
* @param v2 比较数
* @return 如果v1 大于v2 则 返回true 否则false
*/
public static boolean compare(String v1, String v2) {
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
int bj = b1.compareTo(b2);
boolean res;
if (bj > 0)
res = true;
else
res = false;
return res;
}
}
/**
* @Description: Double类型运算工具类
*/
public class DoubleUtil { /**
* 提供精确的加法运算。
*
* @param v1
* 被加数
* @param v2
* 加数
* @return 两个参数的和
*/ public static double add(double v1, double v2)
{
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
} /**
* 提供精确的减法运算。
*
* @param v1
* 被减数
* @param v2
* 减数
* @return 两个参数的差
*/ public static double sub(double v1, double v2)
{
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
} /**
* 相除
*/ /**
* double 除法
*
* @param d1
* @param d2
* @param scale
* 四舍五入 小数点位数
* @return
*/
public static double div(double d1, double d2, int scale) {
// 当然在此之前，你要判断分母是否为0，
// 为0你可以根据实际需求做相应的处理 BigDecimal bd1 = new BigDecimal(Double.toString(d1));
BigDecimal bd2 = new BigDecimal(Double.toString(d2)); try
{
return bd1.divide(bd2, scale, BigDecimal.ROUND_DOWN).doubleValue();
} catch (Exception e)
{
e.printStackTrace();
return 0;
} } /**
* 提供精确的乘法运算。
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/ public static double mul(double v1,double v2){
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
} /**
* 比较两个double值的大小
* @param v1 值1
* @param v2 值2
* @return 比较结果 -1:v1<v2; 0:v1; 1:v1>v2;
*/
public static Integer compare(double v1, double v2) {
BigDecimal b1 = BigDecimal.valueOf(v1);
BigDecimal b2 = BigDecimal.valueOf(v2); return b1.compareTo(b2);
}
/**
* 按规则加减
*
* @param v1
* 被加数
* @param v2
* 加数
* @param scale
* 保留小数位
* @param roundUp
* 保留规则：
* BigDecimal.ROUND_HALF_DOWN也是五舍六入，
* BigDecimal.ROUND_UP表示进位处理（就是直接加1），
* BigDecimal.ROUND_DOWN表示直接去掉尾数
* @return 两个参数的和
*/ public static Double addFormant(double v1, double v2, int scale, int roundUp) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.add(b2).setScale(scale, roundUp).doubleValue();
}
}
import java.math.BigDecimal; /**
*/
public class MathUtil {
/**
* 乘法
* @param objects
* @return
*/
public static BigDecimal multiply(Object...objects ){
BigDecimal sum = new BigDecimal("1");
for (Object objectValue : objects) {
if(objectValue ==null){
objectValue = 0;
}
if(objectValue instanceof BigDecimal){
sum = sum.multiply((BigDecimal) objectValue);
}else{
sum = sum.multiply(new BigDecimal(objectValue.toString()));
}
}
return sum;
} /**
* 加法
* @param objects
* @return
*/
public static BigDecimal add(Object...objects ){
BigDecimal sum = new BigDecimal("0");
for (Object objectValue : objects) {
if(objectValue ==null){
objectValue = 0;
}
if(objectValue instanceof BigDecimal){
sum = sum.add((BigDecimal) objectValue);
}else{
sum = sum.add(new BigDecimal(objectValue.toString()));
}
}
return sum;
} /**
* 减法
* @param objects
* @return
*/
public static BigDecimal subtract(Object...objects ){
BigDecimal sum = null;
for (int i = 0; i < objects.length; i++) {
Object objectValue = objects[i];
if(objectValue ==null){
objectValue= 0;
}
if(i==0){
if(objectValue instanceof BigDecimal){
sum = (BigDecimal) objectValue;
}else{
sum = new BigDecimal(objectValue.toString());
}
}else{
if(objectValue instanceof BigDecimal){
sum = sum.subtract((BigDecimal) objectValue);
}else{
sum = sum.subtract(new BigDecimal(objectValue.toString()));
}
}
}
return sum;
} /**
* 除法
* @param objects
* @return
*/
public static BigDecimal divide(Object...objects ){
BigDecimal sum = null;
if(objects.length>1){
for (int i = 0; i < objects.length; i++) {
Object objectValue = objects[i];
if(i==0){
if(objectValue ==null){
return null;
}
if(objectValue instanceof BigDecimal){
sum = (BigDecimal) objectValue;
}else{
sum = new BigDecimal(objectValue.toString());
}
}else{
if(objectValue ==null){
return null;
}
if(objectValue instanceof BigDecimal){
sum = sum.divide((BigDecimal) objectValue);
}else{
sum = sum.divide(new BigDecimal(objectValue.toString()));
}
}
}
return sum;
}else{
return null;
}
}
}
异常处理工具类
/**
* 异常处理工具类
*
*/
@UtilityClass
public class Exceptions { /**
* 将CheckedException转换为UncheckedException.
*
* @param e Throwable
* @return {RuntimeException}
*/
public static RuntimeException unchecked(Throwable e) {
if (e instanceof Error) {
throw (Error) e;
} else if (e instanceof IllegalAccessException ||
e instanceof IllegalArgumentException ||
e instanceof NoSuchMethodException) {
return new IllegalArgumentException(e);
} else if (e instanceof InvocationTargetException) {
return new RuntimeException(((InvocationTargetException) e).getTargetException());
} else if (e instanceof RuntimeException) {
return (RuntimeException) e;
} else if (e instanceof InterruptedException) {
Thread.currentThread().interrupt();
}
return Exceptions.runtime(e);
} /**
* 不采用 RuntimeException 包装，直接抛出，使异常更加精准
*
* @param throwable Throwable
* @param <T> 泛型标记
* @return Throwable
* @throws T 泛型
*/
@SuppressWarnings("unchecked")
private static <T extends Throwable> T runtime(Throwable throwable) throws T {
throw (T) throwable;
} /**
* 代理异常解包
*
* @param wrapped 包装过得异常
* @return 解包后的异常
*/
public static Throwable unwrap(Throwable wrapped) {
Throwable unwrapped = wrapped;
while (true) {
if (unwrapped instanceof InvocationTargetException) {
unwrapped = ((InvocationTargetException) unwrapped).getTargetException();
} else if (unwrapped instanceof UndeclaredThrowableException) {
unwrapped = ((UndeclaredThrowableException) unwrapped).getUndeclaredThrowable();
} else {
return unwrapped;
}
}
}
}
Http请求工具类
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.*;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestClientException;
import org.springframework.web.client.RestTemplate; import java.util.Map; /**
* Http请求工具类
*
* @author yl
*/
@Slf4j
public class HttpUtil { private static final String AUTHORIZATION = "Authorization"; /**
* GET请求
*
* @param url 请求url
* @param token 请求token
* @return
*/
public static String get(String url, String token) { HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.add(AUTHORIZATION, token); MultiValueMap<String, String> requestBody = new LinkedMultiValueMap<>();
HttpEntity<MultiValueMap> requestEntity = new HttpEntity<MultiValueMap>(requestBody, httpHeaders);
RestTemplate restTemplate = new RestTemplate();
if (log.isInfoEnabled()) {
log.info("[http-get] requestUrl: {}", url);
}
ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class);
String result = response.getBody();
if (log.isInfoEnabled()) {
log.info("[http-get] response: {}", result);
}
return result;
} /**
* application/json方式提交数据 自定义请求头
*
* @param url
* @param object
* @param headerMap
* @return
*/
public static String postWithHeader(String url, Object object, Map<String, String> headerMap) {
String body = "";
try {
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);
httpHeaders.add(HttpHeaders.AUTHORIZATION, headerMap.get(HttpHeaders.AUTHORIZATION));
log.info("地址 : " + url + "\n" + "参数 : " + JSON.toJSONString(object) + "\n" + "请求头 : " + httpHeaders.toString());
//设置参数
HttpEntity<Object> requestEntity = new HttpEntity<>(object, httpHeaders);
RestTemplate restTemplate = new RestTemplate();
ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, requestEntity, String.class);
body = responseEntity.getBody();
} catch (RestClientException e) {
e.printStackTrace();
log.error("Rest调用异常!!!地址 : " + url + "\n" + "参数 : " + JSON.toJSONString(object) + "\n" + "请求头 : " + headerMap.toString(), e);
}
return body;
} /**
* post请求带请求体
* @param url
* @param requestBody
* @return
*/
public static JSONObject postJson(String url, Object requestBody) {
RestTemplate restTemplate = new RestTemplate();
log.info("[http] requestUrl: " + url);
if (requestBody != null) {
log.info("[http] requestBody:" + JSON.toJSONString(requestBody));
}
JSONObject response = restTemplate.postForObject(url, requestBody, JSONObject.class);
log.info("[http] response:" + response.toJSONString());
return response;
}
}
Jackson工具类
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j; import java.io.IOException; @Slf4j
public class JacksonUtil { private final static ObjectMapper OBJECT_MAPPER = new ObjectMapper(); /**
* 获取实体
* @return ObjectMapper
*/
private static ObjectMapper getInstance() {
return OBJECT_MAPPER;
} /**
* bean、array、List、Map --> json
*
* @param obj obj
* @return json
*/
public static String writeValueAsString(Object obj) {
try {
return getInstance().writeValueAsString(obj);
} catch (JsonGenerationException e) {
log.error(e.getMessage(), e);
} catch (JsonMappingException e) {
log.error(e.getMessage(), e);
} catch (IOException e) {
log.error(e.getMessage(), e);
}
return null;
} /**
* string --> bean、Map、List(array)
*
* @param jsonStr jsonStr
* @param clazz 类型
* @return obj 对象
*/
public static <T> T readValue(String jsonStr, Class<T> clazz) {
try {
return getInstance().readValue(jsonStr, clazz);
} catch (JsonParseException e) {
log.error(e.getMessage(), e);
} catch (JsonMappingException e) {
log.error(e.getMessage(), e);
} catch (IOException e) {
log.error(e.getMessage(), e);
}
return null;
}
}
日志格式生成类
import com.alibaba.druid.util.StringUtils;
import com.oristand.common.model.LogType; /**
* 生成[标题][大类][小类][过滤1]..格式log
*/
public class LogCreate { /**
*
* @param logTitle log标题
* @param logType1 log大类型
* @param logType2 log小类型
* @param filters 过滤字段，用于查询日志
* @return
*/
public static String create(String logTitle, LogType logType1, LogType logType2, String... filters) {
StringBuilder sb = new StringBuilder();
sb.append("[").append(StringUtils.isEmpty(logTitle) ? "" : logTitle).append("]");
sb.append("[").append(null == logType1 ? "" : logType1.getDesc()).append("]");
sb.append("[").append(null == logType2 ? "" : logType2.getDesc()).append("]");
for (String filter : filters) {
sb.append("[").append(StringUtils.isEmpty(filter) ? "" : filter).append("]");
}
return sb.toString();
} }
Redis工具类
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* Redis工具类
*/
@Component
public final class RedisUtil {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
// =============================common============================
/***
* 读取所有以某字符开头的key
* @param key key前缀
* @return java.util.Set<java.lang.String>
*/
public Set<String> vagueFindKey(String key) {
return redisTemplate.keys(key + StringPool.ASTERISK);
}
/**
* 以redis文件夹名称读取所有key
*
* @param key 文件夹key
* @return java.util.Set<java.lang.String>
*/
public Set<String> skey(String key) {
return redisTemplate.keys(key + StringPool.COLON_STA);
}
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @return
*/
public Boolean expire(String key, long time) {
try {
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据key 获取过期时间
*
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public Boolean hasKey(String key) {
try {
return redisTemplate.hasKey(key);
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public void del(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
// ============================String=============================
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public Boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public Boolean set(String key, Object value, long time) {
try {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 递增
*
* @param key 键
* @param delta 要增加几(大于0)
* @return
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @param delta 要减少几(小于0)
* @return
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
// ================================Map=================================
/**
* HashGet
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
public Map<Object, Object> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public Boolean hmset(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet 并设置时间
*
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public Boolean hmset(String key, Map<String, Object> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public Boolean hset(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public Boolean hset(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if (time > 0) {
expire(key, time);
}
return true;
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public Boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
*
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set=============================
/**
* 根据key获取Set中的所有值
*
* @param key 键
* @return
*/
public Set<Object> sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
}
catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public Boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将数据放入set缓存
*
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
}
catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 将set数据放入缓存
*
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key, long time, Object... values) {
try {
long count = redisTemplate.opsForSet().add(key, values);
if (time > 0)
expire(key, time);
return count;
}
catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
*
* @param key 键
* @return
*/
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
}
catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
*
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object... values) {
try {
long count = redisTemplate.opsForSet().remove(key, values);
return count;
}
catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ===============================list=================================
/**
* 获取list缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
}
catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
*
* @param key 键
* @return
*/
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
}
catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 通过索引 获取list中的值
*
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
* @return
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
}
catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public Boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public Boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0)
expire(key, time);
return true;
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public Boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public Boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0)
expire(key, time);
return true;
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据索引修改list中的某条数据
*
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public Boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
*
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key, long count, Object value) {
try {
long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
}
catch (Exception e) {
e.printStackTrace();
return 0;
}
}
}
RestTemplateUtils
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.web.client.RestClientException;
import org.springframework.web.client.RestTemplate;
import java.util.Map;
@Component
@Slf4j
public class RestTemplateUtil
{
@Autowired
private RestTemplate restTemplate;
/**
* application/json方式提交数据
*
* @param url
* @param object
* @return
*/
public String post(String url, Object object)
{
String body = "";
try
{
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.APPLICATION_JSON);
//设置参数
HttpEntity < Object > requestEntity = new HttpEntity < > (object, httpHeaders);
log.info("地址 : " + url + "\n" + "参数 : " + JSON.toJSONString(object) + "\n" + "请求头 : " + httpHeaders.toString());
ResponseEntity < String > responseEntity = restTemplate.postForEntity(url, requestEntity, String.class);
body = responseEntity.getBody();
}
catch (RestClientException e)
{
e.printStackTrace();
log.error("Rest调用异常!!!地址 : " + url + "\n" + "参数 : " + JSON.toJSONString(object), e);
}
return body;
}
/**
* application/json方式提交数据 自定义请求头
*
* @param url
* @param object
* @param headerMap
* @return
*/
public String postWithHeader(String url, Object object, Map < String, String > headerMap)
{
String body = "";
try
{
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);
if (headerMap != null && headerMap.size() != 0)
{
for (String s: headerMap.keySet())
{
httpHeaders.add(s, headerMap.get(s));
}
}
log.info("地址 : " + url + "\n" + "参数 : " + JSON.toJSONString(object) + "\n" + "请求头 : " + httpHeaders.toString());
//设置参数
HttpEntity < Object > requestEntity = new HttpEntity < > (object, httpHeaders);
ResponseEntity < String > responseEntity = restTemplate.postForEntity(url, requestEntity, String.class);
body = responseEntity.getBody();
}
catch (RestClientException e)
{
e.printStackTrace();
log.error("Rest调用异常!!!地址 : " + url + "\n" + "参数 : " + JSON.toJSONString(object) + "\n" + "请求头 : " + headerMap.toString(), e);
}
return body;
}
/**
* 表单提交数据
*
* @param url
* @param map
* @return
*/
public String postFrom(String url, Map < String, String > map)
{
String body = "";
try
{
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
LinkedMultiValueMap < String, String > multiValueMap = new LinkedMultiValueMap < > ();
if (map != null && map.size() != 0)
{
for (Map.Entry < String, String > entry: map.entrySet())
{
multiValueMap.add(entry.getKey(), entry.getValue());
}
}
//设置参数
HttpEntity < LinkedMultiValueMap < String, String >> requestEntity = new HttpEntity < > (multiValueMap, httpHeaders);
log.info("地址 : " + url + "\n" + "参数 : " + map.toString() + "\n" + "请求头 : " + httpHeaders.toString());
ResponseEntity < String > responseEntity = restTemplate.postForEntity(url, requestEntity, String.class);
body = responseEntity.getBody();
}
catch (RestClientException e)
{
e.printStackTrace();
log.error("Rest调用异常!!!地址 : " + url + "\n" + "参数 : " + map.toString(), e);
}
return body;
}
/**
* 表单提交数据 自定义请求头
*
* @param url
* @param map
* @param headerMap
* @return
*/
public String postFromWithHeader(String url, Map < String, String > map, Map < String, String > headerMap)
{
String body = "";
try
{
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
if (headerMap != null && headerMap.size() != 0)
{
for (String s: headerMap.keySet())
{
httpHeaders.add(s, headerMap.get(s));
}
}
LinkedMultiValueMap < String, String > multiValueMap = new LinkedMultiValueMap < > ();
if (map != null && map.size() != 0)
{
for (Map.Entry < String, String > entry: map.entrySet())
{
multiValueMap.add(entry.getKey(), entry.getValue());
}
}
//设置参数
HttpEntity < LinkedMultiValueMap < String, String >> requestEntity = new HttpEntity < > (multiValueMap, httpHeaders);
log.info("地址 : " + url + "\n" + "参数 : " + map.toString() + "\n" + "请求头 : " + headerMap.toString());
ResponseEntity < String > responseEntity = restTemplate.postForEntity(url, requestEntity, String.class);
body = responseEntity.getBody();
}
catch (Exception e)
{
e.printStackTrace();
log.error("Rest调用异常!!!地址 : " + url + "\n" + "参数 : " + map.toString() + "\n" + "请求头 : " + headerMap.toString(), e);
}
return body;
}
}
SendMailUtils
发送邮件主类
import com.oristand.common.model.MyAuthenticator;
import com.oristand.common.model.SimpleMail;
import org.springframework.stereotype.Component; import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.mail.*;
import javax.mail.internet.*;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set; @Component
public class SendMailUtil { public static boolean sendMail(SimpleMail mailInfo){
String host = mailInfo.getHost();
String port = mailInfo.getPort();
String username = mailInfo.getUserName();
String password = mailInfo.getPassword();
String from = mailInfo.getFrom();
String[] to = mailInfo.getTo();
String[] cc = mailInfo.getCc();
Boolean needAuth = mailInfo.getNeedAuth();
Map<String,String> fileInfo = mailInfo.getFiles(); Properties props = new Properties();
props.put("mail.smtp.host", host);
props.put("mail.smtp.port", port);
props.put("mail.smtp.auth", needAuth?"true":"flase"); MyAuthenticator auth = null;
if(needAuth){
auth = new MyAuthenticator(username, password);
} Session session = Session.getInstance(props,auth); try {
MimeMessage msg = new MimeMessage(session);
msg.setFrom(new InternetAddress(from));
if(to.length>0){
InternetAddress[] toAddrs = new InternetAddress[to.length];
for(int i=0;i<to.length;i++){
toAddrs[i] = new InternetAddress(to[i]);
}
msg.setRecipients(Message.RecipientType.TO, toAddrs);
}
if(cc!=null && cc.length>0){
InternetAddress[] ccAddrs = new InternetAddress[cc.length];
for(int i=0;i<cc.length;i++){
ccAddrs[i] = new InternetAddress(cc[i]);
}
msg.setRecipients(Message.RecipientType.CC, ccAddrs);
}
msg.setSubject(toChinese(mailInfo.getSubject())); // 创建多重消息
Multipart multipart = new MimeMultipart(); // 创建消息部分
BodyPart messageBodyPart = new MimeBodyPart(); // 消息
messageBodyPart.setText(mailInfo.getContent()); // 设置文本消息部分
multipart.addBodyPart(messageBodyPart); // 附件部分
if(fileInfo!=null && fileInfo.size()>0){
Set<Entry<String, String>> files = fileInfo.entrySet();
for (Entry<String, String> entry : files) {
String filename = entry.getKey();
String filePath = entry.getValue();
messageBodyPart = new MimeBodyPart();
// 设置要发送附件的文件路径
DataSource source = new FileDataSource(filePath);
messageBodyPart.setDataHandler(new DataHandler(source));
// messageBodyPart.setFileName(filename);
// 处理附件名称中文（附带文件路径）乱码问题
messageBodyPart.setFileName(MimeUtility.encodeText(filename));
multipart.addBodyPart(messageBodyPart);
}
} // 发送完整消息
msg.setContent(multipart); Transport.send(msg);
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
} public static String toChinese(String text){
try {
text = MimeUtility.encodeText(text, "utf-8", "B");
} catch (Exception e) {
e.printStackTrace();
}
return text;
}
}
获取认证auth类
import javax.mail.Authenticator;
import javax.mail.PasswordAuthentication; public class MyAuthenticator extends Authenticator {
String userName=null;
String password=null; public MyAuthenticator(){
} public MyAuthenticator(String username, String password) {
this.userName = username;
this.password = password;
}
protected PasswordAuthentication getPasswordAuthentication(){
return new PasswordAuthentication(userName, password);
}
}
SimpleMail（发送邮件主类参数）
public class SimpleMail {
private String[] to; //收件人
private String[] cc; //抄送人
private String from = "service7@bulkea.oristand.com"; //发件人
private String host = "smtp.exmail.qq.com";
private String port = "25";
private String userName = "service7@bulkea.oristand.com";
private String password = "Ori20180905";
private String subject;
private String content;
private Boolean needAuth = true;
private Map<String, String> files; //附件
public SimpleMail(String[] to, String[] cc, String subject, String content) {
super();
this.to = to;
this.cc = cc;
this.subject = subject;
this.content = content;
}
public String[] getTo() {
return to;
}
public void setTo(String[] to) {
this.to = to;
}
public String getFrom() {
return from;
}
public void setFrom(String from) {
this.from = from;
}
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public Map<String, String> getFiles() {
return files;
}
public void setFiles(Map<String, String> files) {
this.files = files;
}
public String[] getCc() {
return cc;
}
public void setCc(String[] cc) {
this.cc = cc;
}
public String getPort() {
return port;
}
public void setPort(String port) {
this.port = port;
}
public Boolean getNeedAuth() {
return needAuth;
}
public void setNeedAuth(Boolean needAuth) {
this.needAuth = needAuth;
}
}
分割List为多个List
import java.util.ArrayList;
import java.util.List; public class SplitListUtil {
public static <T> List<List<T>> split(List<T> sList, int num) {
List<List<T>> eList = new ArrayList<List<T>>();
int size = sList.size(); if (sList.size() > num) {
int i = size / num; if ((i * num) < size) {
i = i + 1;
} for (int s = 0; s < i; s++) {
List<T> a = new ArrayList<T>();
int i1 = s * num;
int i2 = num + (s * num); if (i2 > size) {
i2 = size;
} for (int n = i1; n < i2; n++) {
a.add(sList.get(n));
} eList.add(a);
} return eList;
} else {
eList.add(sList); return eList;
}
}
}
静态String池
/**
* 静态 String 池
*/
public interface StringPool {
String AMPERSAND = "&";
String AND = "and";
String AT = "@";
String ASTERISK = "*";
String STAR = ASTERISK;
String SLASH = "/";
String BACK_SLASH = "\\";
String DOUBLE_SLASH = "#//";
String COLON = ":";
String COMMA = ",";
String DASH = "-";
String DOLLAR = "$";
String DOT = ".";
String EMPTY = "";
String EMPTY_JSON = "{}";
String EQUALS = "=";
String FALSE = "false";
String HASH = "#";
String HAT = "^";
String LEFT_BRACE = "{";
String LEFT_BRACKET = "(";
String LEFT_CHEV = "<";
String NEWLINE = "\n";
String N = "n";
String NO = "no";
String NULL = "null";
String OFF = "off";
String ON = "on";
String PERCENT = "%";
String PIPE = "|";
String PLUS = "+";
String QUESTION_MARK = "?";
String EXCLAMATION_MARK = "!";
String QUOTE = "\"";
String RETURN = "\r";
String TAB = "\t";
String RIGHT_BRACE = "}";
String RIGHT_BRACKET = ")";
String RIGHT_CHEV = ">";
String SEMICOLON = ";";
String SINGLE_QUOTE = "'";
String BACKTICK = "`";
String SPACE = " ";
String TILDA = "~";
String LEFT_SQ_BRACKET = "[";
String RIGHT_SQ_BRACKET = "]";
String TRUE = "true";
String UNDERSCORE = "_";
String UTF_8 = "UTF-8";
String GBK = "GBK";
String ISO_8859_1 = "ISO-8859-1";
String Y = "y";
String YES = "yes";
String ONE = "1";
String ZERO = "0";
String TWO = "2";
String DOLLAR_LEFT_BRACE = "${";
String UNKNOWN = "unknown";
String UNDEFINED = "undefined";
String GET = "GET";
String POST = "POST";
String COLON_STA = ":*";
}
字符串工具类
package com.oristand.common.util;
import org.springframework.lang.Nullable;
import org.springframework.util.PatternMatchUtils;
import org.springframework.web.util.HtmlUtils;
import java.io.StringReader;
import java.io.StringWriter;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
/**
* 继承自Spring util的工具类，减少jar依赖
*
*/
public class StringUtil extends org.springframework.util.StringUtils
{
public static final int INDEX_NOT_FOUND = -1;
//判断是否null或空值，或全部空格
public static boolean isEmpty(Object str)
{
if (str == null || str.toString()
.equals(""))
{
return true;
}
if (str.toString()
.trim()
.equals(""))
{
return true;
}
return false;
}
/**
* 检查 参数String 是否为有意义的字符串<br>
* 不为null,且不为空
*
* @param string
* @return
*/
public static boolean isValid(String string)
{
if (string == null || string.isEmpty())
{
return false;
}
else
{
return true;
}
}
/**
* 检查 参数StringBuffer 是否为有意义的字符串<br>
* 不为null,且不为空
*
* @param
* @return
*/
public static boolean isValid(StringBuffer sb)
{
if (sb == null || sb.length() == 0)
{
return false;
}
else
{
return true;
}
}
/**
* 检查 参数StringBuilder 是否为有意义的字符串<br>
* 不为null,且不为空
*
* @param
* @return
*/
public static boolean isValid(StringBuilder sb)
{
if (sb == null || sb.length() == 0)
{
return false;
}
else
{
return true;
}
}
/**
* 检查 参数Object 是否为有意义的对象<br>
* 不为null,且不为空
*
* @param object
* @return
*/
public static boolean isValid(Object object)
{
if (object == null || object.toString()
.length() == 0)
{
return false;
}
else
{
return true;
}
}
/**
* 中文：/[\u4e00-\u9fa5]/
* 日文：/[\u0800-\u4e00]/
* 韩文：/[\uac00-\ud7ff]/
*
* @param str
* @return
*/
public static boolean isJapanesChar(String str)
{
boolean temp = false;
Pattern p = Pattern.compile("[ࠀ-一]");
Matcher m = p.matcher(str);
if (m.find())
{
temp = true;
}
return temp;
}
public static String getString(String str)
{
if (str == null || "".equals(str))
{
return "";
}
else
{
return str;
}
}
private static boolean isMatch(String regex, String orginal)
{
if (orginal == null || orginal.trim()
.equals(""))
{
return false;
}
Pattern pattern = Pattern.compile(regex);
Matcher isNum = pattern.matcher(orginal);
return isNum.matches();
}
/**
* 是否是小数
* @param orginal
* @return
*/
public static boolean isDecimal(String orginal)
{
return isMatch("[-+]{0,1}\\d+\\.\\d*|[-+]{0,1}\\d*\\.\\d+", orginal);
}
//判断是否null或空值，或全部空格
public static boolean isEmptyOrNull(Object str)
{
if (str == null || str.toString()
.equals("")) return true;
if (str.toString()
.trim()
.equals("")) return true;
if (str.toString()
.trim()
.toUpperCase()
.equals("NULL")) return true;
return false;
}
/**
* 是否是正整数
* @param orginal
* @return
*/
public static boolean isPositiveInteger(String orginal)
{
return isMatch("^\\+{0,1}[1-9]\\d*", orginal);
}
/**
* 是否是负整数
* @param orginal
* @return
*/
public static boolean isNegativeInteger(String orginal)
{
return isMatch("^-[1-9]\\d*", orginal);
}
/**
* 是否是整数
* @param orginal
* @return
*/
public static boolean isWholeNumber(String orginal)
{
return isMatch("[+-]{0,1}0", orginal) || isPositiveInteger(orginal) || isNegativeInteger(orginal);
}
/**
* 是否是实数
* @param orginal
* @return
*/
public static boolean isRealNumber(Object orginal)
{
if (isEmptyOrNull(orginal)) return false;
return isWholeNumber(orginal.toString()) || isDecimal(orginal.toString());
}
public static String getNumberValuePro(Object a)
{
if (isEmpty(a))
{
return "0";
}
if (isRealNumber(a))
{
return a.toString();
}
return "0";
}
public static String getStringValue(Object a)
{
if (isEmpty(a))
{
return "";
}
return a.toString();
}
public static String getUsFormatCreateDate(Object obj)
{
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
Date orderDate;
try
{
if (isEmptyOrNull(obj))
{
orderDate = new Date();
}
else
{
orderDate = sdf1.parse(getStringValue(obj));
}
sdf2.setTimeZone(TimeZone.getTimeZone("America/Los_Angeles"));
String orderDateStr = sdf2.format(orderDate);
return orderDateStr;
}
catch (Exception e)
{
e.printStackTrace();
return null;
}
}
/**
* 逗号拼接List元素
* @param list
* @return
*/
public static String listToStr(List < String > list)
{
if (list == null || list.size() == 0)
{
return "";
}
StringBuffer sb = new StringBuffer();
for (String t: list)
{
sb.append(String.valueOf(t) + ",");
}
if (sb.length() > 1)
{
sb.deleteCharAt(sb.length() - 1);
}
return sb.toString();
}
/**
* 截取字符串
*
* @param s
* @param maxlength
* @return
*/
public static String substringpro(String s, int begin, int maxlength)
{
try
{
int tempcz = s.length() - maxlength; //相差的字节数
if (tempcz <= 0)
{
return s;
}
else
{
return s.substring(begin, maxlength);
}
}
catch (Exception e)
{
return s;
}
}
/**
* Check whether the given {@code CharSequence} contains actual <em>text</em>.
* <p>More specifically, this method returns {@code true} if the
* {@code CharSequence} is not {@code null}, its length is greater than
* 0, and it contains at least one non-whitespace character.
* <pre class="code">
* StringUtil.isBlank(null) = true
* StringUtil.isBlank("") = true
* StringUtil.isBlank(" ") = true
* StringUtil.isBlank("12345") = false
* StringUtil.isBlank(" 12345 ") = false
* </pre>
*
* @param cs the {@code CharSequence} to check (may be {@code null})
* @return {@code true} if the {@code CharSequence} is not {@code null},
* its length is greater than 0, and it does not contain whitespace only
* @see Character#isWhitespace
*/
public static boolean isBlank(final CharSequence cs)
{
return !StringUtil.hasText(cs);
}
/**
* <p>Checks if a CharSequence is not empty (""), not null and not whitespace only.</p>
* <pre>
* StringUtil.isNotBlank(null) = false
* StringUtil.isNotBlank("") = false
* StringUtil.isNotBlank(" ") = false
* StringUtil.isNotBlank("bob") = true
* StringUtil.isNotBlank(" bob ") = true
* </pre>
*
* @param cs the CharSequence to check, may be null
* @return {@code true} if the CharSequence is
* not empty and not null and not whitespace
* @see Character#isWhitespace
*/
public static boolean isNotBlank(final CharSequence cs)
{
return StringUtil.hasText(cs);
}
/**
* 是否全为 Blank
*
* @param css CharSequence
* @return boolean
*/
public static boolean isAllBlank(final CharSequence...css)
{
return Stream.of(css)
.allMatch(StringUtil::isBlank);
}
/**
* 判断一个字符串是否是数字
*
* @param cs the CharSequence to check, may be null
* @return {boolean}
*/
public static boolean isNumeric(final CharSequence cs)
{
if (isBlank(cs))
{
return false;
}
for (int i = cs.length(); --i >= 0;)
{
int chr = cs.charAt(i);
if (chr < 48 || chr > 57)
{
return false;
}
}
return true;
}
/**
* 将字符串中特定模式的字符转换成map中对应的值
* <p>
* use: format("my name is ${name}, and i like ${like}!", {"name":"xx", "like": "Java"})
*
* @param message 需要转换的字符串
* @param params 转换所需的键值对集合
* @return 转换后的字符串
*/
public static String format(@Nullable String message, @Nullable Map < String, Object > params)
{
// message 为 null 返回空字符串
if (message == null)
{
return StringPool.EMPTY;
}
// 参数为 null 或者为空
if (params == null || params.isEmpty())
{
return message;
}
// 替换变量
StringBuilder sb = new StringBuilder((int)(message.length() * 1.5));
int cursor = 0;
for (int start, end;
(start = message.indexOf(StringPool.DOLLAR_LEFT_BRACE, cursor)) != -1 && (end = message.indexOf(StringPool.RIGHT_BRACE, start)) != -1;)
{
sb.append(message, cursor, start);
String key = message.substring(start + 2, end);
Object value = params.get(StringUtil.trimWhitespace(key));
sb.append(value == null ? StringPool.EMPTY : value);
cursor = end + 1;
}
sb.append(message.substring(cursor));
return sb.toString();
}
/**
* 同 log 格式的 format 规则
* <p>
* use: format("my name is {}, and i like {}!", "xx", "Java")
*
* @param message 需要转换的字符串
* @param arguments 需要替换的变量
* @return 转换后的字符串
*/
public static String format(@Nullable String message, @Nullable Object...arguments)
{
// message 为 null 返回空字符串
if (message == null)
{
return StringPool.EMPTY;
}
// 参数为 null 或者为空
if (arguments == null || arguments.length == 0)
{
return message;
}
StringBuilder sb = new StringBuilder((int)(message.length() * 1.5));
int cursor = 0;
int index = 0;
int argsLength = arguments.length;
for (int start, end;
(start = message.indexOf('{', cursor)) != -1 && (end = message.indexOf('}', start)) != -1 && index < argsLength;)
{
sb.append(message, cursor, start);
sb.append(arguments[index]);
cursor = end + 1;
index++;
}
sb.append(message.substring(cursor));
return sb.toString();
}
/**
* Convert a {@code Collection} into a delimited {@code String} (e.g., CSV).
* <p>Useful for {@code toString()} implementations.
*
* @param coll the {@code Collection} to convert
* @return the delimited {@code String}
*/
public static String join(Collection < ? > coll)
{
return StringUtil.collectionToCommaDelimitedString(coll);
}
/**
* Convert a {@code Collection} into a delimited {@code String} (e.g. CSV).
* <p>Useful for {@code toString()} implementations.
*
* @param coll the {@code Collection} to convert
* @param delim the delimiter to use (typically a ",")
* @return the delimited {@code String}
*/
public static String join(Collection < ? > coll, String delim)
{
return StringUtil.collectionToDelimitedString(coll, delim);
}
/**
* Convert a {@code String} array into a comma delimited {@code String}
* (i.e., CSV).
* <p>Useful for {@code toString()} implementations.
*
* @param arr the array to display
* @return the delimited {@code String}
*/
public static String join(Object[] arr)
{
return StringUtil.arrayToCommaDelimitedString(arr);
}
/**
* Convert a {@code String} array into a delimited {@code String} (e.g. CSV).
* <p>Useful for {@code toString()} implementations.
*
* @param arr the array to display
* @param delim the delimiter to use (typically a ",")
* @return the delimited {@code String}
*/
public static String join(Object[] arr, String delim)
{
return StringUtil.arrayToDelimitedString(arr, delim);
}
/**
* 字符串是否符合指定的 表达式
*
* <p>
* pattern styles: "xxx*", "*xxx", "*xxx*" and "xxx*yyy"
* </p>
*
* @param pattern 表达式
* @param str 字符串
* @return 是否匹配
*/
public static boolean simpleMatch(@Nullable String pattern, @Nullable String str)
{
return PatternMatchUtils.simpleMatch(pattern, str);
}
/**
* 字符串是否符合指定的 表达式
*
* <p>
* pattern styles: "xxx*", "*xxx", "*xxx*" and "xxx*yyy"
* </p>
*
* @param patterns 表达式 数组
* @param str 字符串
* @return 是否匹配
*/
public static boolean simpleMatch(@Nullable String[] patterns, String str)
{
return PatternMatchUtils.simpleMatch(patterns, str);
}
/**
* 生成uuid
*
* @return UUID
*/
public static String randomUUID()
{
ThreadLocalRandom random = ThreadLocalRandom.current();
return new UUID(random.nextLong(), random.nextLong())
.toString()
.replace(StringPool.DASH, StringPool.EMPTY);
}
/**
* 转义HTML用于安全过滤
*
* @param html html
* @return {String}
*/
public static String escapeHtml(String html)
{
return StringUtil.isBlank(html) ? StringPool.EMPTY : HtmlUtils.htmlEscape(html);
}
/**
* 清理字符串，清理出某些不可见字符
*
* @param txt 字符串
* @return {String}
*/
public static String cleanChars(String txt)
{
return txt.replaceAll("[ `·•�\\f\\t\\v\\s]", "");
}
private static final String S_INT = "0123456789";
private static final String S_STR = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
private static final String S_ALL = S_INT + S_STR;
/**
* 有序的格式化文本，使用{number}做为占位符<br>
* 例：<br>
* 通常使用：format("this is {0} for {1}", "a", "b") =》 this is a for b<br>
*
* @param pattern 文本格式
* @param arguments 参数
* @return 格式化后的文本
*/
public static String indexedFormat(CharSequence pattern, Object...arguments)
{
return MessageFormat.format(pattern.toString(), arguments);
}
/**
* 切分字符串，不去除切分后每个元素两边的空白符，不去除空白项
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @return 切分后的集合
*/
public static List < String > split(CharSequence str, char separator, int limit)
{
return split(str, separator, limit, false, false);
}
/**
* 分割 字符串 删除常见 空白符
*
* @param str 字符串
* @param delimiter 分割符
* @return 字符串数组
*/
public static String[] splitTrim(@Nullable String str, @Nullable String delimiter)
{
return StringUtil.delimitedListToStringArray(str, delimiter, " \t\n\n\f");
}
/**
* 切分字符串，去除切分后每个元素两边的空白符，去除空白项
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @return 切分后的集合
* @since 3.1.2
*/
public static List < String > splitTrim(CharSequence str, char separator)
{
return splitTrim(str, separator, -1);
}
/**
* 切分字符串，去除切分后每个元素两边的空白符，去除空白项
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @return 切分后的集合
* @since 3.2.0
*/
public static List < String > splitTrim(CharSequence str, CharSequence separator)
{
return splitTrim(str, separator, -1);
}
/**
* 切分字符串，去除切分后每个元素两边的空白符，去除空白项
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @return 切分后的集合
* @since 3.1.0
*/
public static List < String > splitTrim(CharSequence str, char separator, int limit)
{
return split(str, separator, limit, true, true);
}
/**
* 切分字符串，去除切分后每个元素两边的空白符，去除空白项
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @return 切分后的集合
* @since 3.2.0
*/
public static List < String > splitTrim(CharSequence str, CharSequence separator, int limit)
{
return split(str, separator, limit, true, true);
}
/**
* 切分字符串，不限制分片数量
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static List < String > split(CharSequence str, char separator, boolean isTrim, boolean ignoreEmpty)
{
return split(str, separator, 0, isTrim, ignoreEmpty);
}
/**
* 切分字符串
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static List < String > split(CharSequence str, char separator, int limit, boolean isTrim, boolean ignoreEmpty)
{
if (null == str)
{
return new ArrayList < > (0);
}
return StrSpliter.split(str.toString(), separator, limit, isTrim, ignoreEmpty);
}
/**
* 切分字符串
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.0
*/
public static List < String > split(CharSequence str, CharSequence separator, int limit, boolean isTrim, boolean ignoreEmpty)
{
if (null == str)
{
return new ArrayList < > (0);
}
final String separatorStr = (null == separator) ? null : separator.toString();
return StrSpliter.split(str.toString(), separatorStr, limit, isTrim, ignoreEmpty);
}
/**
* 切分字符串
*
* @param str 被切分的字符串
* @param separator 分隔符
* @return 字符串
*/
public static String[] split(CharSequence str, CharSequence separator)
{
if (str == null)
{
return new String[]
{};
}
final String separatorStr = (null == separator) ? null : separator.toString();
return StrSpliter.splitToArray(str.toString(), separatorStr, 0, false, false);
}
/**
* 根据给定长度，将给定字符串截取为多个部分
*
* @param str 字符串
* @param len 每一个小节的长度
* @return 截取后的字符串数组
* @see StrSpliter#splitByLength(String, int)
*/
public static String[] split(CharSequence str, int len)
{
if (null == str)
{
return new String[]
{};
}
return StrSpliter.splitByLength(str.toString(), len);
}
/**
* 指定字符是否在字符串中出现过
*
* @param str 字符串
* @param searchChar 被查找的字符
* @return 是否包含
* @since 3.1.2
*/
public static boolean contains(CharSequence str, char searchChar)
{
return indexOf(str, searchChar) > -1;
}
/**
* 是否包含特定字符，忽略大小写，如果给定两个参数都为<code>null</code>，返回true
*
* @param str 被检测字符串
* @param testStr 被测试是否包含的字符串
* @return 是否包含
*/
public static boolean containsIgnoreCase(CharSequence str, CharSequence testStr)
{
if (null == str)
{
// 如果被监测字符串和
return null == testStr;
}
return str.toString()
.toLowerCase()
.contains(testStr.toString()
.toLowerCase());
}
/**
* 改进JDK subString<br>
* index从0开始计算，最后一个字符为-1<br>
* 如果from和to位置一样，返回 "" <br>
* 如果from或to为负数，则按照length从后向前数位置，如果绝对值大于字符串长度，则from归到0，to归到length<br>
* 如果经过修正的index中from大于to，则互换from和to example: <br>
* abcdefgh 2 3 =》 c <br>
* abcdefgh 2 -3 =》 cde <br>
*
* @param str String
* @param fromIndex 开始的index（包括）
* @param toIndex 结束的index（不包括）
* @return 字串
*/
public static String sub(CharSequence str, int fromIndex, int toIndex)
{
if (isEmpty(str))
{
return StringPool.EMPTY;
}
int len = str.length();
if (fromIndex < 0)
{
fromIndex = len + fromIndex;
if (fromIndex < 0)
{
fromIndex = 0;
}
}
else if (fromIndex > len)
{
fromIndex = len;
}
if (toIndex < 0)
{
toIndex = len + toIndex;
if (toIndex < 0)
{
toIndex = len;
}
}
else if (toIndex > len)
{
toIndex = len;
}
if (toIndex < fromIndex)
{
int tmp = fromIndex;
fromIndex = toIndex;
toIndex = tmp;
}
if (fromIndex == toIndex)
{
return StringPool.EMPTY;
}
return str.toString()
.substring(fromIndex, toIndex);
}
/**
* 截取分隔字符串之前的字符串，不包括分隔字符串<br>
* 如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串<br>
* 如果分隔字符串为空串""，则返回空串，如果分隔字符串未找到，返回原字符串
* <p>
* 栗子：
*
* <pre>
* StringUtil.subBefore(null, *) = null
* StringUtil.subBefore("", *) = ""
* StringUtil.subBefore("abc", "a") = ""
* StringUtil.subBefore("abcba", "b") = "a"
* StringUtil.subBefore("abc", "c") = "ab"
* StringUtil.subBefore("abc", "d") = "abc"
* StringUtil.subBefore("abc", "") = ""
* StringUtil.subBefore("abc", null) = "abc"
* </pre>
*
* @param string 被查找的字符串
* @param separator 分隔字符串（不包括）
* @param isLastSeparator 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
* @return 切割后的字符串
* @since 3.1.1
*/
public static String subBefore(CharSequence string, CharSequence separator, boolean isLastSeparator)
{
if (isEmpty(string) || separator == null)
{
return null == string ? null : string.toString();
}
final String str = string.toString();
final String sep = separator.toString();
if (sep.isEmpty())
{
return StringPool.EMPTY;
}
final int pos = isLastSeparator ? str.lastIndexOf(sep) : str.indexOf(sep);
if (pos == INDEX_NOT_FOUND)
{
return str;
}
return str.substring(0, pos);
}
/**
* 截取分隔字符串之后的字符串，不包括分隔字符串<br>
* 如果给定的字符串为空串（null或""），返回原字符串<br>
* 如果分隔字符串为空串（null或""），则返回空串，如果分隔字符串未找到，返回空串
* <p>
* 栗子：
*
* <pre>
* StringUtil.subAfter(null, *) = null
* StringUtil.subAfter("", *) = ""
* StringUtil.subAfter(*, null) = ""
* StringUtil.subAfter("abc", "a") = "bc"
* StringUtil.subAfter("abcba", "b") = "cba"
* StringUtil.subAfter("abc", "c") = ""
* StringUtil.subAfter("abc", "d") = ""
* StringUtil.subAfter("abc", "") = "abc"
* </pre>
*
* @param string 被查找的字符串
* @param separator 分隔字符串（不包括）
* @param isLastSeparator 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
* @return 切割后的字符串
* @since 3.1.1
*/
public static String subAfter(CharSequence string, CharSequence separator, boolean isLastSeparator)
{
if (isEmpty(string))
{
return null == string ? null : string.toString();
}
if (separator == null)
{
return StringPool.EMPTY;
}
final String str = string.toString();
final String sep = separator.toString();
final int pos = isLastSeparator ? str.lastIndexOf(sep) : str.indexOf(sep);
if (pos == INDEX_NOT_FOUND)
{
return StringPool.EMPTY;
}
return str.substring(pos + separator.length());
}
/**
* 截取指定字符串中间部分，不包括标识字符串<br>
* <p>
* 栗子：
*
* <pre>
* StringUtil.subBetween("wx[b]yz", "[", "]") = "b"
* StringUtil.subBetween(null, *, *) = null
* StringUtil.subBetween(*, null, *) = null
* StringUtil.subBetween(*, *, null) = null
* StringUtil.subBetween("", "", "") = ""
* StringUtil.subBetween("", "", "]") = null
* StringUtil.subBetween("", "[", "]") = null
* StringUtil.subBetween("yabcz", "", "") = ""
* StringUtil.subBetween("yabcz", "y", "z") = "abc"
* StringUtil.subBetween("yabczyabcz", "y", "z") = "abc"
* </pre>
*
* @param str 被切割的字符串
* @param before 截取开始的字符串标识
* @param after 截取到的字符串标识
* @return 截取后的字符串
* @since 3.1.1
*/
public static String subBetween(CharSequence str, CharSequence before, CharSequence after)
{
if (str == null || before == null || after == null)
{
return null;
}
final String str2 = str.toString();
final String before2 = before.toString();
final String after2 = after.toString();
final int start = str2.indexOf(before2);
if (start != INDEX_NOT_FOUND)
{
final int end = str2.indexOf(after2, start + before2.length());
if (end != INDEX_NOT_FOUND)
{
return str2.substring(start + before2.length(), end);
}
}
return null;
}
/**
* 截取指定字符串中间部分，不包括标识字符串<br>
* <p>
* 栗子：
*
* <pre>
* StringUtil.subBetween(null, *) = null
* StringUtil.subBetween("", "") = ""
* StringUtil.subBetween("", "tag") = null
* StringUtil.subBetween("tagabctag", null) = null
* StringUtil.subBetween("tagabctag", "") = ""
* StringUtil.subBetween("tagabctag", "tag") = "abc"
* </pre>
*
* @param str 被切割的字符串
* @param beforeAndAfter 截取开始和结束的字符串标识
* @return 截取后的字符串
* @since 3.1.1
*/
public static String subBetween(CharSequence str, CharSequence beforeAndAfter)
{
return subBetween(str, beforeAndAfter, beforeAndAfter);
}
/**
* 去掉指定前缀
*
* @param str 字符串
* @param prefix 前缀
* @return 切掉后的字符串，若前缀不是 preffix， 返回原字符串
*/
public static String removePrefix(CharSequence str, CharSequence prefix)
{
if (isEmpty(str) || isEmpty(prefix))
{
return StringPool.EMPTY;
}
final String str2 = str.toString();
if (str2.startsWith(prefix.toString()))
{
return subSuf(str2, prefix.length());
}
return str2;
}
/**
* 忽略大小写去掉指定前缀
*
* @param str 字符串
* @param prefix 前缀
* @return 切掉后的字符串，若前缀不是 prefix， 返回原字符串
*/
public static String removePrefixIgnoreCase(CharSequence str, CharSequence prefix)
{
if (isEmpty(str) || isEmpty(prefix))
{
return StringPool.EMPTY;
}
final String str2 = str.toString();
if (str2.toLowerCase()
.startsWith(prefix.toString()
.toLowerCase()))
{
return subSuf(str2, prefix.length());
}
return str2;
}
/**
* 去掉指定后缀
*
* @param str 字符串
* @param suffix 后缀
* @return 切掉后的字符串，若后缀不是 suffix， 返回原字符串
*/
public static String removeSuffix(CharSequence str, CharSequence suffix)
{
if (isEmpty(str) || isEmpty(suffix))
{
return StringPool.EMPTY;
}
final String str2 = str.toString();
if (str2.endsWith(suffix.toString()))
{
return subPre(str2, str2.length() - suffix.length());
}
return str2;
}
/**
* 去掉指定后缀，并小写首字母
*
* @param str 字符串
* @param suffix 后缀
* @return 切掉后的字符串，若后缀不是 suffix， 返回原字符串
*/
public static String removeSufAndLowerFirst(CharSequence str, CharSequence suffix)
{
return firstCharToLower(removeSuffix(str, suffix));
}
/**
* 忽略大小写去掉指定后缀
*
* @param str 字符串
* @param suffix 后缀
* @return 切掉后的字符串，若后缀不是 suffix， 返回原字符串
*/
public static String removeSuffixIgnoreCase(CharSequence str, CharSequence suffix)
{
if (isEmpty(str) || isEmpty(suffix))
{
return StringPool.EMPTY;
}
final String str2 = str.toString();
if (str2.toLowerCase()
.endsWith(suffix.toString()
.toLowerCase()))
{
return subPre(str2, str2.length() - suffix.length());
}
return str2;
}
/**
* 首字母变小写
*
* @param str 字符串
* @return {String}
*/
public static String firstCharToLower(String str)
{
char firstChar = str.charAt(0);
if (firstChar >= CharPool.UPPER_A && firstChar <= CharPool.UPPER_Z)
{
char[] arr = str.toCharArray();
arr[0] += CharPool.LOWER_A - CharPool.UPPER_A;
return new String(arr);
}
return str;
}
/**
* 首字母变大写
*
* @param str 字符串
* @return {String}
*/
public static String firstCharToUpper(String str)
{
char firstChar = str.charAt(0);
if (firstChar >= CharPool.LOWER_A && firstChar <= CharPool.LOWER_Z)
{
char[] arr = str.toCharArray();
arr[0] -= CharPool.LOWER_A - CharPool.UPPER_A;
return new String(arr);
}
return str;
}
/**
* 切割指定位置之前部分的字符串
*
* @param string 字符串
* @param toIndex 切割到的位置（不包括）
* @return 切割后的剩余的前半部分字符串
*/
public static String subPre(CharSequence string, int toIndex)
{
return sub(string, 0, toIndex);
}
/**
* 切割指定位置之后部分的字符串
*
* @param string 字符串
* @param fromIndex 切割开始的位置（包括）
* @return 切割后后剩余的后半部分字符串
*/
public static String subSuf(CharSequence string, int fromIndex)
{
if (isEmpty(string))
{
return null;
}
return sub(string, fromIndex, string.length());
}
/**
* 指定范围内查找指定字符
*
* @param str 字符串
* @param searchChar 被查找的字符
* @return 位置
*/
public static int indexOf(final CharSequence str, char searchChar)
{
return indexOf(str, searchChar, 0);
}
/**
* 指定范围内查找指定字符
*
* @param str 字符串
* @param searchChar 被查找的字符
* @param start 起始位置，如果小于0，从0开始查找
* @return 位置
*/
public static int indexOf(final CharSequence str, char searchChar, int start)
{
if (str instanceof String)
{
return ((String) str)
.indexOf(searchChar, start);
}
else
{
return indexOf(str, searchChar, start, -1);
}
}
/**
* 指定范围内查找指定字符
*
* @param str 字符串
* @param searchChar 被查找的字符
* @param start 起始位置，如果小于0，从0开始查找
* @param end 终止位置，如果超过str.length()则默认查找到字符串末尾
* @return 位置
*/
public static int indexOf(final CharSequence str, char searchChar, int start, int end)
{
final int len = str.length();
if (start < 0 || start > len)
{
start = 0;
}
if (end > len || end < 0)
{
end = len;
}
for (int i = start; i < end; i++)
{
if (str.charAt(i) == searchChar)
{
return i;
}
}
return -1;
}
/**
* 指定范围内查找字符串，忽略大小写<br>
*
* <pre>
* StringUtil.indexOfIgnoreCase(null, *, *) = -1
* StringUtil.indexOfIgnoreCase(*, null, *) = -1
* StringUtil.indexOfIgnoreCase("", "", 0) = 0
* StringUtil.indexOfIgnoreCase("aabaabaa", "A", 0) = 0
* StringUtil.indexOfIgnoreCase("aabaabaa", "B", 0) = 2
* StringUtil.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
* StringUtil.indexOfIgnoreCase("aabaabaa", "B", 3) = 5
* StringUtil.indexOfIgnoreCase("aabaabaa", "B", 9) = -1
* StringUtil.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
* StringUtil.indexOfIgnoreCase("aabaabaa", "", 2) = 2
* StringUtil.indexOfIgnoreCase("abc", "", 9) = -1
* </pre>
*
* @param str 字符串
* @param searchStr 需要查找位置的字符串
* @return 位置
* @since 3.2.1
*/
public static int indexOfIgnoreCase(final CharSequence str, final CharSequence searchStr)
{
return indexOfIgnoreCase(str, searchStr, 0);
}
/**
* 指定范围内查找字符串
*
* <pre>
* StringUtil.indexOfIgnoreCase(null, *, *) = -1
* StringUtil.indexOfIgnoreCase(*, null, *) = -1
* StringUtil.indexOfIgnoreCase("", "", 0) = 0
* StringUtil.indexOfIgnoreCase("aabaabaa", "A", 0) = 0
* StringUtil.indexOfIgnoreCase("aabaabaa", "B", 0) = 2
* StringUtil.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1
* StringUtil.indexOfIgnoreCase("aabaabaa", "B", 3) = 5
* StringUtil.indexOfIgnoreCase("aabaabaa", "B", 9) = -1
* StringUtil.indexOfIgnoreCase("aabaabaa", "B", -1) = 2
* StringUtil.indexOfIgnoreCase("aabaabaa", "", 2) = 2
* StringUtil.indexOfIgnoreCase("abc", "", 9) = -1
* </pre>
*
* @param str 字符串
* @param searchStr 需要查找位置的字符串
* @param fromIndex 起始位置
* @return 位置
* @since 3.2.1
*/
public static int indexOfIgnoreCase(final CharSequence str, final CharSequence searchStr, int fromIndex)
{
return indexOf(str, searchStr, fromIndex, true);
}
/**
* 指定范围内反向查找字符串
*
* @param str 字符串
* @param searchStr 需要查找位置的字符串
* @param fromIndex 起始位置
* @param ignoreCase 是否忽略大小写
* @return 位置
* @since 3.2.1
*/
public static int indexOf(final CharSequence str, CharSequence searchStr, int fromIndex, boolean ignoreCase)
{
if (str == null || searchStr == null)
{
return INDEX_NOT_FOUND;
}
if (fromIndex < 0)
{
fromIndex = 0;
}
final int endLimit = str.length() - searchStr.length() + 1;
if (fromIndex > endLimit)
{
return INDEX_NOT_FOUND;
}
if (searchStr.length() == 0)
{
return fromIndex;
}
if (false == ignoreCase)
{
// 不忽略大小写调用JDK方法
return str.toString()
.indexOf(searchStr.toString(), fromIndex);
}
for (int i = fromIndex; i < endLimit; i++)
{
if (isSubEquals(str, i, searchStr, 0, searchStr.length(), true))
{
return i;
}
}
return INDEX_NOT_FOUND;
}
/**
* 指定范围内查找字符串，忽略大小写<br>
*
* @param str 字符串
* @param searchStr 需要查找位置的字符串
* @return 位置
* @since 3.2.1
*/
public static int lastIndexOfIgnoreCase(final CharSequence str, final CharSequence searchStr)
{
return lastIndexOfIgnoreCase(str, searchStr, str.length());
}
/**
* 指定范围内查找字符串，忽略大小写<br>
*
* @param str 字符串
* @param searchStr 需要查找位置的字符串
* @param fromIndex 起始位置，从后往前计数
* @return 位置
* @since 3.2.1
*/
public static int lastIndexOfIgnoreCase(final CharSequence str, final CharSequence searchStr, int fromIndex)
{
return lastIndexOf(str, searchStr, fromIndex, true);
}
/**
* 指定范围内查找字符串<br>
*
* @param str 字符串
* @param searchStr 需要查找位置的字符串
* @param fromIndex 起始位置，从后往前计数
* @param ignoreCase 是否忽略大小写
* @return 位置
* @since 3.2.1
*/
public static int lastIndexOf(final CharSequence str, final CharSequence searchStr, int fromIndex, boolean ignoreCase)
{
if (str == null || searchStr == null)
{
return INDEX_NOT_FOUND;
}
if (fromIndex < 0)
{
fromIndex = 0;
}
fromIndex = Math.min(fromIndex, str.length());
if (searchStr.length() == 0)
{
return fromIndex;
}
if (!ignoreCase)
{
// 不忽略大小写调用JDK方法
return str.toString()
.lastIndexOf(searchStr.toString(), fromIndex);
}
for (int i = fromIndex; i > 0; i--)
{
if (isSubEquals(str, i, searchStr, 0, searchStr.length(), true))
{
return i;
}
}
return INDEX_NOT_FOUND;
}
/**
* 返回字符串 searchStr 在字符串 str 中第 ordinal 次出现的位置。<br>
* 此方法来自：Apache-Commons-Lang
* <p>
* 栗子（*代表任意字符）：
*
* <pre>
* StringUtil.ordinalIndexOf(null, *, *) = -1
* StringUtil.ordinalIndexOf(*, null, *) = -1
* StringUtil.ordinalIndexOf("", "", *) = 0
* StringUtil.ordinalIndexOf("aabaabaa", "a", 1) = 0
* StringUtil.ordinalIndexOf("aabaabaa", "a", 2) = 1
* StringUtil.ordinalIndexOf("aabaabaa", "b", 1) = 2
* StringUtil.ordinalIndexOf("aabaabaa", "b", 2) = 5
* StringUtil.ordinalIndexOf("aabaabaa", "ab", 1) = 1
* StringUtil.ordinalIndexOf("aabaabaa", "ab", 2) = 4
* StringUtil.ordinalIndexOf("aabaabaa", "", 1) = 0
* StringUtil.ordinalIndexOf("aabaabaa", "", 2) = 0
* </pre>
*
* @param str 被检查的字符串，可以为null
* @param searchStr 被查找的字符串，可以为null
* @param ordinal 第几次出现的位置
* @return 查找到的位置
* @since 3.2.3
*/
public static int ordinalIndexOf(String str, String searchStr, int ordinal)
{
if (str == null || searchStr == null || ordinal <= 0)
{
return INDEX_NOT_FOUND;
}
if (searchStr.length() == 0)
{
return 0;
}
int found = 0;
int index = INDEX_NOT_FOUND;
do {
index = str.indexOf(searchStr, index + 1);
if (index < 0)
{
return index;
}
found++;
} while (found < ordinal);
return index;
}
/**
* 截取两个字符串的不同部分（长度一致），判断截取的子串是否相同<br>
* 任意一个字符串为null返回false
*
* @param str1 第一个字符串
* @param start1 第一个字符串开始的位置
* @param str2 第二个字符串
* @param start2 第二个字符串开始的位置
* @param length 截取长度
* @param ignoreCase 是否忽略大小写
* @return 子串是否相同
* @since 3.2.1
*/
public static boolean isSubEquals(CharSequence str1, int start1, CharSequence str2, int start2, int length, boolean ignoreCase)
{
if (null == str1 || null == str2)
{
return false;
}
return str1.toString()
.regionMatches(ignoreCase, start1, str2.toString(), start2, length);
}
/**
* 比较两个字符串（大小写敏感）。
*
* <pre>
* equalsIgnoreCase(null, null) = true
* equalsIgnoreCase(null, "abc") = false
* equalsIgnoreCase("abc", null) = false
* equalsIgnoreCase("abc", "abc") = true
* equalsIgnoreCase("abc", "ABC") = true
* </pre>
*
* @param str1 要比较的字符串1
* @param str2 要比较的字符串2
* @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code>
*/
public static boolean equals(CharSequence str1, CharSequence str2)
{
return equals(str1, str2, false);
}
/**
* 比较两个字符串（大小写不敏感）。
*
* <pre>
* equalsIgnoreCase(null, null) = true
* equalsIgnoreCase(null, "abc") = false
* equalsIgnoreCase("abc", null) = false
* equalsIgnoreCase("abc", "abc") = true
* equalsIgnoreCase("abc", "ABC") = true
* </pre>
*
* @param str1 要比较的字符串1
* @param str2 要比较的字符串2
* @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code>
*/
public static boolean equalsIgnoreCase(CharSequence str1, CharSequence str2)
{
return equals(str1, str2, true);
}
/**
* 比较两个字符串是否相等。
*
* @param str1 要比较的字符串1
* @param str2 要比较的字符串2
* @param ignoreCase 是否忽略大小写
* @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code>
* @since 3.2.0
*/
public static boolean equals(CharSequence str1, CharSequence str2, boolean ignoreCase)
{
if (null == str1)
{
// 只有两个都为null才判断相等
return str2 == null;
}
if (null == str2)
{
// 字符串2空，字符串1非空，直接false
return false;
}
if (ignoreCase)
{
return str1.toString()
.equalsIgnoreCase(str2.toString());
}
else
{
return str1.equals(str2);
}
}
/**
* 创建StringBuilder对象
*
* @return StringBuilder对象
*/
public static StringBuilder builder()
{
return new StringBuilder();
}
/**
* 创建StringBuilder对象
*
* @param capacity 初始大小
* @return StringBuilder对象
*/
public static StringBuilder builder(int capacity)
{
return new StringBuilder(capacity);
}
/**
* 创建StringBuilder对象
*
* @param strs 初始字符串列表
* @return StringBuilder对象
*/
public static StringBuilder builder(CharSequence...strs)
{
final StringBuilder sb = new StringBuilder();
for (CharSequence str: strs)
{
sb.append(str);
}
return sb;
}
/**
* 创建StringBuilder对象
*
* @param sb 初始StringBuilder
* @param strs 初始字符串列表
* @return StringBuilder对象
*/
public static StringBuilder appendBuilder(StringBuilder sb, CharSequence...strs)
{
for (CharSequence str: strs)
{
sb.append(str);
}
return sb;
}
/**
* 获得StringReader
*
* @param str 字符串
* @return StringReader
*/
public static StringReader getReader(CharSequence str)
{
if (null == str)
{
return null;
}
return new StringReader(str.toString());
}
/**
* 获得StringWriter
*
* @return StringWriter
*/
public static StringWriter getWriter()
{
return new StringWriter();
}
/**
* 统计指定内容中包含指定字符的数量
*
* @param content 内容
* @param charForSearch 被统计的字符
* @return 包含数量
*/
public static int count(CharSequence content, char charForSearch)
{
int count = 0;
if (isEmpty(content))
{
return 0;
}
int contentLength = content.length();
for (int i = 0; i < contentLength; i++)
{
if (charForSearch == content.charAt(i))
{
count++;
}
}
return count;
}
/**
* 下划线转驼峰
*
* @param para 字符串
* @return String
*/
public static String underlineToHump(String para)
{
StringBuilder result = new StringBuilder();
String[] a = para.split("_");
for (String s: a)
{
if (result.length() == 0)
{
result.append(s.toLowerCase());
}
else
{
result.append(s.substring(0, 1)
.toUpperCase());
result.append(s.substring(1)
.toLowerCase());
}
}
return result.toString();
}
/**
* 驼峰转下划线
*
* @param para 字符串
* @return String
*/
public static String humpToUnderline(String para)
{
para = firstCharToLower(para);
StringBuilder sb = new StringBuilder(para);
int temp = 0;
for (int i = 0; i < para.length(); i++)
{
if (Character.isUpperCase(para.charAt(i)))
{
sb.insert(i + temp, "_");
temp += 1;
}
}
return sb.toString()
.toLowerCase();
}
/**
* 横线转驼峰
*
* @param para 字符串
* @return String
*/
public static String lineToHump(String para)
{
StringBuilder result = new StringBuilder();
String[] a = para.split("-");
for (String s: a)
{
if (result.length() == 0)
{
result.append(s.toLowerCase());
}
else
{
result.append(s.substring(0, 1)
.toUpperCase());
result.append(s.substring(1)
.toLowerCase());
}
}
return result.toString();
}
/**
* 驼峰转横线
*
* @param para 字符串
* @return String
*/
public static String humpToLine(String para)
{
para = firstCharToLower(para);
StringBuilder sb = new StringBuilder(para);
int temp = 0;
for (int i = 0; i < para.length(); i++)
{
if (Character.isUpperCase(para.charAt(i)))
{
sb.insert(i + temp, "-");
temp += 1;
}
}
return sb.toString()
.toLowerCase();
}
/**
* trimToEmpty
*
* @param str 字符串
* @return String
*/
public static String trimToEmpty(String str)
{
return str == null ? "" : str.trim();
}
/**
* 替换是否忽略大小写
*
* @param text 字符串
* @param searchString 旧的字符串
* @param replacement 新的字符串
* @param ignoreCase true:忽略，false:不忽略
* @return String
*/
public static String replaceIgnoreCase(String text, String searchString, String replacement, boolean ignoreCase)
{
return replace(text, searchString, replacement, -1, ignoreCase);
}
private static String replace(String text, String searchString, String replacement, int max, boolean ignoreCase)
{
if (!isEmpty(text) && !isEmpty(searchString) && replacement != null && max != 0)
{
if (ignoreCase)
{
searchString = searchString.toLowerCase();
}
int start = 0;
int end = indexOf(text, searchString, start, ignoreCase);
if (end == -1)
{
return text;
}
else
{
int replLength = searchString.length();
int increase = replacement.length() - replLength;
increase = increase < 0 ? 0 : increase;
increase *= max < 0 ? 16 : (max > 64 ? 64 : max);
StringBuilder buf;
for (buf = new StringBuilder(text.length() + increase); end != -1; end = indexOf(text, searchString, start, ignoreCase))
{
buf.append(text, start, end)
.append(replacement);
start = end + replLength;
--max;
if (max == 0)
{
break;
}
}
buf.append(text, start, text.length());
return buf.toString();
}
}
else
{
return text;
}
}
/**
* 正则替换字符串
*
* @param content 字符串
* @param pattern 正则表达式
* @param newString 新的替换字符串
* @return String
*/
public static String regReplace(String content, String pattern, String newString)
{
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(content);
String result = m.replaceAll(newString);
return result;
}
}
字符串切分类
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 字符串切分器
*
* @author Looly
*/
public class StrSpliter
{
//---------------------------------------------------------------------------------------------- Split by char
/**
* 切分字符串路径，仅支持Unix分界符：/
*
* @param str 被切分的字符串
* @return 切分后的集合
* @since 3.0.8
*/
public static List < String > splitPath(String str)
{
return splitPath(str, 0);
}
/**
* 切分字符串路径，仅支持Unix分界符：/
*
* @param str 被切分的字符串
* @return 切分后的集合
* @since 3.0.8
*/
public static String[] splitPathToArray(String str)
{
return toArray(splitPath(str));
}
/**
* 切分字符串路径，仅支持Unix分界符：/
*
* @param str 被切分的字符串
* @param limit 限制分片数
* @return 切分后的集合
* @since 3.0.8
*/
public static List < String > splitPath(String str, int limit)
{
return split(str, StringPool.SLASH, limit, true, true);
}
/**
* 切分字符串路径，仅支持Unix分界符：/
*
* @param str 被切分的字符串
* @param limit 限制分片数
* @return 切分后的集合
* @since 3.0.8
*/
public static String[] splitPathToArray(String str, int limit)
{
return toArray(splitPath(str, limit));
}
/**
* 切分字符串
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
public static List < String > splitTrim(String str, char separator, boolean ignoreEmpty)
{
return split(str, separator, 0, true, ignoreEmpty);
}
/**
* 切分字符串
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static List < String > split(String str, char separator, boolean isTrim, boolean ignoreEmpty)
{
return split(str, separator, 0, isTrim, ignoreEmpty);
}
/**
* 切分字符串，大小写敏感，去除每个元素两边空白符
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static List < String > splitTrim(String str, char separator, int limit, boolean ignoreEmpty)
{
return split(str, separator, limit, true, ignoreEmpty, false);
}
/**
* 切分字符串，大小写敏感
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static List < String > split(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty)
{
return split(str, separator, limit, isTrim, ignoreEmpty, false);
}
/**
* 切分字符串，忽略大小写
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
public static List < String > splitIgnoreCase(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty)
{
return split(str, separator, limit, isTrim, ignoreEmpty, true);
}
/**
* 切分字符串
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数，-1不限制
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @param ignoreCase 是否忽略大小写
* @return 切分后的集合
* @since 3.2.1
*/
public static List < String > split(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty, boolean ignoreCase)
{
if (StringUtil.isEmpty(str))
{
return new ArrayList < String > (0);
}
if (limit == 1)
{
return addToList(new ArrayList < String > (1), str, isTrim, ignoreEmpty);
}
final ArrayList < String > list = new ArrayList < > (limit > 0 ? limit : 16);
int len = str.length();
int start = 0;
for (int i = 0; i < len; i++)
{
if (Objects.equals(separator, str.charAt(i)))
{
addToList(list, str.substring(start, i), isTrim, ignoreEmpty);
start = i + 1;
//检查是否超出范围（最大允许limit-1个，剩下一个留给末尾字符串）
if (limit > 0 && list.size() > limit - 2)
{
break;
}
}
}
return addToList(list, str.substring(start, len), isTrim, ignoreEmpty);
}
/**
* 切分字符串为字符串数组
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static String[] splitToArray(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty)
{
return toArray(split(str, separator, limit, isTrim, ignoreEmpty));
}
//---------------------------------------------------------------------------------------------- Split by String
/**
* 切分字符串，不忽略大小写
*
* @param str 被切分的字符串
* @param separator 分隔符字符串
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static List < String > split(String str, String separator, boolean isTrim, boolean ignoreEmpty)
{
return split(str, separator, -1, isTrim, ignoreEmpty, false);
}
/**
* 切分字符串，去除每个元素两边空格，忽略大小写
*
* @param str 被切分的字符串
* @param separator 分隔符字符串
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
public static List < String > splitTrim(String str, String separator, boolean ignoreEmpty)
{
return split(str, separator, true, ignoreEmpty);
}
/**
* 切分字符串，不忽略大小写
*
* @param str 被切分的字符串
* @param separator 分隔符字符串
* @param limit 限制分片数
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static List < String > split(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty)
{
return split(str, separator, limit, isTrim, ignoreEmpty, false);
}
/**
* 切分字符串，去除每个元素两边空格，忽略大小写
*
* @param str 被切分的字符串
* @param separator 分隔符字符串
* @param limit 限制分片数
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
public static List < String > splitTrim(String str, String separator, int limit, boolean ignoreEmpty)
{
return split(str, separator, limit, true, ignoreEmpty);
}
/**
* 切分字符串，忽略大小写
*
* @param str 被切分的字符串
* @param separator 分隔符字符串
* @param limit 限制分片数
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
public static List < String > splitIgnoreCase(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty)
{
return split(str, separator, limit, isTrim, ignoreEmpty, true);
}
/**
* 切分字符串，去除每个元素两边空格，忽略大小写
*
* @param str 被切分的字符串
* @param separator 分隔符字符串
* @param limit 限制分片数
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.2.1
*/
public static List < String > splitTrimIgnoreCase(String str, String separator, int limit, boolean ignoreEmpty)
{
return split(str, separator, limit, true, ignoreEmpty, true);
}
/**
* 切分字符串
*
* @param str 被切分的字符串
* @param separator 分隔符字符串
* @param limit 限制分片数
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @param ignoreCase 是否忽略大小写
* @return 切分后的集合
* @since 3.2.1
*/
public static List < String > split(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty, boolean ignoreCase)
{
if (StringUtil.isEmpty(str))
{
return new ArrayList < String > (0);
}
if (limit == 1)
{
return addToList(new ArrayList < String > (1), str, isTrim, ignoreEmpty);
}
if (StringUtil.isEmpty(separator))
{
return split(str, limit);
}
else if (separator.length() == 1)
{
return split(str, separator.charAt(0), limit, isTrim, ignoreEmpty, ignoreCase);
}
final ArrayList < String > list = new ArrayList < > ();
int len = str.length();
int separatorLen = separator.length();
int start = 0;
int i = 0;
while (i < len)
{
i = StringUtil.indexOf(str, separator, start, ignoreCase);
if (i > -1)
{
addToList(list, str.substring(start, i), isTrim, ignoreEmpty);
start = i + separatorLen;
//检查是否超出范围（最大允许limit-1个，剩下一个留给末尾字符串）
if (limit > 0 && list.size() > limit - 2)
{
break;
}
}
else
{
break;
}
}
return addToList(list, str.substring(start, len), isTrim, ignoreEmpty);
}
/**
* 切分字符串为字符串数组
*
* @param str 被切分的字符串
* @param separator 分隔符字符
* @param limit 限制分片数
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static String[] splitToArray(String str, String separator, int limit, boolean isTrim, boolean ignoreEmpty)
{
return toArray(split(str, separator, limit, isTrim, ignoreEmpty));
}
//---------------------------------------------------------------------------------------------- Split by Whitespace
/**
* 使用空白符切分字符串<br>
* 切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一
*
* @param str 被切分的字符串
* @param limit 限制分片数
* @return 切分后的集合
* @since 3.0.8
*/
public static List < String > split(String str, int limit)
{
if (StringUtil.isEmpty(str))
{
return new ArrayList < String > (0);
}
if (limit == 1)
{
return addToList(new ArrayList < String > (1), str, true, true);
}
final ArrayList < String > list = new ArrayList < > ();
int len = str.length();
int start = 0;
for (int i = 0; i < len; i++)
{
if (StringUtil.isEmpty(str.charAt(i)))
{
addToList(list, str.substring(start, i), true, true);
start = i + 1;
if (limit > 0 && list.size() > limit - 2)
{
break;
}
}
}
return addToList(list, str.substring(start, len), true, true);
}
/**
* 切分字符串为字符串数组
*
* @param str 被切分的字符串
* @param limit 限制分片数
* @return 切分后的集合
* @since 3.0.8
*/
public static String[] splitToArray(String str, int limit)
{
return toArray(split(str, limit));
}
//---------------------------------------------------------------------------------------------- Split by regex
/**
* 通过正则切分字符串
*
* @param str 字符串
* @param separatorPattern 分隔符正则{@link Pattern}
* @param limit 限制分片数
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static List < String > split(String str, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty)
{
if (StringUtil.isEmpty(str))
{
return new ArrayList < String > (0);
}
if (limit == 1)
{
return addToList(new ArrayList < String > (1), str, isTrim, ignoreEmpty);
}
if (null == separatorPattern)
{
return split(str, limit);
}
final Matcher matcher = separatorPattern.matcher(str);
final ArrayList < String > list = new ArrayList < > ();
int len = str.length();
int start = 0;
while (matcher.find())
{
addToList(list, str.substring(start, matcher.start()), isTrim, ignoreEmpty);
start = matcher.end();
if (limit > 0 && list.size() > limit - 2)
{
break;
}
}
return addToList(list, str.substring(start, len), isTrim, ignoreEmpty);
}
/**
* 通过正则切分字符串为字符串数组
*
* @param str 被切分的字符串
* @param separatorPattern 分隔符正则{@link Pattern}
* @param limit 限制分片数
* @param isTrim 是否去除切分字符串后每个元素两边的空格
* @param ignoreEmpty 是否忽略空串
* @return 切分后的集合
* @since 3.0.8
*/
public static String[] splitToArray(String str, Pattern separatorPattern, int limit, boolean isTrim, boolean ignoreEmpty)
{
return toArray(split(str, separatorPattern, limit, isTrim, ignoreEmpty));
}
//---------------------------------------------------------------------------------------------- Split by length
/**
* 根据给定长度，将给定字符串截取为多个部分
*
* @param str 字符串
* @param len 每一个小节的长度
* @return 截取后的字符串数组
*/
public static String[] splitByLength(String str, int len)
{
int partCount = str.length() / len;
int lastPartCount = str.length() % len;
int fixPart = 0;
if (lastPartCount != 0)
{
fixPart = 1;
}
final String[] strs = new String[partCount + fixPart];
for (int i = 0; i < partCount + fixPart; i++)
{
if (i == partCount + fixPart - 1 && lastPartCount != 0)
{
strs[i] = str.substring(i * len, i * len + lastPartCount);
}
else
{
strs[i] = str.substring(i * len, i * len + len);
}
}
return strs;
}
//---------------------------------------------------------------------------------------------------------- Private method start
/**
* 将字符串加入List中
*
* @param list 列表
* @param part 被加入的部分
* @param isTrim 是否去除两端空白符
* @param ignoreEmpty 是否略过空字符串（空字符串不做为一个元素）
* @return 列表
*/
private static List < String > addToList(List < String > list, String part, boolean isTrim, boolean ignoreEmpty)
{
part = part.toString();
if (isTrim)
{
part = part.trim();
}
if (false == ignoreEmpty || false == part.isEmpty())
{
list.add(part);
}
return list;
}
/**
* List转Array
*
* @param list List
* @return Array
*/
private static String[] toArray(List < String > list)
{
return list.toArray(new String[list.size()]);
}
//---------------------------------------------------------------------------------------------------------- Private method end
}
获取Token工具类
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import java.util.HashMap;
import java.util.Map; @Slf4j
@Component
public class TokenUtil
{
@Autowired
private RestTemplateUtil restTemplateUtil;
public String getToken(String username, String password, String url)
{
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.APPLICATION_JSON);
//设置参数
JSONObject json = new JSONObject();
json.put("username", username);
json.put("password", password);
HttpEntity < Object > requestEntity = new HttpEntity < > (json, httpHeaders);
RestTemplate restTemplate = new RestTemplate();
ResponseEntity < String > responseEntity = restTemplate.postForEntity(url, requestEntity, String.class);
String result = responseEntity.getBody();
log.info(result);
JSONObject object = JSONObject.parseObject(result);
Integer code = object.getInteger("code");
if (code == HttpStatus.OK.value())
{
return object.getString("token");
}
else
{
log.error("获取token失败");
return "";
}
}
}
有用的工具类（Java）的更多相关文章
- JavaSE-基础语法(二)-系统类(java.lang.*)和工具类(java.util.*)
系统类(java.lang.*)和工具类(java.util.*) 一.系统类(java.lang.*) 这个包下包含java语言的核心类,如String.Math.System和Thread类等,使 ...
- 获取Spring容器中Bean实例的工具类(Java泛型方法实现)
在使用Spring做IoC容器的时候,有的类不方便直接注入bean,需要手动获得一个类型的bean. 因此,实现一个获得bean实例的工具类,就很有必要. 以前,写了一个根据bean的名称和类型获取b ...
- 一些非常有用的工具类之javamail（from韩顺平）
之前编写一个类淘宝服务器时,需要使用javamail发送邮件,搜到的一个工具类,很有用. 需要下载导入:activation.jar和mail.jar package com.cx.service; ...
- 加密解密工具类(Java,DES)
一个Java版的DES加密工具类,能够用来进行网络传输数据加密,保存password的时候进行加密. import java.security.Key; import java.security.sp ...
- java工具类——java将一串数据按照gzip方式压缩和解压缩
我要整理在工作中用到的工具类分享出来,也方便自己以后查阅使用,这些工具类都是我自己实际工作中使用的 import java.io.ByteArrayInputStream; import java.i ...
- redis集群使用Java工具类(Java jedis集群工具类)
package com.xiaomi.weather.vote.webservices.util.redisCache; import com.google.common.base.Strings; ...
- Redis 工具类 java 实现的redis 工具类
最近了解了一下非关系型数据库 redis 会使用简单的命令 在自己本地电脑 使用时必须先启动服务器端 在启动客户端 redis 简介 Redis是一个开源的使用ANSI C语言编写.支持网络.可基于内 ...
- Http请求工具类(Java原生Form+Json)
package com.tzx.cc.common.constant.util; import java.io.IOException; import java.io.InputStream; imp ...
- 005-guava 集合-集合工具类-java.util.Collections中未包含的集合工具[Maps,Lists,Sets]，Iterables、Multisets、Multimaps、Tables
一.概述 工具类与特定集合接口的对应关系归纳如下: 集合接口 属于JDK还是Guava 对应的Guava工具类 Collection JDK Collections2:不要和java.util.Col ...
- 二维码生成工具类java版
注意:这里我不提供所需jar包的路径,我会把所有引用的jar包显示出来,大家自行Google package com.net.util; import java.awt.BasicStroke; im ...
随机推荐
- WCF 动态调用 动态代理
关键词:WCF动态调用.动态调用WCF.WCF使用动态代理精简代码架构.使用反射执行WCF接口 代码地址: https://gitee.com/s0611163/DynamicWCF https:// ...
- Java 键值对数据本地保存与读取
代码: package com.sux.demo.utils; import com.alibaba.fastjson.JSONObject; import java.io.File; import ...
- Problem 1342B - Binary Period （思维）
AC代码: #include<bits/stdc++.h> using namespace std; int main() { //freopen("in.txt", ...
- 类加载机制-深入理解jvm
一.什么是类的加载: 如上图,java文件通过编译器变成了.class文件,接下来类加载器又将这些.class文件加载到JVM中.其中类装载器的作用其实就是类的加载. 二.原理 (类的加载过程及其最终 ...
- mybatis-plus数据批量插入
为了提高数据处理效率,大量数据需要插入数据时可以采用批量数据插入的策略提高数据插入的效率. 如下是实现方法 1.代码结构 2.实体类 package little.tiger.one.applicat ...
- 【RK3399】1.RK3399开发板基础配置
最近在小黄鱼入手了一个RK3399的开发板,RK的芯片我也是第一次使用.FireFly配套提供了完善的教程,可以在他们的WIKI上找到.上面有的内容就不在本文叙述了,大家可以参考教程https://w ...
- 简易机器学习笔记（九）LeNet实例 - 在眼疾识别数据集iChallenge-PM上的应用
前言 上一节大概讲了一下LeNet的内容,这一章就直接来用,实际上用一下LeNet来进行训练和分类试试. 调用的数据集: https://aistudio.baidu.com/datasetdetai ...
- java进阶(14)--日期时间处理
一.获取系统当前时间: 1.Date(),精确到毫秒的当前当前时间 2.示例,欧美风格时间格式
- crypto常用工具
古典密码 维吉尼亚密码(Vigenere): https://github.com/atomcated/Vigenere(加密解密程序,包含自动猜测密钥功能) https://www.guballa. ...
- spring——DI_依赖注入
Spring的注入方式 Dependency Injection 概念 依赖注入(Dependency Injection) 依赖:指Bean对象的创建依赖于容器,Bean对象的依赖资源 注入:指Be ...