有用的工具类（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 ...
随机推荐
- # 0x56 动态规划-状态压缩DP
0x56 动态规划-状态压缩DP Mondriaan's Dream Description Squares and rectangles fascinated the famous Dutch pa ...
- 源码深度解析 Handler 机制及应用
本文以源码分析+实际应用的形式,详细讲解了 Handler 机制的原理,以及在开发中的使用场景和要注意的地方. 一.基本原理回顾 在 Android 开发中,Handler及相关衍生类的应用经常用到, ...
- 去重N皇后
题目:将上下对称.左右对称棋局.主副对角线对称棋局和旋转后重复视为重复,则要求输出去重后的N皇后问题的棋盘布局 这道题是一道作业题,我都惊到了,一向弱智的作业题中竟然冒出一道这样的题,这题最起码橙黄之 ...
- java进阶(4)--抽象类与接口的区别
1.抽象类是半抽象的,接口是全抽象的 2.抽象类中有构造方法,接口中没有构造方法 3.类与类之间不能多继承,接口与接口之间支持多继承 4.一个类可以同时实现多个接口,一个类只能继承一个抽象 ...
- OpenShift image registry 访问镜像
1. OpenShift 内部 image registry Openshift 自带内部 image registry,可通过 podman 实现 image 的 pull 和 push 操作. 对 ...
- 【日常踩坑】解决 kex_exchange_identification 报错
目录 踩坑 原因分析 解决办法 1. 临时关闭代理 2. 修改代理软件配置,22 端口走直连 3. 改用 HTTPS 协议,走 443 端口 参考资料 踩坑 最近在使用 git 时,发现 git pu ...
- 【TouchGFX】MVP 示例分析
控制流 数据流 硬按键改变View界面内容 backend --> model --> presenter --> view View button 控制电路板LED亮灭 vi ...
- java - 字符串转数字
Integer.valueOf("str").intValue(): Integer.valueOf("123").intValue():
- 使用Java分析器优化代码性能，解决OOM问题
有的时候博客内容会有变动,首发博客是最新的,其他博客地址可能会未同步,认准https://blog.zysicyj.top 首发博客地址 背景 最近我一直在做性能优化,对一个单机应用做性能优化.主要是 ...
- [转帖]oracle中Rman增量备份下各级别level的区别
RMAN备份分为全备和增量备份两部分 增量备份:分为0 1 2级 ORACLE官方解释: A level 1 incremental backup can be either of the foll ...