package com.gx.util;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.servlet.http.HttpServletRequest;
import org.apache.log4j.Logger;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.struts2.ServletActionContext;
import org.springframework.core.io.ClassPathResource;
public class Tools {
/**
* Logger for this class
*/
private static final Logger logger = Logger.getLogger(Tools.class);
/**
* MD5加密操作
*
* @param data
* @return
*/
public static String md5(String str) {
if(isNull(str)){
return null;
}
return MD5.encrypt(str);
}
/**
*
* 功能描述：检查是否为null
*
* @since Mar 18, 2010 9:21:03 PM
* @version 1.0
* @param str
* 被检查对象
* @return boolean null?true:false
*/
public static boolean isNull(Object obj) {
if (obj == null)
return true;
return false;
}
/**
*
* 功能描述：检查字符串是否为空
*
* @since Mar 18, 2010 9:25:26 PM
* @version 1.0
* @param str
* 被检查字符串
* @return boolean ""?true:false
*/
public static boolean isEmpty(String str) {
if ("".equals(str.trim()))
return true;
return false;
}
/**
*
* 功能描述：检查字符串是否为空或null
*
* @since Mar 18, 2010 9:27:49 PM
* @version 1.0
* @param str
* 被检查字符串
* @return
*/
public static boolean isNullOrEmpty(String str) {
if (isNull(str) || isEmpty(str))
return true;
return false;
}
/**
* 字符串中某个字符出现多少次
*
* @param str
* @param ch
* @return
*/
public static Integer contain(String str, char ch) {
int count = 0;
for (int i = 0; i < str.length(); i++) {
if (ch == str.charAt(i))
count++;
}
return count;
}
/**
* 功能说明：string转换编码格式
*
* @param str
* @param code 编码格式,比如(utf-8,GBK等)
* @return
* @throws
* @time Aug 15, 2010 10:02:16 AM
*/
public static String StringEncode(String str, String code) {
if (isNullOrEmpty(str))
return null;
if (isNullOrEmpty(code))
return null;
try {
return new String(str.getBytes(), code);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return null;
}
/**
* 功能说明：随机生成字符，含大写、小写、数字
*
* @return
* @time Nov 9, 2010 1:25:47 PM
*/
public static String getRandomChar() {
int index = (int) Math.round(Math.random() * 2);
String randChar = "";
switch (index) {
case 0:// 大写字符
randChar = String
.valueOf((char) Math.round(Math.random() * 25 + 65));
break;
case 1:// 小写字符
randChar = String
.valueOf((char) Math.round(Math.random() * 25 + 97));
break;
default:// 数字
randChar = String.valueOf(Math.round(Math.random() * 9));
break;
}
return randChar;
}
/**
* 功能说明：将日期格式为年月日
*
* @param
* @param
* @param date
* @return
* @throws
* @time Sep 27, 2010 11:01:08 AM
*/
public static String formatDateToYMD(Date date) {
if (date == null)
return null;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
return sdf.format(date);
}
/**
* 功能说明：将日期格式为年月日时分秒
*
* @param
* @param
* @param date
* @return
* @throws
* @time Sep 27, 2010 11:01:40 AM
*/
public static String formatDateToYMDHMS(Date date) {
if (date == null)
return null;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return sdf.format(date);
}
/**
* 将Date 转换成Long
*
* @Title: getLongByDate
* @param @param date
* @param @return
* @return long
*/
public static Long getLongByDate(Date date) {
if (date == null) {
return null;
}
Long time = date.getTime() / 1000; // 得到秒数，Date类型的getTime()返回毫秒数
return time;
}
/**
* Long类型的转换成标准格式(String类型)
* @param str 单位:秒
* @return
*/
public static Date getDateByLong(Long str) {
if(str!=null){
return new Date(str * 1000);
}else{
return null;
}
}
/**
* Date类型的转换成标准格式(String类型)
* @param date
* @return
*/
public static String getStringByDate(Date date) {
if(date!=null){
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return df.format(date);
}else{
return null;
}
}
/**
* 获取上月第一天的日期
*
* @author wangmei
* @return
*/
public static String previousMonthFirstDay() {
String str = "";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar lastDate = Calendar.getInstance();
lastDate.set(Calendar.DATE, 1);// 设为当前月的1号
lastDate.add(Calendar.MONTH, -1);// 减一个月，变为下月的1号
str = sdf.format(lastDate.getTime());
return str;
}
/**
* 获取上月第一天(String)
*
* @return
*/
public static String previousMonFirstDay() {
Calendar cal = Calendar.getInstance();
int year = cal.get(Calendar.YEAR);
int month = cal.get(Calendar.MONTH) + 1;
cal.set(Calendar.DAY_OF_MONTH, 1);
cal.add(Calendar.DAY_OF_MONTH, -1);
int day = cal.get(Calendar.DAY_OF_MONTH);
String months = "";
if (month > 1) {
month--;
} else {
year--;
month = 12;
}
if (!(String.valueOf(month).length() > 1)) {
months = "0" + month;
} else {
months = String.valueOf(month);
}
if (!(String.valueOf(day).length() > 1)) {
} else {
}
String firstDay = "" + year + "-" + months + "-01";
String[] lastMonth = new String[2];
lastMonth[0] = firstDay;
return firstDay + " 00:00:00";
}
/**
* 获取当月第一天,返回字符串
* @return
*/
public static String currentMonFirstDay() {
String str = "";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar lastDate = Calendar.getInstance();
lastDate.set(Calendar.DATE, 1);// 设为当前月的1号
str = sdf.format(lastDate.getTime());
return str;
}
/**
* 获得上月最后一天的日期
*
* @return
*/
public static String PreviousMonthLastDay() {
String str = "";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar lastDate = Calendar.getInstance();
lastDate.add(Calendar.MONTH, -1);// 减一个月
lastDate.set(Calendar.DATE, 1);// 把日期设置为当月第一天
lastDate.roll(Calendar.DATE, -1);// 日期回滚一天，也就是本月最后一天
str = sdf.format(lastDate.getTime());
return str;
}
/**
* 获取当月最后一天,返回字符串
*
* @author wangmei
* @return
*/
public static String currentMonLastDay() {
String str = "";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar lastDate = Calendar.getInstance();
lastDate.set(Calendar.DATE, 1);// 设为当前月的1号
lastDate.add(Calendar.MONTH, 1);// 加一个月，变为下月的1号
lastDate.add(Calendar.DATE, -1);// 减去一天，变为当月最后一天
str = sdf.format(lastDate.getTime());
return str;
}
/**
* 返回当月有多少天
*
* @param date
* @return
*/
public static int getDaysOfTheMonth(Date date) {// 获取当月天数
Calendar rightNow = Calendar.getInstance();
rightNow.setTime(date); // 要计算你想要的月份，改变这里即可
int days = rightNow.getActualMaximum(Calendar.DAY_OF_MONTH);
return days;
}
/**
* 返回当月有几个星期天
*
* @param date
* @return
*/
public static int getSundays(Date dat) {
int sundays = 0;
SimpleDateFormat sdf = new SimpleDateFormat("EEEE");
Calendar setDate = Calendar.getInstance();
// 从第一天开始
int day;
for (day = 1; day <= getDaysOfTheMonth(dat); day++) {
setDate.set(Calendar.DATE, day);
String str = sdf.format(setDate.getTime());
if (str.equals("星期日")) {
sundays++;
}
}
return sundays;
}
/**
* 获取N天前的时间 （返回格式String类型 2012-08-27 00:00:00）
*
* @Title: getSectionTime
* @Description: 使用方法：n 表示查询天数，例如 今天时间段 n=0;昨天n=1;近一周n=7；取值的时 开始时间
* map.get("startTime")；截止时间map.get("endTime")
* @param @param n
* @param @return
* @return Map<String,String>
* @author 周张豹
* @throws Map
* <String,String>
*/
public static Map<String, String> getNearestTime(Integer n) {
Map<String, String> map = new HashMap<String, String>();
Calendar cal = Calendar.getInstance();
Calendar cale = Calendar.getInstance();
cal.add(Calendar.DATE, -n);
if (n == 0) {
cale.add(Calendar.DATE, -0);
} else {
cale.add(Calendar.DATE, -1);
}
Date s = cal.getTime();
Date e = cale.getTime();
SimpleDateFormat sp = new SimpleDateFormat("yyyy-MM-dd");
map.put("startTime", sp.format(s) + " 00:00:00");// 开始时间
map.put("endTime", sp.format(e) + " 23:59:59");// 截止时间
return map;
}
/**
* 判断时间time是不是在pre跟last之间的时间
* @param d1
* @param d2
* @return
* @throws ParseException
*/
public static boolean compare_date(String time, String pre, String last) throws ParseException {
SimpleDateFormat f = new SimpleDateFormat("HH:mm:ss");
Boolean flag = false;
Date _time = f.parse(time);
Date _pre = f.parse(pre);
Date _last = f.parse(last);
if (_time.after(_pre) && _time.before(_last))
flag = true;
return flag;
}
/**
* 根据不同数据库获取不同的分页sql语句
* @param sql
* @param beginRow
* @param pageSize
* @return
*/
public static String getPageSql(String sql, int beginRow, int pageSize) {
String select = "select";
String from = "from";
if (Tools.isEmpty(sql))
throw new RuntimeException("sql 语句为空");
sql = sql.trim();
String[] temps = sql.split(" ");
if (temps == null || temps.length == 0) {
throw new RuntimeException("sql 语句错误" + sql);
}
if (temps[0].toUpperCase().equals(select.toUpperCase())) {
sql = sql.substring(6).trim();
if (!sql.startsWith("distinct")) {
sql = select + " rownum trow, " + sql;
sql = "(" + sql + ") coTable";
sql = "select coTable.* " + from + sql + " where trow>"
+ beginRow + " and trow<=" + (beginRow + pageSize); // 注意rownum
// 从1
// 开始
} else {
String temp = "(" + select + " " + sql + ") coT";
sql = select + " rownum trow,coT.* " + from + temp;
sql = "(" + sql + ") coTable";
sql = "select coTable.* " + from + sql + " where trow>"
+ beginRow + " and trow<=" + (beginRow + pageSize); // 注意rownum
// 从1
// 开始
}
}
logger.info("getPageSql sql is " + sql);
return sql;
}
/**
* 返回今天是周几
* @param pTime
* @return
* @throws Exception
*/
public static int dayForWeek(Date pTime) throws Exception {
Calendar c = Calendar.getInstance();
c.setTime(pTime);
int dayForWeek = 0;
if (c.get(Calendar.DAY_OF_WEEK) == 1) {
dayForWeek = 7;
} else {
dayForWeek = c.get(Calendar.DAY_OF_WEEK) - 1;
}
return dayForWeek;
}
/**
* 判断日期格式是否是:yyyy-mm-dd
* @param sDate
* @return
*/
public static boolean isValidDate_yyyy_mm_dd(String sDate) {
String datePattern1 = "\\d{4}-\\d{2}-\\d{2}";
String datePattern2 = "^((\\d{2}(([02468][048])|([13579][26]))"
+ "[\\-\\/\\s]?((((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|"
+ "(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?"
+ "((0?[1-9])|([1-2][0-9])))))|(\\d{2}(([02468][1235679])|([13579][01345789]))[\\-\\/\\s]?("
+ "(((0?[13578])|(1[02]))[\\-\\/\\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\\-\\/\\s]?"
+ "((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\\-\\/\\s]?((0?[1-9])|(1[0-9])|(2[0-8]))))))";
if ((sDate != null)) {
Pattern pattern = Pattern.compile(datePattern1);
Matcher match = pattern.matcher(sDate);
if (match.matches()) {
pattern = Pattern.compile(datePattern2);
match = pattern.matcher(sDate);
return match.matches();
} else {
return false;
}
}
return false;
}
/**
* 功能说明：系统集群时获得存放文件路径 为系统配置附件所用
*
* @param fileName
* 文件名称 可能为空
* @return
* @time Dec 27, 2011 9:49:17 AM
*/
public static String getClusterResourcePath(String fileName) {
final String BHT_SYS_FILE_DIR = "file_name";
String separate = File.separator;
String path = getResourcePath();
String rootDir = separate;// 默认为分隔符 linux unix
if ("\\".equals(separate)) {// windows系统
rootDir = path.substring(0, 2);
}
String sysConfigPaht = rootDir + separate + BHT_SYS_FILE_DIR + separate
+ fileName;
File sysConfigFile = new File(sysConfigPaht);
if (sysConfigFile.exists())
return sysConfigPaht;
return path + fileName + separate;
}
/**
* 功能说明：获得web根路径
*
* @return
* @throws
* @time Jul 24, 2010 6:05:03 PM
*/
public static String getResourcePath() {
String basePath = ServletActionContext.getServletContext().getRealPath("");
logger.info("path of webAppRootKey is ----> " + basePath);
return basePath;
}
/**
* 获取文件后缀名
*
* @param fileName
* @return
*/
public static String getTypeOfTheFile(String fileName) {
int pos = fileName.lastIndexOf(".");
return fileName.substring(pos);
}
/**
* 上传文件
* @param src
* @param dst
*/
public static void copy(File src, File dst) {
final int BUFFER_SIZE = 16 * 1024;
try {
InputStream in = null;
OutputStream out = null;
try {
in = new BufferedInputStream(new FileInputStream(src),
BUFFER_SIZE);
out = new BufferedOutputStream(new FileOutputStream(dst),
BUFFER_SIZE);
byte[] buffer = new byte[BUFFER_SIZE];
while (in.read(buffer) > 0) {
out.write(buffer);
}
} finally {
if (null != in) {
in.close();
}
if (null != out) {
out.close();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 功能说明：附件上传
*
* @param request
* @param file
* file对象
* @param accessoryPath
* 附件路径
* @param fileName
* 附件名称
* @time Oct 19, 2010 10:28:00 PM
*/
public static String uploadFile(HttpServletRequest request, File file,
String accessoryPath, String fileName) {
if (file == null)
return "";
// 文件上传目录
String uploadDir = getClusterResourcePath("") + accessoryPath;
// 如果目录不存在则自动创建
File dirPath = new File(uploadDir);
if (!dirPath.exists())
dirPath.mkdirs();
String tempName = "";
for (int i = 0; i < 6; i++) {
tempName += getRandomChar();
}
fileName = fileName+ "_" + tempName;
// 文件上传
String outPath = uploadDir + File.separator + fileName;
try {
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(outPath);
byte[] buffer = new byte[10240];
int len = 0;
while ((len = fis.read(buffer)) > 0) {
fos.write(buffer, 0, len);
fos.flush();
}
fis.close();
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return outPath;
}
/**
* 功能说明：删除目录下所有文件然后上传新文件
*
* @param request
* @param file
* file对象
* @param accessoryPath
* 附件路径
* @param newFileName
* 新文件名称
* @param oldFileName
* 旧文件名称
* @time Oct 19, 2010 10:28:00 PM
*/
public static String unuploadFileForUpdate(HttpServletRequest request,
File file, String accessoryPath, String newFileName,
String oldFileName) {
// 文件上传目录
// String uploadDir = request.getRealPath(File.separator) +
// accessoryPath;
String uploadDir = getClusterResourcePath("") + accessoryPath;
// 如果目录不存在则自动创建
File dirPath = new File(uploadDir);
if (!dirPath.exists()) {
dirPath.mkdirs();
}
if ((oldFileName != null || !"".equals(oldFileName)) && file != null) {
File[] files = dirPath.listFiles();
for (File filee : files) {
if (filee.getName().equals(oldFileName)) {
filee.delete();
break;
}
}
}
if (file != null)
return uploadFile(request, file, accessoryPath, newFileName);
return "";
}
/**
* 功能说明：附件删除
*
* @param request
* @param accessoryPath
* 附件路径
* @param oldFileName
* 旧文件名称
* @time Oct 19, 2010 10:28:00 PM
*/
public static void deleteAccessoryFile(HttpServletRequest request,
String accessoryPath, String oldFileName) {
// 文件上传目录
// String uploadDir = request.getRealPath(File.separator) +
// accessoryPath;
String uploadDir = getClusterResourcePath("") + accessoryPath;
// 如果目录不存在则自动创建
File dirPath = new File(uploadDir);
if (oldFileName != null || !"".equals(oldFileName)) {
File[] files = dirPath.listFiles();
for (File filee : files) {
if (filee.getName().equals(oldFileName)) {
filee.delete();
break;
}
}
}
}
/**
* 功能说明：单个文件删除
*
* @param filePath
* 文件路径
* @return
* @time Oct 20, 2010 10:57:46 AM
*/
public static void deleteFile(HttpServletRequest request, String filePath) {
// 文件上传目录
// filePath = request.getRealPath(File.separator) + filePath;
filePath = getClusterResourcePath("") + filePath;
File file = new File(filePath);
if (file.exists())
file.delete();
}
public static List<Object> readExcel(String targetPath) {
if(isNullOrEmpty(targetPath)){
return null;
}
// 创建对Excel工作簿文件的引用
HSSFWorkbook workbook = null;
List<Object> list=new ArrayList<Object>();
try {
workbook = new HSSFWorkbook(new FileInputStream(targetPath));
// 在Excel文档中，第一张工作表的缺省索引是0
HSSFSheet sheet = workbook.getSheetAt(0);
// 获取到Excel文件中的所有行数
int rows = sheet.getPhysicalNumberOfRows();
for (int i = 0; i < rows; i++) {
// 读取左上端单元格
HSSFRow row = null;
row = sheet.getRow(i + 1);
// 行不为空
if (row != null) {
String value="";
// 获取到Excel文件中的所有的列
int cells = row.getPhysicalNumberOfCells();
// 遍历列
for (int j = 0; j < cells; j++) {
// 获取到列的值
HSSFCell cell = row.getCell(j);
if (cell != null) {
switch (cell.getCellType()) {
case HSSFCell.CELL_TYPE_NUMERIC:
value += String.valueOf(cell.getNumericCellValue())+",";
break;
case HSSFCell.CELL_TYPE_STRING:
value += cell.getStringCellValue() + ",";
break;
default:
value += cell.toString() + ",";
break;
}
}
}
list.add(value.substring(0, value.length()-1));
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return list;
}
/**
* 读取配置文件
* @param path 配置文件路径
* @param key
* @return
*/
public static String getInfoFromProperties(String path, String key){
try {
Properties prop = new Properties();
prop.load(new ClassPathResource("/" + path).getInputStream());
String info = prop.getProperty(key);
if(info != null && info.trim() != ""){
return info;
}
} catch (IOException e) {
logger.error("读取配置文件出错出错！",e);
e.printStackTrace();
}
return "";
}
/**
* 传入数字金额字符串，返回数字金额对应的中文大字与读法
*
* @param money
* 金额字符串
* @return 金额中文大写
*/
public static String getCHSNumber(String money) {
final String[] CH = { "", "", "拾", "佰", "仟", "万", "", "", "", "亿", "",
"", "", "兆" };
final String[] CHS_NUMBER = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒",
"捌", "玖" };
String chs = "";
String tmp_int = money.substring(0, money.indexOf("."));
String tmp_down = money.substring(money.indexOf(".") + 1);
char[] tmp_int_char = tmp_int.toCharArray();
String[] tmp_chs = new String[tmp_int_char.length];
int tab = 0;
for (int i = 0; i < tmp_int_char.length; i++) {
tab = tmp_int_char.length - i - 1;
if (tmp_int_char.length <= 5) {
tmp_chs[tab] = CHS_NUMBER[(int) Float
.parseFloat(tmp_int_char[i] + ".0")];
if (!tmp_chs[tab].equals("零")) {
// tmp_int_char.Length - i 为数字所在的位数
chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
} else {
// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
if (!chs.endsWith("零") && tab != 0) {
chs = chs + tmp_chs[tab];
} else if (chs.endsWith("零") && tab == 0) {
chs = chs.substring(0, chs.length() - 1);
}
}
}
// 如果数字的位数大于５和小于９时
if (tmp_int_char.length > 5 && tmp_int_char.length < 9) {
tmp_chs[tab] = CHS_NUMBER[(int) Float
.parseFloat(tmp_int_char[i] + ".0")];
// 如：123,1234分成两部分
// 第１部分123：万以上亿以下
if (tab >= 4) {
// 当前数字不是大小零时
if (!tmp_chs[tab].equals("零")) {
chs = chs + tmp_chs[tab] + CH[tab - 3];
// 当第１部分算完时在加上"万"
if (tab == 4) {
chs = chs + "万";
}
} else {
// 当前数字为大小"零"时
// 判断前一次形成在字符串结尾有没有零
// 如果没有零就加上零
if (!chs.endsWith("零")) {
chs = chs + tmp_chs[tab];
}
// 当第１部分算完时
if (tab == 4) {
// 先判断字符串有没有零
// 如果有零时就把零去掉再加上"万"
if (chs.endsWith("零")) {
chs = chs.substring(0, chs.length() - 1);
chs = chs + "万";
} else {
// 如果没有零就直接加上"万"
chs = chs + "万";
}
}
}
}
// 如：123,1234分成两部分
// 第１部分1234：万以下
if (tab < 4) {
if (!tmp_chs[tab].equals("零")) {
// tmp_int_char.Length - i 为数字所在的位数
chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
} else {
// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
if (!chs.endsWith("零") && tab != 0) {
chs = chs + tmp_chs[tab];
}
if (chs.endsWith("零") && tab == 0) {
chs = chs.substring(0, chs.length() - 1);
}
}
}
}
// 如果数字的位数大于５和小于９时
if (tmp_int_char.length >= 9 && tmp_int_char.length <= 12) {
tmp_chs[tab] = CHS_NUMBER[(int) Float
.parseFloat(tmp_int_char[i] + ".0")];
if (tab >= 8 && tab < 12) {
// 当前数字不是大小零时
if (!tmp_chs[tab].equals("零")) {
chs = chs + tmp_chs[tab] + CH[tab - 7];
// 当第１部分算完时在加上"万"
if (tab == 8) {
chs = chs + "亿";
}
} else {
// 当前数字为大小"零"时
// 判断前一次形成在字符串结尾有没有零
// 如果没有零就加上零
if (!chs.endsWith("零")) {
chs = chs + tmp_chs[tab];
}
// 当第１部分算完时
if (tab == 8) {
// 先判断字符串有没有零
// 如果有零时就把零去掉再加上"万"
if (chs.endsWith("零")) {
chs = chs.substring(0, chs.length() - 1);
chs = chs + "亿";
} else {
// 如果没有零就直接加上"万"
chs = chs + "亿";
}
}
}
}
// 如：123,1234分成两部分
// 第１部分123：万以上亿以下
if (tab >= 4 && tab < 8) {
// 当前数字不是大小零时
if (!tmp_chs[tab].equals("零")) {
chs = chs + tmp_chs[tab] + CH[tab - 3];
// 当第１部分算完时在加上"万"
if (tab == 4) {
chs = chs + "万";
}
} else {
// 当前数字为大小"零"时
// 判断前一次形成在字符串结尾有没有零
// 如果没有零就加上零
if (!chs.endsWith("零")) {
chs = chs + tmp_chs[tab];
}
// 当第１部分算完时
if (tab == 4) {
// 先判断字符串有没有零
// 如果有零时就把零去掉再加上"万"
if (chs.endsWith("零")) {
chs = chs.substring(0, chs.length() - 1);
if (!chs.endsWith("亿"))
chs = chs + "万";
} else {
// 如果没有零就直接加上"万"
if (!chs.endsWith("亿"))
chs = chs + "万";
}
}
}
}
// 如：123,1234分成两部分
// 第１部分1234：万以下
if (tab < 4) {
if (!tmp_chs[tab].equals("零")) {
// tmp_int_char.length - i 为数字所在的位数
chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
} else {
// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
if (!chs.endsWith("零") && tab != 0) {
chs = chs + tmp_chs[tab];
}
if (chs.endsWith("零") && tab == 0) {
chs = chs.substring(0, chs.length() - 1);
}
}
}
}
// 如果数字的位数大于12和小于16时
if (tmp_int_char.length > 12 && tmp_int_char.length <= 16) {
tmp_chs[tab] = CHS_NUMBER[(int) Float
.parseFloat(tmp_int_char[i] + ".0")];
if (tab >= 12 && tab < 16) {
// 当前数字不是大小零时
if (!tmp_chs[tab].equals("零")) {
chs = chs + tmp_chs[tab] + CH[tab - 11];
// 当第１部分算完时在加上"万"
if (tab == 12) {
chs = chs + "兆";
}
} else {
// 当前数字为大小"零"时
// 判断前一次形成在字符串结尾有没有零
// 如果没有零就加上零
if (!chs.endsWith("零")) {
chs = chs + tmp_chs[tab];
}
// 当第１部分算完时
if (tab == 12) {
// 先判断字符串有没有零
// 如果有零时就把零去掉再加上"万"
if (chs.endsWith("零")) {
chs = chs.substring(0, chs.length() - 1);
chs = chs + "兆";
} else {
// 如果没有零就直接加上"万"
chs = chs + "兆";
}
}
}
}
if (tab >= 8 && tab < 12) {
// 当前数字不是大小零时
if (!tmp_chs[tab].equals("零")) {
chs = chs + tmp_chs[tab] + CH[tab - 7];
// 当第１部分算完时在加上"万"
if (tab == 8) {
chs = chs + "亿";
}
} else {
// 当前数字为大小"零"时
// 判断前一次形成在字符串结尾有没有零
// 如果没有零就加上零
if (!chs.endsWith("零")) {
chs = chs + tmp_chs[tab];
}
// 当第１部分算完时
if (tab == 8) {
// 先判断字符串有没有零
// 如果有零时就把零去掉再加上"万"
if (chs.endsWith("零")) {
chs = chs.substring(0, chs.length() - 1);
if (!chs.endsWith("兆"))
chs = chs + "亿";
} else {
// 如果没有零就直接加上"万"
if (!chs.endsWith("兆"))
chs = chs + "亿";
}
}
}
}
// 如：123,1234分成两部分
// 第１部分123：万以上亿以下
if (tab >= 4 && tab < 8) {
// 当前数字不是大小零时
if (!tmp_chs[tab].equals("零")) {
chs = chs + tmp_chs[tab] + CH[tab - 3];
// 当第１部分算完时在加上"万"
if (tab == 4) {
chs = chs + "万";
}
} else {
// 当前数字为大小"零"时
// 判断前一次形成在字符串结尾有没有零
// 如果没有零就加上零
if (!chs.endsWith("零")) {
chs = chs + tmp_chs[tab];
}
// 当第１部分算完时
if (tab == 4) {
// 先判断字符串有没有零
// 如果有零时就把零去掉再加上"万"
if (chs.endsWith("零")) {
chs = chs.substring(0, chs.length() - 1);
if (!chs.endsWith("亿"))
if (!chs.endsWith("兆"))
if (!chs.endsWith("兆"))
chs = chs + "万";
} else {
// 如果没有零就直接加上"万"
if (!chs.endsWith("亿"))
if (!chs.endsWith("兆"))
chs = chs + "万";
}
}
}
}
// 如：123,1234分成两部分
// 第１部分1234：万以下
if (tab < 4) {
if (!tmp_chs[tab].equals("零")) {
// tmp_int_char.length - i 为数字所在的位数
chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
} else {
// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
if (!chs.endsWith("零") && tab != 0) {
chs = chs + tmp_chs[tab];
}
if (chs.endsWith("零") && tab == 0) {
chs = chs.substring(0, chs.length() - 1);
}
}
}
}
// 如果数字的位数大于16
if (tmp_int_char.length > 16) {
tmp_chs[tab] = CHS_NUMBER[(int) Float
.parseFloat(tmp_int_char[i] + ".0")];
if (tab >= 12) {
chs = chs + tmp_chs[tab];
// 当第１部分算完时在加上"万"
if (tab == 12) {
chs = chs + "兆";
}
}
if (tab >= 8 && tab < 12) {
// 当前数字不是大小零时
if (!tmp_chs[tab].equals("零")) {
chs = chs + tmp_chs[tab] + CH[tab - 7];
// 当第１部分算完时在加上"万"
if (tab == 8) {
chs = chs + "亿";
}
} else {
// 当前数字为大小"零"时
// 判断前一次形成在字符串结尾有没有零
// 如果没有零就加上零
if (!chs.endsWith("零")) {
chs = chs + tmp_chs[tab];
}
// 当第１部分算完时
if (tab == 8) {
// 先判断字符串有没有零
// 如果有零时就把零去掉再加上"万"
if (chs.endsWith("零")) {
chs = chs.substring(0, chs.length() - 1);
if (!chs.endsWith("兆"))
chs = chs + "亿";
} else {
// 如果没有零就直接加上"万"
if (!chs.endsWith("兆"))
chs = chs + "亿";
}
}
}
}
// 如：123,1234分成两部分
// 第１部分123：万以上亿以下
if (tab >= 4 && tab < 8) {
// 当前数字不是大小零时
if (!tmp_chs[tab].equals("零")) {
chs = chs + tmp_chs[tab] + CH[tab - 3];
// 当第１部分算完时在加上"万"
if (tab == 4) {
chs = chs + "万";
}
} else {
// 当前数字为大小"零"时
// 判断前一次形成在字符串结尾有没有零
// 如果没有零就加上零
if (!chs.endsWith("零")) {
chs = chs + tmp_chs[tab];
}
// 当第１部分算完时
if (tab == 4) {
// 先判断字符串有没有零
// 如果有零时就把零去掉再加上"万"
if (chs.endsWith("零")) {
chs = chs.substring(0, chs.length() - 1);
if (!chs.endsWith("兆"))
if (!chs.endsWith("亿"))
chs = chs + "万";
} else {
// 如果没有零就直接加上"万"
if (!chs.endsWith("兆"))
if (!chs.endsWith("亿"))
chs = chs + "万";
}
}
}
}
// 如：123,1234分成两部分
// 第１部分1234：万以下
if (tab < 4) {
if (!tmp_chs[tab].equals("零")) {
// tmp_int_char.length - i 为数字所在的位数
chs = chs + tmp_chs[tab] + CH[tmp_int_char.length - i];
} else {// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零
if (!chs.endsWith("零") && tab != 0) {
chs = chs + tmp_chs[tab];
}
if (chs.endsWith("零") && tab == 0) {
chs = chs.substring(0, chs.length() - 1);
}
}
}
}
}
if (tmp_down != null) {
char[] tmp = tmp_down.toCharArray();
if (tmp.length == 1) {
if (tmp[0] != '0')
chs = chs + "元"
+ CHS_NUMBER[(int) Float.parseFloat(tmp[0] + ".0")]
+ "角整";
else
chs = chs + "元整";
} else {
if (tmp[1] != '0' && tmp[0] != '0') {
chs = chs + "元"
+ CHS_NUMBER[(int) Float.parseFloat(tmp[0] + ".0")]
+ "角"
+ CHS_NUMBER[(int) Float.parseFloat(tmp[1] + ".0")]
+ "分";
} else if (tmp[1] != '0' && tmp[0] == '0') {
chs = chs + "元零"
+ CHS_NUMBER[(int) Float.parseFloat(tmp[1] + ".0")]
+ "分";
}
}
} else {
chs = chs + "元整";
}
return chs;
}
//---------------------------------------------------------------------------------
/**
* 功 能: 拷贝文件(只能拷贝文件)
*
* @param strSourceFileName
* 指定的文件全路径名
* @param strDestDir
* 拷贝到指定的文件夹
* @return 如果成功true;否则false
*/
public boolean copyTo(String strSourceFileName, String strDestDir) {
File fileSource = new File(strSourceFileName);
File fileDest = new File(strDestDir);
// 如果源文件不存或源文件是文件夹
if (!fileSource.exists() || !fileSource.isFile()) {
logger.debug("源文件[" + strSourceFileName + "],不存在或是文件夹!");
return false;
}
// 如果目标文件夹不存在
if (!fileDest.isDirectory() || !fileDest.exists()) {
if (!fileDest.mkdirs()) {
logger.debug("目录文件夹不存，在创建目标文件夹时失败!");
return false;
}
}
try {
String strAbsFilename = strDestDir + File.separator + fileSource.getName();
FileInputStream fileInput = new FileInputStream(strSourceFileName);
FileOutputStream fileOutput = new FileOutputStream(strAbsFilename);
logger.debug("开始拷贝文件:");
int count = -1;
long nWriteSize = 0;
long nFileSize = fileSource.length();
byte[] data = new byte[1024];
while (-1 != (count = fileInput.read(data, 0, 1024))) {
fileOutput.write(data, 0, count);
nWriteSize += count;
long size = (nWriteSize * 100) / nFileSize;
long t = nWriteSize;
String msg = null;
if (size <= 100 && size >= 0) {
msg = "\r拷贝文件进度: " + size + "% \t" + "\t 已拷贝: " + t;
logger.debug(msg);
} else if (size > 100) {
msg = "\r拷贝文件进度: " + 100 + "% \t" + "\t 已拷贝: " + t;
logger.debug(msg);
}
}
fileInput.close();
fileOutput.close();
logger.debug("拷贝文件成功!");
return true;
} catch (Exception e) {
logger.debug("异常信息：[");
logger.error(e);
logger.debug("]");
return false;
}
}
/**
* 删除指定的文件
*
* @param strFileName
* 指定绝对路径的文件名
* @return 如果删除成功true否则false
*/
public boolean deleteFile(String strFileName) {
File fileDelete = new File(strFileName);
if (!fileDelete.exists() || !fileDelete.isFile()) {
logger.debug("错误: " + strFileName + "不存在!");
return false;
}
return fileDelete.delete();
}
/**
* 移动文件(只能移动文件)
*
* @param strSourceFileName
* 是指定的文件全路径名
* @param strDestDir
* 移动到指定的文件夹中
* @return 如果成功true; 否则false
*/
public boolean moveFile(String strSourceFileName, String strDestDir) {
if (copyTo(strSourceFileName, strDestDir))
return this.deleteFile(strSourceFileName);
else
return false;
}
/**
* 创建文件夹
*
* @param strDir
* 要创建的文件夹名称
* @return 如果成功true;否则false
*/
public boolean makedir(String strDir) {
File fileNew = new File(strDir);
if (!fileNew.exists()) {
logger.debug("文件夹不存在--创建文件夹");
return fileNew.mkdirs();
} else {
logger.debug("文件夹存在");
return true;
}
}
/**
* 删除文件夹
*
* @param strDir
* 要删除的文件夹名称
* @return 如果成功true;否则false
*/
public boolean removeDir(String strDir) {
File rmDir = new File(strDir);
if (rmDir.isDirectory() && rmDir.exists()) {
String[] fileList = rmDir.list();
for (int i = 0; i < fileList.length; i++) {
String subFile = strDir + File.separator + fileList[i];
File tmp = new File(subFile);
if (tmp.isFile())
tmp.delete();
else if (tmp.isDirectory())
removeDir(subFile);
else {
logger.debug("error!");
}
}
rmDir.delete();
} else
return false;
return true;
}
}
相关推荐
这个名为"keil 5代码整理插件TOOLS.zip"的压缩包提供了对Keil 5的增强功能，帮助开发者更高效地管理和组织代码。 压缩包中包含了四个常用的插件，这些插件通常是针对特定的开发需求设计的，例如代码格式化、自动...
- **MyGeoTools.doc**：这可能是一份个人整理的GeoTools学习笔记，包含了使用GeoTools开发GIS应用的关键概念和代码示例。 - **MyGeoTools.mht**：可能是另一种格式的学习资料，MHT是单个文件的Web档案，可能包含...
geotools中文资料，我学习时候，整理的资料, 另外我的新浪博客，有关于gis 的flex -js-android-ios资料 欢迎下载，大家一起学习，我建了个gis群 291301205 新浪 http://blog.sina.com.cn/skywalkershaka 因为我下...
2. **XML格式化**：此插件能够将杂乱无章的XML代码整理成整洁、易读的格式，包括缩进、换行以及标签对齐。 3. **折叠/展开节点**：XML文档通常包含多级嵌套，XMLTools允许用户折叠或展开节点，以便于查看和管理文档...
用户可以通过该工具快速地对大量的WPS文档进行分类、整理和查找，极大地节省了时间。例如，在处理大量报告或论文时，可以一键将所有文档按照日期、标题或自定义规则排序，使得文件管理变得井然有序。 其次，格式...
很抱歉，由于我无法看到图片内容，所以无法直接从图片中提取文字内容进行处理。但是，基于标题和描述，我可以为您提供有关“LightTools”这个软件的中文说明的知识点。LightTools是一款由Synopsys公司开发的专业光学...
6. **音乐信息提取**：能从音乐文件中读取元数据，如歌手、专辑、发行日期等，方便用户管理和整理音乐库。 7. **便捷操作**：界面简洁直观，操作流程简单易懂，即使是对电脑操作不太熟练的用户也能快速上手。 8. *...
这极大地提高了工作效率，尤其对那些需要频繁整理演示文稿的用户来说，它是一款不可或缺的辅助工具。 OneKeyTools-Lite不仅仅局限于PPT的合并，它还提供了其他批量处理功能，如批量转换PPT格式、批量添加水印、批量...
2. **映像管理**：软件提供了映像管理功能，用户可以创建、编辑和转换光盘映像，方便整理和分享数字资源。同时，DAEMON Tools Lite还支持加密映像，保护个人数据安全。 3. **快速加载**：DAEMON Tools Lite的快速...
XMLTools插件还提供了其他实用工具，如XML格式化，它可以整理XML文档的缩进和换行，使其更易于阅读；查找和替换功能针对XML特性进行了优化，支持XPath表达式，使得在XML文档中进行精准查找和替换变得简单。 总之，...
标题中的“NEO TOOLS个人版”指的是一个个人开发者或团队整理的一套工具集合，专门针对SEGA KIT1.0和其他代码资料进行处理和管理。这个工具集可能包含了多种实用程序，帮助开发者在编程、调试或者分析SEGA平台相关的...
Notepad++中的JSON格式化工具可以帮助用户对杂乱无章的JSON数据进行美化和整理，使其变得清晰易读。用户可以通过该工具自动缩进、格式化JSON文本，同时也能检查JSON的有效性，确保数据结构正确无误。 再来说说...
比如，当你需要将几个独立的研究报告组合成一个综合报告，或者把不同来源的数据整理到一起时，PDF合并工具能轻松完成任务。PDFT4.exe可能支持批量合并，允许用户一次性处理多个PDF文件，极大地提高了工作效率。 ...
1. **XML格式化**：Xml Tools Plugin提供了XML文档的自动格式化功能，可以快速整理杂乱无章的XML代码，使其变得更加整洁易读。用户可以通过快捷键或菜单选项轻松触发这一功能，调整缩进方式（空格或制表符）、缩进...
2. **格式化**：插件可以自动将杂乱无章的XML代码整理成整洁、易读的格式。这对于处理大型或复杂的XML文件尤其有用，可以提高工作效率。 3. **XPath支持**：XPath是一种语言，用于在XML文档中查找信息。通过集成...
【简洁一键云盘搜索工具Tools v1.0.txt打包整理.zip】这个压缩包文件看起来包含了一个名为"简洁一键云盘搜索工具Tools v1.0.txt"的文本文件，可能是一个介绍或指南，详细阐述了一款云盘搜索工具的使用方法和特点。...
1. **文件格式化**：XML Tools插件包含了一个XML格式化器，可以将杂乱无章的XML代码自动整理成整洁的结构，使代码更易于阅读和理解。它能自动调整缩进，对元素进行正确的排序，并处理嵌套的XML标签，使得整个文档...
使用阿里的规范手册整理规范所有代码 将当时临时添加或欠缺考虑的命名或方法进行优化 将maven私人仓库转移到中心仓库 目录 protools common http mail security all common 数据的处理 文件的处理 script 引擎...
收集整理开源的数据标注工具_Data_Label_Tools
描述中的"Web Tools Pro 专业版网站管理器v1.70.txt打包整理.zip"进一步确认了这是一个压缩包文件，包含了与Web Tools Pro v1.70相关的文本文件（可能是使用手册、安装指南或者更新日志等）。".txt"扩展名通常代表纯...