//要求j2se 1.4
package com.yss.util;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.lang.reflect.Field;
import java.text.*;
import javax.xml.bind.JAXBElement;
import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;
import javax.xml.namespace.QName;
import com.yss.ciss.util.YssException;
/**
* <p>
* Title:公用函数，请勿加入数据库访问类函数！
* </p>
* <p>
* Description: 这个类包含了一些常用的函数，如日期的分析处理，数值的判断等等 <br>
* 一些VB中常用java中使用不便的函数
* </p>
* <p>
* Copyright: Copyright (c) 2003
* </p>
* <p>
* Company: Ysstech
* </p>
*
* @author alex
* @version 1.0
*/
public class YssFun {
public YssFun() {
}
/**
* 合法套账号
* @author CISS
* @create 2012-10-22
* @param number
* @return
*/
public static String getSetCode(String number ) {
return getSetCode(Double.parseDouble(number));
}
/**
* 合法套账号
* @author CISS
* @create 2012-10-22
* @param number
* @return
*/
public static String getSetCode(double number ) {
String format="000";
if (number>999)
format="000000";
return formatNumber(number,format);
}
// 时间日期类函数****************************************************************
// 这些函数都是基于java.util.date，java.sql.date类型的参数也可填入处理
/**
* 两种日期类型转换 java.sql.date本身就是java.util.date不用转换
* java.util.date到java.sql.date的转换用这个函数实现
*/
public static java.sql.Date toSqlDate(Date dDate) {
return new java.sql.Date(dDate.getTime());
}
/**
* 将传入的yyyyMMdd的日期格式转换为yyyy-MM-dd
* @author CISS
* @create 2012-10-22
* @param sDate
* String
* @throws YssException
* @return String
*/
public static String formatStrToDateformat(String sDate)
throws YssException {
String sRetu;
String sErr = "日期字符格式不正确！";
if (sDate.length() != 8) {
throw new YssException(sErr);
}
sRetu = YssFun.left(sDate, 4) + "-" + YssFun.mid(sDate, 4, 2) + "-"
+ YssFun.right(sDate, 2);
if (!isDate(sRetu)) {
throw new YssException(sErr);
}
return sRetu;
}
/**
* 日期格式化，类似vb的format
* @author CISS
* @create 2012-10-22
* @param dDate
* Date
* @param format
* String：日期格式
* @return String：返回格式化好的日期字符串
*/
public static String formatDate(Date dDate, String format) {
return (new SimpleDateFormat(format)).format(dDate);
}
/**
* 日期格式化，采用日期字符串做源日期参数
* @author CISS
* @create 2012-10-22
* @param sDate
* String
* @param format
* String
* @throws YssException
* @return String
*/
public static String formatDate(String sDate, String format)
throws ParseException {
return formatDate(toDate(sDate), format);
}
/**
* 日期格式化，用标准格式yyyy-MM-dd
* @author CISS
* @create 2012-10-22
* @param dDate
* @return
*/
public static String formatDate(Date dDate) {
return (new SimpleDateFormat(YssCons.YSS_DATE)).format(dDate);
}
/**
* 检查字符串是否以比对字符集开头，如果以其中一个开头就返回true，否则返回false
* @author Dranson
* @create 2005-08-09
* @param str
* String 被检查字符串
* @param ary
* String[] 比对字符集
* @return boolean
*/
public static boolean oneStart(String str, String[] ary) {
for (int i = 0; i < ary.length; i++) {
if (str.startsWith(ary[i]))
return true;
}
return false;
}
/**
* 检查字符串是否以比对字符集开头，如果以其中一个开头就返回true，否则返回false
* @author Dranson
* @create 2005-08-09
* @param str
* String 被检查字符串
* @param arys
* String 比对字符集(多个字符串用英文逗号间隔)
* @return boolean
*/
public static boolean oneStart(String str, String arys) {
return oneStart(str, arys.split(","));
}
/**
* 检查字符串是否以比对字符集结尾，如果以其中一个结尾就返回true，否则返回false
* @author Dranson
* @create 2005-08-09
* @param str
* String 被检查字符串
* @param ary
* String[] 比对字符集
* @return boolean
*/
public static boolean oneEnd(String str, String[] ary) {
for (int i = 0; i < ary.length; i++) {
if (str.endsWith(ary[i]))
return true;
}
return false;
}
/**
* 检查字符串是否以比对字符集结尾，如果以其中一个结尾就返回true，否则返回false
* @author Dranson
* @create 2005-08-09
* @param str
* String 被检查字符串
* @param arys
* String 比对字符集(多个字符串用英文逗号间隔)
* @return boolean
*/
public static boolean oneEnd(String str, String arys) {
return oneEnd(str, arys.split(","));
}
/**
* 检查字符串是否包含比对字符集，如果包含其中一个就返回true，否则返回false
* @author Dranson
* @create 2005-08-09
* @param str
* String 被检查字符串
* @param ary
* String[] 比对字符集
* @return boolean
*/
public static boolean oneOf(String str, String[] ary) {
for (int i = 0; i < ary.length; i++) {
if (str.indexOf(ary[i]) > -1)
return true;
}
return false;
}
/**
* 检查字符串是否包含比对字符集，如果包含其中一个就返回true，否则返回false
* @author Dranson
* @create 2005-08-09
* @param str
* String 被检查字符串
* @param arys
* String 比对字符集(多个字符串用英文逗号间隔)
* @return boolean
*/
public static boolean oneOf(String str, String arys) {
return oneOf(str, arys.split(","));
}
/**
* 检查字符串是否等于比对字符集，如果等于其中一个就返回true，否则返回false
* @author Dranson
* @create 2005-08-09
* @param str
* String 被检查字符串
* @param ary
* String[] 比对字符集
* @return boolean
*/
public static boolean oneCase(String str, String[] ary) {
for (int i = 0; i < ary.length; i++) {
if (str.equalsIgnoreCase(ary[i]))
return true;
}
return false;
}
/**
* 检查字符串是否等于比对字符集，如果等于其中一个就返回true，否则返回false
* @author Dranson
* @create 2005-08-09
* @param str
* String 被检查字符串
* @param arys
* String 比对字符集(多个字符串用英文逗号间隔)
* @return boolean
*/
public static boolean oneCase(String str, String arys) {
return oneCase(str, arys.split(","));
}
/**
* 字符串to日期时间 注意要指定日期格式，不像vb可以自动识别
* @author CISS
* @create 2012-10-22
* @param sDate
* @param format
* @return
* @throws YssException
*/
public static Date parseDate(String sDate, String format)
throws YssException {
GregorianCalendar cl = new GregorianCalendar();
final String DERR = "解析日期出错！";
int year;
try {
cl.setTime((new SimpleDateFormat(format)).parse(sDate));
year = cl.get(Calendar.YEAR);
// 年份要控制一下
if (year < 1000 || year > 9999)
throw new YssException(DERR + "\n\t年份必须在1000－9999之间");
return cl.getTime();
} catch (ParseException pe) {
throw new YssException(DERR, pe);
}
}
/**
* 日期解析，用标准格式yyyy-MM-dd
* @author CISS
* @create 2012-10-22
* @param sDate
* @return
* @throws YssException
*/
public static Date parseDate(String sDate) throws YssException {
return parseDate(sDate, YssCons.YSS_DATE);
}
/**
* 是否可以转换成日期，仅解析用/-.间隔的日期 dDate用于返回日期，改写dDate中已经存在的日期
* @author CISS
* @create 2012-10-22
* @param sDate
* @param dDate
* @return
*/
public static boolean isDate(String sDate, Date dDate) {
long ltmp;
try {
ltmp = toDate(sDate).getTime();
if (dDate != null)
dDate.setTime(ltmp);
return true;
} catch (ParseException ye) {
return false;
}
}
/**
* 是否可以转换成日期，仅解析用/-.间隔的日期 dDate用于返回日期，改写dDate中已经存在的日期
* @author CISS
* @create 2012-10-22
* @param sDate
* @return
*/
public static final boolean isDate(String sDate) {
return isDate(sDate, null);
}
/**
* 类似vb的CDate函数，自动分析sDate，如格式正常，返回日期，否则报错。
* 注意这里只能处理单纯日期，不处理时间，年份正常范围在0-99和1000－9999 仅解析用/-.间隔的日期
* @author CISS
* @create 2012-10-22
* @param sDate
* @return
* @throws ParseException
*/
public static Date toDate(String sDate) throws ParseException {
return DateFormat.getDateInstance().parse(sDate);
}
/**
* 将US格式的时间字符串转化为日期格式
* @author CISS
* @create 2012-10-22
* @param sDate
* @return
* @throws ParseException
*/
public static Date parseUSDate(String sDate) throws ParseException {
return new java.text.SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy",
Locale.US).parse(sDate);
}
/*
* public static void main(String[] args) { try{
* System.out.println(YssFun.formatDate(YssFun.toDate("2009-1-1
* 12:00:00"))); }catch(Exception e){
* } }
*/
/**
* 判断年月日是否在正常范围 年份正常范围在0-99和1000－9999
* @author CISS
* @create 2012-10-22
* @param year
* @param month
* @param day
* @return
* @throws ParseException
*/
public static boolean isValidDate(int year, int month, int day) {
GregorianCalendar cl;
if (year < 0 || (year > 99 && (year < 1000 || year > 9999)))
return false;
if (year < 30)
year += 2000;
else if (year <= 99)
year += 1900;
if (month < 1 || month > 12)
return false;
cl = new GregorianCalendar(year, month - 1, 1); // 参数月份从0开始所以减一
if (day < cl.getActualMinimum(Calendar.DAY_OF_MONTH)
|| day > cl.getActualMaximum(Calendar.DAY_OF_MONTH))
return false;
return true;
}
/**
* 判断该日期是否为月末
* @author CISS
* @create 2012-10-22
* @param dt
* @return
*/
public static boolean isEndMonth(Date dt) {
return !(getMonth(addDay(dt, 1)) == getMonth(dt));
}
/**
* 得到年份(月份getMonth，日getDay，星期getWeekDay) 包装了GregorianCalendar类的get方法
* Calendar类中定义了月份，星期几的常数。 <br>
* <big><b>注意月份常数0开始，一般不要使用</b></big>
* @author CISS
* @create 2012-10-22
* @param dDate
* @return
*/
public static int getYear(Date dDate) {
return getDateItems(dDate, Calendar.YEAR);
}
/**
* 得到月份
* @author CISS
* @create 2012-10-22
* @param dDate
* @return
*/
public static int getMonth(Date dDate) {
return getDateItems(dDate, Calendar.MONTH) + 1;
}
/**
* 得到每月天数 1 - 31
* @author CISS
* @create 2012-10-22
* @param dDate
* @return
*/
public static int getDay(Date dDate) {
return getDateItems(dDate, Calendar.DAY_OF_MONTH);
}
/**
* 24小时
* @author CISS
* @create 2012-10-22
* @param dDate
* @return
*/
public static int getHour(Date dDate) {
return getDateItems(dDate, Calendar.HOUR_OF_DAY);
}
/**
* 分
* @author CISS
* @create 2012-10-22
* @param dDate
* @return
*/
public static int getMinute(Date dDate) {
return getDateItems(dDate, Calendar.MINUTE);
}
/**
* 秒
* @author CISS
* @create 2012-10-22
* @param dDate
* @return
*/
public static int getSecond(Date dDate) {
return getDateItems(dDate, Calendar.SECOND);
}
/**
* 星期
* @author CISS
* @create 2012-10-22
* @param dDate
* @return
*/
public static int getWeekDay(Date dDate) {
return getDateItems(dDate, Calendar.DAY_OF_WEEK);
}
/**
* 得到某月下的多少个周
* @author CISS
* @create 2012-10-22
* @param dDate
* @return
*/
public static int getWeek(Date dDate) {
int days = getDay(dDate);
if (days % 7 == 0) {
return days / 7;
} else {
return days / 7 + 1;
}
}
/**
* 返回日期中的任何元素
* @author CISS
* @create 2012-10-22
* @param field：Calendar类中的常数，如YEAR/MONTH/DAY_OF_MONTH...
* <br>
* <b><big>注意返回的month一月份是从0开始的！</big></b>
*/
public static final int getDateItems(Date dDate, int field) {
GregorianCalendar cl = new GregorianCalendar();
cl.setTime(dDate);
return cl.get(field);
}
/**
* 加减day
* @author CISS
* @create 2012-10-22
* @param dDate
* @param days
* @return
*/
public static final Date addDay(Date dDate, int days) {
return addDate(dDate, days, Calendar.DAY_OF_MONTH);
}
/**
* 加减月份
* @author CISS
* @create 2012-10-22
* @param dDate
* @param months
* @return
*/
public static final Date addMonth(Date dDate, int months) {
return addDate(dDate, months, Calendar.MONTH);
}
/**
* 加减年份
* @author CISS
* @create 2012-10-22
* @param dDate
* @param years
* @return
*/
public static final Date addYear(Date dDate, int years) {
return addDate(dDate, years, Calendar.YEAR);
}
/**
* 加减小时
* @author CISS
* @create 2012-10-22
* @param dDate
* @param hours
* @return
*/
public static Date addHour(Date dDate, int hours) {
return addDate(dDate, hours, Calendar.HOUR_OF_DAY);
}
/**
* 加减分钟
* @author CISS
* @create 2012-10-22
* @param dDate
* @param minutes
* @return
*/
public static Date addMinute(Date dDate, int minutes) {
return addDate(dDate, minutes, Calendar.MINUTE);
}
/**
* 加减秒
* @author CISS
* @create 2012-10-22
* @param dDate
* @param second
* @return
*/
public static Date addSecond(Date dDate, int second) {
return addDate(dDate, second, Calendar.SECOND);
}
/**
* 加减日期 field指定是年、月、日，amount是数量
* @author CISS
* @create 2012-10-22
* @param dDate
* @param amount
* @param field
* @return
*/
public static Date addDate(Date dDate, int amount, int field) {
GregorianCalendar cl = new GregorianCalendar();
cl.setTime(dDate);
cl.add(field, amount);
return cl.getTime();
}
/**
* 返回两个日期相差date2-date1的天数
* @author CISS
* @create 2012-10-22
* @param dDate1：被减日期
* @param dDate2：日期
*/
public static int dateDiff(java.util.Date dDate1, java.util.Date dDate2) {
int year = 0;
int month = 0;
int day = 0;
// 算法说明：这里考虑到了时分秒的差异可能造成的差一天，只设置年月日相减算出差异
// 失败算法：毫秒数相减除一天毫秒；毫秒数先除再减；毫秒数弥补时区差后先除再减
// 失败算法：设置calendar的时分秒为0后相减（有时设置不灵）
GregorianCalendar cl1 = new GregorianCalendar();
GregorianCalendar cl2 = null;
cl1.setTime(dDate2);
year = cl1.get(Calendar.YEAR);
month = cl1.get(Calendar.MONTH);
day = cl1.get(Calendar.DAY_OF_MONTH);
cl2 = new GregorianCalendar(year, month, day);
cl1.setTime(dDate1);
year = cl1.get(Calendar.YEAR);
month = cl1.get(Calendar.MONTH);
day = cl1.get(Calendar.DAY_OF_MONTH);
cl1.clear();
cl1.set(year, month, day);
return (int) YssD.round(YssD.sub(cl2.getTimeInMillis(), cl1
.getTimeInMillis())
/ (1000 * 3600 * 24), 0);
}
/**
* 返回date2与当前日期的差
* @author CISS
* @create 2012-10-22
* @param dDate2
* @return
*/
public static int dateDiff(java.util.Date dDate2) {
return dateDiff(new java.util.Date(), dDate2);
}
/**
* 通过只算年份和月份，获取月份差，不计四舍五入
* @author CISS
* @create 2012-10-22
* @param dDate1
* Date：起始月
* @param dDate2
* Date：终止月
* @return int：dDate2-dDate1的月份差
*/
public static int monthDiff(java.util.Date dDate1, java.util.Date dDate2) {
int year, month;
GregorianCalendar cld = new GregorianCalendar();
cld.setTime(dDate2);
year = cld.get(Calendar.YEAR);
month = cld.get(Calendar.MONTH);
cld.setTime(dDate1);
year -= cld.get(Calendar.YEAR);
month -= cld.get(Calendar.MONTH);
return year * 12 + month;
}
/**
* 返回date2与当前日期，月份差
* @author CISS
* @create 2012-10-22
* @param dDate2
* @return
*/
public static int monthDiff(java.util.Date dDate2) {
return monthDiff(new java.util.Date(), dDate2);
}
/**
* 判断闰年 return new GregorianCalendar().isLeapYear(year);
* @author CISS
* @create 2012-10-22
* @param year
* @return
*/
public static boolean isLeapYear(int year) {
return new GregorianCalendar().isLeapYear(year);
}
/**
* 判断闰年
* @author CISS
* @create 2012-10-22
* @param dDate
* @return
*/
public static boolean isLeapYear(Date dDate) {
GregorianCalendar cl = new GregorianCalendar();
cl.setTime(dDate);
return cl.isLeapYear(cl.get(Calendar.YEAR));
}
/**
* 获取指定年份范围内的闰年数
* @author CISS
* @create 2012-10-22
* @param startYear：起始年（包含）
* @param endYear：结束年（包含）
*/
public static int getLeapYears(int startYear, int endYear) {
int count = 0;
GregorianCalendar cl = new GregorianCalendar();
for (int i = startYear; i <= endYear; i++)
if (cl.isLeapYear(i))
count++;
return count;
}
/**
* 获取指定日期范围内的闰年数
* @author CISS
* @create 2012-10-22
* @param startDate：起始日期（包含）
* @param endDate：结束日期（包含）
*/
public static int getLeapYears(Date startDate, Date endDate)
throws ParseException {
int leapDays = 0;
Date dDate;
for (int i = getYear(startDate); i <= getYear(endDate); i++) {
if (isLeapYear(i)) {
dDate = toDate(i + "-02-29");
if (dateDiff(dDate, startDate) <= 0
&& dateDiff(dDate, endDate) >= 0) {
leapDays++;
}
}
}
return leapDays;
}
/**
* 月末日28/29/30/31？ 使用GregorianCalendar.getActualMaximum
* @author CISS
* @create 2012-10-22
* @param year
* @param month
* @return
*/
public static int endOfMonth(int year, int month) {
return new GregorianCalendar(year, month - 1, 1)
.getActualMaximum(Calendar.DAY_OF_MONTH);
}
/**
* 月末日28/29/30/31？ 使用GregorianCalendar.getActualMaximum
* @author CISS
* @create 2012-10-22
* @param dDate
* @return
*/
public static int endOfMonth(Date dDate) {
GregorianCalendar cl = new GregorianCalendar();
cl.setTime(dDate);
return cl.getActualMaximum(Calendar.DAY_OF_MONTH);
}
// 数字类函数********************************************************************
// (因为金额小数只有两位，所以double可以表示足够大的数据)
/**
* 判断是否数值 Decimal
* @author CISS
* @create 2012-10-22
* @param sNum
* @return
*/
public static boolean isNumeric(String sNum) {
try {
toNumber(sNum);
return true;
} catch (YssException ye) {
return false;
}
}
/**
* 自动分析sNum格式，解析成double类型返回 支持千分符，科学计数，百分数...前后空格，前导的+号和0 遇其它非法格式报错
* @author CISS
* @create 2012-10-22
* @param sNum
* @return
* @throws YssException
*/
public static double toNumber(String sNum) throws YssException {
int i = 0;
DecimalFormat df = new DecimalFormat(sNum.indexOf("%") > 0 ? "#,###.#%"
: "#,###.#E0");
try {
sNum = trim(sNum);
if (sNum.length() > 1)
if (sNum.charAt(0) == '0') { // 去前导连续0，注意只有一个0的情况
if (sNum.charAt(1) != '.')
for (i = 0; i < sNum.length() - 1; i++)
if (sNum.charAt(i) != '0')
break;
} else if (sNum.charAt(0) == '+')
i = 1;
return df.parse(
i == 0 || sNum.indexOf("%") > 0 ? sNum : sNum.substring(i))
.doubleValue();
} catch (Exception pe) {
throw new YssException("非法数值格式！", pe);
}
}
/**
* 把字符串变双精度，格式不对返回0，不报错
* @author CISS
* @create 2012-10-22
* @param sNum
* String
* @return int
*/
public static double toDouble(String sNum) {
try {
return toNumber(sNum);
} catch (Exception e) {
return 0.0;
}
}
/**
* 把字符串变整数，格式不对返回0，不报错
* @author CISS
* @create 2012-10-22
* @param sNum
* String
* @return int
*/
public static int toInt(String sNum) {
try {
return (int) toNumber(sNum);
} catch (Exception e) {
return 0;
}
}
/**
* 数字格式化 //注意不一定四舍五入，有时候（偶数后的5）舍5！alex20041124解决这个问题！ 相当于vb中的format，不过只能是数字
* @author CISS
* @create 2012-10-22
* @param number
* @param format
* @return
*/
public static final String formatNumber(double number, String format) {
int decs = 0;// 要保留的小数位数
if (format.trim().length() == 0)
format = "#0.00";
int i = format.indexOf(".");
// alex20041124，先按照format中指定的小数位数对number进行round，再格式化
if (i >= 0) {
for (decs = ++i; decs < format.length(); decs++) {
if (format.charAt(decs) != '0' && format.charAt(decs) != '#')
break;
}
decs -= i;
}
if (format.indexOf("%") >= 0)
decs += 2;// 百分比
return (new DecimalFormat(format)).format(YssD.round(number, decs));
}
public static final String formatNumber(long number, String format) {
return (new DecimalFormat(format)).format(number);
}
/**
* 数字取指定小数位数，默认四舍五入 如果bTranc=true则舍去下一位
* @author CISS
* @create 2012-10-22
* @param val1
* @param lDecs
* @param bTrunc
* @return
*/
public static double roundIt(double val1, int lDecs, boolean bTrunc) {
return YssD.round(val1, lDecs, bTrunc);
}
/**
* 数字取指定小数位数，默认四舍五入
* @author CISS
* @create 2012-10-22
* @param val1
* @param lDecs
* @return
*/
public static final double roundIt(double val1, int lDecs) {
return roundIt(val1, lDecs, false);
}
/**
* 数值格式化函数，与formatNumber不同，这个可以保证四舍五入！ 另有同名的日期格式化函数，以兼容原vb下的同名函数
* @author CISS
* @create 2012-10-22
* @param val1
* @param sForm
* @return
*/
public static String roundF(double val1, String sForm) {
int ldec = 2;
String stmp;
boolean percent = false;
// 先round再format
if (sForm.length() != 0) {
stmp = sForm.trim();
if (stmp.charAt(stmp.length() - 1) == '%') {
stmp = stmp.substring(0, stmp.length() - 1).trim();
percent = true;
}
ldec = stmp.indexOf(".");
if (ldec >= 0)
ldec = stmp.length() - ldec - 1;
else
ldec = 0;
if (percent)
ldec += 2;
val1 = roundIt(val1, ldec);
}
return new DecimalFormat(sForm).format(val1);
}
/**
* 数值格式化函数，与formatNumber不同，这个可以保证四舍五入！ 另有同名的日期格式化函数，以兼容原vb下的同名函数
* @author CISS
* @create 2012-10-22
* @param val1
* @param sForm
* @return
*/
public static final String roundF(Date val1, String sForm) {
return formatDate(val1, sForm);
}
/**
* 把数字转换成中文大写金额，分以下小数截位
* @author CISS
* @create 2012-10-22
* @param dblMoney
* double：数字
* @param blnFull
* boolean： =False,2001.30->贰仟零壹元叁角整 =True,2001.30->贰仟零佰零拾壹元叁角零分
* @param bZheng
* boolean：是否强制末尾加整字（如果不是到分，那么一定有整）
* @return String
*/
public static final String chineseAmount(double dblMoney, boolean blnFull,
boolean bZheng) {
String conChineseNum = "零壹贰叁肆伍陆柒捌玖";
String conChineseMUnit = "分角元拾佰仟万拾佰仟亿";
String strMoney = null;
String T1 = "";
char T2, t0 = ' ';
int ii, jj, kk;
boolean noZero = false;
strMoney = new DecimalFormat("0.00").format(YssD.round(dblMoney, 2,
true));// 去掉前导0
kk = 0;
if (blnFull) {
for (ii = strMoney.length() - 1; ii >= 0; ii--) {
T2 = strMoney.charAt(ii);
if (T2 >= '0' && T2 <= '9') {
T1 = String.valueOf(conChineseNum.charAt(T2 - '0'))
+ String.valueOf(conChineseMUnit.charAt(kk++)) + T1;
if (kk > 10)
kk -= 8;
}
}
} else {
for (ii = strMoney.length() - 1; ii >= 0; ii--) {
T2 = strMoney.charAt(ii);
if (T2 == '0' && !noZero) {
if (kk == 2 || kk == 6)
T1 = String.valueOf(conChineseMUnit.charAt(kk)) + T1;
else if (kk == 10)
T1 = String.valueOf(conChineseMUnit.charAt(kk))
+ (T1.charAt(0) == '万' ? T1.substring(1) : T1);
if (++kk > 10)
kk -= 8;
} else if (T2 == '.' && !noZero) {
} else {
noZero = true;
if (T2 >= '0' && T2 <= '9') {
if (T2 == '0') {
if (T2 != t0) {
t0 = T2;
jj = T2 - '0';
if (kk == 2 || kk == 6 || kk == 10)
T1 = String.valueOf(conChineseMUnit
.charAt(kk))
+ T1;
else
T1 = String.valueOf(conChineseNum
.charAt(jj))
+ T1;
} else {
if (kk == 2 || kk == 6)
T1 = String.valueOf(conChineseMUnit
.charAt(kk))
+ T1;
else if (kk == 10)
T1 = String.valueOf(conChineseMUnit
.charAt(kk))
+ (T1.charAt(0) == '万' ? T1
.substring(1) : T1);
}
} else {
t0 = T2;
jj = T2 - '0';
if (kk == 10 && T1.charAt(0) == '万')
T1 = T1.substring(1);
T1 = String.valueOf(conChineseNum.charAt(jj))
+ String
.valueOf(conChineseMUnit.charAt(kk))
+ T1;
}
if (++kk > 10)
kk -= 8;
}
}
}
T2 = T1.charAt(0);
while (conChineseMUnit.indexOf(T2) >= 0 || T2 == '零') {
T1 = T1.substring(1);
if (T1.length() > 1)
T2 = T1.charAt(0);
else
break;
}
if (T1.length() == 0)
T1 = "零元";
}
return T1
.concat(bZheng || T1.charAt(T1.length() - 1) != '分' ? "整" : "");
}
public static String chineseAmount(double dblMoney, boolean blnFull) {
return chineseAmount(dblMoney, blnFull, false);
}
public static String chineseAmount(double dblMoney) {
return chineseAmount(dblMoney, false, false);
}
public static String chineseAmount(String strMoney, boolean blnFull,
boolean bZheng) {
try {
return chineseAmount(toNumber(strMoney), blnFull, bZheng);
} catch (YssException ye) { // 不是数字，toNumber报错
return "";
}
}
public static String chineseAmount(String strMoney, boolean blnFull) {
try {
return chineseAmount(toNumber(strMoney), blnFull, false);
} catch (YssException ye) {
return "";
}
}
public static String chineseAmount(String strMoney) {
try {
return chineseAmount(toNumber(strMoney), false, false);
} catch (YssException ye) {
return "";
}
}
// 字符串类函数********************************************************************
/**
* java可以实现left,right,mid，可是如果超过长度，会报错，这里提供容错版本
* @author CISS
* @create 2012-10-22
* @param sSrc
* @param iLen
* @return String
*/
public static final String left(String sSrc, int iLen) {
if (iLen >= sSrc.length())
return sSrc;
return sSrc.substring(0, iLen);
}
public static final String right(String sSrc, int iLen) {
if (iLen >= sSrc.length())
return sSrc;
return sSrc.substring(sSrc.length() - iLen);
}
public static final String mid(String sSrc, int iStart, int iLen) {
if (iStart + iLen >= sSrc.length())
return sSrc.substring(iStart);
return sSrc.substring(iStart, iStart + iLen);
}
public static final String mid(String sSrc, int iStart) {
return sSrc.substring(iStart);
}
/**
* 去除字符串尾部空格
* @author CISS
* @create 2012-10-22
* @param sSrc
* String：源串
* @return String：去除尾部空格后的结果
*/
public static final String rTrim(String sSrc) {
int i;
for (i = sSrc.length() - 1; i >= 0; i--)
if (sSrc.charAt(i) != ' ')
break;
if (i < 0)
return "";
return sSrc.substring(0, i + 1);
}
/**
* 去除字符串开头空格
* @author CISS
* @create 2012-10-22
* @param sSrc
* String：源串
* @return String：去除开头空格后的结果
*/
public static final String lTrim(String sSrc) {
int len = sSrc.length();
int i;
for (i = 0; i < len; i++)
if (sSrc.charAt(i) != ' ')
break;
if (i >= len)
return "";
return sSrc.substring(i);
}
/**
* 去除字符串首尾的空格
* @author CISS
* @create 2012-10-22
* @param sSrc
* String：源串
* @return String：去除空格后的结果串
*/
public static final String trim(String sSrc) {
int i, j;
// 去除尾部空格
for (i = sSrc.length() - 1; i >= 0; i--)
if (sSrc.charAt(i) != ' ')
break;
if (i < 0)
return "";
// 去除开头空格
for (j = 0; j < i; j++) {
if (sSrc.charAt(j) != ' ')
break;
}
return sSrc.substring(j, i + 1);// 返回从j到i的字符
}
/**
* 去除字符串中的所有的空格
* @author CISS
* @create 2012-10-22
* @param sSrc 源字符串
* @return String：去除空格后的结果串
*/
public static final String ATrim(String sSrc) {
Pattern p = Pattern.compile("\\s*|\t|\r|\n");
Matcher m = p.matcher(sSrc);
return m.replaceAll("");
}
/**
* 去除字符串中的所有全角的空白字符
* @author CISS
* @create 2012-10-22
* @param sSrc 源字符串
* @return String：去除全角的空白字符后的结果串
*/
public static final String QTrim(String sSrc) {
String RegularExp = "^[ ]+|[ ]+$";
return (sSrc.replaceAll(RegularExp, "")).trim();
}
/**
* 其实string的split方法，如果limit参数为负数，也可以显示这一功能，只是默认是0
* 代替java的String类的split方法，即使最后以分隔符结束，也能正确返回最后的空串
* @author CISS
* @create 2012-10-22
* @param sSrc
* String：要split的原始串
* @param delimiter
* String：分隔符
* @return String[]：返回字符串数组
*/
public static final String[] split(String sSrc, String delimiter) {
String[] sarr;
int l, len;
sarr = java.util.regex.Pattern.compile(delimiter, 0).split(sSrc + " ",
0);
l = sarr.length - 1;
len = sarr[l].length();
if (len <= 1)
sarr[l] = "";
else
sarr[l] = sarr[l].substring(0, len - 1);
return sarr;
}
/**
* 将指定范围的数组元素组合起来成一个字符串
* @author CISS
* @create 2012-10-22
* @param sArr
* String[]
* @param delimiter
* String：连接字符
* @param iStart
* int：起始元素位置
* @param iEnd
* int：截止元素
* @return String：组合成的字符串
*/
public static final String join(String[] sArr, String delimiter,
int iStart, int iEnd) {
StringBuffer buf = new StringBuffer();
for (int i = (iStart != 0 ? iStart : 0); i < (iEnd != 0 ? iEnd + 1
: sArr.length); i++)
buf.append(delimiter).append(sArr[i]);
return (buf.length() > 0 && delimiter.length() > 0 ? buf
.substring(delimiter.length()) : buf.toString());
}
public static final String join(String[] sArr, String delimiter, int iStart) {
return join(sArr, delimiter, iStart, 0);
}
public static final String join(String[] sArr, String delimiter) {
return join(sArr, delimiter, 0, 0);
}
public static int getStart(String strAccLen) {
int iStart = 0;
for (int i = 0, j = strAccLen.indexOf("6"); i < j; i++) {
iStart += strAccLen.charAt(i) - '0';
}
return iStart;
}
/**
* 将日期字符串转化成短日期格式
* @author CISS
* @create 2012-10-22
* @param str
* @return
* @throws YssException
*/
public static Date stringToForamtDate(String str) throws ParseException {
return toDate(formatDate(toDate(str.trim())));
}
/**
* 将日期字符串转化成java.sql.Date格式
* @author CISS
* @create 2012-10-22
* @param str
* @return
* @throws YssException
*/
public static java.sql.Date toSqlDate(String str) throws ParseException {
return toSqlDate(toDate(str.trim()));
}
/**
* 获取当年实际天数
* @author CISS
* @create 2012-10-22
* @param year
* @return
* @throws YssException
*/
public static int getActualYDays(Date date) throws YssException {
int days = 0;
int year = getYear(date);
try{
Date sDate = toDate(year+"-01-01");
Date eDate = toDate(year+"-12-31");
days = dateDiff(sDate,eDate)+1;
}catch(Exception e){
throw new YssException("获取"+year+"年实际天数出错");
}
return days;
}
public static int getActualYDays() throws YssException {
return getActualYDays(new Date());
}
/**
* 获取当月实际天数
* @author CISS
* @create 2012-10-22
* @param date
* @return
* @throws YssException
*/
public static int getActualMDays(Date date) throws YssException {
int days = 0;
int year = getYear(date);
int month = getMonth(date);
try{
Date sDate = toDate(year+"-"+month+"-1");
Date eDate = addDay(toDate(year+"-"+(month+1)+"-1"),-1);
days = dateDiff(sDate,eDate)+1;
}catch(Exception e){
throw new YssException("获取当月实际天数出错");
}
return days;
}
public static int getActualMDays() throws YssException {
return getActualMDays(new Date());
}
/**
* 获取月末最后一天(日期)
* @author CISS
* @create 2012-10-22
* @param date
* @return
* @throws YssException
* @throws ParseException
*/
public static Date getMonthLastDay(Date date) throws ParseException {
int year = getYear(date);
int month = getMonth(date);
Date mlastDay = addDay(toDate(year+"-"+(month+1)+"-1"),-1);
return mlastDay;
}
/**
* 解析合并项的单元格坐标信息
* @author CISS
* @create 2012-10-22
* @param collection 后台传回带有合计项的明细集合
* @param columns 统计维度字符串，前台传递
* @param startRow 内容体起始行
* @param flag 是否存有 "合计"项，true:存在,false:不存在. 注意:当只有一个维度的时候应当设置为false
* @return 合并区域的坐标字符串拼接
* @throws YssException
*/
public static String mergeCell(Collection collection,String columns,int startRow,boolean flag)throws YssException{
StringBuffer datas = new StringBuffer();
if(columns != null && columns.length() > 0){
String[] properties = columns.split(",");
if(collection != null && collection.size() > 0){
int size = properties.length;
//如果多于一个维度，最明细维度不统计合并
if(properties.length > 1){
size = properties.length-1;
}
String tmpValue = null;
String value_next = null;
for(int i = 0; i < size; i++){
//当前维度
String col = properties[i];
//起始行计数器
int row_1 = startRow;
//截止行计数器
int row_2 = startRow - 1;
//存放上一个维度的值
String colTmp = "undefined";
Object obj = null;
Iterator it = collection.iterator();
while(it.hasNext()){
try{
row_2++;
//获取对象当前维度值
Object pro = it.next();
//存放当前维度值
String value = null;
if(pro.getClass().getName().indexOf("ListOrderedMap")>=0){
Object tmpvalue = ((Map)pro).get(col);
value = String.valueOf(tmpvalue);
}else{
Field field = pro.getClass().getDeclaredField(col);
field.setAccessible(true);
value = String.valueOf(field.get(pro));
field.setAccessible(false);
}
if(flag){
//下一个维度
if(size < 1){
throw new YssException("业务类参数错误：当统计维度少于2个时，请设定合计统计项为False！");
}
//判断当前遍历的行是否为合计行
String sumrow = getPreCol(pro,properties,i);
if(sumrow.indexOf("合计") >= 0 || sumrow.indexOf("小计") >= 0){
//如果是合计行，则只需维度的合并起始指针下移
row_1++;
continue;
}
//下一个维度
String nextCol = properties[i+1];
//获取对象下一个维度值
if(pro.getClass().getName().indexOf("ListOrderedMap")>=0){
Object tmpvalue = ((Map)pro).get(nextCol);
value_next = String.valueOf(tmpvalue);
}else{
Field field_next = pro.getClass().getDeclaredField(nextCol);
field_next.setAccessible(true);
value_next = String.valueOf(field_next.get(pro));
field_next.setAccessible(false);
//取出下一个维度的值 存放在临时变量
if (tmpValue==null||tmpValue.trim().length()==0) {
tmpValue = value_next;
}
}
if("合计".equals(value_next.trim()) || "小计".equals(value_next.trim())){
/**
* 合并前台BGrid中产品二级类型与产品三级类型一致的单元格
* 注意此处为硬编码 by lzl
*/
// System.out.println(pro.getClass().getName());
if (tmpValue.equals(value)&&col.equalsIgnoreCase("proSecondType")) {
//纵向合并当前维度
datas.append(row_1).append(",").append(i).append(",").append(row_2).append(",").append(i+1).append("_");
//横向合并合计项
datas.append(row_2).append(",").append(i+1).append(",").append(row_2).append(",").append(properties.length-1).append("_");
int t = i;
for (;t<properties.length-1;t++) {
datas.append(row_2-1).append(",").append(t+2).append(",").append(row_2).append(",").append(t+2).append("_");
}
} else {
//纵向合并当前维度
datas.append(row_1).append(",").append(i).append(",").append(row_2).append(",").append(i).append("_");
//横向合并合计项
datas.append(row_2).append(",").append(i+1).append(",").append(row_2).append(",").append(properties.length-1).append("_");
}
tmpValue = null;
//合计起始位置前移
row_1 = row_2 + 1;
}
}else{
value = getPreCol(pro,properties,i);
//当第一次进入时，需要临时存放第一个单元格的值
if("undefined".equals(colTmp)){
colTmp = value.trim();
obj = pro;
}else{
if(!colTmp.equals(value.trim())){
/**
* BEGIN by lzl
* 下面判断是对于产品二级类型及三级类型的列合并
* 注意：为硬编码
*/
if (col.equalsIgnoreCase("productTwoType")) {
Field field = obj.getClass().getDeclaredField(col);
field.setAccessible(true);
tmpValue = String.valueOf(field.get(obj));
field.setAccessible(false);
Field field_next = obj.getClass().getDeclaredField(properties[i+1]);
field_next.setAccessible(true);
value_next = String.valueOf(field_next.get(obj));
field_next.setAccessible(false);
if (value_next!=null&&value_next.equals(tmpValue)) {
datas.append(row_1).append(",").append(i).append(",").append(row_2-1).append(",").append(i+1).append("_");
} else {
datas.append(row_1).append(",").append(i).append(",").append(row_2-1).append(",").append(i).append("_");
}
//END
} else {
datas.append(row_1).append(",").append(i).append(",").append(row_2-1).append(",").append(i).append("_");
}
// datas.append(row_1).append(",").append(i).append(",").append(row_2-1).append(",").append(i).append("_");
tmpValue = null;
colTmp = value.trim();
obj = pro;
row_1 = row_2;
}else if((row_2-(startRow-1)) == collection.size()){
datas.append(row_1).append(",").append(i).append(",").append(row_2).append(",").append(i).append("_");
}
}
}
}catch(Exception e){
e.printStackTrace();
throw new YssException(e);
}
// System.out.println(datas.toString());
}
}
//如果存在合并需求，则统计最后一个总计合并坐标
if(flag){
int tx = collection.size() + startRow - 1;
datas.append(tx).append(",").append(0).append(",").append(tx).append(",").append(properties.length-1).append("_");
}
}
}
if(datas.length() > 0){
datas.setLength(datas.length()-1);
}
return datas.toString();
}
/**
* 获取所属维度key值
* @author CISS
* @create 2012-10-22
* @param obj 当前对象
* @param properties 维度数组
* @param index 当前维度索引
* @return 所属维度key
* @throws YssException
*/
private static String getPreCol(Object obj,String[] properties,int index)throws YssException{
StringBuffer result = new StringBuffer();
String value = null;
try{
for(int i = 0; i <= index; i++){
String property = properties[i];
if(obj.getClass().getName().indexOf("ListOrderedMap")>=0){
Object tmp = ((Map)obj).get(property);
value = String.valueOf(tmp);
}else{
Field field = obj.getClass().getDeclaredField(property);
field.setAccessible(true);
value = String.valueOf(field.get(obj));
field.setAccessible(false);
}
if(value == null || value.trim().length() == 0 || "null".equalsIgnoreCase(value.trim())){
value = "--";
}
result.append(value);
}
return result.toString();
}catch(Exception e){
e.printStackTrace();
throw new YssException("解析单元格合并坐标失败");
}
}
/**
* 判断星期数
* @author CISS
* @create 2012-10-22
* @param querydate
* @return
* @throws YssException
*/
public static int getWeekOfYear(Date querydate)throws YssException{
//每月多少日
int [] monthOfFullDay = new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
//当前日，在本年中第几日
int currentDayOfYear = 0;
//是否为润年，即能被4整除
boolean isFullYear = isLeapYear(querydate);
boolean currentDayOfWeekIsLastDay = false;
boolean firstDayOfYearIsFirstDayOfWeek = false;
int year = getYear(querydate);
//当前月份
int month = getMonth(querydate);
//当前日
int day = getDay(querydate);
//当前星期几
int week = getWeekDay(querydate);
//循环计算天数
for(int i=1;i<=monthOfFullDay.length;i++){
//判断数组月份是否小于等于当前月份
if(i<month){
//是闰年和2月份
if(isFullYear && i==2)
currentDayOfYear = currentDayOfYear + 29;
else
currentDayOfYear = currentDayOfYear + monthOfFullDay[i-1];
}
if(i==month)
currentDayOfYear = currentDayOfYear + day;
}
//设置本年1月1日
Date firstDayOfYear = parseDate(year+"-01-01");
if(getWeekDay(firstDayOfYear)==2){
firstDayOfYearIsFirstDayOfWeek = true;
}
int weeksOfYear = currentDayOfYear;
//本星期是否为最后一日，否，则减去本星期所有日
if(!currentDayOfWeekIsLastDay){
weeksOfYear = weeksOfYear + getWeekDay(firstDayOfYear);
}
//是否第一个星期为第一日（即星期日），否，则减去本星期所有日
if(!firstDayOfYearIsFirstDayOfWeek){
weeksOfYear = weeksOfYear + 7;
}
return weeksOfYear/7;
}
/**
* 比较date1 所在的月份是否在 comparedDate所在的月份之后
* @author CISS
* @create 2012-10-22
* @param date
* @param comparedDate
* @return
* @throws YssException
*/
public static boolean afterMonth(Date date,Date comparedDate)throws YssException{
if(date==null){
throw new YssException("比较的日期不能为空!");
}
else if(comparedDate==null){
throw new YssException("被比较的日期不能为空!");
}
else{
int dyear=date.getYear();
int cyear=comparedDate.getYear();
if(dyear>cyear){
return true;
}
else if(dyear<cyear){
return false;
}
else{
int dmonth=date.getMonth();
int cmonth=comparedDate.getMonth();
return dmonth-cmonth>0?true:false;
}
}
}
/**
* 判断两个日期所属月份是否相同
* @author CISS
* @create 2012-10-22
* @param date1
* @param date2
* @return
* @throws YssException
*/
public static boolean isSameMonth(Date date1,Date date2)throws YssException{
if(date1==null || date2==null){
throw new YssException("两个判断的月份不能为空");
}else{
if(date1.getYear()==date2.getYear() && date1.getMonth()==date2.getMonth()){
return true;
}else{
return false;
}
}
}
/**
* 获取日期所在的年月
* @author CISS
* @create 2012-10-22
* @param date
* @return
* @throws YssException
*/
public static String getMonthCode(Date date)throws YssException{
if(date==null){
throw new YssException("日期不能为空");
}else{
return String.valueOf(date.getYear())+String.valueOf(date.getMonth());
}
}
/**
* XMLGregorianCalendar 类型 转换成 Date 类型
* 与新平台交互参数转换方法
* @author CISS
* @create 2012-10-22
* @param cal
* @return
* @throws Exception
*/
public static Date convertToDate(XMLGregorianCalendar cal) throws Exception{
GregorianCalendar ca = cal.toGregorianCalendar();
return ca.getTime();
}
/**
* Date 类型 转换成 XMLGregorianCalendar 类型
* 与新平台交互参数转换方法
* @author CISS
* @create 2012-10-22
* @param date
* @return
*/
public static XMLGregorianCalendar toxmldate(Date date){
if (date == null)
return null;
GregorianCalendar gc = new GregorianCalendar ();
XMLGregorianCalendar xmldate =null;
gc.setTime(date);
try {
xmldate = DatatypeFactory.newInstance().newXMLGregorianCalendar(gc);
} catch (DatatypeConfigurationException e) {
e.printStackTrace();
}
return xmldate;
}
/**
* 该方法主要用于构建作为Xfire客户端时，请求参数封装（所有参数需参考生成客户端中实体属性的设置）
* @author CISS
* @create 2012-10-22
* @param packge
* @param qname
* @param value
*/
public static JAXBElement createJAXBElement(String packge,String qname,String value){
return new JAXBElement<String>(new QName(packge, qname), String.class, value);
}
}
浙公网安备 33010602011771号