();
33 | //设置字符编码
34 | hints.put(EncodeHintType.CHARACTER_SET, "utf-8");
35 | // 指定纠错等级
36 | hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
37 | hints.put(EncodeHintType.MARGIN, 1);
38 | BitMatrix matrix = null;
39 | try {
40 | matrix = new MultiFormatWriter().encode(content, BarcodeFormat.QR_CODE, width, height, hints);
41 | } catch (WriterException e) {
42 | e.printStackTrace();
43 | }
44 |
45 | return matrix;
46 | }
47 |
48 | /**
49 | * 写入二维码、以及将照片logo写入二维码中
50 | * @param matrix 要写入的二维码
51 | * @param format 二维码照片格式
52 | * @param imagePath 二维码照片保存路径
53 | * @param logoPath logo路径
54 | * @throws java.io.IOException
55 | */
56 | public static void writeToFile(BitMatrix matrix, String format, String imagePath, String logoPath) throws IOException {
57 | MatrixToImageWriter.writeToFile(matrix, format, new File(imagePath), new MatrixToImageConfig());
58 |
59 | //添加logo图片, 此处一定需要重新进行读取，而不能直接使用二维码的BufferedImage 对象
60 | BufferedImage img = ImageIO.read(new File(imagePath));
61 | MatrixToImageWriterEx.overlapImage(img, format, imagePath, logoPath, DEFAULT_CONFIG);
62 | }
63 |
64 | /**
65 | * 写入二维码、以及将照片logo写入二维码中
66 | * @param matrix 要写入的二维码
67 | * @param format 二维码照片格式
68 | * @param imagePath 二维码照片保存路径
69 | * @param logoPath logo路径
70 | * @param logoConfig logo配置对象
71 | * @throws java.io.IOException
72 | */
73 | public static void writeToFile(BitMatrix matrix, String format, String imagePath, String logoPath, MatrixToLogoImageConfig logoConfig) throws IOException {
74 | MatrixToImageWriter.writeToFile(matrix, format, new File(imagePath), new MatrixToImageConfig());
75 |
76 | //添加logo图片, 此处一定需要重新进行读取，而不能直接使用二维码的BufferedImage 对象
77 | BufferedImage img = ImageIO.read(new File(imagePath));
78 | MatrixToImageWriterEx.overlapImage(img, format, imagePath, logoPath, logoConfig);
79 | }
80 |
81 | /**
82 | * 将照片logo添加到二维码中间
83 | * @param image 生成的二维码照片对象
84 | * @param imagePath 照片保存路径
85 | * @param logoPath logo照片路径
86 | * @param formate 照片格式
87 | */
88 | public static void overlapImage(BufferedImage image, String formate, String imagePath, String logoPath, MatrixToLogoImageConfig logoConfig) {
89 | try {
90 | //将logo写入二维码中
91 | drawImage(logoPath, image, logoConfig);
92 |
93 | //写入logo照片到二维码
94 | ImageIO.write(image, formate, new File(imagePath));
95 | } catch (Exception e) {
96 | e.printStackTrace();
97 | }
98 | }
99 |
100 | /**
101 | * 将照片添加到二维码中间，并生成流
102 | * @author:chenming
103 | * @date:2014年12月31日
104 | *
105 | * @param matrix 要写入的二维码
106 | * @param formate 照片格式
107 | * @param logoPath 要写入照片的路径
108 | * @param logoConfig logo配置对象 可以为null，为 null 默认 DEFAULT_CONFIG
109 | * @throws java.io.IOException
110 | */
111 | public static void overlapImage(BitMatrix matrix,String formate,String logoPath,MatrixToLogoImageConfig logoConfig,OutputStream out) throws IOException{
112 | //将matrix转换为bufferImage
113 | BufferedImage image = MatrixToImageWriter.toBufferedImage(matrix);
114 |
115 | //将logo照片绘制到二维码中间
116 | drawImage(logoPath, image, logoConfig);
117 |
118 | //输出
119 | ImageIO.write(image, formate, out);
120 | }
121 |
122 | /**
123 | * 将照片添加到二维码中间，并生成流
124 | * @author:chenming
125 | * @date:2014年12月31日
126 | *
127 | * @param image 要写入的二维码
128 | * @param formate 照片格式
129 | * @param logoPath 要写入照片的路径
130 | * @param logoConfig logo配置对象 可以为null，为 null 默认 DEFAULT_CONFIG
131 | * @throws java.io.IOException
132 | */
133 | public static void overlapImage(BufferedImage image,String formate,String logoPath,MatrixToLogoImageConfig logoConfig,OutputStream out) throws IOException{
134 | //将logo照片绘制到二维码中间
135 | drawImage(logoPath, image, logoConfig);
136 |
137 | //输出
138 | ImageIO.write(image, formate, out);
139 | }
140 |
141 | /**
142 | * 将logo添加到二维码中间
143 | * @author:chenming
144 | * @date:2014年12月31日
145 | *
146 | * @param logoPath logo路径
147 | * @param image 需要绘制的二维码图片
148 | * @param logoConfig 配置参数
149 | * @throws java.io.IOException
150 | */
151 | private static void drawImage(String logoPath,BufferedImage image,MatrixToLogoImageConfig logoConfig) throws IOException{
152 | if(logoConfig == null){
153 | logoConfig = DEFAULT_CONFIG;
154 | }
155 |
156 | try {
157 | BufferedImage logo = ImageIO.read(new File(logoPath));
158 | logo.setRGB(0, 0, BufferedImage.TYPE_INT_BGR);
159 | Graphics2D g = image.createGraphics();
160 |
161 | //考虑到logo照片贴到二维码中，建议大小不要超过二维码的1/5;
162 | int width = image.getWidth() / logoConfig.getLogoPart();
163 | int height = image.getHeight() / logoConfig.getLogoPart();
164 |
165 | //logo起始位置，此目的是为logo居中显示
166 | int x = (image.getWidth() - width) / 2;
167 | int y = (image.getHeight() - height) / 2;
168 |
169 | //绘制图
170 | g.drawImage(logo, x, y, width, height, null);
171 |
172 | //给logo画边框
173 | //构造一个具有指定线条宽度以及 cap 和 join 风格的默认值的实心 BasicStroke
174 | // g.setStroke(new BasicStroke(logoConfig.getBorder()));
175 | // g.setColor(logoConfig.getBorderColor());
176 | // g.drawRect(x, y, width, height);
177 |
178 | g.dispose();
179 | } catch (Exception e) { //捕捉异常后不做任何处理，防止图片路径错误而导致二维码生成失败
180 |
181 | }
182 | }
183 |
184 | }
185 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/QRCode/MatrixToLogoImageConfig.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.QRCode;
2 |
3 | import java.awt.Color;
4 |
5 | public class MatrixToLogoImageConfig {
6 | //logo默认边框颜色
7 | public static final Color DEFAULT_BORDERCOLOR = Color.RED;
8 | //logo默认边框宽度
9 | public static final int DEFAULT_BORDER = 2;
10 | //logo大小默认为照片的1/5
11 | public static final int DEFAULT_LOGOPART = 5;
12 |
13 | private final int border = DEFAULT_BORDER;
14 | private final Color borderColor;
15 | private final int logoPart;
16 |
17 | /**
18 | * Creates a default config with on color {@link #BLACK} and off color
19 | * {@link #WHITE}, generating normal black-on-white barcodes.
20 | */
21 | public MatrixToLogoImageConfig() {
22 | this(DEFAULT_BORDERCOLOR, DEFAULT_LOGOPART);
23 | }
24 |
25 |
26 | public MatrixToLogoImageConfig(Color borderColor, int logoPart) {
27 | this.borderColor = borderColor;
28 | this.logoPart = logoPart;
29 | }
30 |
31 |
32 | public Color getBorderColor() {
33 | return borderColor;
34 | }
35 |
36 |
37 | public int getBorder() {
38 | return border;
39 | }
40 |
41 |
42 | public int getLogoPart() {
43 | return logoPart;
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/base/ConvertUtils.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.base;
2 |
3 | import java.sql.Timestamp;
4 | import java.text.SimpleDateFormat;
5 |
6 | /**
7 | * 转换工具类
8 | * 若待转换值为null或者出现异常，则使用默认值
9 | *
10 | * @Author:chenssy
11 | * @date:2016年5月21日 上午10:18:12
12 | */
13 | public class ConvertUtils {
14 |
15 | /**
16 | * 字符串转换为int
17 | *
18 | * @author:chenssy
19 | * @date : 2016年5月21日 上午10:16:27
20 | *
21 | * @param str
22 | * 待转换的字符串
23 | * @param defaultValue
24 | * 默认值
25 | * @return
26 | */
27 | public static int strToInt(String str, int defaultValue) {
28 | try {
29 | defaultValue = Integer.parseInt(str);
30 | } catch (Exception localException) {
31 | }
32 | return defaultValue;
33 | }
34 |
35 | /**
36 | * String转换为long
37 | *
38 | * @author:chenssy
39 | * @date : 2016年5月21日 上午10:18:44
40 | *
41 | * @param str
42 | * 待转换字符串
43 | * @param defaultValue
44 | * 默认值
45 | * @return
46 | */
47 | public static long strToLong(String str, long defaultValue) {
48 | try {
49 | defaultValue = Long.parseLong(str);
50 | } catch (Exception localException) {
51 | }
52 | return defaultValue;
53 | }
54 |
55 | /**
56 | * 字符串转换为float
57 | *
58 | * @author:chenssy
59 | * @date : 2016年5月21日 上午10:19:12
60 | *
61 | * @param str
62 | *
63 | * @param defaultValue
64 | * @return
65 | */
66 | public static float strToFloat(String str, float defaultValue) {
67 | try {
68 | defaultValue = Float.parseFloat(str);
69 | } catch (Exception localException) {
70 | }
71 | return defaultValue;
72 | }
73 |
74 | /**
75 | * String转换为Double
76 | *
77 | * @author:chenssy
78 | * @date : 2016年5月21日 上午10:21:59
79 | *
80 | * @param str
81 | * 待转换字符串
82 | * @param defaultValue
83 | * 默认值
84 | * @return
85 | */
86 | public static double strToDouble(String str, double defaultValue) {
87 | try {
88 | defaultValue = Double.parseDouble(str);
89 | } catch (Exception localException) {
90 | }
91 | return defaultValue;
92 | }
93 |
94 | /**
95 | * 字符串转换日期
96 | *
97 | * @author:chenssy
98 | * @date : 2016年5月21日 上午10:27:01
99 | *
100 | * @param str
101 | * 待转换的字符串
102 | * @param defaultValue
103 | * 默认日期
104 | * @return
105 | */
106 | public static java.util.Date strToDate(String str,java.util.Date defaultValue) {
107 | return strToDate(str, "yyyy-MM-dd HH:mm:ss", defaultValue);
108 | }
109 |
110 | /**
111 | * 字符串转换为指定格式的日期
112 | *
113 | * @author:chenssy
114 | * @date : 2016年5月21日 上午10:27:24
115 | *
116 | * @param str
117 | * 待转换的字符串
118 | * @param format
119 | * 日期格式
120 | * @param defaultValue
121 | * 默认日期
122 | * @return
123 | */
124 | public static java.util.Date strToDate(String str, String format,java.util.Date defaultValue) {
125 | SimpleDateFormat fmt = new SimpleDateFormat(format);
126 | try {
127 | defaultValue = fmt.parse(str);
128 | } catch (Exception localException) {
129 | }
130 | return defaultValue;
131 | }
132 |
133 | /**
134 | * 日期转换为字符串
135 | *
136 | * @author:chenssy
137 | * @date : 2016年5月21日 上午10:28:05
138 | *
139 | * @param date
140 | * 待转换的日期
141 | * @param defaultValue
142 | * 默认字符串
143 | * @return
144 | */
145 | public static String dateToStr(java.util.Date date, String defaultValue) {
146 | return dateToStr(date, "yyyy-MM-dd HH:mm:ss", defaultValue);
147 | }
148 |
149 | /**
150 | * 日期转换为指定格式的字符串
151 | *
152 | * @author:chenssy
153 | * @date : 2016年5月21日 上午10:28:51
154 | *
155 | * @param date
156 | * 待转换的日期
157 | * @param format
158 | * 指定格式
159 | * @param defaultValue
160 | * 默认值
161 | * @return
162 | */
163 | public static String dateToStr(java.util.Date date, String format, String defaultValue) {
164 | SimpleDateFormat sdf = new SimpleDateFormat(format);
165 | try {
166 | defaultValue = sdf.format(date);
167 | } catch (Exception localException) {
168 | }
169 | return defaultValue;
170 | }
171 |
172 | /**
173 | * 如果字符串为空则使用默认字符串
174 | *
175 | * @author:chenssy
176 | * @date : 2016年5月21日 上午10:29:35
177 | *
178 | * @param str
179 | * 字符串
180 | * @param defaultValue
181 | * 默认值
182 | * @return
183 | */
184 | public static String strToStr(String str, String defaultValue) {
185 | if ((str != null) && (!(str.isEmpty())))
186 | defaultValue = str;
187 | return defaultValue;
188 | }
189 |
190 | /**
191 | * util date 转换为 sqldate
192 | *
193 | * @author:chenssy
194 | * @date : 2016年5月21日 上午10:30:09
195 | *
196 | * @param date
197 | * @return
198 | */
199 | public static java.sql.Date dateToSqlDate(java.util.Date date) {
200 | return new java.sql.Date(date.getTime());
201 | }
202 |
203 | /**
204 | * sql date 转换为 util date
205 | *
206 | * @author:chenssy
207 | * @date : 2016年5月21日 上午10:30:26
208 | *
209 | * @param date
210 | * @return
211 | */
212 | public static java.util.Date sqlDateToDate(java.sql.Date date) {
213 | return new java.util.Date(date.getTime());
214 | }
215 |
216 | /**
217 | * date 转换为 timestamp
218 | *
219 | * @author:chenssy
220 | * @date : 2016年5月21日 上午10:30:51
221 | *
222 | * @param date
223 | * @return
224 | */
225 | public static Timestamp dateToSqlTimestamp(java.util.Date date) {
226 | return new Timestamp(date.getTime());
227 | }
228 |
229 | /**
230 | * timestamp 转换为date
231 | *
232 | * @author:chenssy
233 | * @date : 2016年5月21日 上午10:31:13
234 | *
235 | * @param date
236 | * @return
237 | */
238 | public static java.util.Date qlTimestampToDate(Timestamp date) {
239 | return new java.util.Date(date.getTime());
240 | }
241 | }
242 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/base/IdcardValidator.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.base;
2 |
3 | import java.util.regex.Pattern;
4 |
5 | /**
6 | * --15位身份证号码：第7、8位为出生年份(两位数)，第9、10位为出生月份，第11、12位代表出生日期，第15位代表性别，奇数为男，偶数为女。
7 | * --18位身份证号码
8 | * ：第7、8、9、10位为出生年份(四位数)，第11、第12位为出生月份，第13、14位代表出生日期，第17位代表性别，奇数为男，偶数为女。
9 | *
10 | * @Author:chenssy
11 | * @date:2016年6月1日 下午12:29:41
12 | *
13 | */
14 | public class IdcardValidator {
15 |
16 | /**
17 | * 省，直辖市代码表： { 11:"北京",12:"天津",13:"河北",14:"山西",15:"内蒙古",
18 | * 21:"辽宁",22:"吉林",23:"黑龙江",31:"上海",32:"江苏",
19 | * 33:"浙江",34:"安徽",35:"福建",36:"江西",37:"山东",41:"河南",
20 | * 42:"湖北",43:"湖南",44:"广东",45:"广西",46:"海南",50:"重庆",
21 | * 51:"四川",52:"贵州",53:"云南",54:"西藏",61:"陕西",62:"甘肃",
22 | * 63:"青海",64:"宁夏",65:"新疆",71:"台湾",81:"香港",82:"澳门",91:"国外"}
23 | */
24 |
25 | // 每位加权因子
26 | private static int power[] = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 };
27 |
28 | /**
29 | * 验证身份证是否合法
30 | *
31 | * @author : chenssy
32 | * @date : 2016年6月1日 下午12:30:03
33 | *
34 | * @param idcard
35 | * @return
36 | */
37 | @SuppressWarnings("static-access")
38 | public boolean isValidatedAllIdcard(String idcard) {
39 | return this.isValidate18Idcard(idcard);
40 | }
41 |
42 | /**
43 | *
44 |
45 | * 判断18位身份证的合法性
46 | *
47 | * 根据〖中华人民共和国国家标准GB11643-1999〗中有关公民身份号码的规定，公民身份号码是特征组合码，由十七位数字本体码和一位数字校验码组成。
48 | * 排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码和一位数字校验码。
49 | *
50 | * 顺序码: 表示在同一地址码所标识的区域范围内，对同年、同月、同 日出生的人编定的顺序号，顺序码的奇数分配给男性，偶数分配 给女性。
51 | *
52 | *
53 | * 1.前1、2位数字表示：所在省份的代码； 2.第3、4位数字表示：所在城市的代码； 3.第5、6位数字表示：所在区县的代码；
54 | * 4.第7~14位数字表示：出生年、月、日； 5.第15、16位数字表示：所在地的派出所的代码；
55 | * 6.第17位数字表示性别：奇数表示男性，偶数表示女性；
56 | * 7.第18位数字是校检码：也有的说是个人信息码，一般是随计算机的随机产生，用来检验身份证的正确性。校检码可以是0~9的数字，有时也用x表示。
57 | *
58 | *
59 | * 第十八位数字(校验码)的计算方法为： 1.将前面的身份证号码17位数分别乘以不同的系数。从第一位到第十七位的系数分别为：7 9 10 5 8 4
60 | * 2 1 6 3 7 9 10 5 8 4 2
61 | *
62 | *
63 | * 2.将这17位数字和系数相乘的结果相加。
64 | *
65 | *
66 | * 3.用加出来和除以11，看余数是多少？
67 | *
68 | * 4.余数只可能有0 1 2 3 4 5 6 7 8 9 10这11个数字。其分别对应的最后一位身份证的号码为1 0 X 9 8 7 6 5 4 3
69 | * 2。
70 | *
71 | * 5.通过上面得知如果余数是2，就会在身份证的第18位数字上出现罗马数字的Ⅹ。如果余数是10，身份证的最后一位号码就是2。
72 | *
73 | *
74 | * @author : chenssy
75 | * @date : 2016年6月1日 下午12:31:10
76 | *
77 | * @param idcard
78 | * 待验证的身份证
79 | * @return
80 | */
81 | public static boolean isValidate18Idcard(String idcard) {
82 | // 非18位为假
83 | if (idcard.length() != 18) {
84 | return false;
85 | }
86 | // 获取前17位
87 | String idcard17 = idcard.substring(0, 17);
88 | // 获取第18位
89 | String idcard18Code = idcard.substring(17, 18);
90 | char c[] = null;
91 | String checkCode = "";
92 | // 是否都为数字
93 | if (isDigital(idcard17)) {
94 | c = idcard17.toCharArray();
95 | } else {
96 | return false;
97 | }
98 |
99 | if (null != c) {
100 | int bit[] = new int[idcard17.length()];
101 | bit = converCharToInt(c);
102 | int sum17 = 0;
103 | sum17 = getPowerSum(bit);
104 | // 将和值与11取模得到余数进行校验码判断
105 | checkCode = getCheckCodeBySum(sum17);
106 | if (null == checkCode) {
107 | return false;
108 | }
109 | // 将身份证的第18位与算出来的校码进行匹配，不相等就为假
110 | if (!idcard18Code.equalsIgnoreCase(checkCode)) {
111 | return false;
112 | }
113 | }
114 |
115 | return true;
116 | }
117 |
118 | /**
119 | * 18位身份证号码的基本数字和位数验校
120 | *
121 | * @author : chenssy
122 | * @date : 2016年6月1日 下午12:31:49
123 | *
124 | * @param idcard
125 | * 待验证的身份证
126 | * @return
127 | */
128 | public static boolean is18Idcard(String idcard) {
129 | return Pattern.matches("^[1-9]\\d{5}[1-9]\\d{3}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}([\\d|x|X]{1})$", idcard);
130 | }
131 |
132 | /**
133 | * 数字验证
134 | *
135 | * @author : chenssy
136 | * @date : 2016年6月1日 下午12:32:18
137 | *
138 | * @param str
139 | * @return
140 | */
141 | private static boolean isDigital(String str) {
142 | return str == null || "".equals(str) ? false : str.matches("^[0-9]*$");
143 | }
144 |
145 | /**
146 | * 将身份证的每位和对应位的加权因子相乘之后，再得到和值
147 | *
148 | * @author : chenssy
149 | * @date : 2016年6月1日 下午12:32:34
150 | *
151 | * @param bit
152 | * @return
153 | */
154 | private static int getPowerSum(int[] bit) {
155 | int sum = 0;
156 | if (power.length != bit.length) {
157 | return sum;
158 | }
159 |
160 | for (int i = 0; i < bit.length; i++) {
161 | for (int j = 0; j < power.length; j++) {
162 | if (i == j) {
163 | sum = sum + bit[i] * power[j];
164 | }
165 | }
166 | }
167 |
168 | return sum;
169 | }
170 |
171 | /**
172 | * 将和值与11取模得到余数进行校验码判断
173 | *
174 | * @author : chenssy
175 | * @date : 2016年6月1日 下午12:32:51
176 | *
177 | * @param sum17
178 | * @return
179 | */
180 | private static String getCheckCodeBySum(int sum17) {
181 | String checkCode = null;
182 | switch (sum17 % 11) {
183 | case 10:
184 | checkCode = "2";
185 | break;
186 | case 9:
187 | checkCode = "3";
188 | break;
189 | case 8:
190 | checkCode = "4";
191 | break;
192 | case 7:
193 | checkCode = "5";
194 | break;
195 | case 6:
196 | checkCode = "6";
197 | break;
198 | case 5:
199 | checkCode = "7";
200 | break;
201 | case 4:
202 | checkCode = "8";
203 | break;
204 | case 3:
205 | checkCode = "9";
206 | break;
207 | case 2:
208 | checkCode = "x";
209 | break;
210 | case 1:
211 | checkCode = "0";
212 | break;
213 | case 0:
214 | checkCode = "1";
215 | break;
216 | }
217 | return checkCode;
218 | }
219 |
220 | /**
221 | * 将字符数组转为整型数组
222 | *
223 | * @author : chenssy
224 | * @date : 2016年6月1日 下午12:33:22
225 | *
226 | * @param c
227 | * @return
228 | * @throws NumberFormatException
229 | */
230 | private static int[] converCharToInt(char[] c) throws NumberFormatException {
231 | int[] a = new int[c.length];
232 | int k = 0;
233 | for (char temp : c) {
234 | a[k++] = Integer.parseInt(String.valueOf(temp));
235 | }
236 | return a;
237 | }
238 |
239 | /**
240 | *
241 | * @param idno
242 | * @return 身份证信息中代表性别的数值
243 | */
244 | public static int getUserSex(String idno) {
245 | String sex="1";
246 | if(idno!=null){
247 | if(idno.length()>15){
248 | sex = idno.substring(16, 17);
249 | }
250 | }
251 |
252 | return Integer.parseInt(sex) % 2==0 ? 0:1;
253 | }
254 | }
255 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/base/MoneyUtils.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.base;
2 |
3 | import java.math.BigDecimal;
4 | import java.math.RoundingMode;
5 |
6 | /**
7 | * 金钱处理工具类
8 | *
9 | * @Author:chenssy
10 | * @date:2014年8月7日
11 | */
12 | public class MoneyUtils {
13 |
14 | /**
15 | * 汉语中数字大写
16 | */
17 | private static final String[] CN_UPPER_NUMBER = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖" };
18 |
19 | /**
20 | * 汉语中货币单位大写
21 | */
22 | private static final String[] CN_UPPER_MONETRAY_UNIT = { "分", "角", "元","拾", "佰", "仟", "万", "拾",
23 | "佰", "仟", "亿", "拾", "佰", "仟", "兆", "拾",
24 | "佰", "仟" };
25 | /**
26 | * 特殊字符：整
27 | */
28 | private static final String CN_FULL = "";
29 |
30 | /**
31 | * 特殊字符：负
32 | */
33 | private static final String CN_NEGATIVE = "负";
34 | /**
35 | * 零元整
36 | */
37 | private static final String CN_ZEOR_FULL = "零元整";
38 |
39 | /**
40 | * 金额的精度，默认值为2
41 | */
42 | private static final int MONEY_PRECISION = 2;
43 |
44 | /**
45 | * 人民币转换为大写,格式为：x万x千x百x十x元x角x分
46 | *
47 | * @autor:chenssy
48 | * @date:2014年8月7日
49 | *
50 | * @param numberOfMoney 传入的金额
51 | * @return
52 | */
53 | public static String number2CNMontray(String numberOfMoney) {
54 | return number2CNMontray(new BigDecimal(numberOfMoney));
55 | }
56 |
57 |
58 | /**
59 | * 人民币转换为大写,格式为：x万x千x百x十x元x角x分
60 | * @autor:chenssy
61 | * @date:2014年8月7日
62 | *
63 | * @param numberOfMoney
64 | * 传入的金额
65 | * @return
66 | */
67 | public static String number2CNMontray(BigDecimal numberOfMoney) {
68 | StringBuffer sb = new StringBuffer();
69 | int signum = numberOfMoney.signum();
70 | // 零元整的情况
71 | if (signum == 0) {
72 | return CN_ZEOR_FULL;
73 | }
74 | //这里会进行金额的四舍五入
75 | long number = numberOfMoney.movePointRight(MONEY_PRECISION).setScale(0, 4).abs().longValue();
76 | // 得到小数点后两位值
77 | long scale = number % 100;
78 | int numUnit = 0;
79 | int numIndex = 0;
80 | boolean getZero = false;
81 | // 判断最后两位数，一共有四中情况：00 = 0, 01 = 1, 10, 11
82 | if (!(scale > 0)) {
83 | numIndex = 2;
84 | number = number / 100;
85 | getZero = true;
86 | }
87 | if ((scale > 0) && (!(scale % 10 > 0))) {
88 | numIndex = 1;
89 | number = number / 10;
90 | getZero = true;
91 | }
92 | int zeroSize = 0;
93 | while (true) {
94 | if (number <= 0) {
95 | break;
96 | }
97 | // 每次获取到最后一个数
98 | numUnit = (int) (number % 10);
99 | if (numUnit > 0) {
100 | if ((numIndex == 9) && (zeroSize >= 3)) {
101 | sb.insert(0, CN_UPPER_MONETRAY_UNIT[6]);
102 | }
103 | if ((numIndex == 13) && (zeroSize >= 3)) {
104 | sb.insert(0, CN_UPPER_MONETRAY_UNIT[10]);
105 | }
106 | sb.insert(0, CN_UPPER_MONETRAY_UNIT[numIndex]);
107 | sb.insert(0, CN_UPPER_NUMBER[numUnit]);
108 | getZero = false;
109 | zeroSize = 0;
110 | } else {
111 | ++zeroSize;
112 | if (!(getZero)) {
113 | sb.insert(0, CN_UPPER_NUMBER[numUnit]);
114 | }
115 | if (numIndex == 2) {
116 | if (number > 0) {
117 | sb.insert(0, CN_UPPER_MONETRAY_UNIT[numIndex]);
118 | }
119 | } else if (((numIndex - 2) % 4 == 0) && (number % 1000 > 0)) {
120 | sb.insert(0, CN_UPPER_MONETRAY_UNIT[numIndex]);
121 | }
122 | getZero = true;
123 | }
124 | // 让number每次都去掉最后一个数
125 | number = number / 10;
126 | ++numIndex;
127 | }
128 | // 如果signum == -1，则说明输入的数字为负数，就在最前面追加特殊字符：负
129 | if (signum == -1) {
130 | sb.insert(0, CN_NEGATIVE);
131 | }
132 | // 输入的数字小数点后两位为"00"的情况，则要在最后追加特殊字符：整
133 | if (!(scale > 0)) {
134 | sb.append(CN_FULL);
135 | }
136 | return sb.toString();
137 | }
138 |
139 | /**
140 | * 将人民币转换为会计格式金额(xxxx,xxxx,xxxx.xx),保留两位小数
141 | * @autor:chenssy
142 | * @date:2014年8月7日
143 | *
144 | * @param money
145 | * 待转换的金额
146 | * @return
147 | */
148 | public static String accountantMoney(BigDecimal money){
149 | return accountantMoney(money, 2, 1);
150 | }
151 |
152 | /**
153 | * 格式化金额，显示为xxx万元，xxx百万,xxx亿
154 | * @autor:chenssy
155 | * @date:2014年8月7日
156 | *
157 | * @param money
158 | * 待处理的金额
159 | * @param scale
160 | * 小数点后保留的位数
161 | * @param divisor
162 | * 格式化值（10:十元、100:百元,1000千元，10000万元......）
163 | * @return
164 | */
165 | public static String getFormatMoney(BigDecimal money,int scale,double divisor){
166 | return formatMoney(money, scale, divisor) + getCellFormat(divisor);
167 | }
168 |
169 | /**
170 | * 获取会计格式的人民币(格式为:xxxx,xxxx,xxxx.xx)
171 | * @autor:chenssy
172 | * @date:2014年8月7日
173 | *
174 | * @param money
175 | * 待处理的金额
176 | * @param scale
177 | * 小数点后保留的位数
178 | * @param divisor
179 | * 格式化值（10:十元、100:百元,1000千元，10000万元......）
180 | * @return
181 | */
182 | public static String getAccountantMoney(BigDecimal money, int scale, double divisor){
183 | return accountantMoney(money, scale, divisor) + getCellFormat(divisor);
184 | }
185 |
186 | /**
187 | * 将人民币转换为会计格式金额(xxxx,xxxx,xxxx.xx)
188 | * @autor:chenssy
189 | * @date:2014年8月7日
190 | *
191 | * @param money
192 | * 待处理的金额
193 | * @param scale
194 | * 小数点后保留的位数
195 | * @param divisor
196 | * 格式化值
197 | * @return
198 | */
199 | private static String accountantMoney(BigDecimal money,int scale,double divisor){
200 | String disposeMoneyStr = formatMoney(money, scale, divisor);
201 | //小数点处理
202 | int dotPosition = disposeMoneyStr.indexOf(".");
203 | String exceptDotMoeny = null;//小数点之前的字符串
204 | String dotMeony = null;//小数点之后的字符串
205 | if(dotPosition > 0){
206 | exceptDotMoeny = disposeMoneyStr.substring(0,dotPosition);
207 | dotMeony = disposeMoneyStr.substring(dotPosition);
208 | }else{
209 | exceptDotMoeny = disposeMoneyStr;
210 | }
211 | //负数处理
212 | int negativePosition = exceptDotMoeny.indexOf("-");
213 | if(negativePosition == 0){
214 | exceptDotMoeny = exceptDotMoeny.substring(1);
215 | }
216 | StringBuffer reverseExceptDotMoney = new StringBuffer(exceptDotMoeny);
217 | reverseExceptDotMoney.reverse();//字符串倒转
218 | char[] moneyChar = reverseExceptDotMoney.toString().toCharArray();
219 | StringBuffer returnMeony = new StringBuffer();//返回值
220 | for(int i = 0; i < moneyChar.length; i++){
221 | if(i != 0 && i % 3 == 0){
222 | returnMeony.append(",");//每隔3位加','
223 | }
224 | returnMeony.append(moneyChar[i]);
225 | }
226 | returnMeony.reverse();//字符串倒转
227 | if(dotPosition > 0){
228 | returnMeony.append(dotMeony);
229 | }
230 | if(negativePosition == 0){
231 | return "-" + returnMeony.toString();
232 | }else{
233 | return returnMeony.toString();
234 | }
235 | }
236 |
237 | /**
238 | * 格式化金额，显示为xxx万元，xxx百万,xxx亿
239 | * @autor:chenssy
240 | * @date:2014年8月7日
241 | *
242 | * @param money
243 | * 待处理的金额
244 | * @param scale
245 | * 小数点后保留的位数
246 | * @param divisor
247 | * 格式化值
248 | * @return
249 | */
250 | private static String formatMoney(BigDecimal money,int scale,double divisor){
251 | if (divisor == 0) {
252 | return "0.00";
253 | }
254 | if (scale < 0) {
255 | return "0.00";
256 | }
257 | BigDecimal divisorBD = new BigDecimal(divisor);
258 | return money.divide(divisorBD, scale, RoundingMode.HALF_UP).toString();
259 | }
260 |
261 | private static String getCellFormat(double divisor){
262 | String str = String.valueOf(divisor);
263 | int len = str.substring(0,str.indexOf(".")).length();
264 | String cell = "";
265 | switch(len){
266 | case 1:
267 | cell = "元";
268 | break;
269 | case 2:
270 | cell = "十元";
271 | break;
272 | case 3:
273 | cell = "百元";
274 | break;
275 | case 4:
276 | cell = "千元";
277 | break;
278 | case 5:
279 | cell = "万元";
280 | break;
281 | case 6:
282 | cell = "十万元";
283 | break;
284 | case 7:
285 | cell = "百万元";
286 | break;
287 | case 8:
288 | cell = "千万元";
289 | break;
290 | case 9:
291 | cell = "亿元";
292 | break;
293 | case 10:
294 | cell = "十亿元";
295 | break;
296 | }
297 | return cell;
298 | }
299 | }
300 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/base/RegexUtils.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.base;
2 |
3 | import java.util.regex.Matcher;
4 | import java.util.regex.Pattern;
5 |
6 | /**
7 | * 正则表达式工具类，验证数据是否符合规范
8 | *
9 | * @Author:chenssy
10 | * @date:2014年8月7日
11 | */
12 | public class RegexUtils {
13 |
14 | /**
15 | * 判断字符串是否符合正则表达式
16 | *
17 | * @author : chenssy
18 | * @date : 2016年6月1日 下午12:43:05
19 | *
20 | * @param str
21 | * @param regex
22 | * @return
23 | */
24 | public static boolean find(String str, String regex) {
25 | Pattern p = Pattern.compile(regex);
26 | Matcher m = p.matcher(str);
27 | boolean b = m.find();
28 | return b;
29 | }
30 |
31 | /**
32 | * 判断输入的字符串是否符合Email格式.
33 | * @autor:chenssy
34 | * @date:2014年8月7日
35 | *
36 | * @param email
37 | * 传入的字符串
38 | * @return 符合Email格式返回true，否则返回false
39 | */
40 | public static boolean isEmail(String email) {
41 | if (email == null || email.length() < 1 || email.length() > 256) {
42 | return false;
43 | }
44 | Pattern pattern = Pattern.compile("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$");
45 | return pattern.matcher(email).matches();
46 | }
47 |
48 | /**
49 | * 判断输入的字符串是否为纯汉字
50 | * @autor:chenssy
51 | * @date:2014年8月7日
52 | *
53 | * @param value
54 | * 传入的字符串
55 | * @return
56 | */
57 | public static boolean isChinese(String value) {
58 | Pattern pattern = Pattern.compile("[\u0391-\uFFE5]+$");
59 | return pattern.matcher(value).matches();
60 | }
61 |
62 | /**
63 | * 判断是否为浮点数，包括double和float
64 | * @autor:chenssy
65 | * @date:2014年8月7日
66 | *
67 | * @param value
68 | * 传入的字符串
69 | * @return
70 | */
71 | public static boolean isDouble(String value) {
72 | Pattern pattern = Pattern.compile("^[-\\+]?\\d+\\.\\d+$");
73 | return pattern.matcher(value).matches();
74 | }
75 |
76 | /**
77 | * 判断是否为整数
78 | * @autor:chenssy
79 | * @date:2014年8月7日
80 | *
81 | * @param value
82 | * 传入的字符串
83 | * @return
84 | */
85 | public static boolean isInteger(String value) {
86 | Pattern pattern = Pattern.compile("^[-\\+]?[\\d]+$");
87 | return pattern.matcher(value).matches();
88 | }
89 | }
90 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/base/StringUtils.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.base;
2 |
3 | import java.util.regex.Matcher;
4 | import java.util.regex.Pattern;
5 |
6 | /**
7 | *
8 | * 字符串工具类，对字符串进行常规的处理
9 | *
10 | * @Author:chenssy
11 | * @date:2014年8月5日
12 | */
13 | public class StringUtils {
14 |
15 | /**
16 | * 将半角的符号转换成全角符号.(即英文字符转中文字符)
17 | * @autor:chenssy
18 | * @date:2014年8月7日
19 | *
20 | * @param str
21 | * 要转换的字符
22 | * @return
23 | */
24 | public static String changeToFull(String str) {
25 | String source = "1234567890!@#$%^&*()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_=+\\|[];:'\",<.>/?";
26 | String[] decode = { "１", "２", "３", "４", "５", "６", "７", "８", "９", "０",
27 | "！", "＠", "＃", "＄", "％", "︿", "＆", "＊", "（", "）", "ａ", "ｂ",
28 | "ｃ", "ｄ", "ｅ", "ｆ", "ｇ", "ｈ", "ｉ", "ｊ", "ｋ", "ｌ", "ｍ", "ｎ",
29 | "ｏ", "ｐ", "ｑ", "ｒ", "ｓ", "ｔ", "ｕ", "ｖ", "ｗ", "ｘ", "ｙ", "ｚ",
30 | "Ａ", "Ｂ", "Ｃ", "Ｄ", "Ｅ", "Ｆ", "Ｇ", "Ｈ", "Ｉ", "Ｊ", "Ｋ", "Ｌ",
31 | "Ｍ", "Ｎ", "Ｏ", "Ｐ", "Ｑ", "Ｒ", "Ｓ", "Ｔ", "Ｕ", "Ｖ", "Ｗ", "Ｘ",
32 | "Ｙ", "Ｚ", "－", "＿", "＝", "＋", "＼", "｜", "【", "】", "；", "：",
33 | "'", "\"", "，", "〈", "。", "〉", "／", "？" };
34 | String result = "";
35 | for (int i = 0; i < str.length(); i++) {
36 | int pos = source.indexOf(str.charAt(i));
37 | if (pos != -1) {
38 | result += decode[pos];
39 | } else {
40 | result += str.charAt(i);
41 | }
42 | }
43 | return result;
44 | }
45 |
46 | /**
47 | * 将字符转换为编码为Unicode，格式 为'\u0020'
48 | * unicodeEscaped(' ') = "\u0020"
49 | * unicodeEscaped('A') = "\u0041"
50 | * @autor:chenssy
51 | * @date:2014年8月7日
52 | *
53 | * @param ch
54 | * 待转换的char 字符
55 | * @return
56 | */
57 | public static String unicodeEscaped(char ch) {
58 | if (ch < 0x10) {
59 | return "\\u000" + Integer.toHexString(ch);
60 | } else if (ch < 0x100) {
61 | return "\\u00" + Integer.toHexString(ch);
62 | } else if (ch < 0x1000) {
63 | return "\\u0" + Integer.toHexString(ch);
64 | }
65 | return "\\u" + Integer.toHexString(ch);
66 | }
67 |
68 | /**
69 | * 进行toString操作，若为空，返回默认值
70 | * @autor:chenssy
71 | * @date:2014年8月9日
72 | *
73 | * @param object
74 | * 要进行toString操作的对象
75 | * @param nullStr
76 | * 返回的默认值
77 | * @return
78 | */
79 | public static String toString(Object object,String nullStr){
80 | return object == null ? nullStr : object.toString();
81 | }
82 |
83 | /**
84 | * 将字符串重复N次，null、""不在循环次数里面
85 | * 当value == null || value == "" return value;
86 | * 当count <= 1 返回 value
87 | * @autor:chenssy
88 | * @date:2014年8月9日
89 | *
90 | * @param value
91 | * 需要循环的字符串
92 | * @param count
93 | * 循环的次数
94 | * @return
95 | */
96 | public static String repeatString(String value,int count){
97 | if(value == null || "".equals(value) || count <= 1){
98 | return value;
99 | }
100 |
101 | int length = value.length();
102 | if(length == 1){ //长度为1，存在字符
103 | return repeatChar(value.charAt(0), count);
104 | }
105 |
106 | int outputLength = length * count;
107 | switch (length) {
108 | case 1:
109 | return repeatChar(value.charAt(0), count);
110 | case 2:
111 | char ch0 = value.charAt(0);
112 | char ch1 = value.charAt(1);
113 | char[] output2 = new char[outputLength];
114 | for (int i = count * 2 - 2; i >= 0; i--, i--) {
115 | output2[i] = ch0;
116 | output2[i + 1] = ch1;
117 | }
118 | return new String(output2);
119 | default:
120 | StringBuilder buf = new StringBuilder(outputLength);
121 | for (int i = 0; i < count; i++) {
122 | buf.append(value);
123 | }
124 | return buf.toString();
125 | }
126 |
127 | }
128 |
129 | /**
130 | * 将某个字符重复N次
131 | * @autor:chenssy
132 | * @date:2014年8月9日
133 | *
134 | * @param ch
135 | * 需要循环的字符
136 | * @param count
137 | * 循环的次数
138 | * @return
139 | */
140 | public static String repeatChar(char ch, int count) {
141 | char[] buf = new char[count];
142 | for (int i = count - 1; i >= 0; i--) {
143 | buf[i] = ch;
144 | }
145 | return new String(buf);
146 | }
147 |
148 | /**
149 | * 判断字符串是否全部都为小写
150 | * @autor:chenssy
151 | * @date:2014年8月9日
152 | *
153 | * @param value
154 | * 待判断的字符串
155 | * @return
156 | */
157 | public static boolean isAllLowerCase(String value){
158 | if(value == null || "".equals(value)){
159 | return false;
160 | }
161 | for (int i = 0; i < value.length(); i++) {
162 | if (Character.isLowerCase(value.charAt(i)) == false) {
163 | return false;
164 | }
165 | }
166 | return true;
167 | }
168 |
169 | /**
170 | * 判断字符串是否全部大写
171 | * @autor:chenssy
172 | * @date:2014年8月9日
173 | *
174 | * @param value
175 | * 待判断的字符串
176 | * @return
177 | */
178 | public static boolean isAllUpperCase(String value){
179 | if(value == null || "".equals(value)){
180 | return false;
181 | }
182 | for (int i = 0; i < value.length(); i++) {
183 | if (Character.isUpperCase(value.charAt(i)) == false) {
184 | return false;
185 | }
186 | }
187 | return true;
188 | }
189 |
190 | /**
191 | * 反转字符串
192 | * @autor:chenssy
193 | * @date:2014年8月9日
194 | *
195 | * @param value
196 | * 待反转的字符串
197 | * @return
198 | */
199 | public static String reverse(String value){
200 | if(value == null){
201 | return null;
202 | }
203 | return new StringBuffer(value).reverse().toString();
204 | }
205 |
206 | /**
207 | * @desc:截取字符串，支持中英文混乱，其中中文当做两位处理
208 | * @autor:chenssy
209 | * @date:2014年8月10日
210 | *
211 | * @param resourceString
212 | * @param length
213 | * @return
214 | */
215 | public static String subString(String resourceString,int length){
216 | String resultString = "";
217 | if (resourceString == null || "".equals(resourceString) || length < 1) {
218 | return resourceString;
219 | }
220 |
221 | if (resourceString.length() < length) {
222 | return resourceString;
223 | }
224 |
225 | char[] chr = resourceString.toCharArray();
226 | int strNum = 0;
227 | int strGBKNum = 0;
228 | boolean isHaveDot = false;
229 |
230 | for (int i = 0; i < resourceString.length(); i++) {
231 | if (chr[i] >= 0xa1){// 0xa1汉字最小位开始
232 | strNum = strNum + 2;
233 | strGBKNum++;
234 | } else {
235 | strNum++;
236 | }
237 |
238 | if (strNum == length || strNum == length + 1) {
239 | if (i + 1 < resourceString.length()) {
240 | isHaveDot = true;
241 | }
242 | break;
243 | }
244 | }
245 | resultString = resourceString.substring(0, strNum - strGBKNum);
246 | if (isHaveDot) {
247 | resultString = resultString + "...";
248 | }
249 |
250 | return resultString;
251 | }
252 |
253 | /**
254 | *
255 | * @autor:chenssy
256 | * @date:2014年8月10日
257 | *
258 | * @param htmlString
259 | * @param length
260 | * @return
261 | */
262 | public static String subHTMLString(String htmlString,int length){
263 | return subString(delHTMLTag(htmlString), length);
264 | }
265 |
266 | /**
267 | * 过滤html标签，包括script、style、html、空格、回车标签
268 | * @autor:chenssy
269 | * @date:2014年8月10日
270 | *
271 | * @param htmlStr
272 | * @return
273 | */
274 | public static String delHTMLTag(String htmlStr){
275 | String regEx_script = "]*?>[\\s\\S]*?<\\/script>"; // 定义script的正则表达式
276 | String regEx_style = "]*?>[\\s\\S]*?<\\/style>"; // 定义style的正则表达式
277 | String regEx_html = "<[^>]+>"; // 定义HTML标签的正则表达式
278 | String regEx_space = "\\s*|\t|\r|\n";//定义空格回车换行符
279 |
280 | Pattern p_script = Pattern.compile(regEx_script, Pattern.CASE_INSENSITIVE);
281 | Matcher m_script = p_script.matcher(htmlStr);
282 | htmlStr = m_script.replaceAll(""); // 过滤script标签
283 |
284 | Pattern p_style = Pattern.compile(regEx_style, Pattern.CASE_INSENSITIVE);
285 | Matcher m_style = p_style.matcher(htmlStr);
286 | htmlStr = m_style.replaceAll(""); // 过滤style标签
287 |
288 | Pattern p_html = Pattern.compile(regEx_html, Pattern.CASE_INSENSITIVE);
289 | Matcher m_html = p_html.matcher(htmlStr);
290 | htmlStr = m_html.replaceAll(""); // 过滤html标签
291 |
292 | Pattern p_space = Pattern.compile(regEx_space, Pattern.CASE_INSENSITIVE);
293 | Matcher m_space = p_space.matcher(htmlStr);
294 | htmlStr = m_space.replaceAll(""); // 过滤空格回车标签
295 |
296 | return htmlStr.trim(); // 返回文本字符串
297 | }
298 | }
299 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/base/ValidateHelper.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.base;
2 |
3 | import java.lang.reflect.Array;
4 | import java.util.Collection;
5 | import java.util.Date;
6 | import java.util.Map;
7 |
8 | /**
9 | * 判断对象、字符串、集合是否为空、不为空
10 | *
11 | * @Author:chenssy
12 | * @date:2014年8月4日
13 | */
14 | public final class ValidateHelper {
15 |
16 | /**
17 | * 判断数组是否为空
18 | * @author chenssy
19 | * @date Dec 23, 2013
20 | * @param array
21 | * @return boolean
22 | */
23 | @SuppressWarnings("unused")
24 | private static boolean isEmptyArray(T[] array){
25 | if (array == null || array.length == 0){
26 | return true;
27 | }
28 | else{
29 | return false;
30 | }
31 | }
32 |
33 | /**
34 | * 判断数组是否不为空
35 | * @author chenssy
36 | * @date Dec 23, 2013
37 | * @param array
38 | * @return boolean
39 | */
40 | public static boolean isNotEmptyArray(T[] array){
41 | if (array != null && array.length > 0){
42 | return true;
43 | }
44 | else{
45 | return false;
46 | }
47 | }
48 |
49 | /**
50 | * 判断字符串是否为空
51 | * @author chenssy
52 | * @date Dec 23, 2013
53 | * @param string
54 | * @return boolean
55 | */
56 | public static boolean isEmptyString(String string){
57 | if (string == null || string.length() == 0){
58 | return true;
59 | }
60 | else{
61 | return false;
62 | }
63 | }
64 |
65 | /**
66 | * 判断字符串是否不为空
67 | * @author chenssy
68 | * @date Dec 23, 2013
69 | * @param string
70 | * @return boolean
71 | */
72 | public static boolean isNotEmptyString(String string){
73 | if (string != null && string.length() > 0){
74 | return true;
75 | }
76 | else{
77 | return false;
78 | }
79 | }
80 |
81 | /**
82 | * 判断集合是否为空
83 | * @author chenssy
84 | * @date Dec 26, 2013
85 | * @param collection
86 | * @return boolean
87 | */
88 | public static boolean isEmptyCollection(Collection collection){
89 | if (collection == null || collection.isEmpty()){
90 | return true;
91 | }
92 | else{
93 | return false;
94 | }
95 | }
96 |
97 | /**
98 | * 判断集合是否不为空
99 | * @author chenssy
100 | * @date Dec 26, 2013
101 | * @param collection
102 | * @return boolean
103 | */
104 | public static boolean isNotEmptyCollection(Collection collection){
105 | if (collection != null && !collection.isEmpty()){
106 | return true;
107 | }
108 | else{
109 | return false;
110 | }
111 | }
112 |
113 | /**
114 | * 判断map集合是否不为空
115 | * @author chenssy
116 | * @date Dec 26, 2013
117 | * @param map
118 | * @return boolean
119 | */
120 | @SuppressWarnings("rawtypes")
121 | public static boolean isNotEmptyMap(Map map){
122 | if (map != null && !map.isEmpty()){
123 | return true;
124 | }
125 | else{
126 | return false;
127 | }
128 | }
129 |
130 | /**
131 | * 判断map集合是否为空
132 | * @author ming.chen
133 | * @date Dec 26, 2013
134 | * @param map
135 | * @return boolean
136 | */
137 | @SuppressWarnings("rawtypes")
138 | public static boolean isEmptyMap(Map map){
139 | if (map == null || map.isEmpty()){
140 | return true;
141 | }
142 | else{
143 | return false;
144 | }
145 | }
146 |
147 | /**
148 | * 检验对象是否为空,String 中只有空格在对象中也算空.
149 | * @param object
150 | * @return 为空返回true,否则false.
151 | */
152 | @SuppressWarnings("rawtypes")
153 | public static boolean isEmpty(Object object) {
154 | if (null == object)
155 | return true;
156 | else if (object instanceof String)
157 | return "".equals(object.toString().trim());
158 | else if (object instanceof Iterable)
159 | return !((Iterable) object).iterator().hasNext();
160 | else if (object.getClass().isArray())
161 | return Array.getLength(object) == 0;
162 | else if (object instanceof Map)
163 | return ((Map) object).size() == 0;
164 | else if (Number.class.isAssignableFrom(object.getClass()))
165 | return false;
166 | else if (Date.class.isAssignableFrom(object.getClass()))
167 | return false;
168 | else
169 | return false;
170 | }
171 | }
172 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/beanConvert/BeanMapConvert.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.beanConvert;
2 |
3 | import java.beans.BeanInfo;
4 | import java.beans.IntrospectionException;
5 | import java.beans.Introspector;
6 | import java.beans.PropertyDescriptor;
7 | import java.lang.reflect.InvocationTargetException;
8 | import java.lang.reflect.Method;
9 | import java.util.HashMap;
10 | import java.util.Map;
11 |
12 | /**
13 | * Bean与Map的转换
14 | *
15 | * @author chenssy
16 | * @date 2016-09-24
17 | * @since 1.0.0
18 | */
19 | public class BeanMapConvert {
20 | /**
21 | * Bean转换为Map
22 | *
23 | * @param object
24 | * @return String-Object的HashMap
25 | *
26 | * @author chenssy
27 | * @date 2016-09-25
28 | * @since v1.0.0
29 | */
30 | public static Map bean2MapObject(Object object){
31 | if(object == null){
32 | return null;
33 | }
34 |
35 | Map map = new HashMap();
36 | try {
37 | BeanInfo beanInfo = Introspector.getBeanInfo(object.getClass());
38 | PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
39 | for (PropertyDescriptor property : propertyDescriptors) {
40 | String key = property.getName();
41 | // 过滤class属性
42 | if (!key.equals("class")) {
43 | // 得到property对应的getter方法
44 | Method getter = property.getReadMethod();
45 | Object value = getter.invoke(object);
46 |
47 | map.put(key, value);
48 | }
49 | }
50 | } catch (Exception e) {
51 | e.printStackTrace();
52 | }
53 |
54 | return map;
55 | }
56 |
57 | /**
58 | * Map转换为Java Bean
59 | *
60 | * @param map
61 | * 待转换的Map
62 | * @param object
63 | * Java Bean
64 | * @return java.lang.Object
65 | *
66 | * @author chenssy
67 | * @date 2016-09-25
68 | * @since v1.0.0
69 | */
70 | public static Object map2Bean(Map map,Object object){
71 | if(map == null || object == null){
72 | return null;
73 | }
74 | try {
75 | BeanInfo beanInfo = Introspector.getBeanInfo(object.getClass());
76 | PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
77 |
78 | for (PropertyDescriptor property : propertyDescriptors) {
79 | String key = property.getName();
80 | if (map.containsKey(key)) {
81 | Object value = map.get(key);
82 | // 得到property对应的setter方法
83 | Method setter = property.getWriteMethod();
84 | setter.invoke(object, value);
85 | }
86 | }
87 | } catch (IntrospectionException e) {
88 | e.printStackTrace();
89 | } catch (InvocationTargetException e) {
90 | e.printStackTrace();
91 | } catch (IllegalAccessException e) {
92 | e.printStackTrace();
93 | }
94 | return object;
95 | }
96 | }
97 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/clone/CloneUtils.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.clone;
2 |
3 | import java.io.ByteArrayInputStream;
4 | import java.io.ByteArrayOutputStream;
5 | import java.io.IOException;
6 | import java.io.ObjectInputStream;
7 | import java.io.ObjectOutputStream;
8 | import java.io.Serializable;
9 | import java.util.Collection;
10 |
11 | /**
12 | * 克隆工具类，进行深克隆,包括对象、集合
13 | *
14 | * @Author:chenssy
15 | * @date:2014年8月9日
16 | */
17 | public class CloneUtils {
18 |
19 | /**
20 | * 采用对象的序列化完成对象的深克隆
21 | * @autor:chenssy
22 | * @date:2014年8月9日
23 | *
24 | * @param obj
25 | * 待克隆的对象
26 | * @return
27 | */
28 | @SuppressWarnings("unchecked")
29 | public static T cloneObject(T obj) {
30 | T cloneObj = null;
31 | try {
32 | // 写入字节流
33 | ByteArrayOutputStream out = new ByteArrayOutputStream();
34 | ObjectOutputStream obs = new ObjectOutputStream(out);
35 | obs.writeObject(obj);
36 | obs.close();
37 |
38 | // 分配内存，写入原始对象，生成新对象
39 | ByteArrayInputStream ios = new ByteArrayInputStream(out.toByteArray());
40 | ObjectInputStream ois = new ObjectInputStream(ios);
41 | // 返回生成的新对象
42 | cloneObj = (T) ois.readObject();
43 | ois.close();
44 | } catch (Exception e) {
45 | e.printStackTrace();
46 | }
47 | return cloneObj;
48 | }
49 |
50 | /**
51 | * 利用序列化完成集合的深克隆
52 | * @autor:chenssy
53 | * @date:2014年8月9日
54 | *
55 | * @param collection
56 | * 待克隆的集合
57 | * @return
58 | * @throws ClassNotFoundException
59 | * @throws java.io.IOException
60 | */
61 | @SuppressWarnings("unchecked")
62 | public static Collection cloneCollection(Collection collection) throws ClassNotFoundException, IOException{
63 | ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
64 | ObjectOutputStream out = new ObjectOutputStream(byteOut);
65 | out.writeObject(collection);
66 | out.close();
67 |
68 | ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
69 | ObjectInputStream in = new ObjectInputStream(byteIn);
70 | Collection dest = (Collection) in.readObject();
71 | in.close();
72 |
73 | return dest;
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/date/DateFormatUtils.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.date;
2 |
3 | import java.text.ParsePosition;
4 | import java.text.SimpleDateFormat;
5 | import java.util.Date;
6 |
7 | /**
8 | * 日期格式化工具类
9 | *
10 | * @Author:chenssy
11 | * @date:2016年5月26日 下午12:39:57
12 | *
13 | */
14 | public class DateFormatUtils {
15 | /** yyyy:年 */
16 | public static final String DATE_YEAR = "yyyy";
17 |
18 | /** MM：月 */
19 | public static final String DATE_MONTH = "MM";
20 |
21 | /** DD：日 */
22 | public static final String DATE_DAY = "dd";
23 |
24 | /** HH：时 */
25 | public static final String DATE_HOUR = "HH";
26 |
27 | /** mm：分 */
28 | public static final String DATE_MINUTE = "mm";
29 |
30 | /** ss：秒 */
31 | public static final String DATE_SECONDES = "ss";
32 |
33 | /** yyyy-MM-dd */
34 | public static final String DATE_FORMAT1 = "yyyy-MM-dd";
35 |
36 | /** yyyy-MM-dd hh:mm:ss */
37 | public static final String DATE_FORMAT2 = "yyyy-MM-dd HH:mm:ss";
38 |
39 | /** yyyy-MM-dd hh:mm:ss|SSS */
40 | public static final String TIME_FORMAT_SSS = "yyyy-MM-dd HH:mm:ss|SSS";
41 |
42 | /** yyyyMMdd */
43 | public static final String DATE_NOFUll_FORMAT = "yyyyMMdd";
44 |
45 | /** yyyyMMddhhmmss */
46 | public static final String TIME_NOFUll_FORMAT = "yyyyMMddHHmmss";
47 |
48 | /**
49 | *
50 | * 格式转换
51 | * yyyy-MM-dd hh:mm:ss 和 yyyyMMddhhmmss 相互转换
52 | * yyyy-mm-dd 和yyyymmss 相互转换
53 | * @author chenssy
54 | * @date Dec 26, 2013
55 | * @param value
56 | * 日期
57 | * @return String
58 | */
59 | public static String formatString(String value) {
60 | String sReturn = "";
61 | if (value == null || "".equals(value))
62 | return sReturn;
63 | if (value.length() == 14) { //长度为14格式转换成yyyy-mm-dd hh:mm:ss
64 | sReturn = value.substring(0, 4) + "-" + value.substring(4, 6) + "-" + value.substring(6, 8) + " "
65 | + value.substring(8, 10) + ":" + value.substring(10, 12) + ":" + value.substring(12, 14);
66 | return sReturn;
67 | }
68 | if (value.length() == 19) { //长度为19格式转换成yyyymmddhhmmss
69 | sReturn = value.substring(0, 4) + value.substring(5, 7) + value.substring(8, 10) + value.substring(11, 13)
70 | + value.substring(14, 16) + value.substring(17, 19);
71 | return sReturn;
72 | }
73 | if(value.length() == 10){ //长度为10格式转换成yyyymmhh
74 | sReturn = value.substring(0, 4) + value.substring(5,7) + value.substring(8,10);
75 | }
76 | if(value.length() == 8){ //长度为8格式转化成yyyy-mm-dd
77 | sReturn = value.substring(0, 4) + "-" + value.substring(4, 6) + "-" + value.substring(6, 8);
78 | }
79 | return sReturn;
80 | }
81 |
82 | public static String formatDate(String date, String format) {
83 | if (date == null || "".equals(date)){
84 | return "";
85 | }
86 | Date dt = null;
87 | SimpleDateFormat inFmt = null;
88 | SimpleDateFormat outFmt = null;
89 | ParsePosition pos = new ParsePosition(0);
90 | date = date.replace("-", "").replace(":", "");
91 | if ((date == null) || ("".equals(date.trim())))
92 | return "";
93 | try {
94 | if (Long.parseLong(date) == 0L)
95 | return "";
96 | } catch (Exception nume) {
97 | return date;
98 | }
99 | try {
100 | switch (date.trim().length()) {
101 | case 14:
102 | inFmt = new SimpleDateFormat("yyyyMMddHHmmss");
103 | break;
104 | case 12:
105 | inFmt = new SimpleDateFormat("yyyyMMddHHmm");
106 | break;
107 | case 10:
108 | inFmt = new SimpleDateFormat("yyyyMMddHH");
109 | break;
110 | case 8:
111 | inFmt = new SimpleDateFormat("yyyyMMdd");
112 | break;
113 | case 6:
114 | inFmt = new SimpleDateFormat("yyyyMM");
115 | break;
116 | case 7:
117 | case 9:
118 | case 11:
119 | case 13:
120 | default:
121 | return date;
122 | }
123 | if ((dt = inFmt.parse(date, pos)) == null)
124 | return date;
125 | if ((format == null) || ("".equals(format.trim()))) {
126 | outFmt = new SimpleDateFormat("yyyy年MM月dd日");
127 | } else {
128 | outFmt = new SimpleDateFormat(format);
129 | }
130 | return outFmt.format(dt);
131 | } catch (Exception ex) {
132 | }
133 | return date;
134 | }
135 |
136 | /**
137 | * 格式化日期
138 | *
139 | * @author chenming
140 | * @date 2016年5月31日
141 | *
142 | * @param date
143 | * @param format
144 | * @return
145 | */
146 | public static String formatDate(Date date,String format){
147 | return formatDate(DateUtils.date2String(date), format);
148 | }
149 |
150 | /**
151 | * @desc:格式化是时间，采用默认格式（yyyy-MM-dd HH:mm:ss）
152 | * @autor:chenssy
153 | * @date:2014年8月6日
154 | *
155 | * @param value
156 | * @return
157 | */
158 | public static String formatDate(String value){
159 | return getFormat(DATE_FORMAT2).format(DateUtils.string2Date(value, DATE_FORMAT2));
160 | }
161 |
162 | /**
163 | * 格式化日期
164 | *
165 | * @author : chenssy
166 | * @date : 2016年5月31日 下午5:40:58
167 | *
168 | * @param value
169 | * @return
170 | */
171 | public static String formatDate(Date value){
172 | return formatDate(DateUtils.date2String(value));
173 | }
174 |
175 | /**
176 | * 获取日期显示格式，为空默认为yyyy-mm-dd HH:mm:ss
177 | * @author chenssy
178 | * @date Dec 30, 2013
179 | * @param format
180 | * @return
181 | * @return SimpleDateFormat
182 | */
183 | protected static SimpleDateFormat getFormat(String format){
184 | if(format == null || "".equals(format)){
185 | format = DATE_FORMAT2;
186 | }
187 | return new SimpleDateFormat(format);
188 | }
189 | }
190 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/date/DateUtils.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.date;
2 |
3 | import java.text.DateFormat;
4 | import java.text.ParseException;
5 | import java.text.SimpleDateFormat;
6 | import java.util.Calendar;
7 | import java.util.Date;
8 |
9 | /**
10 | * @desc:时间处理工具类
11 | *
12 | * @Author:chenssy
13 | * @date:2014年8月4日
14 | */
15 | public class DateUtils {
16 | private static final String[] weeks = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
17 | /**
18 | * 根据指定格式获取当前时间
19 | * @author chenssy
20 | * @date Dec 27, 2013
21 | * @param format
22 | * @return String
23 | */
24 | public static String getCurrentTime(String format){
25 | SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
26 | Date date = new Date();
27 | return sdf.format(date);
28 | }
29 |
30 | /**
31 | * 获取当前时间，格式为：yyyy-MM-dd HH:mm:ss
32 | * @author chenssy
33 | * @date Dec 27, 2013
34 | * @return String
35 | */
36 | public static String getCurrentTime(){
37 | return getCurrentTime(DateFormatUtils.DATE_FORMAT2);
38 | }
39 |
40 | /**
41 | * 获取指定格式的当前时间：为空时格式为yyyy-mm-dd HH:mm:ss
42 | * @author chenssy
43 | * @date Dec 30, 2013
44 | * @param format
45 | * @return Date
46 | */
47 | public static Date getCurrentDate(String format){
48 | SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
49 | String dateS = getCurrentTime(format);
50 | Date date = null;
51 | try {
52 | date = sdf.parse(dateS);
53 | } catch (ParseException e) {
54 | e.printStackTrace();
55 | }
56 | return date;
57 | }
58 |
59 | /**
60 | * 获取当前时间，格式为yyyy-MM-dd HH:mm:ss
61 | * @author chenssy
62 | * @date Dec 30, 2013
63 | * @return Date
64 | */
65 | public static Date getCurrentDate(){
66 | return getCurrentDate(DateFormatUtils.DATE_FORMAT2);
67 | }
68 |
69 | /**
70 | * 给指定日期加入年份，为空时默认当前时间
71 | * @author chenssy
72 | * @date Dec 30, 2013
73 | * @param year 年份 正数相加、负数相减
74 | * @param date 为空时，默认为当前时间
75 | * @param format 默认格式为：yyyy-MM-dd HH:mm:ss
76 | * @return String
77 | */
78 | public static String addYearToDate(int year,Date date,String format){
79 | Calendar calender = getCalendar(date,format);
80 | SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
81 |
82 | calender.add(Calendar.YEAR, year);
83 |
84 | return sdf.format(calender.getTime());
85 | }
86 |
87 | /**
88 | * 给指定日期加入年份，为空时默认当前时间
89 | * @author chenssy
90 | * @date Dec 30, 2013
91 | * @param year 年份 正数相加、负数相减
92 | * @param date 为空时，默认为当前时间
93 | * @param format 默认格式为：yyyy-MM-dd HH:mm:ss
94 | * @return String
95 | */
96 | public static String addYearToDate(int year,String date,String format){
97 | Date newDate = new Date();
98 | if(null != date && !"".equals(date)){
99 | newDate = string2Date(date, format);
100 | }
101 |
102 | return addYearToDate(year, newDate, format);
103 | }
104 |
105 | /**
106 | * 给指定日期增加月份 为空时默认当前时间
107 | * @author chenssy
108 | * @date Dec 30, 2013
109 | * @param month 增加月份 正数相加、负数相减
110 | * @param date 指定时间
111 | * @param format 指定格式 为空默认 yyyy-mm-dd HH:mm:ss
112 | * @return String
113 | */
114 | public static String addMothToDate(int month,Date date,String format) {
115 | Calendar calender = getCalendar(date,format);
116 | SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
117 |
118 | calender.add(Calendar.MONTH, month);
119 |
120 | return sdf.format(calender.getTime());
121 | }
122 |
123 | /**
124 | * 给指定日期增加月份 为空时默认当前时间
125 | * @author chenssy
126 | * @date Dec 30, 2013
127 | * @param month 增加月份 正数相加、负数相减
128 | * @param date 指定时间
129 | * @param format 指定格式 为空默认 yyyy-mm-dd HH:mm:ss
130 | * @return String
131 | */
132 | public static String addMothToDate(int month,String date,String format) {
133 | Date newDate = new Date();
134 | if(null != date && !"".equals(date)){
135 | newDate = string2Date(date, format);
136 | }
137 |
138 | return addMothToDate(month, newDate, format);
139 | }
140 |
141 | /**
142 | * 给指定日期增加天数，为空时默认当前时间
143 | * @author chenssy
144 | * @date Dec 31, 2013
145 | * @param day 增加天数 正数相加、负数相减
146 | * @param date 指定日期
147 | * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
148 | * @return String
149 | */
150 | public static String addDayToDate(int day,Date date,String format) {
151 | Calendar calendar = getCalendar(date, format);
152 | SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
153 |
154 | calendar.add(Calendar.DATE, day);
155 |
156 | return sdf.format(calendar.getTime());
157 | }
158 |
159 | /**
160 | * 给指定日期增加天数，为空时默认当前时间
161 | * @author chenssy
162 | * @date Dec 31, 2013
163 | * @param day 增加天数 正数相加、负数相减
164 | * @param date 指定日期
165 | * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
166 | * @return String
167 | */
168 | public static String addDayToDate(int day,String date,String format) {
169 | Date newDate = new Date();
170 | if(null != date && !"".equals(date)){
171 | newDate = string2Date(date, format);
172 | }
173 |
174 | return addDayToDate(day, newDate, format);
175 | }
176 |
177 | /**
178 | * 给指定日期增加小时，为空时默认当前时间
179 | * @author chenssy
180 | * @date Dec 31, 2013
181 | * @param hour 增加小时 正数相加、负数相减
182 | * @param date 指定日期
183 | * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
184 | * @return String
185 | */
186 | public static String addHourToDate(int hour,Date date,String format) {
187 | Calendar calendar = getCalendar(date, format);
188 | SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
189 |
190 | calendar.add(Calendar.HOUR, hour);
191 |
192 | return sdf.format(calendar.getTime());
193 | }
194 |
195 | /**
196 | * 给指定日期增加小时，为空时默认当前时间
197 | * @author chenssy
198 | * @date Dec 31, 2013
199 | * @param hour 增加小时 正数相加、负数相减
200 | * @param date 指定日期
201 | * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
202 | * @return String
203 | */
204 | public static String addHourToDate(int hour,String date,String format) {
205 | Date newDate = new Date();
206 | if(null != date && !"".equals(date)){
207 | newDate = string2Date(date, format);
208 | }
209 |
210 | return addHourToDate(hour, newDate, format);
211 | }
212 |
213 | /**
214 | * 给指定的日期增加分钟，为空时默认当前时间
215 | * @author chenssy
216 | * @date Dec 31, 2013
217 | * @param minute 增加分钟 正数相加、负数相减
218 | * @param date 指定日期
219 | * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
220 | * @return String
221 | */
222 | public static String addMinuteToDate(int minute,Date date,String format) {
223 | Calendar calendar = getCalendar(date, format);
224 | SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
225 |
226 | calendar.add(Calendar.MINUTE, minute);
227 |
228 | return sdf.format(calendar.getTime());
229 | }
230 |
231 | /**
232 | * 给指定的日期增加分钟，为空时默认当前时间
233 | * @author chenssy
234 | * @date Dec 31, 2013
235 | * @param minute 增加分钟 正数相加、负数相减
236 | * @param date 指定日期
237 | * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
238 | * @return String
239 | */
240 | public static String addMinuteToDate(int minute,String date,String format){
241 | Date newDate = new Date();
242 | if(null != date && !"".equals(date)){
243 | newDate = string2Date(date, format);
244 | }
245 |
246 | return addMinuteToDate(minute, newDate, format);
247 | }
248 |
249 | /**
250 | * 给指定日期增加秒，为空时默认当前时间
251 | * @author chenssy
252 | * @date Dec 31, 2013
253 | * @param second 增加秒 正数相加、负数相减
254 | * @param date 指定日期
255 | * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
256 | * @return String
257 | */
258 | public static String addSecondToDate(int second,Date date,String format){
259 | Calendar calendar = getCalendar(date, format);
260 | SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
261 |
262 | calendar.add(Calendar.SECOND, second);
263 |
264 | return sdf.format(calendar.getTime());
265 | }
266 |
267 | /**
268 | * 给指定日期增加秒，为空时默认当前时间
269 | * @author chenssy
270 | * @date Dec 31, 2013
271 | * @param second 增加秒 正数相加、负数相减
272 | * @param date 指定日期
273 | * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
274 | * @return String
275 | * @throws Exception
276 | */
277 | public static String addSecondToDate(int second,String date,String format){
278 | Date newDate = new Date();
279 | if(null != date && !"".equals(date)){
280 | newDate = string2Date(date, format);
281 | }
282 |
283 | return addSecondToDate(second, newDate, format);
284 | }
285 |
286 | /**
287 | * 获取指定格式指定时间的日历
288 | * @author chenssy
289 | * @date Dec 30, 2013
290 | * @param date 时间
291 | * @param format 格式
292 | * @return Calendar
293 | */
294 | public static Calendar getCalendar(Date date,String format){
295 | if(date == null){
296 | date = getCurrentDate(format);
297 | }
298 |
299 | Calendar calender = Calendar.getInstance();
300 | calender.setTime(date);
301 |
302 | return calender;
303 | }
304 |
305 | /**
306 | * 字符串转换为日期，日期格式为
307 | *
308 | * @author : chenssy
309 | * @date : 2016年5月31日 下午5:20:22
310 | *
311 | * @param value
312 | * @return
313 | */
314 | public static Date string2Date(String value){
315 | if(value == null || "".equals(value)){
316 | return null;
317 | }
318 |
319 | SimpleDateFormat sdf = DateFormatUtils.getFormat(DateFormatUtils.DATE_FORMAT2);
320 | Date date = null;
321 |
322 | try {
323 | value = DateFormatUtils.formatDate(value, DateFormatUtils.DATE_FORMAT2);
324 | date = sdf.parse(value);
325 | } catch (Exception e) {
326 | e.printStackTrace();
327 | }
328 | return date;
329 | }
330 |
331 | /**
332 | * 将字符串(格式符合规范)转换成Date
333 | * @author chenssy
334 | * @date Dec 31, 2013
335 | * @param value 需要转换的字符串
336 | * @param format 日期格式
337 | * @return Date
338 | */
339 | public static Date string2Date(String value,String format){
340 | if(value == null || "".equals(value)){
341 | return null;
342 | }
343 |
344 | SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
345 | Date date = null;
346 |
347 | try {
348 | value = DateFormatUtils.formatDate(value, format);
349 | date = sdf.parse(value);
350 | } catch (Exception e) {
351 | e.printStackTrace();
352 | }
353 | return date;
354 | }
355 |
356 | /**
357 | * 将日期格式转换成String
358 | * @author chenssy
359 | * @date Dec 31, 2013
360 | *
361 | * @param value 需要转换的日期
362 | * @param format 日期格式
363 | * @return String
364 | */
365 | public static String date2String(Date value,String format){
366 | if(value == null){
367 | return null;
368 | }
369 |
370 | SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
371 | return sdf.format(value);
372 | }
373 |
374 | /**
375 | * 日期转换为字符串
376 | *
377 | * @author : chenssy
378 | * @date : 2016年5月31日 下午5:21:38
379 | *
380 | * @param value
381 | * @return
382 | */
383 | public static String date2String(Date value){
384 | if(value == null){
385 | return null;
386 | }
387 |
388 | SimpleDateFormat sdf = DateFormatUtils.getFormat(DateFormatUtils.DATE_FORMAT2);
389 | return sdf.format(value);
390 | }
391 |
392 | /**
393 | * 获取指定日期的年份
394 | * @author chenssy
395 | * @date Dec 31, 2013
396 | * @param value 日期
397 | * @return int
398 | */
399 | public static int getCurrentYear(Date value){
400 | String date = date2String(value, DateFormatUtils.DATE_YEAR);
401 | return Integer.valueOf(date);
402 | }
403 |
404 | /**
405 | * 获取指定日期的年份
406 | * @author chenssy
407 | * @date Dec 31, 2013
408 | * @param value 日期
409 | * @return int
410 | */
411 | public static int getCurrentYear(String value) {
412 | Date date = string2Date(value, DateFormatUtils.DATE_YEAR);
413 | Calendar calendar = getCalendar(date, DateFormatUtils.DATE_YEAR);
414 | return calendar.get(Calendar.YEAR);
415 | }
416 |
417 | /**
418 | * 获取指定日期的月份
419 | * @author chenssy
420 | * @date Dec 31, 2013
421 | * @param value 日期
422 | * @return int
423 | */
424 | public static int getCurrentMonth(Date value){
425 | String date = date2String(value, DateFormatUtils.DATE_MONTH);
426 | return Integer.valueOf(date);
427 | }
428 |
429 | /**
430 | * 获取指定日期的月份
431 | * @author chenssy
432 | * @date Dec 31, 2013
433 | * @param value 日期
434 | * @return int
435 | */
436 | public static int getCurrentMonth(String value) {
437 | Date date = string2Date(value, DateFormatUtils.DATE_MONTH);
438 | Calendar calendar = getCalendar(date, DateFormatUtils.DATE_MONTH);
439 |
440 | return calendar.get(Calendar.MONTH);
441 | }
442 |
443 | /**
444 | * 获取指定日期的天份
445 | * @author chenssy
446 | * @date Dec 31, 2013
447 | * @param value 日期
448 | * @return int
449 | */
450 | public static int getCurrentDay(Date value){
451 | String date = date2String(value, DateFormatUtils.DATE_DAY);
452 | return Integer.valueOf(date);
453 | }
454 |
455 | /**
456 | * 获取指定日期的天份
457 | * @author chenssy
458 | * @date Dec 31, 2013
459 | * @param value 日期
460 | * @return int
461 | */
462 | public static int getCurrentDay(String value){
463 | Date date = string2Date(value, DateFormatUtils.DATE_DAY);
464 | Calendar calendar = getCalendar(date, DateFormatUtils.DATE_DAY);
465 |
466 | return calendar.get(Calendar.DATE);
467 | }
468 |
469 | /**
470 | * 获取当前日期为星期几
471 | * @author chenssy
472 | * @date Dec 31, 2013
473 | * @param value 日期
474 | * @return String
475 | */
476 | public static String getCurrentWeek(Date value) {
477 | Calendar calendar = getCalendar(value, DateFormatUtils.DATE_FORMAT1);
478 | int weekIndex = calendar.get(Calendar.DAY_OF_WEEK) - 1 < 0 ? 0 : calendar.get(Calendar.DAY_OF_WEEK) - 1;
479 |
480 | return weeks[weekIndex];
481 | }
482 |
483 | /**
484 | * 获取当前日期为星期几
485 | * @author chenssy
486 | * @date Dec 31, 2013
487 | * @param value 日期
488 | * @return String
489 | */
490 | public static String getCurrentWeek(String value) {
491 | Date date = string2Date(value, DateFormatUtils.DATE_FORMAT1);
492 | return getCurrentWeek(date);
493 | }
494 |
495 | /**
496 | * 获取指定日期的小时
497 | * @author chenssy
498 | * @date Dec 31, 2013
499 | * @param value 日期
500 | * @return int
501 | */
502 | public static int getCurrentHour(Date value){
503 | String date = date2String(value, DateFormatUtils.DATE_HOUR);
504 | return Integer.valueOf(date);
505 | }
506 |
507 | /**
508 | * 获取指定日期的小时
509 | * @author chenssy
510 | * @date Dec 31, 2013
511 | * @param value 日期
512 | * @return
513 | * @return int
514 | */
515 | public static int getCurrentHour(String value) {
516 | Date date = string2Date(value, DateFormatUtils.DATE_HOUR);
517 | Calendar calendar = getCalendar(date, DateFormatUtils.DATE_HOUR);
518 |
519 | return calendar.get(Calendar.DATE);
520 | }
521 |
522 | /**
523 | * 获取指定日期的分钟
524 | * @author chenssy
525 | * @date Dec 31, 2013
526 | * @param value 日期
527 | * @return int
528 | */
529 | public static int getCurrentMinute(Date value){
530 | String date = date2String(value, DateFormatUtils.DATE_MINUTE);
531 | return Integer.valueOf(date);
532 | }
533 |
534 | /**
535 | * 获取指定日期的分钟
536 | * @author chenssy
537 | * @date Dec 31, 2013
538 | * @param value 日期
539 | * @return int
540 | */
541 | public static int getCurrentMinute(String value){
542 | Date date = string2Date(value, DateFormatUtils.DATE_MINUTE);
543 | Calendar calendar = getCalendar(date, DateFormatUtils.DATE_MINUTE);
544 |
545 | return calendar.get(Calendar.MINUTE);
546 | }
547 |
548 | /**
549 | * 比较两个日期相隔多少天(月、年)
550 | * 例：
551 | * compareDate("2009-09-12", null, 0);//比较天
552 | * compareDate("2009-09-12", null, 1);//比较月
553 | * compareDate("2009-09-12", null, 2);//比较年
554 | *
555 | * @author chenssy
556 | * @date Dec 31, 2013
557 | * @param startDay 需要比较的时间 不能为空(null),需要正确的日期格式 ,如：2009-09-12
558 | * @param endDay 被比较的时间 为空(null)则为当前时间
559 | * @param stype 返回值类型 0为多少天，1为多少个月，2为多少年
560 | * @return int
561 | */
562 | public static int compareDate(String startDay,String endDay,int stype) {
563 | int n = 0;
564 | startDay = DateFormatUtils.formatDate(startDay, "yyyy-MM-dd");
565 | endDay = DateFormatUtils.formatDate(endDay, "yyyy-MM-dd");
566 |
567 | String formatStyle = "yyyy-MM-dd";
568 | if(1 == stype){
569 | formatStyle = "yyyy-MM";
570 | }else if(2 == stype){
571 | formatStyle = "yyyy";
572 | }
573 |
574 | endDay = endDay==null ? getCurrentTime("yyyy-MM-dd") : endDay;
575 |
576 | DateFormat df = new SimpleDateFormat(formatStyle);
577 | Calendar c1 = Calendar.getInstance();
578 | Calendar c2 = Calendar.getInstance();
579 | try {
580 | c1.setTime(df.parse(startDay));
581 | c2.setTime(df.parse(endDay));
582 | } catch (Exception e) {
583 | e.printStackTrace();
584 | }
585 | while (!c1.after(c2)) { // 循环对比，直到相等，n 就是所要的结果
586 | n++;
587 | if(stype==1){
588 | c1.add(Calendar.MONTH, 1); // 比较月份，月份+1
589 | }
590 | else{
591 | c1.add(Calendar.DATE, 1); // 比较天数，日期+1
592 | }
593 | }
594 | n = n-1;
595 | if(stype==2){
596 | n = (int)n/365;
597 | }
598 | return n;
599 | }
600 |
601 | /**
602 | * 比较两个时间相差多少小时(分钟、秒)
603 | * @author chenssy
604 | * @date Jan 2, 2014
605 | * @param startTime 需要比较的时间 不能为空，且必须符合正确格式：2012-12-12 12:12:
606 | * @param endTime 需要被比较的时间 若为空则默认当前时间
607 | * @param type 1：小时 2：分钟 3：秒
608 | * @return int
609 | */
610 | public static int compareTime(String startTime , String endTime , int type) {
611 | //endTime是否为空，为空默认当前时间
612 | if(endTime == null || "".equals(endTime)){
613 | endTime = getCurrentTime();
614 | }
615 |
616 | SimpleDateFormat sdf = DateFormatUtils.getFormat("");
617 | int value = 0;
618 | try {
619 | Date begin = sdf.parse(startTime);
620 | Date end = sdf.parse(endTime);
621 | long between = (end.getTime() - begin.getTime()) / 1000; //除以1000转换成豪秒
622 | if(type == 1){ //小时
623 | value = (int) (between % (24 * 36000) / 3600);
624 | }
625 | else if(type == 2){
626 | value = (int) (between % 3600 / 60);
627 | }
628 | else if(type == 3){
629 | value = (int) (between % 60 / 60);
630 | }
631 | } catch (ParseException e) {
632 | e.printStackTrace();
633 | }
634 | return value;
635 | }
636 |
637 | /**
638 | * 比较两个日期的大小。
639 | * 若date1 > date2 则返回 1
640 | * 若date1 = date2 则返回 0
641 | * 若date1 < date2 则返回-1
642 | * @autor:chenssy
643 | * @date:2014年9月9日
644 | *
645 | * @param date1
646 | * @param date2
647 | * @param format 待转换的格式
648 | * @return 比较结果
649 | */
650 | public static int compare(String date1, String date2,String format) {
651 | DateFormat df = DateFormatUtils.getFormat(format);
652 | try {
653 | Date dt1 = df.parse(date1);
654 | Date dt2 = df.parse(date2);
655 | if (dt1.getTime() > dt2.getTime()) {
656 | return 1;
657 | } else if (dt1.getTime() < dt2.getTime()) {
658 | return -1;
659 | } else {
660 | return 0;
661 | }
662 | } catch (Exception exception) {
663 | exception.printStackTrace();
664 | }
665 | return 0;
666 | }
667 |
668 | /**
669 | * 获取指定月份的第一天
670 | *
671 | * @author : chenssy
672 | * @date : 2016年5月31日 下午5:31:10
673 | *
674 | * @param date
675 | * @return
676 | */
677 | public static String getMonthFirstDate(String date){
678 | date = DateFormatUtils.formatDate(date);
679 | return DateFormatUtils.formatDate(date, "yyyy-MM") + "-01";
680 | }
681 |
682 | /**
683 | * 获取指定月份的最后一天
684 | *
685 | * @author : chenssy
686 | * @date : 2016年5月31日 下午5:32:09
687 | *
688 | * @param strdate
689 | * @return
690 | */
691 | public static String getMonthLastDate(String date) {
692 | Date strDate = DateUtils.string2Date(getMonthFirstDate(date));
693 | Calendar calendar = Calendar.getInstance();
694 | calendar.setTime(strDate);
695 | calendar.add(Calendar.MONTH, 1);
696 | calendar.add(Calendar.DAY_OF_YEAR, -1);
697 | return DateFormatUtils.formatDate(calendar.getTime());
698 | }
699 |
700 | /**
701 | * 获取所在星期的第一天
702 | *
703 | * @author : chenssy
704 | * @date : 2016年6月1日 下午12:38:53
705 | *
706 | * @param date
707 | * @return
708 | */
709 | @SuppressWarnings("static-access")
710 | public static Date getWeekFirstDate(Date date) {
711 | Calendar now = Calendar.getInstance();
712 | now.setTime(date);
713 | int today = now.get(Calendar.DAY_OF_WEEK);
714 | int first_day_of_week = now.get(Calendar.DATE) + 2 - today; // 星期一
715 | now.set(now.DATE, first_day_of_week);
716 | return now.getTime();
717 | }
718 |
719 | /**
720 | * 获取所在星期的最后一天
721 | *
722 | * @author : chenssy
723 | * @date : 2016年6月1日 下午12:40:31
724 | *
725 | * @param date
726 | * @return
727 | */
728 | @SuppressWarnings("static-access")
729 | public static Date geWeektLastDate(Date date) {
730 | Calendar now = Calendar.getInstance();
731 | now.setTime(date);
732 | int today = now.get(Calendar.DAY_OF_WEEK);
733 | int first_day_of_week = now.get(Calendar.DATE) + 2 - today; // 星期一
734 | int last_day_of_week = first_day_of_week + 6; // 星期日
735 | now.set(now.DATE, last_day_of_week);
736 | return now.getTime();
737 | }
738 | }
739 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/date/TimestampUtils.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.date;
2 |
3 | import java.sql.Timestamp;
4 | import java.text.SimpleDateFormat;
5 | import java.util.Date;
6 |
7 | /**
8 | * TimeStamp工具类，提供TimeStamp与String、Date的转换
9 | *
10 | * @author chenssy
11 | * @date 2016-09-24
12 | * @since 1.0.0
13 | */
14 | public class TimestampUtils {
15 |
16 | /**
17 | * String转换为TimeStamp
18 | * @param value
19 | * 待转换的String，格式必须为 yyyy-mm-dd hh:mm:ss[.f...] 这样的格式，中括号表示可选，否则报错
20 | * @return java.sql.Timestamp
21 | *
22 | * @author chenssy
23 | * @date 2016-09-24
24 | * @since v1.0.0
25 | */
26 | public static Timestamp string2Timestamp(String value){
27 | if(value == null && !"".equals(value.trim())){
28 | return null;
29 | }
30 | Timestamp ts = new Timestamp(System.currentTimeMillis());
31 | ts = Timestamp.valueOf(value);
32 | return ts;
33 | }
34 |
35 | /**
36 | * 将Timestamp 转换为String类型，format为null则使用默认格式 yyyy-MM-dd HH:mm:ss
37 | *
38 | * @param value
39 | * 待转换的Timestamp
40 | * @param format
41 | * String的格式
42 | * @return java.lang.String
43 | *
44 | * @author chenssy
45 | * @date 2016-09-24
46 | * @since v1.0.0
47 | */
48 | public static String timestamp2String(Timestamp value,String format){
49 | if(null == value){
50 | return "";
51 | }
52 | SimpleDateFormat sdf = DateFormatUtils.getFormat(format);
53 |
54 | return sdf.format(value);
55 | }
56 |
57 | /**
58 | * Date转换为Timestamp
59 | *
60 | * @param date
61 | * 待转换的Date
62 | * @return java.sql.Timestamp
63 | *
64 | * @author chenssy
65 | * @date 2016-09-24
66 | * @since v1.0.0
67 | */
68 | public static Timestamp date2Timestamp(Date date){
69 | if(date == null){
70 | return null;
71 | }
72 | return new Timestamp(date.getTime());
73 | }
74 |
75 | /**
76 | * Timestamp转换为Date
77 | *
78 | * @param time
79 | * 待转换的Timestamp
80 | * @return java.util.Date
81 | *
82 | * @author chenssy
83 | * @date 2016-09-24
84 | * @since v1.0.0
85 | */
86 | public static Date timestamp2Date(Timestamp time){
87 | return time == null ? null : time;
88 | }
89 | }
90 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/encrypt/AESUtils.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.encrypt;
2 |
3 | import java.security.SecureRandom;
4 |
5 | import javax.crypto.Cipher;
6 | import javax.crypto.KeyGenerator;
7 | import javax.crypto.spec.SecretKeySpec;
8 |
9 |
10 | /**
11 | * AES加解密
12 | *
13 | * @Author:chenssy
14 | * @date:2016年5月21日 上午9:01:41
15 | */
16 | class AESUtils {
17 | /** 默认秘钥 */
18 | protected static final String KEY = "NOPO3nzMD3dndwS0MccuMeXCHgVlGOoYyFwLdS24Im2e7YyhB0wrUsyYf0";
19 |
20 | /**
21 | * AES解密
22 | *
23 | * @author:chenssy
24 | * @date : 2016年5月21日 上午9:48:12
25 | *
26 | * @param encryptValue
27 | * 待解密内容
28 | * @param key
29 | * 秘钥
30 | * @return
31 | * @throws Exception
32 | */
33 | protected static String decrypt(String encryptValue, String key) throws Exception {
34 | return aesDecryptByBytes(base64Decode(encryptValue), key);
35 | }
36 |
37 | /**
38 | * AES加密
39 | *
40 | * @author:chenssy
41 | * @date : 2016年5月21日 上午9:48:42
42 | *
43 | * @param value
44 | * 待加密内容
45 | * @param key
46 | * 秘钥
47 | * @return
48 | * @throws Exception
49 | */
50 | protected static String encrypt(String value, String key) throws Exception {
51 | return base64Encode(aesEncryptToBytes(value, key));
52 | }
53 |
54 | private static String base64Encode(byte[] bytes){
55 | return Base64Utils.encrypt(bytes);
56 | }
57 |
58 | @SuppressWarnings("static-access")
59 | private static byte[] base64Decode(String base64Code) throws Exception{
60 | return base64Code == null ? null : new Base64Utils().decrypt(base64Code);
61 | }
62 |
63 | private static byte[] aesEncryptToBytes(String content, String encryptKey) throws Exception {
64 | KeyGenerator kgen = KeyGenerator.getInstance("AES");
65 | kgen.init(128, new SecureRandom(encryptKey.getBytes()));
66 |
67 | Cipher cipher = Cipher.getInstance("AES");
68 | cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));
69 |
70 | return cipher.doFinal(content.getBytes("utf-8"));
71 | }
72 |
73 | private static String aesDecryptByBytes(byte[] encryptBytes, String decryptKey) throws Exception {
74 | KeyGenerator kgen = KeyGenerator.getInstance("AES");
75 | kgen.init(128, new SecureRandom(decryptKey.getBytes()));
76 |
77 | Cipher cipher = Cipher.getInstance("AES");
78 | cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));
79 | byte[] decryptBytes = cipher.doFinal(encryptBytes);
80 |
81 | return new String(decryptBytes);
82 | }
83 |
84 | }
85 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/encrypt/Base64Utils.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.encrypt;
2 |
3 | import java.io.UnsupportedEncodingException;
4 |
5 | /**
6 | * BASE64加解密工具类
7 | *
8 | * @Author:chenssy
9 | * @date:2016年5月20日 下午5:05:30
10 | *
11 | */
12 | class Base64Utils {
13 |
14 | private static char[] base64EncodeChars = new char[] { 'A', 'B', 'C', 'D',
15 | 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q',
16 | 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
17 | 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',
18 | 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
19 | '4', '5', '6', '7', '8', '9', '+', '/' };
20 |
21 | private static byte[] base64DecodeChars = new byte[] { -1, -1, -1, -1, -1,
22 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
23 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
24 | -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59,
25 | 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
26 | 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1,
27 | -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
28 | 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1,
29 | -1, -1 };
30 |
31 | /**
32 | * BASE64加密
33 | *
34 | * @author : chenssy
35 | * @date : 2016年5月20日 下午5:10:18
36 | *
37 | * @param data
38 | * @return
39 | */
40 | protected static String encrypt(byte[] data) {
41 | StringBuffer sb = new StringBuffer();
42 | int len = data.length;
43 | int i = 0;
44 | int b1, b2, b3;
45 | while (i < len) {
46 | b1 = data[i++] & 0xff;
47 | if (i == len) {
48 | sb.append(base64EncodeChars[b1 >>> 2]);
49 | sb.append(base64EncodeChars[(b1 & 0x3) << 4]);
50 | sb.append("==");
51 | break;
52 | }
53 | b2 = data[i++] & 0xff;
54 | if (i == len) {
55 | sb.append(base64EncodeChars[b1 >>> 2]);
56 | sb.append(base64EncodeChars[((b1 & 0x03) << 4)
57 | | ((b2 & 0xf0) >>> 4)]);
58 | sb.append(base64EncodeChars[(b2 & 0x0f) << 2]);
59 | sb.append("=");
60 | break;
61 | }
62 | b3 = data[i++] & 0xff;
63 | sb.append(base64EncodeChars[b1 >>> 2]);
64 | sb.append(base64EncodeChars[((b1 & 0x03) << 4)
65 | | ((b2 & 0xf0) >>> 4)]);
66 | sb.append(base64EncodeChars[((b2 & 0x0f) << 2)
67 | | ((b3 & 0xc0) >>> 6)]);
68 | sb.append(base64EncodeChars[b3 & 0x3f]);
69 | }
70 | return sb.toString();
71 | }
72 |
73 | /**
74 | * Base64 解密
75 | *
76 | * @author : chenssy
77 | * @date : 2016年5月20日 下午5:11:51
78 | *
79 | * @param str
80 | * @return
81 | * @throws java.io.UnsupportedEncodingException
82 | */
83 | protected static byte[] decrypt(String str) throws Exception{
84 | StringBuffer sb = new StringBuffer();
85 | byte[] data = str.getBytes("US-ASCII");
86 | int len = data.length;
87 | int i = 0;
88 | int b1, b2, b3, b4;
89 | while (i < len) {
90 |
91 | do {
92 | b1 = base64DecodeChars[data[i++]];
93 | } while (i < len && b1 == -1);
94 | if (b1 == -1)
95 | break;
96 |
97 | do {
98 | b2 = base64DecodeChars[data[i++]];
99 | } while (i < len && b2 == -1);
100 | if (b2 == -1)
101 | break;
102 | sb.append((char) ((b1 << 2) | ((b2 & 0x30) >>> 4)));
103 |
104 | do {
105 | b3 = data[i++];
106 | if (b3 == 61)
107 | return sb.toString().getBytes("iso8859-1");
108 | b3 = base64DecodeChars[b3];
109 | } while (i < len && b3 == -1);
110 | if (b3 == -1)
111 | break;
112 | sb.append((char) (((b2 & 0x0f) << 4) | ((b3 & 0x3c) >>> 2)));
113 |
114 | do {
115 | b4 = data[i++];
116 | if (b4 == 61)
117 | return sb.toString().getBytes("iso8859-1");
118 | b4 = base64DecodeChars[b4];
119 | } while (i < len && b4 == -1);
120 | if (b4 == -1)
121 | break;
122 | sb.append((char) (((b3 & 0x03) << 6) | b4));
123 | }
124 | return sb.toString().getBytes("iso8859-1");
125 | }
126 | }
127 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/encrypt/DESUtils.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.encrypt;
2 |
3 | import java.security.SecureRandom;
4 |
5 | import javax.crypto.Cipher;
6 | import javax.crypto.SecretKey;
7 | import javax.crypto.SecretKeyFactory;
8 | import javax.crypto.spec.DESKeySpec;
9 |
10 | /**
11 | * DES加解密工具类
12 | *
13 | * @Author:chenssy
14 | * @date:2016年5月20日 下午5:19:00
15 | *
16 | */
17 | class DESUtils {
18 | /** 默认key */
19 | protected final static String KEY = "ScAKC0XhadTHT3Al0QIDAQAB";
20 |
21 | /**
22 | * DES加密
23 | *
24 | * @author : chenssy
25 | * @date : 2016年5月20日 下午5:51:37
26 | *
27 | * @param data
28 | * 待加密字符串
29 | * @param key
30 | * 校验位
31 | * @return
32 | */
33 | @SuppressWarnings("restriction")
34 | protected static String encrypt(String data,String key) {
35 | String encryptedData = null;
36 | try {
37 | // DES算法要求有一个可信任的随机数源
38 | SecureRandom sr = new SecureRandom();
39 | DESKeySpec deskey = new DESKeySpec(key.getBytes());
40 | // 创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象
41 | SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
42 | SecretKey secretKey = keyFactory.generateSecret(deskey);
43 | // 加密对象
44 | Cipher cipher = Cipher.getInstance("DES");
45 | cipher.init(Cipher.ENCRYPT_MODE, secretKey, sr);
46 | // 加密，并把字节数组编码成字符串
47 | encryptedData = new sun.misc.BASE64Encoder().encode(cipher.doFinal(data.getBytes()));
48 | } catch (Exception e) {
49 | throw new RuntimeException("加密错误，错误信息：", e);
50 | }
51 | return encryptedData;
52 | }
53 |
54 | /**
55 | * DES解密
56 | *
57 | * @author : chenssy
58 | * @date : 2016年5月20日 下午5:52:23
59 | *
60 | * @param cryptData
61 | * 待解密密文
62 | * @param key
63 | * 校验位
64 | * @return
65 | */
66 | @SuppressWarnings("restriction")
67 | protected static String decrypt(String cryptData,String key) {
68 | String decryptedData = null;
69 | try {
70 | // DES算法要求有一个可信任的随机数源
71 | SecureRandom sr = new SecureRandom();
72 | DESKeySpec deskey = new DESKeySpec(key.getBytes());
73 | // 创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象
74 | SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
75 | SecretKey secretKey = keyFactory.generateSecret(deskey);
76 | // 解密对象
77 | Cipher cipher = Cipher.getInstance("DES");
78 | cipher.init(Cipher.DECRYPT_MODE, secretKey, sr);
79 | // 把字符串解码为字节数组，并解密
80 | decryptedData = new String(cipher.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(cryptData)));
81 | } catch (Exception e) {
82 | throw new RuntimeException("解密错误，错误信息：", e);
83 | }
84 | return decryptedData;
85 | }
86 |
87 | }
88 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/encrypt/EncryptAndDecryptUtils.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.encrypt;
2 |
3 |
4 | /**
5 | * 加解密工具类
6 | * 工具类包括：MD5加密、SHA加密、Base64加解密、DES加解密、AES加解密
7 | *
8 | * @Author:chenssy
9 | * @date:2016年5月20日 下午4:44:51
10 | *
11 | */
12 | public class EncryptAndDecryptUtils {
13 |
14 | /**
15 | * MD5 加密
16 | *
17 | * @author : chenssy
18 | * @date : 2016年5月20日 下午4:54:23
19 | *
20 | * @param value
21 | * 待加密字符
22 | * @return
23 | */
24 | public static String md5Encrypt(String value){
25 | String result = null;
26 | if(value != null && !"".equals(value.trim())){
27 | result = MD5Utils.encrypt(value,MD5Utils.MD5_KEY);
28 | }
29 | return result;
30 | }
31 |
32 | /**
33 | * SHA加密
34 | *
35 | * @author : chenssy
36 | * @date : 2016年5月20日 下午4:59:42
37 | *
38 | * @param value
39 | * 待加密字符
40 | * @return 密文
41 | */
42 | public static String shaEncrypt(String value){
43 | String result = null;
44 | if(value != null && !"".equals(value.trim())){
45 | result = MD5Utils.encrypt(value,MD5Utils.SHA_KEY);
46 | }
47 | return result;
48 | }
49 |
50 | /**
51 | * BASE64 加密
52 | *
53 | * @author : chenssy
54 | * @date : 2016年5月20日 下午5:16:12
55 | *
56 | * @param value
57 | * 待加密字符串
58 | * @return
59 | */
60 | public static String base64Encrypt(String value){
61 | String result = null;
62 | if(value != null && !"".equals(value.trim())){
63 | result = Base64Utils.encrypt(value.getBytes());
64 | }
65 | return result;
66 |
67 | }
68 |
69 | /**
70 | * BASE64 解密
71 | *
72 | * @author : chenssy
73 | * @date : 2016年5月20日 下午5:16:34
74 | *
75 | * @param value
76 | * 待解密字符串
77 | * @return
78 | */
79 | public static String base64Decrypt(String value){
80 | String result = null;
81 | try {
82 | if(value != null && !"".equals(value.trim())){
83 | byte[] bytes = Base64Utils.decrypt(value);
84 | result = new String(bytes);
85 | }
86 | } catch (Exception e) {
87 | e.printStackTrace();
88 | }
89 | return result;
90 | }
91 |
92 | /**
93 | * DES加密
94 | *
95 | * @author : chenssy
96 | * @date : 2016年5月20日 下午5:39:46
97 | *
98 | * @param value
99 | * 待加密字符
100 | * @param key
101 | * 若key为空，则使用默认key
102 | * @return
103 | * 加密成功返回密文，否则返回null
104 | */
105 | public static String desEncrypt(String value,String key){
106 | key = key == null ? DESUtils.KEY : key;
107 | String result = null;
108 |
109 | try {
110 | if(value != null && !"".equals(value.trim())){
111 | result = DESUtils.encrypt(value, key);
112 | }
113 | } catch (Exception e) {
114 | e.printStackTrace();
115 | }
116 | return result;
117 | }
118 |
119 | /**
120 | * DES解密
121 | *
122 | * @author : chenssy
123 | * @date : 2016年5月20日 下午5:55:56
124 | *
125 | * @param value
126 | * 待解密字符
127 | * @param key
128 | * 若key为空，则使用默认key
129 | * @return
130 | * @return
131 | */
132 | public static String desDecrypt(String value,String key){
133 | key = key == null ? DESUtils.KEY : key;
134 | String result = null;
135 |
136 | try {
137 | if(value != null && !"".equals(value.trim())){
138 | result = DESUtils.decrypt(value, key);
139 | }
140 | } catch (Exception e) {
141 | e.printStackTrace();
142 | }
143 | return result;
144 | }
145 |
146 | /**
147 | * AES加密
148 | *
149 | * @author:chenssy
150 | * @date : 2016年5月21日 上午9:58:58
151 | *
152 | * @param value
153 | * 待加密内容
154 | * @param key
155 | * 秘钥
156 | * @return
157 | */
158 | public static String aesEncrypt(String value,String key ){
159 | key = key == null ? AESUtils.KEY : key;
160 | String result = null;
161 | try {
162 | if(value != null && !"".equals(value.trim())){ //value is not null
163 | result = AESUtils.encrypt(value,key);
164 | }
165 | } catch (Exception e) {
166 | e.printStackTrace();
167 | }
168 |
169 | return result;
170 | }
171 |
172 | /**
173 | * AES解密
174 | *
175 | * @author:chenssy
176 | * @date : 2016年5月21日 上午10:02:07
177 | *
178 | * @param value
179 | * 待解密内容
180 | * @param key
181 | * 秘钥
182 | * @return
183 | */
184 | public static String aesDecrypt(String value , String key){
185 | key = key == null ? AESUtils.KEY : key;
186 | String result = null;
187 | try {
188 | if(value != null && !"".equals(value.trim())){ //value is not null
189 | result = AESUtils.decrypt(value,key);
190 | }
191 | } catch (Exception e) {
192 | e.printStackTrace();
193 | }
194 |
195 | return result;
196 | }
197 | }
198 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/encrypt/MD5Utils.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.encrypt;
2 |
3 | import java.security.MessageDigest;
4 | import java.security.NoSuchAlgorithmException;
5 |
6 | /**
7 | * MD5加密
8 | *
9 | * @Author:chenssy
10 | * @date:2016年4月9日
11 | */
12 | class MD5Utils {
13 | protected final static String MD5_KEY = "MD5";
14 |
15 | protected final static String SHA_KEY = "SHA1";
16 |
17 | protected static String encrypt(String value,String key) {
18 | try {
19 | // 拿到一个MD5转换器（如果想要SHA1参数换成”SHA1”）
20 | MessageDigest messageDigest = MessageDigest.getInstance(key);
21 | // 输入的字符串转换成字节数组
22 | byte[] inputByteArray = value.getBytes();
23 | // inputByteArray是输入字符串转换得到的字节数组
24 | messageDigest.update(inputByteArray);
25 | // 转换并返回结果，也是字节数组，包含16个元素
26 | byte[] resultByteArray = messageDigest.digest();
27 | // 字符数组转换成字符串返回
28 | return byteArrayToHex(resultByteArray);
29 | } catch (NoSuchAlgorithmException e) {
30 | return null;
31 | }
32 | }
33 |
34 | private static String byteArrayToHex(byte[] byteArray) {
35 |
36 | // 首先初始化一个字符数组，用来存放每个16进制字符
37 | char[] hexDigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
38 | 'A', 'B', 'C', 'D', 'E', 'F' };
39 | // new一个字符数组，这个就是用来组成结果字符串的（解释一下：一个byte是八位二进制，也就是2位十六进制字符（2的8次方等于16的2次方））
40 | char[] resultCharArray = new char[byteArray.length * 2];
41 | // 遍历字节数组，通过位运算（位运算效率高），转换成字符放到字符数组中去
42 | int index = 0;
43 | for (byte b : byteArray) {
44 | resultCharArray[index++] = hexDigits[b >>> 4 & 0xf];
45 | resultCharArray[index++] = hexDigits[b & 0xf];
46 | }
47 | // 字符数组组合成字符串返回
48 | return new String(resultCharArray);
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/src/main/java/com/JUtils/excel/ExcelExportHelper.java:
--------------------------------------------------------------------------------
1 | package com.JUtils.excel;
2 |
3 | import java.beans.IntrospectionException;
4 | import java.beans.PropertyDescriptor;
5 | import java.io.File;
6 | import java.io.FileNotFoundException;
7 | import java.io.FileOutputStream;
8 | import java.io.IOException;
9 | import java.lang.reflect.Field;
10 | import java.lang.reflect.InvocationTargetException;
11 | import java.lang.reflect.Method;
12 | import java.text.SimpleDateFormat;
13 | import java.util.ArrayList;
14 | import java.util.Date;
15 | import java.util.Iterator;
16 | import java.util.List;
17 | import java.util.Random;
18 | import java.util.regex.Matcher;
19 | import java.util.regex.Pattern;
20 | import java.util.zip.ZipEntry;
21 | import java.util.zip.ZipOutputStream;
22 |
23 | import org.apache.poi.hssf.usermodel.HSSFCell;
24 | import org.apache.poi.hssf.usermodel.HSSFCellStyle;
25 | import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
26 | import org.apache.poi.hssf.usermodel.HSSFFont;
27 | import org.apache.poi.hssf.usermodel.HSSFPatriarch;
28 | import org.apache.poi.hssf.usermodel.HSSFRichTextString;
29 | import org.apache.poi.hssf.usermodel.HSSFRow;
30 | import org.apache.poi.hssf.usermodel.HSSFSheet;
31 | import org.apache.poi.hssf.usermodel.HSSFWorkbook;
32 | import org.apache.poi.hssf.util.HSSFColor;
33 |
34 | /**
35 | * Excel 生成通用类，为了兼容，所有 Excel 统一生成 Excel2003 即：xx.xls
36 | * @Author : chenssy
37 | * @Date ： 2014年6月15日 下午9:09:38
38 | */
39 | public class ExcelExportHelper {
40 |
41 | /** 时间格式：默认为yyyy-MM-dd */
42 | private String DATE_PATTERN = "yyyy-MM-dd";
43 |
44 | /** 图片宽度，默认为：100 */
45 | private int IMAGE_WIDTH = 30;
46 |
47 | /** 图片高度，默认为：50 */
48 | private int IMAGE_HEIGHT = 5;
49 |
50 | /** 单元格的最大宽度 */
51 | private int[] maxWidth;
52 |
53 | /**
54 | * 单页支持最多数据列：超过65534会出错
55 | * 若数据列多余65534则需要通过MORE_EXCEL_FLAG、MORE_SHEET_FLAG来区别生成多个Excel、还是sheet
56 | */
57 | private int maxRowCount = 2500;
58 |
59 | /** 大量数据，多个Excel标识---0001 */
60 | private String MORE_EXCEL_FLAG = "0001";
61 |
62 | /** 大量数据，多个sheet标识---0001 */
63 | private String MORE_SHEET_FLAG = "0002";
64 |
65 | /**
66 | * 默认构造函数
67 | */
68 | public ExcelExportHelper(){
69 | }
70 |
71 | /**
72 | * @param datePattern 指定的时间格式
73 | */
74 | public ExcelExportHelper(String datePattern){
75 | this.DATE_PATTERN = datePattern;
76 | }
77 |
78 | /**
79 | * @param imageWidth
80 | * 指定图片的宽度
81 | * @param imageHeight
82 | * 指定图片的高度
83 | */
84 | public ExcelExportHelper(int imageWidth,int imageHeight){
85 | this.IMAGE_HEIGHT = imageHeight;
86 | this.IMAGE_WIDTH = imageWidth;
87 | }
88 |
89 | /**
90 | * @param datePatter
91 | * 指定时间格式
92 | * @param imageWidth
93 | * 指定图片的宽度
94 | * @param imageHeight
95 | * 指定图片的高度
96 | */
97 | public ExcelExportHelper(String datePatter,int imageWidht,int imageHeight){
98 | this.DATE_PATTERN = datePatter;
99 | this.IMAGE_HEIGHT = imageHeight;
100 | this.IMAGE_WIDTH = imageWidht;
101 | }
102 |
103 | /**
104 | * 通用方法，使用 java 反射机制，根据提供表头 header ，数据列 excelList 生成 Excel,如有图片请转换为byte[]
105 | * header、excelList规则如下：
106 | * header、excelList中的Bean必须对应（javaBean的属性顺序）：如下
107 | * header：姓名、年龄、性别、班级
108 | * Bean：name、age、sex、class
109 | *
110 | * @author chenssy
111 | * @date 2014年6月15日 下午9:18:37
112 | *
113 | * @param header
114 | * 表格属性列名数组
115 | * @param excelList
116 | * 需要显示的数据集合,集合中一定要放置符合javabean风格的类的对象。此方法支持的 javabean
117 | * 属性的数据类型有基本数据类型及String,Date,byte[](图片数据)
118 | * @param sheetTitle
119 | * 表格标题名
120 | * @return 生成的HSSFWorkBook
121 | * @version 1.0
122 | */
123 | public HSSFWorkbook exportExcel(String[] header,List