StringHelper--封轉自己的字符串工具類


我們每次開發項目,都會有很多的關於字符串的處理,字符串的處理太常見了,無法避免,那么這時如果可以把常用的字符串處理封裝成類,在以后的開發中應該會減少一些工作量,下面代碼對一些常用的字符串處理進行了封裝,如果遇上了其他的關於字符串處理可以不斷加入進來。

現在已經實現的功能有:

1,判斷一個字符串是否為 null 或 空串 或 空白,

2,判斷一個字符串是否不是null且不是空串、不是空白,

3,判斷一個字符串變量是否為 null,

4,判斷一個字符串是否為 空串,

5,比較兩個非空(不是null,不是空串、不是空白)字符串是否"相等",

6,比較兩個字符串是否 "相等",

7,隨機生成一個 32 位長度的 字符串( UUID ),

8,通過 SHA1 對字符串進行加密,

9,對 給定字符串 進行 md5 加密,(對密碼進行加密使用)

10,檢測郵箱合法性,

11,Double進行四舍五入,得到指定位數的小數,

12,根據Unicode編碼完美的判斷中文漢字和符號,

13,判斷是否包含中文漢字,

14判斷是否只有中文漢字,

15判斷郵政編碼.

代碼有詳細備注,不做說明。如下:

  1 public final class StringHelper {  
  2       
  3     /** 
  4      * 判斷一個字符串是否為 null 或 空串 或 空白 
  5      * @param source 需要判斷的字符串 
  6      * @return 當字符串為 null 或 為 空白、空串 時返回 true 
  7      */  
  8     public static boolean empty( String source ) {  
  9         return source == null || source.trim().isEmpty()  ;  
 10     }  
 11       
 12     /** 
 13      * 判斷一個字符串是否不是null且不是空串、不是空白 
 14      * @param source 需要判斷的字符串 
 15      * @return 當 字符串是不是null且不是空串也不是空白時返回 true 
 16      */  
 17     public static boolean notEmpty( String source ) {  
 18         return source != null && source.trim().length() > 0 ;  
 19     }  
 20       
 21     /** 
 22      * 判斷一個字符串變量是否為 null 
 23      * @param source 需要判斷的字符串 
 24      * @return 當 字符串變量 為 null 時返回 true 
 25      */  
 26     public static boolean isNull( String source ) {  
 27         return source == null ;  
 28     }  
 29       
 30     /** 
 31      * 判斷一個字符串是否為 空串 
 32      * @param source 需要判斷的字符串 
 33      * @return 當字符串中的值是 空串 或 空白 串時返回 true 
 34      */  
 35     public static boolean emptyString( String source ) {  
 36         return ( source != null ) && source.length() == source.trim().length() ;  
 37     }  
 38       
 39     /** 
 40      * 判斷一個字符串是否為 空白 串 
 41      * @param source 需要判斷的字符串 
 42      * @return 當字符串中的值是 空白 串時返回 true 
 43      */  
 44     public static boolean blank( String source ){  
 45         return ( source != null ) && source.length() > source.trim().length()  ;  
 46     }  
 47       
 48     /** 
 49      * 比較兩個非空(不是null,不是空串、不是空白)字符串是否"相等" 
 50      * @param one 第一個需要比較的字符串 
 51      * @param theOther 另一個參與比較的字符串 
 52      * @return 當 兩個字符串 都不為空串 且 內容完全一致 (剔除首尾空白后、大小寫也一致)時返回 true 
 53      */  
 54     public static boolean equals( String one , String theOther) {  
 55         return equals(one, theOther,true,false);  
 56     }  
 57       
 58     /** 
 59      * 比較兩個字符串是否 "相等" 
 60      * @param one 參與比較的第一個字符串 
 61      * @param theOther 參與比較的另一個字符串 
 62      * @param escapeSpace 是否需要剔除首尾空白 ( true 表示需要剔除首尾空白,false 表示不剔除 ) 
 63      * @param ignoreCase 是否忽略大小寫 ( true 表示忽略大小寫 ,false 表示不忽略大小寫 ) 
 64      * @return 
 65      */  
 66     public static boolean equals( String one , String theOther , boolean escapeSpace , boolean ignoreCase) {  
 67           
 68         if( one == null || theOther == null ){  
 69             return false ;  
 70         }  
 71           
 72         if( escapeSpace ){  
 73             one = one.trim();  
 74             theOther = theOther.trim();  
 75         }  
 76           
 77         return ignoreCase ? one.equalsIgnoreCase( theOther ) : one.equals( theOther ) ;  
 78     }  
 79       
 80     /** 
 81      * 隨機生成一個 32 位長度的 字符串( UUID ) 
 82      * @return 
 83      */  
 84     public static String random(){  
 85         UUID uuid = UUID.randomUUID();//36位長度(包含了 四個 - )  
 86         String uuidString = uuid.toString();  
 87         uuidString = uuidString.replace("-", "");  
 88         uuidString = uuidString.toUpperCase();  
 89         return uuidString;  
 90     }  
 91       
 92     /** 
 93      * 通過 SHA1 對字符串進行加密 
 94      * @param source 
 95      * @return 
 96      */  
 97     public static String sha1(String source ){  
 98         try{  
 99             MessageDigest md = MessageDigest.getInstance("SHA1");  
100             BASE64Encoder encoder = new BASE64Encoder();  
101             return encoder.encode( md.digest( source.getBytes() ) );  
102         }catch(NoSuchAlgorithmException e){  
103             e.printStackTrace();  
104             return null;  
105         }  
106     }  
107       
108     /** 
109      * 對 給定字符串 進行 md5 加密 
110      * @param source 待加密的字符串 
111      * @return 
112      */  
113     protected static String md524(String source ){  
114         try{  
115             MessageDigest md = MessageDigest.getInstance("MD5");  
116             BASE64Encoder encoder = new BASE64Encoder();  
117             return encoder.encode( md.digest(source.getBytes()) );  
118         }catch(NoSuchAlgorithmException e){  
119             e.printStackTrace();  
120             return null;  
121         }  
122     }  
123       
124     /** 
125      * 對字符串進行MD5加密 
126      * @param source 需要加密的字符串 
127      * @return 返回加密后的字符串 
128      */  
129     public static final String MD5(String source){  
130         if(source != null){  
131             StringBuffer md5 = new StringBuffer();  
132             MessageDigest md = null;  
133             try{  
134                 md = MessageDigest.getInstance("MD5");  
135                 md.update(source.getBytes());  
136                 byte[] mdBytes = md.digest();  
137                   
138                 for(int i = 0;i < mdBytes.length;i++){  
139                     int temp;  
140                     if(mdBytes[i] < 0){  
141                         temp = 256+mdBytes[i];  
142                     }else{  
143                         temp = mdBytes[i];  
144                     }  
145                     if(temp < 16){  
146                         md5.append("0");  
147                     }  
148                     md5.append(Integer.toString(temp,16 ));  
149                 }  
150             }catch(NoSuchAlgorithmException e){  
151                 e.printStackTrace();  
152             }  
153             return md5.toString().toUpperCase();  
154         }  
155         return null;  
156     }  
157     /** 
158      * 檢測郵箱合法性 
159      *  
160      * @param email 
161      * @return 
162      */  
163     public static boolean isEmail(String email) {  
164         if ((email == null) || (email.trim().length() == 0)) {  
165             return false;  
166         }  
167         String regEx = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,4}$";  
168         Pattern p = Pattern.compile(regEx);  
169         Matcher m = p.matcher(email.trim().toLowerCase());  
170    
171         return m.find();  
172     }  
173   
174    
175     /** 
176      * Double進行四舍五入 
177      *  
178      * @param v 
179      * @param scale 
180      * @return 
181      */  
182     public static double getDouble(Double v, int scale) {  
183    
184         if (scale < 0) {  
185             scale = 0;  
186         }  
187         BigDecimal b = new BigDecimal(v);  
188         BigDecimal one = new BigDecimal("1");  
189         return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();  
190     }  
191    
192     /** 
193      * 得到指定位數的小數 
194      * @param v 
195      * @param scale 
196      * @return 
197      */  
198     public static String getDecimals(Double v, int scale) {  
199    
200         return String.format("%." + String.valueOf(scale) + "f", v);  
201    
202     }  
203     /** 
204      * 根據Unicode編碼完美的判斷中文漢字和符號 
205      *  
206      * @param c 
207      * @return 
208      */  
209     private static boolean isChinese(char c) {  
210         Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);  
211         if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS  
212                 || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS  
213                 || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A  
214                 || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B  
215                 || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION  
216                 || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS  
217                 || ub == Character.UnicodeBlock.GENERAL_PUNCTUATION) {  
218             return true;  
219         }  
220         return false;  
221     }  
222    
223     /** 
224      * 判斷是否包含中文漢字 
225      *  
226      * @param strName 
227      * @return 
228      */  
229     public static boolean isChineseHave(String strName) {  
230         char[] ch = strName.toCharArray();  
231         for (int i = 0; i < ch.length; i++) {  
232             char c = ch[i];  
233             if (isChinese(c)) {  
234                 return true;  
235             }  
236         }  
237         return false;  
238     }  
239    
240     /** 
241      * 判斷是否只有中文漢字 
242      *  
243      * @param strName 
244      * @return 
245      */  
246     public static boolean isChineseAll(String strName) {  
247         char[] ch = strName.toCharArray();  
248         for (int i = 0; i < ch.length; i++) {  
249             char c = ch[i];  
250             if (!isChinese(c)) {  
251                 return false;  
252             }  
253         }  
254         return true;  
255     }  
256    
257     /** 
258      * 判斷郵政編碼 
259      *  
260      * @param str 
261      * @return 
262      */  
263     public static boolean isCard(String str) {  
264         Pattern p = Pattern.compile("[1-9]\\d{5}(?!\\d)");  
265         Matcher m = p.matcher(str);  
266         return m.matches();  
267     }  
268    
269 }  


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM