数据类型的转化和判断方法

1.判断字符串是否为可用的数字(如在关于钱的数字上)

public static String getValidNum(String str) {
try {
return new BigDecimal(str.trim()).toString();
} catch (Exception e) {
return -1+"";
}
}

把字符串转化为数字(精度要求较高)，不能转化的默认为-1。

下面一个是关于 时间的转化判断，具体的方法说明就不多说了

import java.text.DateFormat;
import java.text.DateFormatSymbols;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
@SuppressWarnings({ "unchecked", "rawtypes" })
public class DateUtil {
public static String DATE_FORMAT = "yyyy-MM-dd";
public static String DATE_FORMAT_ENUS = "MM/dd/yyyy";
public static String DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
public static String DATETIME_FORMAT_NO_Second = "yyyy-MM-dd HH:mm";
public static String TIME_FORMAT = "HH:mm";
//中文冒号
public static String TIME_FORMAT_CN = "HH：mm";
/**
* 用指定格式解析指定字串为Date类型
* @param str
* @param format
* @return
*/
public static Date getDateFromString(String str, String format) {
try {
return new SimpleDateFormat(format).parse(str);
} catch (ParseException e) {
;
}

return null;
}

/**
* 判断字符串是否为时间
* @param str
* @return 时间字符串(yyyy-MM-dd HH:mm:ss) 不是时间字符串时返回 null
*/
public static String getValidDate(String str) {
SimpleDateFormat format=new SimpleDateFormat(DATETIME_FORMAT);
Date date=null;
try{
format.setLenient(false);
date = format.parse(str);
}catch(Exception e){
format=new java.text.SimpleDateFormat(DATETIME_FORMAT_NO_Second);
try {
format.setLenient(false);
date = format.parse(str);
} catch (ParseException e1) {
format=new java.text.SimpleDateFormat(DATE_FORMAT);
try {
format.setLenient(false);
date=format.parse(str);
} catch (Exception e2) {
return null;
}
}
}
SimpleDateFormat sdf = new SimpleDateFormat(DATETIME_FORMAT);
return sdf.format(date);
}

//----------------------------------获取特定日期
/**
* <p>
* Description:字串6位，前4代表年，后2代表月，<br>
* 返回给定日期中的月份中的最后一天
* </p>
* param term(YYYYMMDD)
*
* @return String
*/
public static String getLastDay(String term) {
int getYear = Integer.parseInt(term.substring(0, 4));
int getMonth = Integer.parseInt(term.substring(4, 6));

String getLastDay = "";

if (getMonth == 2) {
if (getYear % 4 == 0 && getYear % 100 != 0 || getYear % 400 == 0) {
getLastDay = "29";
} else {
getLastDay = "28";
}
} else if (getMonth == 4 || getMonth == 6 || getMonth == 9
|| getMonth == 11) {
getLastDay = "30";
} else {
getLastDay = "31";
}
return String.valueOf(getYear) + "年" + term.substring(4, 6) + "月"
+ getLastDay + "日";
}

/**
* <p>
* 获得本周周一的日期
* </p>
*
* @param date
* @return yyyy-MM-dd格式的日期字符串
* @throws ParseException
*/
public static String getMondayOfThisWeek(String date) throws ParseException {
return getDayOfTheWeek(reviseSundayBug(date), "yyyy-MM-dd",
Calendar.MONDAY);
}

/**
* <p>
* 获得本周周日的日期
* </p>
*
* @param date
* @return yyyy-MM-dd格式的日期字符串
* @throws ParseException
*/
public static String getSundayOfThisWeek(String date) throws ParseException {
if (getDayOfTheWeek(date) == Calendar.SUNDAY) {
Calendar c = Calendar.getInstance();
c.setTime(parseDateStr(date, "yyyy-MM-dd"));
c.add(Calendar.DATE, -7);
date = format(c.getTime(), "yyyy-MM-dd");
}
return getDayOfTheWeek(reviseSundayBug(date), "yyyy-MM-dd",
Calendar.SUNDAY);
}

/**
* <p>
* 修正当前日期是周日时计算本周日期的bug
* </p>
*
* @param date
* @return
* @throws ParseException
*/
private static String reviseSundayBug(String date) throws ParseException {
if (getDayOfTheWeek(date) == Calendar.SUNDAY) {
Calendar c = Calendar.getInstance();
c.setTime(parseDateStr(date, "yyyy-MM-dd"));
c.add(Calendar.DATE, -7);
date = format(c.getTime(), "yyyy-MM-dd");
}
return date;
}

/**
* <p>
* 解析时间日期字符串
* </p>
*
* @param date
* @param format
* @return
* @throws ParseException
*/
public static Date parseDateStr(String date, String format)
throws ParseException {
DateFormat df = new SimpleDateFormat(format);
try {
return df.parse(date);
} catch (ParseException e) {
e.printStackTrace();
throw e;
}
}

/**
* <p>
* 获得一周七天的日期
* </p>
*
* @param date
* @return
* @throws ParseException
*/
public static String[] getOneWeekDates(String date) throws ParseException {
return getOneWeekDates(reviseSundayBug(date), "yyyy-MM-dd");
}

/**
* <p>
* 按照指定格式日期获得一周七天的日期
* </p>
*
* @param date
* @param df
* @return
* @throws ParseException
*/
public static String[] getOneWeekDates(String date, String df)
throws ParseException {
String[] dates = new String[7];
dates[0] = getDayOfTheWeek(date, df, Calendar.MONDAY);
dates[1] = getDayOfTheWeek(date, df, Calendar.TUESDAY);
dates[2] = getDayOfTheWeek(date, df, Calendar.WEDNESDAY);
dates[3] = getDayOfTheWeek(date, df, Calendar.THURSDAY);
dates[4] = getDayOfTheWeek(date, df, Calendar.FRIDAY);
dates[5] = getDayOfTheWeek(date, df, Calendar.SATURDAY);
dates[6] = getDayOfTheWeek(date, df, Calendar.SUNDAY);
return dates;
}

/**
* <p>
* 获得上一周的日期
* </p>
*
* @param date
* 格式形如"YYYY-MM-DD"的字符串
* @return
*/
public static String getLastWeekDate(String date) {
Date d = stringToDate(date, "yyyy-mm-dd");
Calendar calo = Calendar.getInstance();
calo.setTime(d);
calo.add(Calendar.DATE, -7);

return dateToString(d, "yyyy-mm-dd");
}

/**
* <p>
* 获得下一周的日期
* </p>
*
* @param date
* 格式形如"YYYY-MM-DD"的字符串
* @return
*/
public static String getNextWeekDate(String date) {
Date d = stringToDate(date, "yyyy-mm-dd");
Calendar calo = Calendar.getInstance();
calo.setTime(d);
calo.add(Calendar.DATE, 7);

return dateToString(d, "yyyy-mm-dd");
}

/**
* <p>
* 获得指定日期所在周的周几的日期
* </p>
*
* @param date
* 字符串格式的日期
* @param df
* 日期的格式化字符串，如yyyy-MM-dd
* @param DAY_OF_WEEK
* 周几，如Calendar.MONDAY
* @return
* @throws ParseException
*/
public static String getDayOfTheWeek(String date, String df, int DAY_OF_WEEK)
throws ParseException {
Calendar c = Calendar.getInstance();
c.setTime(parseDateStr(date, df));
c.set(Calendar.DAY_OF_WEEK, DAY_OF_WEEK);
// 中国习惯是周日是一个星期的最后一天
if (DAY_OF_WEEK == Calendar.SUNDAY) {
c.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY);
c.add(Calendar.DATE, 1);
}
return new SimpleDateFormat(df).format(c.getTime());
}

