1、该类的作用是将格式为["","",""......]的字符串转换为数组，或将数组转换成格式为["","",""......]的字符串
import com.clfps.utils.StringUtils;
import java.util.ArrayList;
import java.util.List;
/**
*
* * @projectName **-parent
* * @title StingTransfersBetweenArryUtils
* * @package com.**.util
* * @description 该类的作用是将格式为["","",""......]的字符串转换为数组，或将数组转换成格式为["","",""......]的字符串
* * @author IT_CREAT
* * @date
* * @version V1.0.0
*
*/
public class StringBetweenArryUtils {
public static List<String> string2ArryList(String s){
if(StringUtils.isEmpty(s)){
return null;
}
String s1 = s.substring(1,s.length()-1);
String[] sArry = s1.split(",");
List<String> strList = new ArrayList<>();
for(String str : sArry){
String str2 = str.substring(1,str.length()-1);
strList.add(str2);
}
return strList;
}
public static String[] string2Arry(String s){
if(StringUtils.isEmpty(s)){
return null;
}
List<String> list = string2ArryList(s);
String[] strs = new String[list.size()];
list.toArray(strs);
return strs;
}
public static String arry2String(String[] strs){
if(null == strs || strs.length ==0){
return null;
}
String str = "[";
int sign = 0;
for(String s:strs){
if(sign < strs.length -1){
str = str + "\""+ s+ "\"" + ",";
}else{
str = str + "\""+ s + "\"";
}
sign++;
}
str = str +"]";
return str;
}
public static String arryList2String(List<String> strList){
if(null == strList || strList.size() ==0){
return null;
}
String str = "[";
int sign = 0;
for(String s:strList){
if(sign < strList.size() -1){
str = str + "\""+ s+ "\"" + ",";
}else{
str = str + "\""+ s + "\"";
}
sign++;
}
str = str +"]";
return str;
}
public static void main(String[] args) {
String regex = "['123','','123']";
String[] str = string2Arry(regex);
System.out.println(str.length);
for(String str1:str){
System.out.println(str1);
}
System.out.println(arry2String(str));
System.out.println(arryList2String(java.util.Arrays.asList(str)));
}
}2、驼峰命名与sql下划线字段之间的转换工具
/**
*
* * @projectName **-parent
* * @title HumpNamedTools
* * @package com.**.utils
* * @description 驼峰命名与sql下划线字段之间的转换工具
* * @author IT_CREAT
* * @date
* * @version V1.0.0
*
*/
public class HumpNamedTools {
/**
* 将驼峰式命名的字符串转换为下划线小写方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。</br>
* 例如：helloWorld->hello_word
* @param name 转换前的驼峰式命名的字符串
* @return 转换后下划线小写方式命名的字符串
*/
public static String hump2LowerColumnName(String name) {
StringBuilder result = new StringBuilder();
if (name != null && name.length() > 0) {
// 循环处理字符
for (int i = 0; i < name.length(); i++) {
String s = name.substring(i, i + 1);
// 在大写字母前添加下划线
if (s.equals(s.toUpperCase()) && !Character.isDigit(s.charAt(0))) {
result.append("_");
}
// 其他字符直接转成小写
result.append(s.toLowerCase());
}
}
return result.toString();
}
/**
* 将驼峰式命名的字符串转换为下划线大写方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。</br>
* 例如：HelloWorld->HELLO_WORLD
* @param name 转换前的驼峰式命名的字符串
* @return 转换后下划线大写方式命名的字符串
*/
public static String hump2UpperColumnName(String name) {
StringBuilder result = new StringBuilder();
if (name != null && name.length() > 0) {
// 将第一个字符处理成大写
result.append(name.substring(0, 1).toUpperCase());
// 循环处理其余字符
for (int i = 1; i < name.length(); i++) {
String s = name.substring(i, i + 1);
// 在大写字母前添加下划线
if (s.equals(s.toUpperCase()) && !Character.isDigit(s.charAt(0))) {
result.append("_");
}
// 其他字符直接转成大写
result.append(s.toUpperCase());
}
}
return result.toString();
}
/**
* 将下划线大写或小写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。</br>
* 例如：HELLO_WORLD->HelloWorld
* @param name 转换前的下划线大写或小写方式命名的字符串
* @return 转换后的驼峰式命名的字符串
*/
public static String column2HumpName(String name) {
StringBuilder result = new StringBuilder();
// 快速检查
if (name == null || name.isEmpty()) {
// 没必要转换
return "";
} else if (!name.contains("_")) {
// 不含下划线，仅将首字母小写
return name.substring(0, 1).toLowerCase() + name.substring(1);
}
// 用下划线将原始字符串分割
String camels[] = name.split("_");
for (String camel : camels) {
// 跳过原始字符串中开头、结尾的下换线或双重下划线
if (camel.isEmpty()) {
continue;
}
// 处理真正的驼峰片段
if (result.length() == 0) {
// 第一个驼峰片段，全部字母都小写
result.append(camel.toLowerCase());
} else {
// 其他的驼峰片段，首字母大写
result.append(camel.substring(0, 1).toUpperCase());
result.append(camel.substring(1).toLowerCase());
}
}
return result.toString();
}
public static void main(String[] args) {
System.out.println(column2HumpName("hello"));
System.out.println(hump2LowerColumnName("hello5Word"));
}
}
3、注解工具类，用于提取类中含有指定注解的属性和方法
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*
* * @projectName **-parent
* * @title AnnotationUtil
* * @package com.**.utils
* * @description 注解工具类
* * @author IT_CREAT
* * @date
* * @version V1.0.0
*
*/
public class AnnotationUtil {
/**
* 得到含有指定注解的类的属性名字的集合，返回list
*
* @param javaBean
* @param annotationClass
* @return
*/
public static List getVarHaveAnnotation(Object javaBean, Class<? extends Annotation> annotationClass) {
List list = new ArrayList();
//变量
Class<?> clazz = javaBean.getClass();
Field[] fs = clazz.getDeclaredFields();
Field[] sufs = clazz.getSuperclass().getDeclaredFields();
for (Field f : fs) {
if (null != annotationClass && f.isAnnotationPresent(annotationClass)) {
list.add(f.getName());
}
}
for (Field f : sufs) {
if (null != annotationClass && f.isAnnotationPresent(annotationClass)) {
list.add(f.getName());
}
}
return list;
}
/**
* 得到含有指定注解的类的方法名字的集合，返回list
*
* @param javaBean
* @param annotationClass
* @return
*/
public static List getMethodHaveAnnotation(Object javaBean, Class<? extends Annotation> annotationClass) {
List list = new ArrayList();
//方法
Class<?> clazz = javaBean.getClass();
Method[] ms = clazz.getDeclaredMethods();
Method[] sums = clazz.getSuperclass().getDeclaredMethods();
for (Method m : ms) {
if (null != annotationClass && m.isAnnotationPresent(annotationClass)) {
list.add(m.getName());
}
}
for (Method m : sums) {
if (null != annotationClass && m.isAnnotationPresent(annotationClass)) {
list.add(m.getName());
}
}
return list;
}
/**
* 得到对象上含有指定注解的属性名字，返回map,比如：有注解的属性有name,age,那么返回的map就是{name:name,age:age}
*
* @param javaBean
* @param annotationClass
* @return
*/
public static Map getVarMapHaveAnnotation(Object javaBean, Class<? extends Annotation> annotationClass) {
Map map = new HashMap();
//变量
Class<?> clazz = javaBean.getClass();
Field[] fs = clazz.getDeclaredFields();
Field[] sufs = clazz.getSuperclass().getDeclaredFields();
for (Field f : fs) {
if (null != annotationClass && f.isAnnotationPresent(annotationClass)) {
map.put(f.getName(), f.getName());
}
}
for (Field f : sufs) {
if (null != annotationClass && f.isAnnotationPresent(annotationClass)) {
map.put(f.getName(), f.getName());
}
}
return map;
}
/**
* 得到对象上含有指定注解的的方法名字，返回map,比如：有注解的属性有name,age,那么返回的map就是{name:name,age:age}
*
* @param javaBean
* @param annotationClass
* @return
*/
public static Map getMethodMapHaveAnnotation(Object javaBean, Class<? extends Annotation> annotationClass) {
Map map = new HashMap();
//方法
Class<?> clazz = javaBean.getClass();
Method[] ms = clazz.getDeclaredMethods();
Method[] sums = clazz.getSuperclass().getDeclaredMethods();
for (Method m : ms) {
if (null != annotationClass && m.isAnnotationPresent(annotationClass)) {
map.put(m.getName(), m.getName());
}
}
for (Method m : sums) {
if (null != annotationClass && m.isAnnotationPresent(annotationClass)) {
map.put(m.getName(), m.getName());
}
}
return map;
}
public static void main(String[] args) throws ClassNotFoundException {
Class<?> clazz = Class.forName("javax.persistence.Transient");
System.out.println(clazz.getName());
}
}
4、map和javabean对象相互转换工具类，同时该工具类还可以在将对象转为map时，去除对象中含指定注解的属性和空值属性，最后生成自己想要的map，需要引用上面的的注解工具类和驼峰转换类
package com.clfps.utils;
import org.springframework.util.ObjectUtils;
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.*;
/**
*
* * @projectName **-parent
* * @title MapAndJavaBeanUtil
* * @package com.**.utils
* * @description map和javabean对象相互转换工具类
* * @author IT_CREAT
* * @date
* * @version V1.0.0
*
*/
public class MapAndJavaBeanUtil {
/**
* 从map集合中获取属性值
*
* @param map
* @param key
* @param defaultValue
* @param <E>
* @return
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public final static <E> E get(Map map, Object key, E defaultValue) {
Object o = map.get(key);
if (o == null)
return defaultValue;
return (E) o;
}
/**
* Map集合对象转化成 JavaBean集合对象
*
* @param javaBean JavaBean实例对象
* @param mapList Map数据集对象
* @return
*/
@SuppressWarnings({"rawtypes"})
public static <T> List<T> map2JavaBean(T javaBean, List<Map> mapList) throws Exception {
if (mapList == null || mapList.isEmpty()) {
return null;
}
List<T> objectList = new ArrayList<T>();
T object = null;
for (Map map : mapList) {
if (map != null) {
object = map2JavaBean(javaBean, map);
objectList.add(object);
}
}
return objectList;
}
/**
* Map对象转化成 JavaBean对象
*
* @param javaBean JavaBean实例对象
* @param map Map对象
* @return
*/
@SuppressWarnings({"rawtypes", "unchecked", "hiding"})
public static <T> T map2JavaBean(T javaBean, Map map) throws Exception {
// 获取javaBean属性
BeanInfo beanInfo = Introspector.getBeanInfo(javaBean.getClass());
// 创建 JavaBean 对象
Object obj = javaBean.getClass().newInstance();
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
if (propertyDescriptors != null && propertyDescriptors.length > 0) {
String propertyName = null; // javaBean属性名
Object propertyValue = null; // javaBean属性值
for (PropertyDescriptor pd : propertyDescriptors) {
propertyName = pd.getName();
if (map.containsKey(propertyName)) {
propertyValue = map.get(propertyName);
pd.getWriteMethod().invoke(obj, new Object[]{propertyValue});
}
}
return (T) obj;
}
return null;
}
/**
* JavaBean对象转化成sql字段Map对象,移除指定注解字段，null即为不移除,同时移除为空值的字段，需要自己指定，true即为移除
* @param javaBean 传入对象
* @param removeNullValue 是否移除空字段
* @param annotationClass 传入注解的class 如：Transient.class，含有该注解的字段都将不转换，null值及忽略
* @return
* @throws Exception
*/
public static Map javaBean2SqlMap(Object javaBean,Boolean removeNullValue,Class<? extends Annotation>... annotationClass) throws Exception {
Map map = javaBean2SqlMap(javaBean,annotationClass);
if(removeNullValue == false){
return map;
}
Iterator iterator = map.keySet().iterator();
while (iterator.hasNext()) {
String key = (String) iterator.next();
if(ObjectUtils.isEmpty(map.get(key))){
iterator.remove();
}
}
return map;
}
/**
* JavaBean对象转化成Map对象,移除指定注解字段，null即为不移除,同时移除为空值的字段，需要自己指定，true即为移除
*
* @param javaBean 传入对象
* @param removeNullValue 是否移除空字段
* @param annotationClass 传入注解的class 如：Transient.class，含有该注解的字段都将不转换，null值及忽略
* @return
*/
@SuppressWarnings({"rawtypes", "unchecked"})
public static Map javaBean2Map(Object javaBean,Boolean removeNullValue,Class<? extends Annotation>... annotationClass) throws Exception {
Map map = javaBean2Map(javaBean,annotationClass);
if(removeNullValue == false){
return map;
}
Iterator iterator = map.keySet().iterator();
while (iterator.hasNext()) {
String key = (String) iterator.next();
if(ObjectUtils.isEmpty(map.get(key))){
iterator.remove();
}
}
return map;
}
/**
* JavaBean对象转化成Map对象，,移除指定注解字段，null即为不移除
*
* @param javaBean 传入对象
* @param annotationClass 传入注解的class 如：Transient.class
* @return
*/
@SuppressWarnings({"rawtypes", "unchecked"})
private static Map javaBean2Map(Object javaBean,Class<? extends Annotation>... annotationClass) throws Exception {
Map map = new HashMap();
// 获取javaBean属性
BeanInfo beanInfo = Introspector.getBeanInfo(javaBean.getClass());
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
//得到这个类中包含这个注解的所有属性
Map varMap = new HashMap();
if(annotationClass != null){
for(Class<? extends Annotation> an :annotationClass){
Map varMapHaveAnnotation = AnnotationUtil.getVarMapHaveAnnotation(javaBean,an);
Set<String> keys = varMapHaveAnnotation.keySet();
for (String key : keys) {
varMap.put(key,varMapHaveAnnotation.get(key));
}
}
}
if (propertyDescriptors != null && propertyDescriptors.length > 0) {
String propertyName = null; // javaBean属性名
Object propertyValue = null; // javaBean属性值
for (PropertyDescriptor pd : propertyDescriptors) {
propertyName = pd.getName();
if (!varMap.containsKey(propertyName) && !"class".equals(propertyName)) {
Method readMethod = pd.getReadMethod();
propertyValue = readMethod.invoke(javaBean, new Object[0]);
map.put(propertyName, propertyValue);
}
}
}
return map;
}
/**
* JavaBean对象转化成sql字段Map对象,移除指定注解字段，null即为不移除
*
* @param javaBean 传入对象
* @param annotationClass 传入注解的class 如：Transient.class
* @return
*/
@SuppressWarnings({"rawtypes", "unchecked"})
private static Map javaBean2SqlMap(Object javaBean,Class<? extends Annotation>... annotationClass) throws Exception {
Map map = new HashMap();
// 获取javaBean属性
BeanInfo beanInfo = Introspector.getBeanInfo(javaBean.getClass());
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
//得到这个类中包含这个注解的所有属性
Map varMap = new HashMap();
if(annotationClass != null){
for(Class<? extends Annotation> an :annotationClass){
Map varMapHaveAnnotation = AnnotationUtil.getVarMapHaveAnnotation(javaBean,an);
Set<String> keys = varMapHaveAnnotation.keySet();
for (String key : keys) {
varMap.put(key,varMapHaveAnnotation.get(key));
}
}
}
if (propertyDescriptors != null && propertyDescriptors.length > 0) {
String propertyName = null; // javaBean属性名
Object propertyValue = null; // javaBean属性值
for (PropertyDescriptor pd : propertyDescriptors) {
propertyName = pd.getName();
if (!varMap.containsKey(propertyName) && !"class".equals(propertyName)) {
Method readMethod = pd.getReadMethod();
propertyValue = readMethod.invoke(javaBean, new Object[0]);
propertyName = HumpNamedTools.hump2LowerColumnName(propertyName);
map.put(propertyName, propertyValue);
}
}
}
return map;
}
}
5、时间工具类
import org.apache.commons.lang3.StringUtils;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
public class DateTimeUtils {
public static Date getCurrentDate() {
return getCurrentDateTime();
}
public static Date getCurrentDateTime() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date now = new Date();
String tmp = sdf.format(now);
try {
return sdf.parse(tmp);
} catch (ParseException e) {
e.printStackTrace();
return null;
}
}
/**
* 获得昨天yyyy-MM-dd格式的字符串
*
* @return YYYY-MM-DD格式的
*/
public static String getYesterday() {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
Calendar cpcalendar = new GregorianCalendar();
cpcalendar.add(Calendar.DATE, -1);
String now = format.format(cpcalendar.getTime());
return now;
}
/**
* 获得当前日期yyyy-MM-dd格式的字符串
*
* @return YYYY-MM-DD格式的
*/
public static String getCurrentDateString() {
return getCurrentDateTimeString("yyyy-MM-dd");
}
/**
* 获得当前日期和时间,日期加时分秒,yyyy-MM-dd hh:mm:ss
*
* @return
*/
public static String getCurrentDateTimeString() {
return getCurrentDateTimeString("yyyy-MM-dd HH:mm:ss");
}
public static String getCurrentDateTimeString(String format) {
SimpleDateFormat sdf = new SimpleDateFormat(format);
Date now = new Date();
return sdf.format(now);
}
public static Date parse(String param) {
return parse(param, "yyyy-MM-dd HH:mm:ss");
}
public static Date parseShort(String param) {
return parse(param, "yyyy-MM-dd");
}
public static Date parse(String param, String format) {
Date date = null;
SimpleDateFormat sdf = new SimpleDateFormat(format);
try {
date = sdf.parse(param);
} catch (ParseException ex) {
}
return date;
}
public static String formatDateTime(Date date) {
return format(date, "yyyy-MM-dd HH:mm:ss");
}
public static String formatDate(Date date) {
return format(date, "yyyy-MM-dd");
}
public static String format(Date date, String format) {
if (date == null) {
return "";
}
SimpleDateFormat sdf = new SimpleDateFormat(format);
String date_str = "";
try {
date_str = sdf.format(date);
} catch (Exception e) {
}
return date_str;
}
public static String time2String(Date date) {
if (date == null) {
return "";
}
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
String date_str = "";
try {
date_str = sdf.format(date);
} catch (Exception e) {
}
return date_str;
}
/**
* 返回一定时间后的日期
*
* @param date 开始计时的时间
* @param year 增加的年
* @param month 增加的月
* @param day 增加的日
* @return
*/
public static Date getAfterDate(Date date, int year, int month, int day) {
return getAfterDate(date, year, month, day, 0, 0, 0);
}
/**
* 返回一定时间后的日期
*
* @param date 开始计时的时间
* @param year 增加的年
* @param month 增加的月
* @param day 增加的日
* @param hour 增加的小时
* @param minute 增加的分钟
* @param second 增加的秒
* @return
*/
public static Date getAfterDate(Date date, int year, int month, int day, int hour, int minute, int second) {
if (date == null) {
date = new Date();
}
Calendar cal = new GregorianCalendar();
cal.setTime(date);
if (year != 0) {
cal.add(Calendar.YEAR, year);
}
if (month != 0) {
cal.add(Calendar.MONTH, month);
}
if (day != 0) {
cal.add(Calendar.DATE, day);
}
if (hour != 0) {
cal.add(Calendar.HOUR_OF_DAY, hour);
}
if (minute != 0) {
cal.add(Calendar.MINUTE, minute);
}
if (second != 0) {
cal.add(Calendar.SECOND, second);
}
return cal.getTime();
}
//获得当前的年月日时分秒
public static int getCurrentYear() {
Calendar cal = new GregorianCalendar();
return cal.get(Calendar.YEAR);
}
public static int getCurrentMonth() {
Calendar cal = new GregorianCalendar();
return cal.get(Calendar.MONTH) + 1;
}
public static int getCurrentDay() {
Calendar cal = new GregorianCalendar();
return cal.get(Calendar.DAY_OF_MONTH);
}
public static int getCurrentHour() {
Calendar cal = new GregorianCalendar();
return cal.get(Calendar.HOUR_OF_DAY);
}
public static int getCurrentMinute() {
Calendar cal = new GregorianCalendar();
return cal.get(Calendar.MINUTE);
}
public static int getCurrentSecond() {
Calendar cal = new GregorianCalendar();
return cal.get(Calendar.SECOND);
}
//获得一定时间的年月日时分秒
public static int getYear(Date date) {
if (date == null) {
date = new Date();
}
Calendar cal = new GregorianCalendar();
cal.setTime(date);
return cal.get(Calendar.YEAR);
}
public static int getMonth(Date date) {
if (date == null) {
date = new Date();
}
Calendar cal = new GregorianCalendar();
cal.setTime(date);
return cal.get(Calendar.MONTH);
}
public static int getDay(Date date) {
if (date == null) {
date = new Date();
}
Calendar cal = new GregorianCalendar();
cal.setTime(date);
return cal.get(Calendar.DAY_OF_MONTH);
}
public static int getHour(Date date) {
if (date == null) {
date = new Date();
}
Calendar cal = new GregorianCalendar();
cal.setTime(date);
return cal.get(Calendar.HOUR_OF_DAY);
}
public static int getMinute(Date date) {
if (date == null) {
date = new Date();
}
Calendar cal = new GregorianCalendar();
cal.setTime(date);
return cal.get(Calendar.MINUTE);
}
public static int getSecond(Date date) {
if (date == null) {
date = new Date();
}
Calendar cal = new GregorianCalendar();
cal.setTime(date);
return cal.get(Calendar.SECOND);
}
//比较两个时间的差值
public static long getDaysOfDate(Date d1, Date d2) {
double c = (d1.getTime() - d2.getTime()) / 1000 / 3600 / 24;
return (long) Math.floor(c);
}
public static long getHoursOfDate(Date d1, Date d2) {
double c = (d1.getTime() - d2.getTime()) / 1000 / 3600;
return (long) Math.floor(c);
}
public static long getMinutesOfDate(Date d1, Date d2) {
double c = (d1.getTime() - d2.getTime()) / 1000 / 60;
return (long) Math.floor(c);
}
public static long getSecondsOfDate(Date d1, Date d2) {
double c = (d1.getTime() - d2.getTime()) / 1000;
return (long) Math.floor(c);
}
/**
* 取得当前月的最大天数
*
* @return
*/
public static int getDaysOfMonth() {
return getDaysOfMonth(getCurrentYear(), getCurrentMonth());
}
/**
* 取得一个月的最大天数
*
* @param year
* @param month
* @return
*/
public static int getDaysOfMonth(int year, int month) {
return (int) ((toLongTime(month == 12 ? (year + 1) : year,
month == 12 ? 1 : (month + 1), 1) -
toLongTime(year, month, 1)) / (24 * 60 * 60 * 1000));
}
/**
* 取得下一个月的最大天数
*
* @param year
* @param month
* @return
*/
public static int getDaysOfNextMonth(int year, int month) {
year = month == 12 ? year + 1 : year;
month = month == 12 ? 1 : month + 1;
return getDaysOfMonth(year, month);
}
/**
* 取得上个月的最大天数
*
* @param year
* @param month
* @return
*/
public static int getDaysOfPreMonth(int year, int month) {
year = month == 1 ? year - 1 : year;
month = month == 1 ? 12 : month - 1;
return getDaysOfMonth(year, month);
}
/**
* 取上月第一天
*
* @param dqrq Description of Parameter
* @return String
* @since 2003-0416
*/
public static String getFirstDayOfPreMonth(String dqrq) {
String strDQRQ = dqrq;
String strYear = "";
String strMonth = "";
String strDay = "";
if (strDQRQ == null) {
return "";
}
if (strDQRQ.length() == 8) {
strYear = strDQRQ.substring(0, 4);
strMonth = strDQRQ.substring(4, 6);
strDay = strDQRQ.substring(6, 8);
}
if (strDQRQ.length() == 10) {
strYear = strDQRQ.substring(0, 4);
strMonth = strDQRQ.substring(5, 7);
strDay = strDQRQ.substring(8, 10);
}
int iMonth = Integer.parseInt(strMonth);
int iYear = Integer.parseInt(strYear);
if (iMonth == 1) {
iYear = iYear - 1;
iMonth = 12;
} else if (iMonth > 1) {
iMonth = iMonth - 1;
} else {
return "";
}
if (iMonth < 10) {
strMonth = "0" + iMonth;
} else {
strMonth = "" + iMonth;
}
strDay = "01";
if (strDQRQ.length() == 8) {
return iYear + strMonth + strDay;
} else if (strDQRQ.length() == 10) {
return iYear + "-" + strMonth + "-" + strDay;
} else {
return "";
}
}
/**
* 从给定的 year,mongth,day 得到时间的long值表示
* milliseconds after January 1, 1970 00:00:00 GMT).
*
* @param year 年
* @param month 月
* @param day 日
* @return 给定的 year,mongth,day 得到时间的long值表示
*/
public static long toLongTime(int year, int month, int day) {
return toDate(year, month, day).getTime();
}
/**
* 从年月日得到一个Date对象
*
* @param year 年
* @param month 月
* @param day 日
* @return 得到的Date对象
*/
public static Date toDate(int year, int month, int day) {
Calendar cld = new GregorianCalendar();
cld.clear();
cld.set(Calendar.YEAR, year);
cld.set(Calendar.MONTH, month - 1);
cld.set(Calendar.DAY_OF_MONTH, day);
return cld.getTime();
//.getTime();
}
/**
* 将时间转换为时间戳
*
* @param dateTime 具体时间，跟时间格式对应
* @return 时间戳
* @throws ParseException 日期转换异常
*/
public static String dateToStamp(String dateTime) throws ParseException {
String res;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date date = simpleDateFormat.parse(dateTime);
long ts = date.getTime();
res = String.valueOf(ts);
return res;
}
/**
* 将时间转换为时间戳
*
* @param dateTime 具体时间，跟时间格式对应
* @return 时间戳
* @throws ParseException 日期转换异常
*/
public static String dateTimeToStamp(String dateTime) throws ParseException {
String res;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = simpleDateFormat.parse(dateTime);
long ts = date.getTime();
res = String.valueOf(ts);
return res;
}
/**
* 将时间转换为时间戳
*
* @param date 具体时间
* @return 时间戳
* @throws ParseException 日期转换异常
*/
public static String dateToStamp(Date date) throws ParseException {
if(date == null){
return null;
}
String res;
long ts = date.getTime();
res = String.valueOf(ts);
return res;
}
/**
* 将时间戳转换为时间
*
* @param timestamp 时间戳字符串
* @return 时间字符串
*/
public static String stampToDateStr(String timestamp) {
String res;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
long lt = new Long(timestamp);
Date date = new Date(lt);
res = simpleDateFormat.format(date);
return res;
}
/**
* 将时间戳转换为时间
*
* @param timestamp 时间戳字符串
* @return 时间字符串
*/
public static String stampToDateTimeStr(String timestamp) {
String res;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
long lt = new Long(timestamp);
Date date = new Date(lt);
res = simpleDateFormat.format(date);
return res;
}
/**
* 将时间戳转换为时间
*
* @param timestamp 时间戳字符串
* @return 时间字符串
*/
public static Date stampToDateTime(String timestamp) {
if(StringUtils.isBlank(timestamp)){
return null;
}
long lt = new Long(timestamp);
return new Date(lt);
}
/**
* 将时间戳转换为时间
*
* @param timestamp 时间戳字符串
* @return 时间字符串
*/
public static Date stampToDateTime(Long timestamp) {
if(timestamp == null){
return null;
}
return new Date(timestamp);
}
/**
* 将时间戳转换为时间
*
* @param timestamp 时间戳
* @return 时间字符串
*/
public static String stampToDateTimeStr(Long timestamp) {
String res;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = new Date(timestamp);
res = simpleDateFormat.format(date);
return res;
}
/**
* 将时间戳转换为时间
*
* @param timestamp 时间戳
* @return 时间字符串
*/
public static String stampToDateStr(Long timestamp) {
String res;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date date = new Date(timestamp);
res = simpleDateFormat.format(date);
return res;
}
public static void main(String args[]) {
//DateTimeUtil du =new DateTimeUtil();
//log.info(du.getCurrentDateString());
//log.info(du.getCurrentDate());
}
}
6、数组、字符串、对象工具类
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
*
* * @projectName **-parent
* * @title ArrayUtils
* * @package com.**.util
* * @description 数组常用判断类
* * @author IT_CREAT
* * @date
* * @version V1.0.0
*
*/
public class ArrayUtils {
/**
* 判断数组是否为空
* @param objects
* @return
*/
public static Boolean arrayIsEmpty(Object[] objects) {
Boolean bool = false;
if (objects == null || objects.length == 0) {
bool = true;
}
return bool;
}
/**
* 判断集合是否为空
* @param list
* @return
*/
public static Boolean listIsEmpty(List list) {
Boolean bool = false;
if (list == null || list.size() == 0) {
bool = true;
}
return bool;
}
/**
* 判断字符串是否为空
* @param str
* @return
*/
public static Boolean stringIsEmpty(String str) {
Boolean bool = false;
if (str == null || "".equals(str)) {
bool = true;
}
return bool;
}
/**
* 判断对象是否为空
* @param object
* @return
*/
public static Boolean objectIsEmpty(Object object) {
Boolean bool = false;
if (object == null) {
bool = true;
}
return bool;
}
/**
* 判断是否所有字符串都为空
* @param strs
* @return
*/
public static Boolean stringIsAllEmpty(String... strs) {
Boolean bool = true;
if (strs == null) {
return bool;
}
for (String str : strs) {
if (str != null && !"".equals(str)) {
bool = false;
break;
}
}
return bool;
}
/**
* 判断是否所有对象都为空
* @param objects
* @return
*/
public static Boolean objectIsAllEmpty(Object... objects) {
Boolean bool = true;
if (objects == null) {
return bool;
}
for (Object object : objects) {
if (object != null && !(object instanceof String)) {
bool = false;
break;
} else if ((object instanceof String) && object != null && !"".equals(object)) {
bool = false;
break;
}
}
return bool;
}
/**
* 数组转集合
* @param objects
* @return
*/
public static List array2List(Object[] objects){
if(objects == null){
return null;
}
return new ArrayList<>(Arrays.asList(objects));
}
/**
* 集合转数组
* @param list
* @return
*/
public static Object[] list2Array(List list){
if(list == null){
return null;
}
return list.toArray();
}
public static void main(String[] args) {
Boolean bo = false;
System.out.println(objectIsAllEmpty(bo, ""));
System.out.println(stringIsAllEmpty("123", ""));
List list = new ArrayList();
list.add("niahh");
list.add("zaaa");
System.out.println(array2List(list2Array(list)));
}
}