java验证字符串，集合，数组或数值是否为空

1. package com.camel.jelly.helper;    
2.    
3. import java.text.ParseException;    
4. import java.util.Collection;    
5. import java.util.Map;    
6.    
7. /**  
8.  * 常用的验证方法帮助类,提供对字符串，集合，数组，数值的验证  
9.  *   
10.  * @au 
11. package com.camel.jelly.helper;   
12.   
13. import java.text.ParseException;   
14. import java.util.Collection;   
15. import java.util.Map;   
16.   
17. /**  
18.  * 常用的验证方法帮助类,提供对字符串，集合，数组，数值的验证  
19.  */   
20. public class ValidateHelper {    
21.     /**  
22.      * 判断一个字符串是否不是一个空字符串  
23.      *   
24.      * @param s 要判断的字符串  
25.      * @return 如果不为空返回true，否则返回false  
26.      */   
27.     public static boolean isNotEmpty(String s) {    
28.         return ((s != null) && s.length() > 0);    
29.     }    
30.    
31.     /**  
32.      * 判断一个字符串是否是一个空字符串  
33.      *   
34.      * @param s 要判断的字符串  
35.      * @return 如果为空返回true，否则返回false  
36.      */   
37.     public static boolean isEmpty(String s) {    
38.         return ((s == null) || (s.length() == 0));    
39.     }    
40.    
41.     /**  
42.      * 判断一个Collection类型的集合是否不是一个空集合  
43.      *   
44.      * @param c 要判断集合  
45.      * @return 如果不为空返回true，否则返回false  
46.      */   
47.     public static boolean isNotEmpty(Collection c) {    
48.         return ((c != null) && (c.size() > 0));    
49.     }    
50.    
51.     /**  
52.      * 判断一个Collection类型的集合是否是一个空集合  
53.      *   
54.      * @param c 要判断集合  
55.      * @return 如果为空返回true，否则返回false  
56.      */   
57.     public static boolean isEmpty(Collection c) {    
58.         return ((c == null) || (c.size() == 0));    
59.     }    
60.    
61.     /**  
62.      * 判断一个Map类型的集合是否不是一个空集合  
63.      *   
64.      * @param c 要判断的集合  
65.      * @return 如果不为空返回true，否则返回false  
66.      */   
67.     public static boolean isNotEmpty(Map m) {    
68.         return ((m != null) && (m.size() > 0));    
69.     }    
70.    
71.     /**  
72.      * 判断一个Map类型的集合是否是一个空集合  
73.      *   
74.      * @param c 要判断的集合  
75.      * @return 如果为空返回true，否则返回false  
76.      */   
77.     public static boolean isEmpty(Map m) {    
78.         return ((m == null) || (m.size() == 0));    
79.     }    
80.    
81.     /**  
82.      * 判断一个int类型的数组是否不是一个空数组  
83.      *   
84.      * @param c 要判断的数组  
85.      * @return 如果不为空返回true，否则返回false  
86.      */   
87.     public static boolean isNotEmpty(int[] i) {    
88.         return ((i != null) && (i.length > 0));    
89.     }    
90.    
91.     /**  
92.      * 判断一个int类型的数组是否是一个空数组  
93.      *   
94.      * @param c 要判断的数组  
95.      * @return 如果为空返回true，否则返回false  
96.      */   
97.     public static boolean isEmpty(int[] i) {    
98.         return ((i == null) || (i.length == 0));    
99.     }    
100.    
101.     /**  
102.      * 判断一个String类型的数组是否不是一个空数组  
103.      *   
104.      * @param c 要判断的数组  
105.      * @return 如果不为空返回true，否则返回false  
106.      */   
107.     public static boolean isNotEmpty(String[] s) {    
108.         return ((s != null) && (s.length > 0));    
109.     }    
110.    
111.     /**  
112.      * 判断一个String类型的数组是否是一个空数组  
113.      *   
114.      * @param c 要判断的数组  
115.      * @return 如果为空返回true，否则返回false  
116.      */   
117.     public static boolean isEmpty(String[] s) {    
118.         return ((s == null) || (s.length == 0));    
119.     }    
120.    
121.     /**  
122.      * 验证一个字符串是否是Double类型  
123.      *   
124.      * @param s 要验证的字符串  
125.      * @return 如果是Double类型则返回true,否则返回false  
126.      */   
127.     public static boolean isDouble(String s) {    
128.         if (s == null || s.equals(""))    
129.             return false;    
130.         String num = "0123456789.";    
131.         if (s.indexOf('.') >= 0)    
132.             if (s.indexOf('.', s.indexOf('.') + 1) > 0)    
133.                 return false;    
134.         for (int i = 0; i < s.length(); i++) {    
135.             if (num.indexOf(s.charAt(i)) < 0) {    
136.                 return false;    
137.             } else {    
138.                 try {    
139.                     Double.parseDouble(s);    
140.                 } catch (NumberFormatException e) {    
141.                     return false;    
142.                 }    
143.             }    
144.         }    
145.         return true;    
146.     }    
147.    
148.     /**  
149.      * 验证一个字符串是否是Float类型  
150.      *   
151.      * @param s 要验证的字符串  
152.      * @return 如果是Float类型则返回true,否则返回false  
153.      */   
154.     public static boolean isFloat(String s) {    
155.         if (s == null || s.equals(""))    
156.             return false;    
157.         String num = "0123456789.";    
158.         if (s.indexOf('.') >= 0)    
159.             if (s.indexOf('.', s.indexOf('.') + 1) > 0)    
160.                 return false;    
161.         for (int i = 0; i < s.length(); i++) {    
162.             if (num.indexOf(s.charAt(i)) < 0) {    
163.                 return false;    
164.             } else {    
165.                 try {    
166.                     Float.parseFloat(s);    
167.                 } catch (NumberFormatException e) {    
168.                     return false;    
169.                 }    
170.             }    
171.         }    
172.         return true;    
173.     }    
174.    
175.     /**  
176.      * 验证一个字符串是否是整形  
177.      *   
178.      * @param s 要验证的字符串  
179.      * @return 如果是整形则返回true,否则返回false  
180.      */   
181.     public static boolean isInteger(String s) {    
182.         if (s == null || s.length() == 0) {    
183.             return false;    
184.         } else {    
185.             String str = "0123456789";    
186.             String num = "-0123456789";    
187.             if (num.indexOf(s.charAt(0)) < 0)    
188.                 return false;    
189.             for (int i = 1; i < s.length(); i++) {    
190.                 if (str.indexOf(s.charAt(i)) < 0) {    
191.                     return false;    
192.                 } else {    
193.                     try {    
194.                         Integer.parseInt(s);    
195.                     } catch (NumberFormatException e) {    
196.                         return false;    
197.                     }    
198.                 }    
199.             }    
200.         }    
201.         return true;    
202.     }    
203.    
204.     /**  
205.      * 验证一个字符串是否是一个.和一组数字组成  
206.      *   
207.      * @param s 要传入的数字字符串  
208.      * @return 如果是一个长类型数字返回true,否则返回false  
209.      */   
210.     public static boolean isLongNumber(String s) {    
211.         if (s == null || s.equals(""))    
212.             return false;    
213.         String num = "0123456789.";    
214.         if (s.indexOf('.') >= 0)    
215.             if (s.indexOf('.', s.indexOf('.') + 1) > 0)    
216.                 return false;    
217.         for (int i = 0; i < s.length(); i++) {    
218.             if (num.indexOf(s.charAt(i)) < 0)    
219.                 return false;    
220.         }    
221.         return true;    
222.     }    
223.    
224.     /**  
225.      * 验证一个字符串是否是数字组成  
226.      *   
227.      * @param s 要验证的字符串  
228.      * @return 如果字符串是数字组成的则返回true,否则返回false  
229.      */   
230.     public static boolean isNumber(String s) {    
231.         if (s == null || s.equals(""))    
232.             return false;    
233.         String num = "0123456789";    
234.         for (int i = 0; i < s.length(); i++) {    
235.             if (num.indexOf(s.charAt(i)) < 0)    
236.                 return false;    
237.         }    
238.         return true;    
239.     }    
240.    
241.     /**  
242.      * 验证一个字符串是否一个合法日期,日期格式：yyyy-MM-dd  
243.      *   
244.      * @param date 要验证的字符串日期  
245.      * @return 如果字符串是一个合法的日期返回true,否则返回false  
246.      */   
247.     public static boolean isDate(String date) {    
248.         java.text.SimpleDateFormat df = new java.text.SimpleDateFormat("yyyy-MM-dd");    
249.         try {    
250.             df.setLenient(false);    
251.             df.parse(date);    
252.             return true;    
253.         } catch (ParseException e) {    
254.             return false;    
255.         }    
256.     }    
257.    
258.     /**  
259.      * 验证一个字符串是否一个合法日期时间,日期时间格式：yyyy-MM-dd HH:mm:ss  
260.      *   
261.      * @param date 要验证的字符串日期时间  
262.      * @return 如果字符串是一个合法的日期时间返回true,否则返回false  
263.      */   
264.     public static boolean isTimestamp(String time) {    
265.         java.text.SimpleDateFormat df = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");    
266.         try {    
267.             df.setLenient(false);    
268.             df.parse(time);    
269.             return true;    
270.         } catch (ParseException e) {    
271.             return false;    
272.         }    
273.     }    
274.    
275.     /**  
276.      * 根据字节数组指定的开始和结尾长度来计算字符串值  
277.      *   
278.      * @param bytes 字节数组  
279.      * @param begin 开始索引  
280.      * @param end 结束索引  
281.      * @return 转换后的字符串结果  
282.      */   
283.     public static String getString(byte[] bytes, int begin, int end) throws RuntimeException {    
284.         byte[] newBytes = new byte[end - begin];    
285.         for (int i = begin, j = 0; i < end; i++, j++) {    
286.             byte c = bytes[i];    
287.             newBytes[j] = c;    
288.         }    
289.         return (new String(newBytes));    
290.     }    
291.    
292.     /**  
293.      * 根据字节数组指定的开始和结尾长度来计算字符串的字节长度  
294.      *   
295.      * @param bytes 字节数组  
296.      * @param begin 开始索引  
297.      * @param end 结束索引  
298.      * @return 转换后的字符串长度  
299.      */   
300.     public static int getLength(byte[] bytes, int begin, int end) {    
301.         byte[] newBytes = new byte[end - begin];    
302.         try {    
303.             for (int i = begin, j = 0; i < end; i++, j++) {    
304.                 byte b = bytes[i];    
305.                 newBytes[j] = b;    
306.             }    
307.         } catch (RuntimeException ex) {    
308.             ex.printStackTrace();    
309.         }    
310.         return (newBytes.length);    
311.     }    
312.    
313. }