/**
* <p>
* 获得当前日期是周几
* </p>
*
* @param date
* @return 周几在Calendar类中对应的静态变量值
* @throws ParseException
*/
public static int getDayOfTheWeek(String date) throws ParseException {
Calendar c = Calendar.getInstance();
c.setTime(parseDateStr(date, "yyyy-MM-dd"));
return c.get(Calendar.DAY_OF_WEEK);
}

/**
* <p>
* 获得当前日期是周几
* </p>
*
* @param date
* @return
* @throws ParseException
*/
public static int getDayOfTheWeek(Date date) throws ParseException {
Calendar c = Calendar.getInstance();
c.setTime(date);
return c.get(Calendar.DAY_OF_WEEK);
}

/**
* <p>
* 获得当前日期是周几
* </p>
*
* @param date
* @param DAY_OF_WEEK
* @return
* @throws ParseException
*/
public static Date getDayOfTheWeek(Date date, int DAY_OF_WEEK)
throws ParseException {
Calendar c = Calendar.getInstance();
c.setTime(date);

c.set(Calendar.DAY_OF_WEEK, DAY_OF_WEEK);
// 中国习惯是周日是一个星期的最后一天
if (DAY_OF_WEEK == Calendar.SUNDAY) {
c.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY);
c.add(Calendar.DATE, 1);
}

