package com.hx.util;
|
|
import java.io.BufferedReader;
|
import java.io.DataOutputStream;
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.IOException;
|
import java.io.UnsupportedEncodingException;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.net.FileNameMap;
|
import java.net.HttpURLConnection;
|
import java.net.InetAddress;
|
import java.net.URL;
|
import java.net.URLConnection;
|
import java.net.URLDecoder;
|
import java.net.UnknownHostException;
|
import java.security.MessageDigest;
|
import java.security.NoSuchAlgorithmException;
|
import java.sql.Timestamp;
|
import java.text.DateFormat;
|
import java.text.DecimalFormat;
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
import javax.servlet.http.HttpServletRequest;
|
|
import org.apache.commons.io.IOUtils;
|
import org.apache.poi.hssf.usermodel.HSSFCell;
|
import org.apache.poi.hssf.usermodel.HSSFDataFormatter;
|
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
|
import org.apache.poi.hssf.usermodel.HSSFRow;
|
import org.apache.poi.hssf.usermodel.HSSFSheet;
|
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
|
import org.apache.poi.ss.usermodel.Cell;
|
|
import net.sf.json.JSONArray;
|
import net.sf.json.JSONException;
|
import net.sf.json.JSONObject;
|
import net.sourceforge.pinyin4j.PinyinHelper;
|
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
|
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
|
import org.springframework.cglib.beans.BeanMap;
|
|
public class SimpleTool {
|
|
public static SimpleDateFormat myformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
public static DecimalFormat fmt = new DecimalFormat("0.00");
|
public static Byte[] lock = new Byte[] {0};
|
|
/**对象转map*/
|
public static Map<?, ?> objectToMap(Object obj) {
|
if(obj == null)
|
return null;
|
|
return new org.apache.commons.beanutils.BeanMap(obj);
|
}
|
|
/**
|
* 将对象装换为map
|
*
|
* @param bean
|
* @return
|
*/
|
public static <T> Map<String, Object> beanToMap(T bean) {
|
Map<String, Object> map = new HashMap<>();
|
if (bean != null) {
|
BeanMap beanMap = BeanMap.create(bean);
|
for (Object key : beanMap.keySet()) {
|
map.put(key + "", beanMap.get(key));
|
}
|
}
|
return map;
|
}
|
|
/**
|
* 将对象装换为map
|
*
|
* @param bean
|
* @return
|
*/
|
public static Map<String, String> beanToMapS(Object bean) {
|
Map<String, String> map = new HashMap<>();
|
if (bean != null) {
|
BeanMap beanMap = BeanMap.create(bean);
|
for (Object key : beanMap.keySet()) {
|
if(beanMap.get(key) != null){
|
map.put(key + "", beanMap.get(key).toString());
|
}else{
|
map.put(key + "", "");
|
}
|
}
|
}
|
return map;
|
}
|
|
|
/**
|
* 后台格式构建返回值格式列表-后台获取列表
|
* @param count 返回总条数
|
* @return JSONObject 特定格式的JSONObject
|
*/
|
public static JSONObject resAdminLsit(Integer status,String errMsg,JSONArray arr,Integer count){
|
|
JSONObject fObj = new JSONObject();
|
try{
|
fObj.put("code", status);
|
fObj.put("count", count);
|
fObj.put("msg", errMsg);
|
fObj.put("data", arr);
|
}catch (Exception e) {
|
e.printStackTrace();
|
}
|
return fObj;
|
}
|
|
/**
|
* 获取指定格式的Double 类型数据
|
*
|
* @param type
|
* 转换格式的类型 默认为 "#.#"
|
* @param e
|
* 要转换的数据源
|
**/
|
public static Double getTypeDouble(String type, Double e) {
|
if (!checkNotNull(type))
|
type = "0.00";
|
fmt = new DecimalFormat(type);
|
fmt.setRoundingMode(RoundingMode.HALF_UP); // 保留小数点后两位并四舍五入，确保价钱准确
|
Double d = Double.valueOf(fmt.format(e));
|
return d;
|
}
|
|
/**
|
* 首字母大写
|
*
|
* @param str
|
*/
|
public static String capitalized(String str) {
|
if ("".equals(str.trim()) || str == null) {
|
return "";
|
}
|
String key = str.substring(0, 1).toUpperCase();
|
String keys = key + str.substring(1, str.length());
|
return keys;
|
}
|
|
/** 判断参数是否为null，如果null抛出对应异常 */
|
public static void checkErrMsg(Object obj, String errMsg) {
|
if (!checkNotNull(obj))
|
throw new RuntimeException(errMsg);
|
}
|
|
/*** 创建文件（自动生成文件夹。）(需要真实路径) **/
|
public static File createFile(String mkdirPath, String fileName) throws IOException {
|
System.out.println(mkdirPath + fileName);
|
// mkdirPath =
|
// "E:\\work\\soft\\MyEclipse\\apache-tomcat-7.0.61\\webapps\\ROOT\\";
|
|
File f = new File(mkdirPath);
|
if (!f.exists()) {
|
f.mkdirs();
|
}
|
File file = new File(f, fileName);
|
if (!file.exists()) {
|
file.createNewFile();
|
}
|
|
// System.out.println(file.getAbsolutePath());
|
return file;
|
}
|
|
/**
|
* 构建返回值格式
|
*
|
* @param status
|
* 返回状态
|
* @param errMsg
|
* 返回附带信息
|
* @param inf
|
* 返回实体值
|
* @return JSONObject 特定格式的JSONObject
|
*/
|
public static JSONObject res(Integer status, String errMsg, JSONObject inf) {
|
JSONObject res = new JSONObject();
|
JSONObject fObj = new JSONObject();
|
try {
|
res.put("status", status);
|
res.put("errMsg", errMsg);
|
|
fObj.put("res", res);
|
fObj.put("inf", inf);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return fObj;
|
}
|
|
/**
|
* Date类型转换为10位时间戳
|
*
|
* @param time
|
* @return
|
*/
|
public static Integer DateToTimestamp(Date time) {
|
Timestamp ts = new Timestamp(time.getTime());
|
return (int) ((ts.getTime()) / 1000);
|
}
|
|
/** 判断当前时间是什么时候 **/
|
public static Boolean IsTime(Date date, Integer year, Integer month, Integer day, Integer hour, Integer minute) {
|
Calendar cal = new GregorianCalendar();
|
cal.setTime(date);
|
if (year != null) {
|
int iyear = cal.get(Calendar.YEAR);
|
if (iyear != year)
|
return false;
|
}
|
|
if (month != null) {
|
int imonth = cal.get(Calendar.MONTH);// 获取月份(月份从0开始计算的)
|
imonth = imonth + 1;
|
if (imonth != month)
|
return false;
|
}
|
|
if (day != null) {
|
int iday = cal.get(Calendar.DATE);// 获取日
|
if (iday != day)
|
return false;
|
}
|
|
if (hour != null) {
|
int ihour = cal.get(Calendar.HOUR_OF_DAY);// 24小时 0- 23
|
if (ihour != hour)
|
return false;
|
}
|
|
if (minute != null) {
|
int iminute = cal.get(Calendar.MINUTE);
|
if (iminute != minute)
|
return false;
|
}
|
// Boolean b = yearTag && monthTag && dayTag && hourTag && minuteTag;
|
return true;
|
}
|
|
/**
|
* 根据具体时间属性判断是否相同
|
*
|
*/
|
public static Boolean DateEquals(Date date1, Date date2, Boolean year, Boolean month, Boolean day, Boolean hour,
|
Boolean minute) {
|
|
Calendar calendar1 = new GregorianCalendar();
|
Calendar calendar2 = new GregorianCalendar();
|
calendar1.setTime(date1);
|
calendar2.setTime(date2);
|
|
if (year) {
|
if (calendar1.get(Calendar.YEAR) != calendar2.get(Calendar.YEAR)) {
|
return false;
|
}
|
}
|
if (month) {
|
if (calendar1.get(Calendar.MONTH) != calendar2.get(Calendar.MONTH)) {
|
return false;
|
}
|
}
|
if (day) {
|
if (calendar1.get(Calendar.DATE) != calendar2.get(Calendar.DATE)) {
|
return false;
|
}
|
}
|
if (year) {
|
if (calendar1.get(Calendar.HOUR_OF_DAY) != calendar2.get(Calendar.HOUR_OF_DAY)) {
|
return false;
|
}
|
}
|
if (year) {
|
if (calendar1.get(Calendar.MINUTE) != calendar2.get(Calendar.MINUTE)) {
|
return false;
|
}
|
}
|
|
// Boolean b = yearTag && monthTag && dayTag && hourTag && minuteTag;
|
|
return true;
|
}
|
|
/** 获取10位数时间戳 */
|
public static Integer getTenTime(Date date) {
|
Timestamp ts = new Timestamp(date.getTime());
|
return (int) ((ts.getTime()) / 1000);
|
}
|
|
/**
|
* 获取指定日期的明天 difDay 把日期往后增加一天.整数往后推,负数往前移动
|
*
|
* @return date
|
*/
|
@SuppressWarnings("static-access")
|
public static Date getDetailDay(Date today, int difDay) {
|
Calendar calendar = new GregorianCalendar();
|
calendar.setTime(today);
|
calendar.add(calendar.DATE, difDay);// 把日期往后增加一天.整数往后推,负数往前移动
|
Date d = calendar.getTime();
|
return d;
|
}
|
|
/**
|
* 获取想要的格式的时间
|
*
|
* @return String
|
*/
|
public static String getTypeDate(String type, Date date) {
|
if (date == null)
|
return null;
|
|
if (SimpleTool.checkNotNull(type)) {
|
myformat = new SimpleDateFormat(type);
|
String returnDate = myformat.format(date);
|
myformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
return returnDate;
|
} else {
|
String returnDate = myformat.format(date);
|
return returnDate;
|
}
|
|
}
|
|
/**
|
* 比较两个时间天数差 startTime - endTime
|
*
|
* @param type
|
* (无效)
|
* @return String
|
* @throws ParseException
|
*/
|
public static int getDiffDate(String type, Date startTime, Date endTime) throws ParseException {
|
type = "yyyyMMdd";
|
SimpleDateFormat myformat = new SimpleDateFormat(type);
|
int i = 0;
|
i = (int) ((myformat.parse(myformat.format(startTime)).getTime()
|
- myformat.parse(myformat.format(endTime)).getTime()) / (1000 * 60 * 60 * 24));
|
// return
|
// myformat.parse(myformat.format(date1)).compareTo(myformat.parse(myformat.format(date2)));
|
return i;
|
}
|
|
/**
|
* 得到两个时间的分钟差 date1 - date2 这个是个奇葩。但是整型了。
|
*
|
* @return int
|
* @throws ParseException
|
*/
|
public static int getLeftDateForMinue(Date date1, Date date2) throws ParseException {
|
long times = date1.getTime() - date2.getTime();
|
times = times / (1000 * 60);
|
return (int) times;
|
}
|
|
/**把字符串转为特定时间格式
|
*
|
* @param type 时间格式
|
* @param sDate 字符串时间（可以为空）
|
* @return date
|
* @throws ParseException
|
*/
|
public static Date parseStringForDate(String type, String sDate){
|
Date date = null;
|
try {
|
if(SimpleTool.checkNotNull(sDate)) {
|
SimpleDateFormat myformat = new SimpleDateFormat(type);
|
date = myformat.parse(sDate);
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return date;
|
}
|
|
/**
|
* 判断是否为空
|
*/
|
public static boolean checkNotNull(Object o) {
|
boolean b = false;
|
if (o != null && !"".equals(o)&&!"undefined".equals(o)&&!" ".equals(o)) {
|
b = true;
|
}
|
return b;
|
}
|
|
/**
|
* 判断是否为空 (多个)
|
*/
|
public static boolean checkNotNullM(Object[] os) {
|
boolean b = true;
|
for (Object o : os) {
|
if (o == null || "".equals(o))
|
return false;
|
}
|
return b;
|
}
|
|
/**
|
* 获取服务器端的webapps路径
|
*
|
* @return
|
*/
|
public String findServerPath() {
|
String classPath = this.getClass().getClassLoader().getResource("/").getPath();
|
try {
|
classPath = URLDecoder.decode(classPath, "gb2312");
|
} catch (UnsupportedEncodingException e) {
|
e.printStackTrace();
|
}
|
String[] strPath = classPath.split("/");
|
String path = "";
|
for (int i = 0; i < strPath.length; i++) {
|
if (i > 0 && i <= 3) {
|
path = path + strPath[i] + "/";
|
}
|
}
|
return path;
|
}
|
|
/**
|
* 删除文件 输入真是路径
|
*/
|
public static void deleteFile(String sPath) {
|
File file = new File(sPath);
|
// 判断目录或文件是否存在
|
if (file.exists()) {
|
// 判断是否为文件
|
if (file.isFile()) { // 为文件时调用删除文件方法
|
deleteFileForOne(sPath);
|
} else { // 为目录时调用删除目录方法
|
throw new RuntimeException("dir is no del");
|
// deleteDirectory(sPath);
|
}
|
}
|
}
|
|
/**
|
* 删除目录（文件夹）以及目录下的文件
|
*
|
* @param sPath
|
* 被删除目录的文件路径
|
* @return 目录删除成功返回true，否则返回false
|
*/
|
public static boolean deleteDirectory(String sPath) {
|
// 如果sPath不以文件分隔符结尾，自动添加文件分隔符
|
if (!sPath.endsWith(File.separator)) {
|
sPath = sPath + File.separator;
|
}
|
File dirFile = new File(sPath);
|
// 如果dir对应的文件不存在，或者不是一个目录，则退出
|
if (!dirFile.exists() || !dirFile.isDirectory()) {
|
return false;
|
}
|
Boolean flag = true;
|
// 删除文件夹下的所有文件(包括子目录)
|
File[] files = dirFile.listFiles();
|
for (int i = 0; i < files.length; i++) {
|
// 删除子文件
|
if (files[i].isFile()) {
|
flag = deleteFileForOne(files[i].getAbsolutePath());
|
if (!flag)
|
break;
|
} // 删除子目录
|
else {
|
flag = deleteDirectory(files[i].getAbsolutePath());
|
if (!flag)
|
break;
|
}
|
}
|
if (!flag)
|
return false;
|
// 删除当前目录
|
if (dirFile.delete()) {
|
return true;
|
} else {
|
return false;
|
}
|
}
|
|
/**
|
* 删除单个文件
|
*
|
* @param sPath
|
* 被删除文件的文件名
|
* @return 单个文件删除成功返回true，否则返回false
|
*/
|
public static boolean deleteFileForOne(String sPath) {
|
Boolean flag = false;
|
File file = new File(sPath);
|
// 路径为文件且不为空则进行删除
|
if (file.isFile() && file.exists()) {
|
file.delete();
|
flag = true;
|
}
|
return flag;
|
}
|
|
|
/**
|
* 获取uuid
|
*/
|
public static String getUUIDName() {
|
return UUID.randomUUID().toString();
|
}
|
|
|
/** 获取异常信息 **/
|
public static String getExceptionMsg(Exception e) {
|
StringBuffer emsg = new StringBuffer();
|
if (e != null) {
|
StackTraceElement[] st = e.getStackTrace();
|
for (StackTraceElement stackTraceElement : st) {
|
String exclass = stackTraceElement.getClassName();
|
String method = stackTraceElement.getMethodName();
|
emsg.append("[类:" + exclass + "]调用---" + method + "----时在第" + stackTraceElement.getLineNumber()
|
+ "行代码处发生异常!异常类型:" + e.toString() + "(" + e.getMessage() + ")\r\n");
|
}
|
}
|
return emsg.toString();
|
}
|
|
/**
|
* 获取指定格式的Double 类型数据
|
*
|
* 转换格式的类型 默认为 "#.##"
|
* @param e
|
* 要转换的数据源
|
**/
|
public static Double getTypeDouble(Double e) {
|
fmt.setRoundingMode(RoundingMode.HALF_UP); // 保留小数点后两位并四舍五入，确保价钱准确
|
Double d = Double.valueOf(fmt.format(e));
|
return d;
|
}
|
|
|
/**
|
* SHA1 加密
|
*
|
* @param decript
|
* @return
|
*/
|
public static String SHA1(String decript) {
|
try {
|
MessageDigest digest = MessageDigest.getInstance("SHA-1");
|
digest.update(decript.getBytes());
|
byte messageDigest[] = digest.digest();
|
// Create Hex String
|
StringBuffer hexString = new StringBuffer();
|
// 字节数组转换为 十六进制 数
|
for (int i = 0; i < messageDigest.length; i++) {
|
String shaHex = Integer.toHexString(messageDigest[i] & 0xFF);
|
if (shaHex.length() < 2) {
|
hexString.append(0);
|
}
|
hexString.append(shaHex);
|
}
|
return hexString.toString();
|
} catch (NoSuchAlgorithmException e) {
|
e.printStackTrace();
|
}
|
return "";
|
}
|
|
|
public static String getLocalIP() {
|
InetAddress addr = null;
|
try {
|
addr = InetAddress.getLocalHost();
|
} catch (UnknownHostException e) {
|
e.printStackTrace();
|
}
|
|
byte[] ipAddr = addr.getAddress();
|
String ipAddrStr = "";
|
for (int i = 0; i < ipAddr.length; i++) {
|
if (i > 0) {
|
ipAddrStr += ".";
|
}
|
ipAddrStr += ipAddr[i] & 0xFF;
|
}
|
// System.out.println("i am ip:......"+ipAddrStr);
|
return ipAddrStr;
|
}
|
|
/**随机生成字符串（0-9）
|
*
|
* @param lengthCount 长度
|
* @return
|
*/
|
public static String generateCardNo(Integer lengthCount) {
|
if(!SimpleTool.checkNotNull(lengthCount)) {
|
lengthCount = 6;
|
}
|
java.util.Random r=new java.util.Random();
|
StringBuilder str = new StringBuilder();//定义变长字符串
|
for(int i=0;i<lengthCount;i++){
|
str.append(r.nextInt(10));
|
}
|
return str.toString();
|
}
|
|
/**判断是不是视频文件
|
* @param fileName 文件名称
|
* @return boolean true是视频文件
|
*/
|
public static boolean getMimeType(String fileName) {
|
boolean b = false;
|
FileNameMap fileNameMap = URLConnection.getFileNameMap();
|
String type = fileNameMap.getContentTypeFor(fileName);
|
//是视频type是为空的
|
if(!checkNotNull(type)) {
|
b = true;
|
}
|
return b;
|
}
|
|
/**
|
* 判断是否为视频
|
* @param fileName
|
* @return
|
*/
|
public static String isVideo(String fileName) {
|
FileNameMap fileNameMap = URLConnection.getFileNameMap();
|
String type = fileNameMap.getContentTypeFor(fileName);
|
return type;
|
}
|
|
/**判断是否是中文*/
|
public static boolean isChineseChar(String str){
|
boolean temp = false;
|
Pattern p=Pattern.compile("[\u4e00-\u9fa5]");
|
Matcher m=p.matcher(str);
|
if(m.find()){
|
temp = true;
|
}
|
return temp;
|
}
|
|
/**去除字符串中不是中文的字符
|
*
|
*/
|
public static String deleteNoChinese(String str){
|
String name="";
|
if(checkNotNull(str)){
|
for(int i=0;i<str.length();i++){
|
String s = str.substring(i, i+1);
|
if(isChineseChar(s)){
|
name = name +s;
|
}
|
}
|
}
|
return name;
|
}
|
|
/**生成字母（全部是中文的）*/
|
public static String convertHanzi3Pinyin(String hanzi,boolean full){
|
hanzi = deleteNoChinese(hanzi);
|
hanzi = convertHanzi2Pinyin(hanzi,false);
|
return hanzi;
|
}
|
|
/***获取字符串拼音的第一个字母（大写）**/
|
public static String convertStringPinyinOne(String hanzi) {
|
if(SimpleTool.checkNotNull(hanzi)) {
|
//转化为便宜
|
hanzi = convertHanzi2Pinyin(hanzi,false);
|
//转化大写
|
hanzi = hanzi.toUpperCase();
|
/*//获取第一个
|
byte[] datas = hanzi.getBytes();
|
if(datas.length>0) {
|
byte[] datas2 = new byte[] {datas[0]};
|
hanzi = new String(datas2);
|
}else {
|
hanzi = "";
|
}*/
|
}
|
return hanzi;
|
}
|
|
|
/***将汉字转成拼音(取首字母或全拼)
|
* @param hanzi
|
* @param full 是否全拼
|
* @return
|
*/
|
public static String convertHanzi2Pinyin(String hanzi,boolean full){
|
//获取第一个字
|
/* if(checkNotNull(hanzi)){
|
boolean isHave = true;
|
Integer l = hanzi.length();
|
Integer index = 0;
|
while (isHave) {
|
String hanzi2 = hanzi.substring(index,index+1);
|
if(isChineseChar(hanzi2)){
|
isHave = false;
|
hanzi = hanzi2;
|
}else{
|
if(index<l-1){
|
index++;
|
}else{
|
isHave = false;
|
}
|
}
|
}
|
}
|
*/
|
//去除所有的空格
|
if(checkNotNull(hanzi)){
|
hanzi = hanzi.replaceAll(" ", "");
|
}
|
|
/***
|
* ^[\u2E80-\u9FFF]+$ 匹配所有东亚区的语言
|
* ^[\u4E00-\u9FFF]+$ 匹配简体和繁体
|
* ^[\u4E00-\u9FA5]+$ 匹配简体
|
*/
|
String regExp="^[\u4E00-\u9FFF]+$";
|
StringBuffer sb=new StringBuffer();
|
if(hanzi==null||"".equals(hanzi.trim())){
|
return "";
|
}
|
String pinyin="";
|
for(int i=0;i<hanzi.length();i++){
|
char unit=hanzi.charAt(i);
|
if(match(String.valueOf(unit),regExp)){//是汉字，则转拼音
|
pinyin=convertSingleHanzi2Pinyin(unit);
|
if(full){
|
sb.append(pinyin);
|
}else{
|
sb.append(pinyin.charAt(0));
|
}
|
}else{
|
sb.append(unit);
|
}
|
}
|
return sb.toString();
|
}
|
|
/***将单个汉字转成拼音
|
* @param hanzi
|
* @return
|
*/
|
private static String convertSingleHanzi2Pinyin(char hanzi){
|
HanyuPinyinOutputFormat outputFormat = new HanyuPinyinOutputFormat();
|
outputFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
|
String[] res;
|
StringBuffer sb=new StringBuffer();
|
try {
|
res = PinyinHelper.toHanyuPinyinStringArray(hanzi,outputFormat);
|
sb.append(res[0]);//对于多音字，只用第一个拼音
|
} catch (Exception e) {
|
e.printStackTrace();
|
return "";
|
}
|
return sb.toString();
|
}
|
|
/***@param str 源字符串
|
* @param regex 正则表达式
|
* @return 是否匹配
|
*/
|
public static boolean match(String str,String regex){
|
Pattern pattern=Pattern.compile(regex);
|
Matcher matcher=pattern.matcher(str);
|
return matcher.find();
|
}
|
|
/** 读取 Excel文件内容(3.24 quan)
|
*
|
* @param excel_name File
|
* @return
|
* @throws Exception
|
*/
|
public static List<String[]> readExcelByeFile2(File excel_name) throws Exception {
|
// 结果集
|
List<String[]> list = new ArrayList<String[]>();
|
HSSFWorkbook hssfworkbook = new HSSFWorkbook(new FileInputStream(excel_name));
|
|
// 遍历该表格中所有的工作表，i表示工作表的数量 getNumberOfSheets表示工作表的总数
|
HSSFSheet hssfsheet = hssfworkbook.getSheetAt(0);
|
|
// 遍历该行所有的行,j表示行数 getPhysicalNumberOfRows行的总数
|
for (int j = 0; j < hssfsheet.getPhysicalNumberOfRows(); j++) {
|
HSSFRow hssfrow = hssfsheet.getRow(j);
|
if(hssfrow!=null){
|
int col = hssfrow.getPhysicalNumberOfCells();
|
// 单行数据
|
String[] arrayString = new String[col];
|
for (int i = 0; i < col; i++) {
|
HSSFCell cell = hssfrow.getCell(i);
|
if (cell == null) {
|
arrayString[i] = "";
|
} else if (cell.getCellType() == 0) {
|
// arrayString[i] = new Double(cell.getNumericCellValue()).toString();
|
short format = cell.getCellStyle().getDataFormat();
|
SimpleDateFormat sdf = null;
|
if(format == 14 || format == 31 || format == 57 || format == 58){
|
//日期
|
sdf = new SimpleDateFormat("yyyy-MM-dd");
|
}else if (format == 20 || format == 32) {
|
//时间
|
sdf = new SimpleDateFormat("HH:mm");
|
}else if (HSSFCell.CELL_TYPE_NUMERIC == cell.getCellType()) {
|
if (HSSFDateUtil.isCellDateFormatted(cell)) {
|
Date d = cell.getDateCellValue();
|
DateFormat formater = new SimpleDateFormat("yyyy年");
|
// DateFormat formater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
arrayString[i] = formater.format(d);
|
} else {
|
arrayString[i] = new BigDecimal(cell.getNumericCellValue()).toString();
|
}
|
}
|
} else {// 如果EXCEL表格中的数据类型为字符串型
|
arrayString[i] = cell.getStringCellValue().trim();
|
}
|
}
|
list.add(arrayString);
|
}
|
}
|
return list;
|
}
|
|
/**
|
* 读取 Excel文件内容
|
*
|
* @param excel_name
|
* @param header 是否包括表头
|
* @return
|
* @throws Exception
|
*/
|
public static List<String[]> readExcelByeFileData(File excel_name,boolean header) throws Exception {
|
// 结果集
|
List<String[]> list = new ArrayList<String[]>();
|
|
HSSFWorkbook hssfworkbook = new HSSFWorkbook(new FileInputStream(
|
excel_name));
|
|
// 遍历该表格中所有的工作表，i表示工作表的数量 getNumberOfSheets表示工作表的总数
|
for(int s=0;s<hssfworkbook.getNumberOfSheets();s++) {
|
HSSFSheet hssfsheet = hssfworkbook.getSheetAt(s);
|
int col = 0;
|
// 遍历该行所有的行,j表示行数 getPhysicalNumberOfRows行的总数 去除标题
|
for (int j = 0; j < hssfsheet.getPhysicalNumberOfRows(); j++) {
|
HSSFRow hssfrow = hssfsheet.getRow(j);
|
if(hssfrow!=null){
|
if(j == 0) {
|
col = hssfrow.getPhysicalNumberOfCells();
|
if(!header) {
|
//不包括表头
|
continue;
|
}
|
}
|
// 单行数据
|
String[] arrayString = new String[col];
|
for (int i = 0; i < col; i++) {
|
HSSFCell cell = hssfrow.getCell(i);
|
if (cell == null) {
|
arrayString[i] = "";
|
} else if (cell.getCellType() == 0) {
|
// arrayString[i] = new Double(cell.getNumericCellValue()).toString();
|
if (HSSFCell.CELL_TYPE_NUMERIC == cell.getCellType()) {
|
short format = cell.getCellStyle().getDataFormat();
|
if(format == 14 || format == 31 || format == 57 || format == 58){
|
//日期（中文时间格式的）
|
Date d = cell.getDateCellValue();
|
DateFormat formater = new SimpleDateFormat("yyyy年");
|
// DateFormat formater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
arrayString[i] = formater.format(d);
|
}else if (HSSFDateUtil.isCellDateFormatted(cell)) {
|
Date d = cell.getDateCellValue();
|
DateFormat formater = new SimpleDateFormat("yyyy年");
|
// DateFormat formater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
arrayString[i] = formater.format(d);
|
} else {
|
if(HSSFCell.CELL_TYPE_STRING == cell.getCellType()){
|
arrayString[i] =cell.getStringCellValue();
|
}else if(HSSFCell.CELL_TYPE_FORMULA==cell.getCellType()){
|
arrayString[i] =cell.getCellFormula();
|
}else if(HSSFCell.CELL_TYPE_NUMERIC== cell.getCellType()){
|
HSSFDataFormatter dataFormatter = new HSSFDataFormatter();
|
arrayString[i] =dataFormatter.formatCellValue(cell);
|
}
|
}
|
}
|
} else if(cell.getCellType() == Cell.CELL_TYPE_BLANK){
|
arrayString[i] = "";
|
} else { // 如果EXCEL表格中的数据类型为字符串型
|
arrayString[i] = cell.getStringCellValue().trim();
|
}
|
}
|
list.add(arrayString);
|
}
|
}
|
}
|
return list;
|
}
|
|
/**
|
* 读取 Excel文件内容（学校信息专用）
|
*
|
* @param excel_name
|
* @return
|
* @throws Exception
|
*/
|
public static List<String[]> readExcelByeFile(File excel_name) throws Exception {
|
// 结果集
|
List<String[]> list = new ArrayList<String[]>();
|
|
HSSFWorkbook hssfworkbook = new HSSFWorkbook(new FileInputStream(
|
excel_name));
|
|
// 遍历该表格中所有的工作表，i表示工作表的数量 getNumberOfSheets表示工作表的总数
|
for(int s=0;s<hssfworkbook.getNumberOfSheets();s++) {
|
HSSFSheet hssfsheet = hssfworkbook.getSheetAt(s);
|
int col = 0;
|
// 遍历该行所有的行,j表示行数 getPhysicalNumberOfRows行的总数 去除标题
|
for (int j = 0; j < hssfsheet.getPhysicalNumberOfRows(); j++) {
|
HSSFRow hssfrow = hssfsheet.getRow(j);
|
if(hssfrow!=null){
|
if(j == 0) {
|
col = hssfrow.getPhysicalNumberOfCells();
|
}else {
|
// int col = hssfrow.getPhysicalNumberOfCells();
|
// 单行数据
|
String[] arrayString = new String[col];
|
for (int i = 0; i < col; i++) {
|
HSSFCell cell = hssfrow.getCell(i);
|
if (cell == null) {
|
arrayString[i] = "";
|
} else if (cell.getCellType() == 0) {
|
// arrayString[i] = new Double(cell.getNumericCellValue()).toString();
|
if (HSSFCell.CELL_TYPE_NUMERIC == cell.getCellType()) {
|
short format = cell.getCellStyle().getDataFormat();
|
if(format == 14 || format == 31 || format == 57 || format == 58){
|
//日期（中文时间格式的）
|
Date d = cell.getDateCellValue();
|
DateFormat formater = new SimpleDateFormat("yyyy年");
|
// DateFormat formater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
arrayString[i] = formater.format(d);
|
}else if (HSSFDateUtil.isCellDateFormatted(cell)) {
|
Date d = cell.getDateCellValue();
|
DateFormat formater = new SimpleDateFormat("yyyy年");
|
// DateFormat formater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
arrayString[i] = formater.format(d);
|
} else {
|
if(HSSFCell.CELL_TYPE_STRING == cell.getCellType()){
|
arrayString[i] =cell.getStringCellValue();
|
}else if(HSSFCell.CELL_TYPE_FORMULA==cell.getCellType()){
|
arrayString[i] =cell.getCellFormula();
|
}else if(HSSFCell.CELL_TYPE_NUMERIC== cell.getCellType()){
|
HSSFDataFormatter dataFormatter = new HSSFDataFormatter();
|
arrayString[i] =dataFormatter.formatCellValue(cell);
|
}
|
}
|
}
|
} else if(cell.getCellType() == Cell.CELL_TYPE_BLANK){
|
arrayString[i] = "";
|
} else { // 如果EXCEL表格中的数据类型为字符串型
|
cell.setCellType(Cell.CELL_TYPE_STRING);
|
String name = cell.getStringCellValue().trim();
|
if(name.equals("-")) {
|
arrayString[i] = "";
|
}else {
|
arrayString[i] = name;
|
}
|
}
|
}
|
list.add(arrayString);
|
}
|
}
|
}
|
}
|
return list;
|
}
|
|
/**获取字符串里面的数字，按顺序排序*/
|
public static String stringNumber(String data) {
|
String da = null;
|
String regEc = "[^0-9]";
|
Pattern pattern = Pattern.compile(regEc);
|
Matcher m = pattern.matcher(data);
|
da = m.replaceAll("").trim();
|
return da;
|
}
|
|
/**
|
* @param url:请求url
|
* @param content: 请求体(参数)
|
* @return errorStr:错误信息;status:状态码，response：返回数据
|
* @throws JSONException
|
*/
|
public static JSONObject requestData(String url, String content) throws JSONException {
|
JSONObject obj = new JSONObject();
|
String errMsg_r = "";
|
String status_r = "0";
|
String response = "";
|
//PrintWriter out = null;
|
DataOutputStream out = null;
|
BufferedReader in = null;
|
try {
|
URL realUrl = new URL(url);
|
// 打开和URL之间的连接
|
URLConnection conn = realUrl.openConnection();
|
HttpURLConnection httpUrlConnection = (HttpURLConnection) conn;
|
// 设置请求属性
|
httpUrlConnection.setRequestProperty("Content-type", "application/json;charset=UTF-8");
|
//httpUrlConnection.setRequestProperty("Content-Type", "application/json");
|
//httpUrlConnection.setRequestProperty("Charset", "UTF-8");
|
httpUrlConnection.setRequestProperty("x-adviewrtb-version", "2.1");
|
// 发送POST请求必须设置如下两行
|
httpUrlConnection.setDoOutput(true);
|
httpUrlConnection.setDoInput(true);
|
// 获取URLConnection对象对应的输出流
|
out = new DataOutputStream(httpUrlConnection.getOutputStream());
|
//out = new PrintWriter(httpUrlConnection.getOutputStream());
|
// 发送请求参数
|
//out.write(content);
|
out.write(content.getBytes("UTF-8"));
|
// flush输出流的缓冲
|
out.flush();
|
httpUrlConnection.connect();
|
// 定义BufferedReader输入流来读取URL的响应
|
// in = new BufferedReader(new InputStreamReader(httpUrlConnection.getInputStream()));
|
String wxMsgXml = IOUtils.toString(httpUrlConnection.getInputStream(), "utf-8");
|
System.out.println("wxMsgXml:"+wxMsgXml);
|
if(SimpleTool.checkNotNull(wxMsgXml)) {
|
obj = JSONObject.fromObject(wxMsgXml);
|
}
|
/* String line;
|
while ((line = in.readLine()) != null) {
|
response += line;
|
} */
|
status_r = new Integer(httpUrlConnection.getResponseCode()).toString();
|
} catch (Exception e) {
|
System.out.println("发送 POST 请求出现异常！" + e);
|
errMsg_r = e.getMessage();
|
e.printStackTrace();
|
}
|
// 使用finally块来关闭输出流、输入流
|
finally {
|
try {
|
if (out != null) { out.close();}
|
if (in != null) {in.close();}
|
} catch (Exception ex) {
|
ex.printStackTrace();
|
}
|
}
|
obj.put("errMsg_r", errMsg_r);
|
obj.put("status_r", status_r);
|
return obj;
|
}
|
|
/**随机生成字数（整数）（包括 0）
|
* @param maxNumber 最大值
|
* @return
|
*/
|
public static Integer randomData(Integer maxNumber) {
|
java.util.Random r=new java.util.Random();
|
return r.nextInt(maxNumber);
|
}
|
|
private static final String[] HEADERS_TO_TRY = {"X-Forwarded-For", "Proxy-Client-IP", "WL-Proxy-Client-IP",
|
"HTTP_X_FORWARDED_FOR", "HTTP_X_FORWARDED", "HTTP_X_CLUSTER_CLIENT_IP", "HTTP_CLIENT_IP",
|
"HTTP_FORWARDED_FOR", "HTTP_FORWARDED", "HTTP_VIA", "REMOTE_ADDR", "X-Real-IP"};
|
|
/**
|
* getClientIpAddress:(获取用户ip，可穿透代理). <br/>
|
* @param request
|
* @return
|
* @author chenjiahe
|
* @Date 2018年3月2日下午4:41:47
|
* @since JDK 1.7
|
*/
|
public static String getClientIpAddress(HttpServletRequest request) {
|
for (String header : HEADERS_TO_TRY) {
|
String ip = request.getHeader(header);
|
if (ip != null && ip.length() != 0 && !"unknown".equalsIgnoreCase(ip)) {
|
return ip;
|
}
|
}
|
return request.getRemoteAddr();
|
}
|
|
}
|