return c.getTime();
}

/**
* <p>
* 得到当前日期指定周日期
* </p>
*
* @param date
* @param DAY_OF_WEEK
* @return
* @throws ParseException
*/
public static Date getDayFromDate(Date date, int DAY_OF_WEEK)
throws ParseException {
Calendar c = Calendar.getInstance();
date = getDayOfTheWeek(date, DAY_OF_WEEK);
c.setTime(date);
c.set(Calendar.DAY_OF_WEEK, DAY_OF_WEEK);
return c.getTime();
}

/**
* <p>
* 得到当前日期那周周一日期
* </p>
*
* @param date
* @return
* @throws ParseException
*/
public static Date getMondayFromDate(Date date) throws ParseException {
return getDayFromDate(date, Calendar.MONDAY);
}

/**
* <p>
* 得到当前日期那周周一日期的字符串
* </p>
*
* @param date
* @return
* @throws ParseException
*/
public static String getMondayStrFromDate(Date date, String pattern)
throws ParseException {
return format(getMondayFromDate(date), pattern);
}

/**
* <p>
* 得到当前日期那周周日日期
* </p>
*
* @param date
* @return
* @throws ParseException
*/
public static Date getSundayFromDate(Date date) throws ParseException {
return getDayFromDate(date, Calendar.SUNDAY);
}

/**
* <p>
* 得到当前日期那周周日日期的字符串
* </p>
*
* @param date
* @return
* @throws ParseException
*/
public static String getSundayStrFromDate(Date date, String pattern)
throws ParseException {
return format(getSundayFromDate(date), pattern);
}

//-----------------------把date转成指定格式的String
/**
* format 格式化date
* @param date
* @param pattern
* 指定格式："yyyy-MM-dd HH:mm:ss" "yyyy年MM月dd日kk时mm分" 的各种组合 Integer.parseInt
* @return
*/
public static String format(Date date, String pattern) {
if (date == null) {
return "N/A";
}
SimpleDateFormat format = new SimpleDateFormat(pattern);
return format.format(date);
}

/**
* format 将字符串转换为日期型
* @param strDate 日期字符串
* @param pattern 指定格式
* @return Date
* @throws Exception
*/
public static Date format(String strDate, String pattern) throws ParseException {

SimpleDateFormat sdf=new SimpleDateFormat();
sdf.applyPattern(pattern);
return sdf.parse(strDate);
}
//-----------------------获取当前日期
/**
* getCurrentDate 获取当前日期
* @return Date
* @throws Exception
*/
public static Date getCurrentDate(){
Calendar cal = Calendar.getInstance();
Date d = cal.getTime();
return d;
}

/**
* getCurrentDateStr 获取当前日期的字符串
* @param pattern 日期格式
* @return String
* @throws Exception
*/
public static String getCurrentDateStr(String pattern){
return format(getCurrentDate(),pattern);
}
//----------------------------------两个日期之间的计算
/**
* yearsBetweenDates 得到两个日期之间相差的年数
* @param newDate 新日期
* @param oldDate 旧日期
* @return int 新日期大，正数；否则负数
* @throws Exception
*/
public static int yearsBetweenDates(Date newDate, Date oldDate) {
Calendar start = Calendar.getInstance();
start.setTime(newDate);
Calendar end = Calendar.getInstance();
end.setTime(oldDate);
int y=end.get(Calendar.YEAR)-start.get(Calendar.YEAR);
return y;
}

/**
* monthsBetweenDates 得到两个日期之间相差的月数
* @param newDate 新日期
* @param oldDate 旧日期
* @return int 新日期大，正数；否则负数
* @throws Exception
*/
public static int monthsBetweenDates(Date newDate, Date oldDate) {
Calendar start = Calendar.getInstance();
start.setTime(newDate);
Calendar end = Calendar.getInstance();
end.setTime(oldDate);
int y=end.get(Calendar.YEAR)-start.get(Calendar.YEAR);
int m=y*12 + end.get(Calendar.MONTH)-start.get(Calendar.MONTH);
return m;
}

/**
* daysBetweenDates 得到两个日期之间相差的天数
* @param newDate 新日期
* @param oldDate 旧日期
* @return int 新日期大，正数；否则负数
* @throws Exception
*/
public static int daysBetweenDates(Date newDate, Date oldDate) {
long time = newDate.getTime() - oldDate.getTime();
int day = (int) (time / (24 * 3600 * 1000));
return day;
}
//----------------------------------日期增加年、月和日的计算
/**
* getDateBetween 取得与原日期相差一定天数的日期，返回Date型日期
* @param date
* @param intBetween
* @return Date
* @throws Exception
*/
public static Date getDateIncreaseDays(Date date, int intBetween) {
Calendar calo = Calendar.getInstance();
calo.setTime(date);
calo.add(Calendar.DATE, intBetween);
return calo.getTime();
}

/**
* getDateIncreaseMonths 取得与原日期相差一定月数的日期，返回Date型日期
* @param date
* @param addMonth
* @return Date
* @throws Exception
*/
public static Date getDateIncreaseMonths(Date date, int addMonth) {
Calendar calo = Calendar.getInstance();
calo.setTime(date);
calo.add(Calendar.MONTH, addMonth);
return calo.getTime();
}

/**
* getDateIncreaseYears 取得与原日期相差一定年数的日期，返回Date型日期
* @param date
* @param addMonth
* @return Date
* @throws Exception
*/
public static Date getDateIncreaseYears(Date date, int addMonth) {
Calendar calo = Calendar.getInstance();
calo.setTime(date);
calo.add(Calendar.YEAR, addMonth);
return calo.getTime();
}

/**
* <p>
* 返回java.sql.Date类型的日期
* </p>
*
* @param d
* @return
*/
public static java.sql.Date getSqlDate(Date d) {
if (d != null) {
java.sql.Date a = new java.sql.Date(d.getTime());
return a;
} else {
return null;
}
}

/**
* <p>
* 把数据库中的日期(2005-03-29 00:00:00.0)转化成java.util.Date型
* </p>
*
* @param sqlstr
* @return
* @throws Exception
*/
public static java.util.Date getStrUtilDate(String sqlstr) throws Exception {
java.util.Date d = null;
if (sqlstr == null || sqlstr.equals("") || sqlstr.length() <= 0)
return d;
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

try {
if (sqlstr.length() < 18) {
sqlstr = sqlstr + " 00:00:00";
}
d = formatter.parse(sqlstr.substring(0, 18));
} catch (ParseException e) {
throw new Exception("在转换" + sqlstr + "为java.util.Date型出错"
+ e.getMessage());
}
return d;
}

/**
* <p>
* 把日期(2005-03-29 00:00:00.0)转化成java.util.Date(2005-03-29 00:00:00.0)型
* </p>
*
* @param sqlstr
* @return
* @throws Exception
*/
public static java.util.Date convertStrToDate(String sqlstr)
throws Exception {
java.util.Date d = null;
if (sqlstr == null || sqlstr.equals("") || sqlstr.length() <= 0)
return d;
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
d = formatter.parse(sqlstr);
} catch (ParseException e) {
throw new Exception("在转换" + sqlstr + "为java.util.Date型出错"
+ e.getMessage());
}
return d;
}

/**
* <p>
* 判断日期date是否不早于当前日期
* </p>
*
* @param date
* @return 只要date不早于当前日期就返回true，否则返回false
* @throws ParseException
*/
public static boolean isNotBeforeToday(String date) throws ParseException {
Date compareDate = parseDateStr(date, "yyyy-MM-dd");
return isToday(date) ? true : compareDate.after(new Date());
}

/**
* <p>
* 判断字符串是否为当天日期
* </p>
*
* @param date
* @return
*/
public static boolean isToday(String date) {
return date.equals(format(new Date(), "yyyy-MM-dd"));
}

/**
* <p>
* Description:将字符串转换为日期型
* </p>
*
* @param strDate
* @param format
* --oracle型日期格式
* @return
*/
public static Date stringToDate(String strDate, String oracleFormat) {

if (strDate == null)
return null;
Hashtable h = new Hashtable();
String javaFormat = new String();
String s = oracleFormat.toLowerCase();
if (s.indexOf("yyyy") != -1)
h.put(new Integer(s.indexOf("yyyy")), "yyyy");
else if (s.indexOf("yy") != -1)
h.put(new Integer(s.indexOf("yy")), "yy");
if (s.indexOf("mm") != -1)
h.put(new Integer(s.indexOf("mm")), "MM");

if (s.indexOf("dd") != -1)
h.put(new Integer(s.indexOf("dd")), "dd");
if (s.indexOf("hh24") != -1)
h.put(new Integer(s.indexOf("hh24")), "HH");
if (s.indexOf("mi") != -1)
h.put(new Integer(s.indexOf("mi")), "mm");
if (s.indexOf("ss") != -1)
h.put(new Integer(s.indexOf("ss")), "ss");

int intStart = 0;
while (s.indexOf("-", intStart) != -1) {
intStart = s.indexOf("-", intStart);
h.put(new Integer(intStart), "-");
intStart++;
}

intStart = 0;
while (s.indexOf("/", intStart) != -1) {
intStart = s.indexOf("/", intStart);
h.put(new Integer(intStart), "/");
intStart++;
}

intStart = 0;
while (s.indexOf(" ", intStart) != -1) {
intStart = s.indexOf(" ", intStart);
h.put(new Integer(intStart), " ");
intStart++;
}

intStart = 0;
while (s.indexOf(":", intStart) != -1) {
intStart = s.indexOf(":", intStart);
h.put(new Integer(intStart), ":");
intStart++;
}

if (s.indexOf("年") != -1)
h.put(new Integer(s.indexOf("年")), "年");
if (s.indexOf("月") != -1)
h.put(new Integer(s.indexOf("月")), "月");
if (s.indexOf("日") != -1)
h.put(new Integer(s.indexOf("日")), "日");
if (s.indexOf("时") != -1)
h.put(new Integer(s.indexOf("时")), "时");
if (s.indexOf("分") != -1)
h.put(new Integer(s.indexOf("分")), "分");
if (s.indexOf("秒") != -1)
h.put(new Integer(s.indexOf("秒")), "秒");

int i = 0;
while (h.size() != 0) {
Enumeration e = h.keys();
int n = 0;
while (e.hasMoreElements()) {
i = ((Integer) e.nextElement()).intValue();
if (i >= n)
n = i;
}
String temp = (String) h.get(new Integer(n));
h.remove(new Integer(n));

javaFormat = temp + javaFormat;
}
// System.out.println(javaFormat);
SimpleDateFormat df = new SimpleDateFormat(javaFormat);

Date myDate = new Date();
try {
myDate = df.parse(strDate);
} catch (Exception e) {
return null;
}

return myDate;
}

/**
* <p>
* Description:获取输入格式的日期字符串，字符串遵循Oracle格式
* </p>
*
* @param d
* @param format
* @return
*/
public static String dateToString(Date d, String format) {
if (d == null)
return "";

Hashtable h = new Hashtable();
String javaFormat = new String();
String s = format.toLowerCase();
if (s.indexOf("yyyy") != -1)
h.put(new Integer(s.indexOf("yyyy")), "yyyy");
else if (s.indexOf("yy") != -1)
h.put(new Integer(s.indexOf("yy")), "yy");
if (s.indexOf("mm") != -1)
h.put(new Integer(s.indexOf("mm")), "MM");

if (s.indexOf("dd") != -1)
h.put(new Integer(s.indexOf("dd")), "dd");
if (s.indexOf("hh24") != -1)
h.put(new Integer(s.indexOf("hh24")), "HH");
if (s.indexOf("mi") != -1)
h.put(new Integer(s.indexOf("mi")), "mm");
if (s.indexOf("ss") != -1)
h.put(new Integer(s.indexOf("ss")), "ss");

int intStart = 0;
while (s.indexOf("-", intStart) != -1) {
intStart = s.indexOf("-", intStart);
h.put(new Integer(intStart), "-");
intStart++;
}

intStart = 0;
while (s.indexOf("/", intStart) != -1) {
intStart = s.indexOf("/", intStart);
h.put(new Integer(intStart), "/");
intStart++;
}

intStart = 0;
while (s.indexOf(" ", intStart) != -1) {
intStart = s.indexOf(" ", intStart);
h.put(new Integer(intStart), " ");
intStart++;
}

intStart = 0;
while (s.indexOf(":", intStart) != -1) {
intStart = s.indexOf(":", intStart);
h.put(new Integer(intStart), ":");
intStart++;
}

if (s.indexOf("年") != -1)
h.put(new Integer(s.indexOf("年")), "年");
if (s.indexOf("月") != -1)
h.put(new Integer(s.indexOf("月")), "月");
if (s.indexOf("日") != -1)
h.put(new Integer(s.indexOf("日")), "日");
if (s.indexOf("时") != -1)
h.put(new Integer(s.indexOf("时")), "时");
if (s.indexOf("分") != -1)
h.put(new Integer(s.indexOf("分")), "分");
if (s.indexOf("秒") != -1)
h.put(new Integer(s.indexOf("秒")), "秒");

int i = 0;
while (h.size() != 0) {
Enumeration e = h.keys();
int n = 0;
while (e.hasMoreElements()) {
i = ((Integer) e.nextElement()).intValue();
if (i >= n)
n = i;
}
String temp = (String) h.get(new Integer(n));
h.remove(new Integer(n));

javaFormat = temp + javaFormat;
}
SimpleDateFormat df = new SimpleDateFormat(javaFormat,
new DateFormatSymbols());

return df.format(d);
}

/**
* <p>
* 取得与原日期相差一定天数的日期，返回Date型日期
* </p>
*
* @param date
* @param intBetween
* @return
*/
public static Date getDateBetween(Date date, int intBetween) {
Calendar calo = Calendar.getInstance();
calo.setTime(date);
calo.add(Calendar.DATE, intBetween);
return calo.getTime();
}

}