JAVA常用方法

1 /**
   2  * 将某个日期以固定格式转化成字符串
   3  *
   4  * @param date
   5  * @return String
   6  */
   7 public static String dateToStr(java.util.Date date)
   8 {
   9     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  10     String str = sdf.format(date);
  11     return str;
  12 }
  13 
  14 
  15 
  16 /**
  17  * 判断任意一个整数是否素数
  18  *
  19  * @param n
  20  * @return boolean
  21  */
  22 public static boolean isPrimes(int n)
  23 {
  24     for (int i = 2; i <= Math.sqrt(n); i++)
  25     {
  26         if (n % i == 0)
  27         {
  28             return false;
  29         }
  30     }
  31     return true;
  32 }
  33 
  34 
  35 /**
  36  * 获得任意一个整数的阶乘，递归
  37  *
  38  * @param n
  39  * @return n!
  40  */
  41 public static int factorial(int n)
  42 {
  43     if (n == 1)
  44     {
  45         return 1;
  46     }
  47     return n * factorial(n - 1);
  48 }
  49 
  50 /**
  51  * 将指定byte数组以16进制的形式打印到控制台
  52  *
  53  * @param hint
  54  *            String
  55  * @param b
  56  *            byte[]
  57  * @return void
  58  */
  59 public static void printHexString(String hint, byte[] b)
  60 {
  61     System.out.print(hint);
  62     for (int i = 0; i < b.length; i++)
  63     {
  64         String hex = Integer.toHexString(b & 0xFF);
  65         if (hex.length() == 1)
  66         {
  67             hex = '0' + hex;
  68         }
  69         System.out.print(hex.toUpperCase() + " ");
  70     }
  71     System.out.println("");
  72 }
  73 
  74 
  75 package net.java2000.tools;
  76 
  77 /**
  78  * Title:        Java Bean 工具
  79  * @version 1.0
  80  */
  81 import java.util.*;
  82 import java.util.regex.Pattern;
  83 
  84 public class StrTools {
  85     /**
  86      * 分割字符串
  87      *
  88      * @param str String 原始字符串
  89      * @param splitsign String 分隔符
  90      * @return String[] 分割后的字符串数组
  91      */
  92     @SuppressWarnings("unchecked")
  93     public static String[] split(String str, String splitsign) {
  94         int index;
  95         if (str == null || splitsign == null)
  96             return null;
  97         ArrayList al = new ArrayList();
  98         while ((index = str.indexOf(splitsign)) != -1) {
  99             al.add(str.substring(0, index));
 100             str = str.substring(index + splitsign.length());
 101         }
 102         al.add(str);
 103         return (String[]) al.toArray(new String[0]);
 104     }
 105 
 106     /**
 107      * 替换字符串
 108      *
 109      * @param from String 原始字符串
 110      * @param to String 目标字符串
 111      * @param source String 母字符串
 112      * @return String 替换后的字符串
 113      */
 114     public static String replace(String from, String to, String source) {
 115         if (source == null || from == null || to == null)
 116             return null;
 117         StringBuffer bf = new StringBuffer("");
 118         int index = -1;
 119         while ((index = source.indexOf(from)) != -1) {
 120             bf.append(source.substring(0, index) + to);
 121             source = source.substring(index + from.length());
 122             index = source.indexOf(from);
 123         }
 124         bf.append(source);
 125         return bf.toString();
 126     }
 127 
 128     /**
 129      * 替换字符串，能能够在HTML页面上直接显示(替换双引号和小于号)
 130      *
 131      * @param str String 原始字符串
 132      * @return String 替换后的字符串
 133      */
 134     public static String htmlencode(String str) {
 135         if (str == null) {
 136             return null;
 137         }
 138 
 139         return replace("\"", """, replace("<", "<", str));
 140     }
 141 
 142     /**
 143      * 替换字符串，将被编码的转换成原始码（替换成双引号和小于号）
 144      *
 145      * @param str String
 146      * @return String
 147      */
 148     public static String htmldecode(String str) {
 149         if (str == null) {
 150             return null;
 151         }
 152 
 153         return replace(""", "\"", replace("<", "<", str));
 154     }
 155 
 156     private static final String _BR = "
";
 157 
 158     /**
 159      * 在页面上直接显示文本内容，替换小于号，空格，回车，TAB
 160      *
 161      * @param str String 原始字符串
 162      * @return String 替换后的字符串
 163      */
 164     public static String htmlshow(String str) {
 165         if (str == null) {
 166             return null;
 167         }
 168 
 169         str = replace("<", "<", str);
 170         str = replace(" ", " ", str);
 171         str = replace("\r\n", _BR, str);
 172         str = replace("\n", _BR, str);
 173         str = replace("\t", "    ", str);
 174         return str;
 175     }
 176 
 177     /**
 178      * 返回指定字节长度的字符串
 179      *
 180      * @param str String 字符串
 181      * @param length int 指定长度
 182      * @return String 返回的字符串
 183      */
 184     public static String toLength(String str, int length) {
 185         if (str == null) {
 186             return null;
 187         }
 188         if (length <= 0) {
 189             return "";
 190         }
 191         try {
 192             if (str.getBytes("GBK").length <= length) {
 193                 return str;
 194             }
 195         } catch (Exception ex) {
 196         }
 197         StringBuffer buff = new StringBuffer();
 198 
 199         int index = 0;
 200         char c;
 201         length -= 3;
 202         while (length > 0) {
 203             c = str.charAt(index);
 204             if (c < 128) {
 205                 length--;
 206             } else {
 207                 length--;
 208                 length--;
 209             }
 210             buff.append(c);
 211             index++;
 212         }
 213         buff.append("...");
 214         return buff.toString();
 215     }
 216 
 217     /**
 218      * 判断是否为整数
 219      *
 220      * @param str 传入的字符串
 221      * @return 是整数返回true,否则返回false
 222      */
 223     public static boolean isInteger(String str) {
 224         Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
 225         return pattern.matcher(str).matches();
 226     }
 227 
 228     /**
 229      * 判断是否为浮点数，包括double和float
 230      *
 231      * @param str 传入的字符串
 232      * @return 是浮点数返回true,否则返回false
 233      */
 234     public static boolean isDouble(String str) {
 235         Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
 236         return pattern.matcher(str).matches();
 237     }
 238 
 239     /**
 240      * 判断输入的字符串是否符合Email样式.
 241      *
 242      * @param str 传入的字符串
 243      * @return 是Email样式返回true,否则返回false
 244      */
 245     public static boolean isEmail(String str) {
 246         Pattern pattern = Pattern.compile("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$");
 247         return pattern.matcher(str).matches();
 248     }
 249 
 250     /**
 251      * 判断输入的字符串是否为纯汉字
 252      *
 253      * @param str 传入的字符窜
 254      * @return 如果是纯汉字返回true,否则返回false
 255      */
 256     public static boolean isChinese(String str) {
 257         Pattern pattern = Pattern.compile("[\u0391-\uFFE5]+$");
 258         return pattern.matcher(str).matches();
 259     }
 260 
 261     /**
 262      * 是否为空白,包括null和""
 263      *
 264      * @param str
 265      * @return
 266      */
 267     public static boolean isBlank(String str) {
 268         return str == null || str.trim().length() == 0;
 269     }
 270 
 271     /**
 272      * 判断是否为质数
 273      *
 274      * @param x
 275      * @return
 276      */
 277     public static boolean isPrime(int x) {
 278         if (x <= 7) {
 279             if (x == 2 || x == 3 || x == 5 || x == 7)
 280                 return true;
 281         }
 282         int c = 7;
 283         if (x % 2 == 0)
 284             return false;
 285         if (x % 3 == 0)
 286             return false;
 287         if (x % 5 == 0)
 288             return false;
 289         int end = (int) Math.sqrt(x);
 290         while (c <= end) {
 291             if (x % c == 0) {
 292                 return false;
 293             }
 294             c += 4;
 295             if (x % c == 0) {
 296                 return false;
 297             }
 298             c += 2;
 299             if (x % c == 0) {
 300                 return false;
 301             }
 302             c += 4;
 303             if (x % c == 0) {
 304                 return false;
 305             }
 306             c += 2;
 307             if (x % c == 0) {
 308                 return false;
 309             }
 310             c += 4;
 311             if (x % c == 0) {
 312                 return false;
 313             }
 314             c += 6;
 315             if (x % c == 0) {
 316                 return false;
 317             }
 318             c += 2;
 319             if (x % c == 0) {
 320                 return false;
 321             }
 322             c += 6;
 323         }
 324         return true;
 325     }
 326 
 327     public static void main(String[] args) {
 328         String[] numbers = { "12345", "-12345", "123.45", "-123.45", ".12345", "-.12345", "a12345", "12345a", "123.a45" };
 329         for (String str : numbers) {
 330             System.out.println(str + "=" + isInteger(str) + " " + isDouble(str));
 331         }
 332 
 333         String[] emails = { "[email protected]", "[email protected]", "[email protected]" };
 334         for (String str : emails) {
 335             System.out.println(str + "=" + isEmail(str));
 336         }
 337         String[] chineses = { "中国", "1中国", "中国1", "1中国2", "中1国" };
 338         for (String str : chineses) {
 339             System.out.println(str + "=" + isChinese(str));
 340         }
 341     }
 342 }
 343 
 344 
 345 
 346 
 347 /* * Db.java
 348 Created on 2007年8月20日, 上午 8:37
 349  */
 350 import java.io.*;
 351 import java.sql.*;
 352 import java.util.Properties;
 353 public class Db {
 354     private String driver;
 355     private String url;
 356     private String user;
 357     private String password;
 358     private Connection conn;
 359     private Statement stm;
 360     private ResultSet rs;
 361     public Db(){
 362         this("DBConf.properties");
 363     }
 364     public Db(String conf) {
 365         loadProperties(conf);
 366         setConn();
 367     }
 368     public Connection getConn(){
 369         return this.conn;
 370     }
 371     //handle the properties file to get the informations for connection
 372     private void loadProperties(String conf){
 373         Properties props = new Properties();
 374         try {
 375             props.load(new FileInputStream(conf));
 376         } catch (FileNotFoundException e) {
 377             e.printStackTrace();
 378         } catch (IOException e) {
 379             e.printStackTrace();
 380         }
 381         this.driver = props.getProperty("driver");
 382         this.url = props.getProperty("url");
 383         this.user = props.getProperty("user");
 384         this.password = props.getProperty("password");
 385     }
 386     //implement the Connection
 387     private void setConn(){
 388         try {
 389             Class.forName(driver);
 390             this.conn = DriverManager.getConnection(url,user,password);
 391         } catch(ClassNotFoundException classnotfoundexception) {
 392             classnotfoundexception.printStackTrace();
 393             System.err.println("db: " + classnotfoundexception.getMessage());
 394         } catch(SQLException sqlexception) {
 395             System.err.println("db.getconn(): " + sqlexception.getMessage());
 396         }
 397     }
 398     public void doInsert(String sql) {
 399         try {
 400             Statement statement = conn.createStatement();
 401             int i = stm.executeUpdate(sql);
 402         } catch(SQLException sqlexception) {
 403             System.err.println("db.executeInset:" + sqlexception.getMessage());
 404         }
 405     }
 406     public void doDelete(String sql) {
 407         try {
 408             stm = conn.createStatement();
 409             int i = stm.executeUpdate(sql);
 410         } catch(SQLException sqlexception) {
 411             System.err.println("db.executeDelete:" + sqlexception.getMessage());
 412         }
 413     }
 414     public void doUpdate(String sql) {
 415         try {
 416             stm = conn.createStatement();
 417             int i = stm.executeUpdate(sql);
 418         } catch(SQLException sqlexception) {
 419             System.err.println("db.executeUpdate:" + sqlexception.getMessage());
 420         }
 421     }
 422 
 423     public ResultSet doSelect(String sql) {
 424         try {
 425             stm = conn.createStatement(java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE,java.sql.ResultSet.CONCUR_READ_ONLY);
 426             rs = stm.executeQuery(sql);
 427         } catch(SQLException sqlexception) {
 428             System.err.println("db.executeQuery: " + sqlexception.getMessage());
 429         }
 430         return rs;
 431     }
 432     public static void main(String[] args){
 433         try{
 434             Db db = new Db();
 435             Connection conn = db.getConn();
 436             if(conn != null && !conn.isClosed()) {
 437                 System.out.println("連結成功");
 438                 ResultSet rs = db.doSelect("select * from content");
 439                 while(rs.next()){
 440                     System.out.println(rs.getString(1)+":"+rs.getString(2)+":"+rs.getString(3));
 441                 }
 442                 rs.close();
 443                 conn.close();
 444             }
 445         }catch(SQLException e) {
 446             e.printStackTrace();
 447         }
 448     }  
 449 }
 450 
 451 
 452 
 453 
 454 
 455 DBConf.properties:
 456     driver=oracle.jdbc.driver.OracleDriver
 457     url=jdbcracle:thintdt151:1521:train
 458     user=XX
 459     password=XX
 460 
 461 
 462 
 463     /**
 464      * 人民币转成大写
 465      *
 466      * @param value
 467      * @return String
 468      */
 469     public static String hangeToBig(double value)
 470 {
 471     char[] hunit = { '拾', '佰', '仟' }; // 段内位置表示
 472     char[] vunit = { '万', '亿' }; // 段名表示
 473     char[] digit = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' }; // 数字表示
 474     long midVal = (long) (value * 100); // 转化成整形
 475     String valStr = String.valueOf(midVal); // 转化成字符串
 476 
 477     String head = valStr.substring(0, valStr.length() - 2); // 取整数部分
 478     String rail = valStr.substring(valStr.length() - 2); // 取小数部分
 479 
 480     String prefix = ""; // 整数部分转化的结果
 481     String suffix = ""; // 小数部分转化的结果
 482     // 处理小数点后面的数
 483     if (rail.equals("00"))
 484     { // 如果小数部分为0
 485         suffix = "整";
 486     }
 487     else
 488     {
 489         suffix = digit[rail.charAt(0) - '0'] + "角" + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来
 490     }
 491     // 处理小数点前面的数
 492     char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组
 493     char zero = '0'; // 标志'0'表示出现过0
 494     byte zeroSerNum = 0; // 连续出现0的次数
 495     for (int i = 0; i < chDig.length; i++)
 496     { // 循环处理每个数字
 497         int idx = (chDig.length - i - 1) % 4; // 取段内位置
 498         int vidx = (chDig.length - i - 1) / 4; // 取段位置
 499         if (chDig == '0')
 500         { // 如果当前字符是0
 501             zeroSerNum++; // 连续0次数递增
 502             if (zero == '0')
 503             { // 标志
 504                 zero = digit[0];
 505             }
 506             else if (idx == 0 && vidx > 0 && zeroSerNum < 4)
 507             {
 508                 prefix += vunit[vidx - 1];
 509                 zero = '0';
 510             }
 511             continue;
 512         }
 513         zeroSerNum = 0; // 连续0次数清零
 514         if (zero != '0')
 515         { // 如果标志不为0,则加上,例如万,亿什么的
 516             prefix += zero;
 517             zero = '0';
 518         }
 519         prefix += digit[chDig - '0']; // 转化该数字表示
 520         if (idx > 0)
 521             prefix += hunit[idx - 1];
 522         if (idx == 0 && vidx > 0)
 523         {
 524             prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿
 525         }
 526     }
 527 
 528     if (prefix.length() > 0)
 529         prefix += '圆'; // 如果整数部分存在,则有圆的字样
 530     return prefix + suffix; // 返回正确表示
 531 }
 532 
 533 
 534 /**
 535  * 全角字符转半角字符
 536  *
 537  * @param QJStr
 538  * @return String
 539  */
 540 public static final String QJToBJChange(String QJStr)
 541 {
 542     char[] chr = QJStr.toCharArray();
 543     String str = "";
 544     for (int i = 0; i < chr.length; i++)
 545     {
 546         chr = (char) ((int) chr - 65248);
 547         str += chr;
 548     }
 549     return str;
 550 }
 551 
 552 
 553 /**
 554  * 去掉字符串中重复的子字符串
 555  *
 556  * @param str
 557  * @return String
 558  */
 559 private static String removeSameString(String str)
 560 {
 561     Set mLinkedSet = new LinkedHashSet();
 562     String[] strArray = str.split(" ");
 563     StringBuffer sb = new StringBuffer();
 564 
 565     for (int i = 0; i < strArray.length; i++)
 566     {
 567         if (!mLinkedSet.contains(strArray))
 568         {
 569             mLinkedSet.add(strArray);
 570             sb.append(strArray + " ");
 571         }
 572     }
 573     System.out.println(mLinkedSet);
 574     return sb.toString().substring(0, sb.toString().length() - 1);
 575 }
 576 
 577 
 578 
 579 
 580 /**
 581  * 设置JSpinner的编辑属性
 582  * @param spinner 目标JSpinner
 583  * @param isAllowInvalid 是否允许输入非法值
 584  * @param isEditable 是否允许编辑
 585  */
 586 public static void setAllowsInvalid(JSpinner spinner, boolean isAllowInvalid, boolean isEditable)
 587 {
 588     JSpinner.NumberEditor editor = new JSpinner.NumberEditor(spinner, "#");
 589     spinner.setEditor(editor);
 590     JFormattedTextField tf = ((JSpinner.NumberEditor)spinner.getEditor()).getTextField();
 591     tf.setEditable(isEditable);
 592     DefaultFormatterFactory factory = (DefaultFormatterFactory)tf.getFormatterFactory();
 593     NumberFormatter formatter = (NumberFormatter)factory.getDefaultFormatter();
 594     formatter.setAllowsInvalid(isAllowInvalid);
 595 }
 596 
 597 
 598 
 599 
 600 /**   
 601  * 根据指定方法的参数去构造一个新的对象的拷贝并将他返回
 602  * @param obj 原始对象
 603  * @return 新对象
 604  * @throws NoSuchMethodException   
 605  * @throws InvocationTargetException   
 606  * @throws IllegalAccessException   
 607  * @throws InstantiationException   
 608  * @throws SecurityException   
 609  * @throws IllegalArgumentException   
 610  */
 611 @SuppressWarnings("unchecked")
 612 public static Object copy(Object obj) throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException,
 613 InvocationTargetException, NoSuchMethodException
 614 {
 615     //获得对象的类型   
 616     Class classType = obj.getClass();
 617 
 618     //通过默认构造方法去创建一个新的对象，getConstructor的视其参数决定调用哪个构造方法   
 619     Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
 620 
 621     //获得对象的所有属性   
 622     Field[] fields = classType.getDeclaredFields();
 623 
 624     for(int i = 0; i < fields.length; i++)
 625     {
 626         //获取数组中对应的属性   
 627         Field field = fields;
 628 
 629         String fieldName = field.getName();
 630         String stringLetter = fieldName.substring(0, 1).toUpperCase();
 631 
 632         //获得相应属性的getXXX和setXXX方法名称   
 633         String getName = "get" + stringLetter + fieldName.substring(1);
 634         String setName = "set" + stringLetter + fieldName.substring(1);
 635 
 636         //获取相应的方法   
 637         Method getMethod = classType.getMethod(getName, new Class[]{});
 638         Method setMethod = classType.getMethod(setName, new Class[]{field.getType()});
 639 
 640         //调用源对象的getXXX（）方法   
 641         Object value = getMethod.invoke(obj, new Object[]{});
 642 
 643         //调用拷贝对象的setXXX（）方法   
 644         setMethod.invoke(objectCopy, new Object[]{value});
 645     }
 646 
 647     return objectCopy;
 648 }
 649 
 650 
 651 //过滤特殊字符
 652 public static String encoding(String src){
 653     if (src==null)
 654         return "";
 655     StringBuilder result=new StringBuilder();
 656     if (src!=null){
 657         src=src.trim();
 658         for (int pos=0;pos){
 659             switch(src.charAt(pos)){
 660             case '\"':result.append(""");break;
 661             case '<':result.append("<");break;
 662             case '>':result.append(">");break;
 663             case '\'':result.append("'");break;
 664             case '&':result.append("&");break;
 665             case '%':result.append("&pc;");break;
 666             case '_':result.append("&ul;");break;
 667             case '#':result.append("&shap;");break;
 668             case '?':result.append("&ques;");break;
 669             default:result.append(src.charAt(pos));break;
 670             }
 671         }
 672     }
 673     return result.toString();
 674 }
 675 
 676 //反过滤特殊字符
 677 public static String decoding(String src){
 678     if (src==null)
 679         return "";
 680     String result=src;
 681     result=result.replace(""", "\"").replace("'", "\'");
 682     result=result.replace("<", "<").replace(">", ">");
 683     result=result.replace("&", "&");
 684     result=result.replace("&pc;", "%").replace("&ul", "_");
 685     result=result.replace("&shap;", "#").replace("&ques", "?");
 686     return result;
 687 }
 688 
 689 //利用反射调用一个继承层次上的函数族，比如安装程序，有安装数据库的，安装文件系统的等，命名均已“install”开始，你就可以将参数part设为“install”，src是其实类实例，root是终止父类
 690 public static  void invokeMethods(String part,T src,Class root) throws ExceptionManager{
 691     if (root!=null){
 692         if (!root.isInstance(src))return;
 693         root=(Class)root.getGenericSuperclass();
 694     }
 695     HashMap invokees=new HashMap();
 696     Class target=src.getClass();
 697     do{
 698         Method [] methods=target.getDeclaredMethods();
 699         for (Method method:methods){
 700             String mn=method.getName();
 701             Boolean isPass=mn.startsWith(part);
 702             if (isPass){
 703                 Integer nopt=method.getParameterTypes().length;
 704                 Boolean isStatic=Modifier.isStatic(method.getModifiers());
 705                 if ((nopt==0)&&(!isStatic)){
 706                     if (!invokees.containsKey(mn))
 707                         invokees.put(mn, method);
 708                 }
 709             }
 710         }
 711         target=(Class)target.getGenericSuperclass();
 712     }while(target!=root);
 713     Iterator methods=invokees.keySet().iterator();
 714     while (methods.hasNext()){
 715         Method invokee=invokees.get(methods.next());
 716         Boolean access=invokee.isAccessible();
 717         invokee.setAccessible(true);
 718         try {
 719             invokee.invoke(src);
 720         } catch (InvocationTargetException e) {
 721             throw ExceptionManager.wrap(e.getTargetException());
 722         }catch (Exception e){}
 723         invokee.setAccessible(access);
 724     }
 725 }
 726 
 727 
 728 
 729 MySQL：   
 730 String Driver="com.mysql.jdbc.Driver";    //驱动程序
 731 String URL="jdbc:mysql://localhost:3306/db_name";    //连接的URL,db_name为数据库名   
 732 String Username="username";    //用户名
 733 String Password="password";    //密码
 734 Class.forName(Driver).new Instance();
 735 Connection con=DriverManager.getConnection(URL,Username,Password);
 736 Microsoft SQL Server 2.0驱动(3个jar的那个):
 737     String Driver="com.microsoft.jdbc.sqlserver.SQLServerDriver";    //连接SQL数据库的方法
 738 String URL="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_name";    //db_name为数据库名
 739 String Username="username";    //用户名
 740 String Password="password";    //密码
 741 Class.forName(Driver).new Instance();    //加载数据可驱动
 742 Connection con=DriverManager.getConnection(URL,UserName,Password);    //
 743 Microsoft SQL Server 3.0驱动(1个jar的那个): // 老紫竹完善
 744     String Driver="com.microsoft.sqlserver.jdbc.SQLServerDriver";    //连接SQL数据库的方法
 745 String URL="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_name";    //db_name为数据库名
 746 String Username="username";    //用户名
 747 String Password="password";    //密码
 748 Class.forName(Driver).new Instance();    //加载数据可驱动
 749 Connection con=DriverManager.getConnection(URL,UserName,Password);    //
 750 Sysbase:
 751     String Driver="com.sybase.jdbc.SybDriver";    //驱动程序
 752 String URL="jdbc:Sysbase://localhost:5007/db_name";    //db_name为数据可名
 753 String Username="username";    //用户名
 754 String Password="password";    //密码
 755 Class.forName(Driver).newInstance();   
 756 Connection con=DriverManager.getConnection(URL,Username,Password);
 757 Oracle(用thin模式):
 758     String Driver="oracle.jdbc.driver.OracleDriver";    //连接数据库的方法
 759 String URL="jdbcracle:thinloaclhost:1521rcl";    //orcl为数据库的SID
 760 String Username="username";    //用户名
 761 String Password="password";    //密码
 762 Class.forName(Driver).newInstance();    //加载数据库驱动
 763 Connection con=DriverManager.getConnection(URL,Username,Password);   
 764 PostgreSQL:
 765     String Driver="org.postgresql.Driver";    //连接数据库的方法
 766 String URL="jdbc:postgresql://localhost/db_name";    //db_name为数据可名
 767 String Username="username";    //用户名
 768 String Password="password";    //密码
 769 Class.forName(Driver).newInstance();   
 770 Connection con=DriverManager.getConnection(URL,Username,Password);
 771 DB2：
 772 String Driver="com.ibm.db2.jdbc.app.DB2.Driver";    //连接具有DB2客户端的Provider实例
 773 //String Driver="com.ibm.db2.jdbc.net.DB2.Driver";    //连接不具有DB2客户端的Provider实例
 774 String URL="jdbc:db2://localhost:5000/db_name";    //db_name为数据可名
 775 String Username="username";    //用户名
 776 String Password="password";    //密码
 777 Class.forName(Driver).newInstance();   
 778 Connection con=DriverManager.getConnection(URL,Username,Password);
 779 Informix:
 780     String Driver="com.informix.jdbc.IfxDriver";   
 781 String URL="jdbc:Informix-sqli://localhost:1533/db_name:INFORMIXSER=myserver";    //db_name为数据可名
 782 String Username="username";    //用户名
 783 String Password="password";    //密码
 784 Class.forName(Driver).newInstance();   
 785 Connection con=DriverManager.getConnection(URL,Username,Password);
 786 JDBC-ODBC:
 787     String Driver="sun.jdbc.odbc.JdbcOdbcDriver";
 788 String URL="jdbcdbc:dbsource";    //dbsource为数据源名
 789 String Username="username";    //用户名
 790 String Password="password";    //密码
 791 Class.forName(Driver).newInstance();   
 792 Connection con=DriverManager.getConnection(URL,Username,Password);
 793 
 794 
 795 
 796 
 797 
 798 
 799 /**
 800  *  把TXT转换为XML
 801  */
 802 import java.io.BufferedReader;
 803 import java.io.BufferedWriter;
 804 import java.io.FileReader;
 805 import java.io.FileWriter;
 806 import java.util.StringTokenizer;
 807 
 808 public class TxtToXml {
 809     private String strTxtFileName;
 810 
 811     private String strXmlFileName;
 812 
 813     public TxtToXml() {
 814         strTxtFileName = new String();
 815         strXmlFileName = new String();
 816     }
 817 
 818     public void createXml(String strTxt, String strXml) {
 819         strTxtFileName = strTxt;
 820         strXmlFileName = strXml;
 821         String strTmp;
 822         try {
 823             BufferedReader inTxt = new BufferedReader(new FileReader(
 824                     strTxtFileName));
 825             BufferedWriter outXml = new BufferedWriter(new FileWriter(
 826                     strXmlFileName));
 827             outXml.write("");
 828             outXml.newLine();
 829             outXml.write("");
 830             while ((strTmp = inTxt.readLine()) != null) {
 831                 StringTokenizer strToken = new StringTokenizer(strTmp, "，");
 832                 String arrTmp[];
 833                 arrTmp = new String[3];
 834                 for (int i = 0; i < 3; i++)
 835                     arrTmp = new String("");
 836                 int index = 0;
 837                 outXml.newLine();
 838                 outXml.write("    ");
 839                 while (strToken.hasMoreElements()) {
 840                     strTmp = (String) strToken.nextElement();
 841                     strTmp = strTmp.trim();
 842                     arrTmp[index++] = strTmp;
 843                 }
 844                 outXml.newLine();
 845                 outXml.write("        " + arrTmp[0] + "");
 846                 outXml.newLine();
 847                 outXml.write("        " + arrTmp[1] + "");
 848                 outXml.newLine();
 849                 outXml.write("        " + arrTmp[2] + "");
 850                 outXml.newLine();
 851                 outXml.write("    ");
 852             }
 853             outXml.newLine();
 854             outXml.write("");
 855             outXml.flush();
 856         } catch (Exception e) {
 857             e.printStackTrace();
 858         }
 859     }
 860 
 861     public static void main(String[] args) {
 862         String txtName = "testtxt.txt";
 863         String xmlName = "testxml.xml";
 864         TxtToXml thisClass = new TxtToXml();
 865         thisClass.createXml(txtName, xmlName);
 866     }
 867 }
 868 
 869 
 870 /**
 871  * 写入日志
 872  * filePath 日志文件的路径
 873  * code 要写入日志文件的内容
 874  */
 875 public static boolean print(String filePath,String code) {
 876     try {
 877         File tofile=new File(filePath);
 878         FileWriter fw=new FileWriter(tofile,true);
 879         BufferedWriter bw=new BufferedWriter(fw);
 880         PrintWriter pw=new PrintWriter(bw);
 881 
 882         System.out.println(getDate()+":"+code);
 883         pw.println(getDate()+":"+code);
 884         pw.close();
 885         bw.close();
 886         fw.close();
 887         return true;
 888     } catch (IOException e) {
 889         return false;
 890     }
 891 }
 892 
 893 
 894 
 895 /**
 896  * 判断是不是合法手机
 897  * handset 手机号码
 898  */
 899 public static boolean isHandset(String handset) {
 900     try {
 901         if(!handset.substring(0,1).equals("1")) {
 902             return false;
 903         }
 904         if (handset==null || handset.length()!=11) {
 905             return false;
 906         }
 907         String check = "^[0123456789]+$";
 908         Pattern regex = Pattern.compile(check);
 909         Matcher matcher = regex.matcher(handset);
 910         boolean isMatched = matcher.matches();
 911         if(isMatched) {
 912             return true;
 913         } else {
 914             return false;
 915         }
 916     } catch (RuntimeException e) {
 917         return false;
 918     }
 919 }
 920 }
 921 
 922 字符串匹配的算法.
 923 public String getMaxMatch(String a,String b) {   
 924     StringBuffer tmp = new StringBuffer();   
 925     String maxString = "";   
 926     int max = 0;   
 927     int len = 0;   
 928     char[] aArray = a.toCharArray();   
 929     char[] bArray = b.toCharArray();   
 930     int posA = 0;   
 931     int posB = 0;   
 932     while(posAmax) {   
 933         posB = 0;   
 934         while(posB<(bArray.length-max)) {                                   
 935             if(aArray[posA]==bArray[posB]) {   
 936                 len = 1;   
 937                 tmp = new StringBuffer();   
 938                 tmp.append(aArray[posA]);                                          
 939                 while((posA+lenlen])) {   
 940                     tmp.append(aArray[posA+len]);   
 941                     len++;   
 942                 }   
 943                 if(len>max) {   
 944                     max = len;   
 945                     maxString = tmp.toString();   
 946                 }   
 947             }   
 948             posB++;   
 949         }   
 950         posA++;   
 951     }           
 952     return maxString;                       
 953 }
 954 
 955 
 956 
 957 import java.text.DecimalFormat;
 958 import java.util.Arrays;
 959 
 960 /**
 961  * 时间计算工具类
 962  */
 963 public class Time {
 964 
 965     /**
 966      * 时间字段常量，表示“秒”
 967      */
 968     public final static int SECOND = 0;
 969 
 970     /**
 971      * 时间字段常量，表示“分”
 972      */
 973     public final static int MINUTE = 1;
 974 
 975     /**
 976      * 时间字段常量，表示“时”
 977      */
 978     public final static int HOUR = 2;
 979 
 980     /**
 981      * 时间字段常量，表示“天”
 982      */
 983     public final static int DAY = 3;
 984 
 985     /**
 986      * 各常量允许的最大值
 987      */
 988     private final int[] maxFields = { 59, 59, 23, Integer.MAX_VALUE - 1 };
 989 
 990     /**
 991      * 各常量允许的最小值
 992      */
 993     private final int[] minFields = { 0, 0, 0, Integer.MIN_VALUE };
 994 
 995     /**
 996      * 默认的字符串格式时间分隔符
 997      */
 998     private String timeSeparator = ":";
 999 
1000     /**
1001      * 时间数据容器
1002      */
1003     private int[] fields = new int[4];   
1004 
1005     /**
1006      * 无参构造，将各字段置为 0
1007      */
1008     public Time() {
1009         this(0, 0, 0, 0);
1010     }
1011 
1012     /**
1013      * 使用时、分构造一个时间
1014      * @param hour      小时
1015      * @param minute    分钟
1016      */
1017     public Time(int hour, int minute) {
1018         this(0, hour, minute, 0);
1019     }
1020 
1021     /**
1022      * 使用时、分、秒构造一个时间
1023      * @param hour      小时
1024      * @param minute    分钟
1025      * @param second    秒
1026      */
1027     public Time(int hour, int minute, int second) {
1028         this(0, hour, minute, second);
1029     }
1030 
1031     /**
1032      * 使用一个字符串构造时间

1033      * Time time = new Time("14:22:23");
1034      * @param time      字符串格式的时间，默认采用“:”作为分隔符
1035      */
1036     public Time(String time) {        
1037         this(time, null);
1038     }
1039 
1040     /**
1041      * 使用天、时、分、秒构造时间，进行全字符的构造
1042      * @param day       天
1043      * @param hour      时
1044      * @param minute    分
1045      * @param second    秒
1046      */
1047     public Time(int day, int hour, int minute, int second) {
1048         set(DAY, day);
1049         set(HOUR, hour);
1050         set(MINUTE, minute);
1051         set(SECOND, second);
1052     }  
1053 
1054     /**
1055      * 使用一个字符串构造时间，指定分隔符

1056      * Time time = new Time("14-22-23", "-");
1057      * @param time      字符串格式的时间
1058      */
1059     public Time(String time, String timeSeparator) {
1060         if(timeSeparator != null) {
1061             setTimeSeparator(timeSeparator);
1062         }
1063         String pattern = patternQuote(this.timeSeparator);
1064         String matcher = new StringBuffer()
1065         .append("\\d+?").append(pattern)
1066         .append("\\d+?").append(pattern)
1067         .append("\\d+?")
1068         .toString();
1069         if(!time.matches(matcher)) {
1070             throw new IllegalArgumentException(time + ", time format error, HH"
1071                     + this.timeSeparator + "mm" + this.timeSeparator + "ss");
1072         }        
1073         String[] times = time.split(pattern);
1074         set(DAY, 0);
1075         set(HOUR, Integer.parseInt(times[0]));
1076         set(MINUTE, Integer.parseInt(times[1]));
1077         set(SECOND, Integer.parseInt(times[2]));
1078     }
1079 
1080     /**
1081      * 设置时间字段的值
1082      * @param field     时间字段常量
1083      * @param value     时间字段的值
1084      */
1085     public void set(int field, int value) {        
1086         if(value < minFields[field]) {
1087             throw new IllegalArgumentException(value +
1088                     ", time value must be positive.");
1089         }
1090         fields[field] = value % (maxFields[field] + 1);
1091         // 进行进位计算
1092         int carry = value / (maxFields[field] + 1);
1093         if(carry > 0) {
1094             int upFieldValue = get(field + 1);
1095             set(field + 1, upFieldValue + carry);
1096         }
1097     }
1098 
1099     /**
1100      * 获得时间字段的值
1101      * @param field     时间字段常量
1102      * @return          该时间字段的值
1103      */
1104     public int get(int field) {
1105         if(field < 0 || field > fields.length - 1) {
1106             throw new IllegalArgumentException(field + ", field value is error.");
1107         }
1108         return fields[field];
1109     }
1110 
1111     /**
1112      * 将时间进行“加”运算，即加上一个时间
1113      * @param time      需要加的时间
1114      * @return          运算后的时间
1115      */
1116     public Time addTime(Time time) {
1117         Time result = new Time();
1118         int up = 0;     // 进位标志
1119         for (int i = 0; i < fields.length; i++) {
1120             int sum = fields + time.fields + up;
1121             up = sum / (maxFields + 1);
1122             result.fields = sum % (maxFields + 1);
1123         }
1124         return result;
1125     }
1126 
1127     /**
1128      * 将时间进行“减”运算，即减去一个时间
1129      * @param time      需要减的时间
1130      * @return          运算后的时间
1131      */
1132     public Time subtractTime(Time time) {
1133         Time result = new Time();
1134         int down = 0;       // 退位标志
1135         for (int i = 0, k = fields.length - 1; i < k; i++) {
1136             int difference = fields + down;
1137             if (difference >= time.fields) {
1138                 difference -= time.fields;
1139                 down = 0;
1140             } else {
1141                 difference += maxFields + 1 - time.fields;
1142                 down = -1;
1143             }
1144             result.fields = difference;
1145         }
1146         result.fields[DAY] = fields[DAY] - time.fields[DAY] + down;
1147         return result;
1148     }
1149 
1150     /**
1151      * 获得时间字段的分隔符
1152      * @return
1153      */
1154     public String getTimeSeparator() {
1155         return timeSeparator;
1156     }
1157 
1158     /**
1159      * 设置时间字段的分隔符（用于字符串格式的时间）
1160      * @param timeSeparator     分隔符字符串
1161      */
1162     public void setTimeSeparator(String timeSeparator) {
1163         this.timeSeparator = timeSeparator;
1164     }
1165 
1166     /**
1167      * 正则表达式引用处理方法，源自 JDK @link java.util.regex.Pattern#quote(String)
1168      */
1169     private String patternQuote(String s) {
1170         int slashEIndex = s.indexOf("\\E");
1171         if (slashEIndex == -1)
1172             return "\\Q" + s + "\\E";
1173 
1174         StringBuilder sb = new StringBuilder(s.length() * 2);
1175         sb.append("\\Q");
1176         slashEIndex = 0;
1177         int current = 0;
1178         while ((slashEIndex = s.indexOf("\\E", current)) != -1) {
1179             sb.append(s.substring(current, slashEIndex));
1180             current = slashEIndex + 2;
1181             sb.append("\\E\\\\E\\Q");
1182         }
1183         sb.append(s.substring(current, s.length()));
1184         sb.append("\\E");
1185         return sb.toString();
1186     }
1187 
1188     public String toString() {
1189         DecimalFormat df = new DecimalFormat("00");
1190         return new StringBuffer().append(fields[DAY]).append(", ")
1191                 .append(df.format(fields[HOUR])).append(timeSeparator)
1192                 .append(df.format(fields[MINUTE])).append(timeSeparator)
1193                 .append(df.format(fields[SECOND]))
1194                 .toString();
1195     }
1196 
1197     public int hashCode() {
1198         final int PRIME = 31;
1199         int result = 1;
1200         result = PRIME * result + Arrays.hashCode(fields);
1201         return result;
1202     }
1203 
1204     public boolean equals(Object obj) {
1205         if (this == obj)
1206             return true;
1207         if (obj == null)
1208             return false;
1209         if (getClass() != obj.getClass())
1210             return false;
1211         final Time other = (Time) obj;
1212         if (!Arrays.equals(fields, other.fields)) {
1213             return false;
1214         }
1215         return true;
1216     }
1217 }
1218 
1219 
1220 
1221 
1222 ISBN（国际标准书号）的校验
1223 
1224 public class Test {
1225 
1226     public static void main(String[] args) {
1227         System.out.println("9787302155638 " + ISBN.checkISBN("9787302155638"));
1228         System.out.println("7564105607 " + ISBN.checkISBN("7564105607"));
1229         System.out.println("730213880X " + ISBN.checkISBN("730213880X"));
1230         System.out.println("7302138800 " + ISBN.checkISBN("7302138800"));
1231         System.out.println("9790000000000 " + ISBN.checkISBN("9790000000000"));
1232         try {
1233             System.out.println(ISBN.checkISBN("9770000000000"));
1234         }catch(Exception e) {
1235             System.out.println("9770000000000 " + e.getMessage());
1236         }
1237         try {
1238             System.out.println(ISBN.checkISBN("123456545"));
1239         }catch(Exception e) {
1240             System.out.println("123456545 " + e.getMessage());
1241         }        
1242     }
1243 }
1244 
1245 public final class ISBN {
1246 
1247     /**
1248      * 根据输入的ISBN号，检验ISBN的有效性。依据 GB/T 5795-2006 和 ISO 2108:2005 ISBN
1249      * 10位标准和13位标准实现（13位标准自2007年1月1日开始实行，在此之前采用10位标准）。
1250      *
1251      * @param String isbn：需要进行校验的ISBN字符串
1252      * @return true：所输入的ISBN校验正确；
 false：所输入的ISBN校验错误
1253      */
1254     public static boolean checkISBN(String isbn) {
1255 
1256         int count = 0;
1257         int checkBitInt = 0;
1258 
1259         // 将ISBN数据全取大写字母
1260         //isbn = isbn.toUpperCase();
1261 
1262         char[] cs = isbn.toCharArray();        
1263         switch (isbn.length()) {
1264         case 10:
1265             // ****************************************************************
1266             // 当ISBN为10位时，进行的校验，用于2007年1月1日前的出版物
1267             // 数据格式：从左至右前9位为ISBN数据，第10位为校验位
1268             // 校验方法：
1269             // (1) 从左至右将前9位数据从10开始至2进行编号，作为位权
1270             // (2) 将9位数据与各位位权进行加权，并求其9位和（称为加权和，记作M）
1271             // (3) 第10位校验位计算方法，校验位为C：
1272             //         M + C ≡ 0 (mod 11)
1273             //  C为10时，记作“X”
1274             // ****************************************************************
1275 
1276             // 取出前9位数字进行加权和计算            
1277             for (int i = 0; i < 9; i++) {
1278                 // 若前9位数据中有非数字字符，则抛出异常
1279                 if (cs < '0' || cs > '9') {
1280                     throw new ISBNFormatException("ISBN " + isbn +
1281                             " 第 " + (i + 1) + " 位中出现非法字符 " + cs);
1282                 }
1283 
1284                 int c = cs - '0';
1285                 // 求加权和
1286                 count += c * (10 - i);
1287             }
1288 
1289             // 取出校验位数据0～9和X符合校验字符要求
1290             if (cs[9] >= '0' && cs[9] <= '9') {
1291                 checkBitInt = cs[9] - '0';
1292             } else if (cs[9] == 'X' || cs[9] == 'x') {
1293                 // 校验位中的“X”表示数据“10”
1294                 checkBitInt = 10;
1295             } else {
1296                 // 非0～9或X时抛出异常
1297                 throw new ISBNFormatException("ISBN " + isbn +
1298                         " 第 10 位中出现非法字符 " + cs[9]);
1299             }
1300 
1301             // 进行校验
1302             if ((count + checkBitInt) % 11 == 0) {
1303                 return true; // 校验成功
1304             } else {
1305                 return false; // 校验失败
1306             }
1307         case 13:
1308             // ****************************************************************
1309             // 当ISBN为13位时，进行的校验，用于2007年1月1日后的出版物
1310             // 数据格式：从左至右前12位为ISBN数据，第13位为校验位
1311             // 校验方法：
1312             // (1) 从左至右将前12位数的取其奇位数和和偶位数和
1313             // (2) 将偶位数和乘3，并其与奇位数和的和，得加权和
1314             // (3) 第13位校验位计算方法，校验位为C：
1315             //         M + C ≡ 0 (mod 10)
1316             // ****************************************************************
1317 
1318             // ISBN为13位数据时，前3位目前只能是“978”（已实行）或“979”（暂未实行）
1319             if (!isbn.startsWith("978") && !isbn.startsWith("979")) {
1320                 throw new ISBNFormatException("ISBN-13 格式不符合标准");
1321             }
1322             // 取出前12位数字进行加权和计算
1323             int countEven = 0;
1324             int countOdd = 0;
1325             for (int i = 0; i < 12; i++) {
1326                 int c = cs - '0';
1327                 // 若前12位数据中有非数字字符，则抛出异常
1328                 if (c < 0 || c > 9) {
1329                     throw new ISBNFormatException("ISBN " + isbn +
1330                             " 第 " + (i + 1) + " 位中出现非法字符 " + cs);
1331                 }
1332                 // 分别计算奇位数和偶位数的和
1333                 if ((i & 0x1) == 0) {
1334                     countOdd += c;
1335                 } else {
1336                     countEven += c;
1337                 }
1338             }
1339             // 求加权和
1340             count = countOdd + (countEven * 3);
1341 
1342             // 取出校验位数据            
1343             if (cs[12] < '0' || cs[12] > '9') {
1344                 // 校验位为非0~9字符时，抛出异常
1345                 throw new ISBNFormatException("ISBN " + isbn
1346                         + " 第 13 位中出现非法字符 " + cs[12]);
1347             }
1348 
1349             checkBitInt = cs[12] - '0';
1350             // 进行校验
1351             if ((count + checkBitInt) % 10 == 0) {
1352                 return true; // 校验成功
1353             } else {
1354                 return false; // 校验失败
1355             }
1356         default:
1357             // ISBN为非10位或13位时抛出异常
1358             throw new ISBNFormatException("ISBN 格式不符合标准");
1359         }
1360     }
1361 }
1362 
1363 
1364 
1365 
1366 
1367 
1368 import java.util.ArrayList;
1369 import java.util.Iterator;
1370 import java.util.LinkedHashMap;
1371 import java.util.List;
1372 import java.util.Map;
1373 
1374 /**
1375  * JSON utility class
1376  *
1377  * @since 2008-04-21
1378  */
1379 public class Json {
1380 
1381     // test
1382     public static void main(String[] args) {
1383         Json json1 = new Json();
1384         json1.add("totalCount", 2);
1385         json1.add("isTest", true);
1386 
1387         Json json_a = new Json();
1388         json_a.add("menuid", 1);
1389         json_a.add("menuname", "testmenu");
1390         json1.add("topics", json_a);
1391 
1392         Json json_b = new Json();
1393         json_b.add("menuid", 2);
1394         json_b.add("menuname", "testmenu");
1395         json1.add("topics", json_b);
1396         System.out.println(json1.toString());
1397     }
1398 
1399     private Map map = new LinkedHashMap();
1400 
1401     /**
1402      * 添加一个 JSON 属性，值为一个字符串，重复添加时产生数组

1403      *
1404      * add("name", "value");

1405      * 添加一个字符串，产生的 JSON 如：{"name":"value"}

1406      *
1407      * add("name", "value1");

1408      * add("name", "value2");

1409      * 添加两个同属性的字符串，产生的 JSON 如：{"name":["value1", "value2"]}

1410      *
1411      * @param key       JSON 属性名
1412      * @param str       字符串格式的属性值
1413      */
1414     public void add(String key, String value) {
1415         addElement(key, value);
1416     }
1417 
1418     public void add(String key, int num) {
1419         addElement(key, new Integer(num));
1420     }
1421 
1422     public void add(String key, boolean b) {
1423         addElement(key, new Boolean(b));
1424     }
1425 
1426     /**
1427      * 添加一个 JSON 属性，值为一个 JSON，重复添加时产生 JSON 数组

1428      *
1429      * Json json1 = new Json();

1430      * json1.add("name1", "value1");

1431      * json1.add("name2", "value2");

1432      * Json json = new Json();

1433      * json.add("message", json1);

1434      * 添加一个 JSON，产生的 JSON 如：{"message":{"name1":"value1", "name2":"value2"}}

1435      *
1436      * Json json1 = new Json();

1437      * json1.add("name1", "value1");

1438      * json1.add("name2", "value2");

1439      * Json json2 = new Json();

1440      * json2.add("name1", "value3");

1441      * json2.add("name2", "value4");

1442      * Json json = new Json();

1443      * json.add("message", json1);

1444      * json.add("message", json2);

1445      * 添加两个同属性的 JSON，产生的 JSON 如：{"message":[{"name1":"value1", "name2":"value2"}, {"name1":"value3", "name2":"value4"}]}

1446      *
1447      * @param key       JSON 属性名
1448      * @param json      JSON 格式的属性值
1449      */
1450     public void add(String key, Json json) {
1451         addElement(key, json);
1452     }
1453 
1454     public String toString() {
1455         StringBuilder sb = new StringBuilder();
1456         sb.append("{");
1457         int k = 0;
1458         for (Iterator i = map.keySet().iterator(); i.hasNext();) {
1459             String key = (String)(i.next());
1460             Object obj = map.get(key);
1461             if (k > 0) {
1462                 sb.append(",");
1463             }
1464             appendKey(sb, key);
1465             if (obj instanceof String) {
1466                 appendString(sb, (String)obj);
1467             } else if (obj instanceof List) {
1468                 appendList(sb, (List)obj);
1469             } else if (obj instanceof Json) {
1470                 appendJson(sb, (Json)obj);
1471             } else {
1472                 appendOther(sb, obj);
1473             }
1474             k++;
1475         }
1476         sb.append("}");
1477         return sb.toString();
1478     }
1479 
1480     private void addElement(String key, Object obj) {
1481         if (!map.containsKey(key)) {
1482             if(obj instanceof Json) {
1483                 List list = new ArrayList();
1484                 list.add(obj);
1485                 map.put(key, list);
1486             } else {
1487                 map.put(key, obj);
1488             }
1489             return;
1490         }
1491 
1492         Object o = map.remove(key);
1493 
1494         if (o instanceof List) {
1495             ((List)o).add(obj);
1496             map.put(key, o);
1497             return;
1498         }
1499 
1500         // o is a String
1501         List list = new ArrayList();
1502         list.add(o);
1503         list.add(obj);
1504         map.put(key, list);
1505     }
1506 
1507     /**
1508      * Append JSON property name
1509      *
1510      * @param sb
1511      * @param key
1512      */
1513     private void appendKey(StringBuilder sb, String key) {
1514         sb.append("\"").append(key).append("\":");
1515     }
1516 
1517     /**
1518      * Append JSON property value that is a String
1519      *
1520      * @param sb
1521      * @param str
1522      */
1523     private void appendString(StringBuilder sb, String str) {
1524         sb.append("\"").append(str).append("\"");
1525     }
1526 
1527     /**
1528      * Append JSON property value that is a Integer
1529      *
1530      * @param sb
1531      * @param num
1532      */
1533     private void appendOther(StringBuilder sb, Object obj) {
1534         sb.append(obj);
1535     }
1536 
1537     /**
1538      * Append JSON property value that is a List
1539      *
1540      * @param sb
1541      * @param list
1542      */
1543     private void appendList(StringBuilder sb, List list) {
1544         sb.append("[");
1545         for (int j = 0, m = list.size(); j < m; j++) {
1546             if (j > 0) {
1547                 sb.append(",");
1548             }
1549             Object obj = list.get(j);
1550             if (obj instanceof String) {
1551                 appendString(sb, (String)obj);
1552             } else if (obj instanceof Json) {
1553                 appendJson(sb, (Json)obj);
1554             } else {
1555                 appendOther(sb, obj);
1556             }
1557         }
1558         sb.append("]");
1559     }
1560 
1561     /**
1562      * Append JSON property value that is a JSON
1563      *
1564      * @param sb
1565      * @param json
1566      */
1567     private void appendJson(StringBuilder sb, Json json) {
1568         sb.append(json.toString());
1569     }
1570 }
1571 
1572 
1573 
1574 /**
1575  * 从指定的字符串中提取Email
1576  * content 指定的字符串
1577  */
1578 public static String parse(String content) {
1579     String email = null;
1580     if (content==null || content.length()<1) {
1581         return email;
1582     }
1583     //找出含有@
1584     int beginPos;
1585     int i;
1586     String token = "@";
1587     String preHalf="";
1588     String sufHalf = "";
1589 
1590     beginPos = content.indexOf(token);
1591     if (beginPos>-1) {
1592         //前项扫描
1593         String s = null;
1594         i= beginPos;
1595         while(i>0) {
1596             s = content.substring(i-1,i);
1597             if (isLetter(s))
1598                 preHalf = s+preHalf;
1599             else
1600                 break;
1601             i--;
1602         }
1603         //后项扫描
1604         i= beginPos+1;
1605         while( i<content.length()) {
1606             s = content.substring(i,i+1);
1607             if (isLetter(s))
1608                 sufHalf =  sufHalf +s;
1609             else
1610                 break;
1611             i++;  
1612         }
1613         //判断合法性
1614         email = preHalf + "@" + sufHalf;
1615         if (isEmail(email)) {
1616             return email;
1617         }
1618     }
1619     return null;
1620 }
1621 
1622 /**
1623  * 判断是不是合法Email
1624  * email Email地址
1625  */
1626 public static boolean isEmail(String email) {
1627     try {
1628         if (email==null || email.length()<1 || email.length()>256) {
1629             return false;
1630         }
1631 
1632         String check = "^([0-9a-zA-Z]+[_.0-9a-zA-Z-]+)@([a-zA-Z0-9-]+[.])+([a-zA-Z]{2,3})$";
1633         Pattern regex = Pattern.compile(check);
1634         Matcher matcher = regex.matcher(email);
1635         boolean isMatched = matcher.matches();
1636         if(isMatched) {
1637             return true;
1638         } else {
1639             return false;
1640         }
1641     } catch (RuntimeException e) {
1642         return false;
1643     }
1644 }
1645 
1646 /**
1647  * 判断是不是合法字符
1648  * c 要判断的字符
1649  */
1650 public static boolean isLetter(String c) {
1651     boolean result = false;
1652 
1653     if (c==null || c.length()<0) {
1654         return false;
1655     }
1656     //a-z
1657     if (c.compareToIgnoreCase("a")>=0 && c.compareToIgnoreCase("z")<=0) {
1658         return true;
1659     }
1660     //0-9
1661     if (c.compareToIgnoreCase("0")>=0 && c.compareToIgnoreCase("9")<=0) {
1662         return true;
1663     }
1664     //. - _
1665     if (c.equals(".") || c.equals("-") || c.equals("_") ) {
1666         return true;
1667     }
1668     return result;
1669 }
1670 
1671 
1672 
1673 /**
1674  * 列出某文件夹及其子文件夹下面的文件，并可根据扩展名过滤
1675  *
1676  * @param path
1677  */
1678 public static void list(File path)
1679 {
1680     if (!path.exists())
1681     {
1682         System.out.println("文件名称不存在!");
1683     }
1684     else
1685     {
1686         if (path.isFile())
1687         {
1688             if (path.getName().toLowerCase().endsWith(".pdf")
1689                     || path.getName().toLowerCase().endsWith(".doc")
1690                     || path.getName().toLowerCase().endsWith(".html")
1691                     || path.getName().toLowerCase().endsWith(".htm"))
1692             {
1693                 System.out.println(path);
1694                 System.out.println(path.getName());
1695             }
1696         }
1697         else
1698         {
1699             File[] files = path.listFiles();
1700             for (int i = 0; i < files.length; i++)
1701             {
1702                 list(files);
1703             }
1704         }
1705     }
1706 }
1707 
1708 
1709 
1710 
1711 /**
1712  * 拷贝一个目录或者文件到指定路径下
1713  *
1714  * @param source
1715  * @param target
1716  */
1717 public static void copy(File source, File target)
1718 {
1719     File tarpath = new File(target, source.getName());
1720     if (source.isDirectory())
1721     {
1722         tarpath.mkdir();
1723         File[] dir = source.listFiles();
1724         for (int i = 0; i < dir.length; i++)
1725         {
1726             copy(dir, tarpath);
1727         }
1728     }
1729     else
1730     {
1731         try
1732         {
1733             InputStream is = new FileInputStream(source);
1734             OutputStream os = new FileOutputStream(tarpath);
1735             byte[] buf = new byte[1024];
1736             int len = 0;
1737             while ((len = is.read(buf)) != -1)
1738             {
1739                 os.write(buf, 0, len);
1740             }
1741             is.close();
1742             os.close();
1743         }
1744         catch (FileNotFoundException e)
1745         {
1746             e.printStackTrace();
1747         }
1748         catch (IOException e)
1749         {
1750             e.printStackTrace();
1751         }
1752     }
1753 }
1754 
1755 
1756 
1757 
1758 Java日期格式化及其使用例子
1759 1 SimpleDateFormat担当重任,怎样格式化都行
1760 
1761 import java.util.Date;
1762 import java.text.SimpleDateFormat;
1763 public class Demo
1764 {
1765     public static void main(String[] args)
1766     {
1767         Date now=new Date();
1768         SimpleDateFormat f=newSimpleDateFormat("今天是"+"yyyy年MM月dd日 E kk点mm分");
1769         System.out.println(f.format(now));
1770 
1771         f=new SimpleDateFormat("a hh点mm分ss秒");
1772         System.out.println(f.format(now));
1773     }
1774 }
1775 
1776 
1777 2 从字符串到日期类型的转换：
1778 
1779 import java.util.Date;
1780 import java.text.SimpleDateFormat;
1781 import java.util.GregorianCalendar;
1782 import java.text.*;
1783 publicclass Demo
1784 {
1785     public static void main(String[] args)
1786     {
1787         String strDate="2005年04月22日";
1788         //注意：SimpleDateFormat构造函数的样式与strDate的样式必须相符
1789         SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy年MM月dd日");
1790         //必须捕获异常
1791 
1792         try
1793         {
1794             Date date=simpleDateFormat.parse(strDate);
1795             System.out.println(date);
1796         }
1797         catch(ParseException px)
1798         {
1799             px.printStackTrace();
1800         }
1801     }
1802 }
1803 
1804 
1805 3 将毫秒数换转成日期类型
1806 
1807 import java.util.Date;
1808 import java.text.SimpleDateFormat;
1809 import java.util.GregorianCalendar;
1810 import java.text.*;
1811 public class Demo
1812 {
1813     public static void main(String[] args)
1814     {
1815         long now=System.currentTimeMillis();
1816         System.out.println("毫秒数："+now);
1817         Date dNow=new Date(now);
1818         System.out.println("日期类型："+dNow);
1819     }
1820 }
1821 
1822 
1823 这3例源自http://blog.csdn.net/zhoujian2003/archive/2005/04/22/358363.aspx
1824 
1825     4 获取系统时期和时间，转换成SQL格式后更新到数据库
1826     (http://blog.csdn.net/netrope/archive/2005/11/19/532729.aspx)
1827 
1828         java.util.Date d=new java.util.Date();    //获取当前系统的时间
1829 
1830 //格式化日期
1831 
1832 new java.text.SimpleDateFormat s= new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
1833 
1834 String dateStr = s.format(d); //转为字符串
1835 
1836 使用RS更新数据库，仍然要用rs.updateString，而不是rs.updateDade。
1837 rs.updateString("regtime",dateStr);  //regtime字段为datetime类型的
1838 下面两例源自 http://blog.csdn.net/kingter520/archive/2004/10/27/155435.aspx
1839 
1840     5 按本地时区输出当前日期
1841 
1842     Date myDate = new Date();
1843 System.out.println(myDate.toLocaleString());
1844 输出结果为：
1845 2003-5-30
1846 
1847 
1848 6 如何格式化小数
1849 
1850 DecimalFormat df = new DecimalFormat(",###.00");  
1851 double aNumber = 33665448856.6568975;
1852 String result = df.format(aNumber);  
1853 Sytem. out.println(result);
1854 
1855 
1856 输出结果为：
1857 33,665,448,856.66
1858 
1859 其他：获取毫秒时间 System.currentTimeMillis();
1860 
1861 7 在数据库里的日期只以年-月-日的方式输出
1862 (http://blog.csdn.net/zzsxvzzsxv/archive/2007/08/27/1761004.aspx)
1863     定义日期格式：SimpleDateFormat sdf = new SimpleDateFormat(yy-MM-dd);
1864 sql语句为：String sqlStr = "select bookDate from roomBook where bookDate between '2007-4-10' and '2007-4-25'";
1865 输出：
1866 System.out.println(df.format(rs.getDate("bookDate")));
1867 
1868 
1869 
1870 
1871 
1872 Java中的鼠标和键盘事件
1873 1、使用MouseListener借口处理鼠标事件
1874 鼠标事件有5种：按下鼠标键，释放鼠标键，点击鼠标键，鼠标进入和鼠标退出
1875 鼠标事件类型是MouseEvent，主要方法有：
1876 getX(),getY() 获取鼠标位置
1877 getModifiers() 获取鼠标左键或者右键
1878 getClickCount() 获取鼠标被点击的次数
1879 getSource() 获取鼠标发生的事件源
1880 事件源获得监视器的方法是addMouseListener()，移去监视器的方法是removeMouseListener()
1881 处理事件源发生的时间的事件的接口是MouseListener 接口中有如下的方法
1882 mousePressed(MouseEvent) 负责处理鼠标按下事件
1883 mouseReleased(MouseEvent) 负责处理鼠标释放事件
1884 mouseEntered(MouseEvent) 负责处理鼠标进入容器事件
1885 mouseExited(MouseEvent) 负责处理鼠标离开事件
1886 mouseClicked(MouseEvent) 负责处理点击事件
1887 2、使用MouseMotionListener接口处理鼠标事件
1888 事件源发生的鼠标事件有2种：拖动鼠标和鼠标移动
1889 鼠标事件的类型是MouseEvent
1890 事件源获得监视器的方法是addMouseMotionListener()
1891 处理事件源发生的事件的接口是MouseMotionListener 接口中有如下的方法
1892 mouseDragged() 负责处理鼠标拖动事件
1893 mouseMoved() 负责处理鼠标移动事件
1894 3、控制鼠标的指针形状
1895 setCursor(Cursor.getPreddfinedCursor(Cursor.鼠标形状定义)) 鼠标形状定义见（书 P 210）
1896 4、键盘事件
1897 键盘事件源使用addKeyListener 方法获得监视器
1898 键盘事件的接口是KeyListener 接口中有3个方法
1899 public void keyPressed(KeyEvent e) 按下键盘按键
1900 public void keyReleased(KeyEvent e) 释放键盘按键
1901 
1902 
1903 
1904 
1905 
1906 public class IsChineseOrEnglish {
1907     //  GENERAL_PUNCTUATION 判断中文的“号
1908     //  CJK_SYMBOLS_AND_PUNCTUATION 判断中文的。号
1909     //  HALFWIDTH_AND_FULLWIDTH_FORMS 判断中文的，号
1910     public static boolean isChinese(char c) {
1911         Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);  
1912         if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
1913                 || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
1914                 || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
1915                 || ub == Character.UnicodeBlock.GENERAL_PUNCTUATION
1916                 || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
1917                 || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS){
1918             return true;
1919         }
1920         return false;
1921     }
1922     public static void isChinese(String strName) {
1923         char[] ch = strName.toCharArray();
1924         for (int i = 0; i < ch.length; i++) {
1925             char c = ch;
1926             if(isChinese(c)==true){
1927                 System.out.println(isChinese(c));
1928                 return;
1929             }else{
1930                 System.out.println(isChinese(c));
1931                 return ;
1932             }
1933         }
1934     }
1935 
1936     public static void main(String[] args){
1937 
1938         isChinese("zhongguo");
1939         isChinese("中国");
1940     }
1941 
1942 }
1943 
1944 
1945 
1946 
1947 
1948 MD5和一个可逆加密算法相接合的加密和解密程序
1949 比较简单。
1950 [code={0}]
1951         import java.security.MessageDigest;
1952 /**
1953  *先通过MD5加密之后，再来一次可逆的加密。
1954  *顺序可以调整，可以选择先用可逆加密，然后再用MD5加密
1955  */
1956 public class MD5andKL{
1957     //MD5加码。32位
1958     public static String MD5(String inStr) {
1959         MessageDigest md5 = null;
1960         try {
1961             md5 = MessageDigest.getInstance("MD5");
1962         } catch (Exception e) {
1963             System.out.println(e.toString());
1964             e.printStackTrace();
1965             return "";
1966         }
1967         char[] charArray = inStr.toCharArray();
1968         byte[] byteArray = new byte[charArray.length];
1969 
1970         for (int i = 0; i < charArray.length; i++)
1971             byteArray = (byte) charArray;
1972 
1973         byte[] md5Bytes = md5.digest(byteArray);
1974 
1975         StringBuffer hexValue = new StringBuffer();
1976 
1977         for (int i = 0; i < md5Bytes.length; i++) {
1978             int val = ((int) md5Bytes) & 0xff;
1979             if (val < 16)
1980                 hexValue.append("0");
1981             hexValue.append(Integer.toHexString(val));
1982         }
1983 
1984         return hexValue.toString();
1985     }
1986 
1987     //可逆的加密算法
1988     public static String KL(String inStr){
1989         //String s = new String(inStr);
1990         char[] a = inStr.toCharArray();  
1991         for (int i = 0;i )  {  
1992             a = (char)(a^'t');  
1993         }  
1994         String s=new String(a);
1995         return s;  
1996     }
1997     //加密后解密
1998     public static String JM(String inStr){
1999         char[] a=inStr.toCharArray();
2000         for (int i = 0;i )  {  
2001             a= (char)(a^'t');  
2002         }      
2003         String k=new String(a);
2004         return k;
2005     }
2006     //测试主函数
2007     public static void main (String args[]){
2008         String s = new String("admin");
2009         System.out.println("原始："+s);
2010         System.out.println("MD5后："+MD5(s));
2011         System.out.println("MD5后再加密："+KL(MD5(s)));
2012         System.out.println("解密为MD5后的："+JM(KL(MD5(s))));
2013     }
2014 }
2015 [/code]
2016 
2017 
2018 
2019         /**
2020          * 取得服务器当前的各种具体时间
2021          * 回车：日期时间
2022          */
2023 
2024         import java.util.*;
2025 
2026 public class GetNowDate{
2027     Calendar  calendar = null;
2028 
2029     public GetNowDate(){
2030         calendar = Calendar.getInstance();
2031         calendar.setTime(new Date());
2032     }
2033 
2034     public int getYear(){
2035         return calendar.get(Calendar.YEAR);
2036     }
2037 
2038     public int getMonth(){
2039         return 1 + calendar.get(Calendar.MONTH);
2040     }
2041 
2042     public int getDay(){
2043         return calendar.get(Calendar.DAY_OF_MONTH);
2044     }
2045 
2046     public int getHour(){
2047         return calendar.get(Calendar.HOUR_OF_DAY);
2048     }
2049 
2050     public int getMinute(){
2051         return calendar.get(Calendar.MINUTE);
2052     }
2053 
2054     public int getSecond(){
2055         return calendar.get(Calendar.SECOND);
2056     }
2057 
2058     public String getDate(){
2059         return getMonth()+"/"+getDay()+"/"+getYear();
2060     }
2061 
2062     public String getTime(){
2063         return getHour()+":"+getMinute()+":"+getSecond();
2064     }
2065 
2066     public String getDate2(){
2067         String yyyy="0000", mm="00", dd="00";
2068         yyyy = yyyy + getYear();
2069         mm   = mm   + getMonth();
2070         dd   = dd + getDay();
2071         yyyy = yyyy.substring(yyyy.length()-4);
2072         mm   = mm.substring(mm.length()-2);
2073         dd   = dd.substring(dd.length()-2);
2074         return yyyy + "/" + mm + "/" +  dd;
2075     }
2076 
2077     public String getTime2(){
2078         String hh="00", mm="00", ss="00";
2079         hh = hh + getHour();
2080         mm = mm + getMinute();
2081         ss = ss + getSecond();
2082         hh = hh.substring(hh.length()-2, hh.length());
2083         mm = mm.substring(mm.length()-2, mm.length());
2084         ss = ss.substring(ss.length()-2, ss.length());
2085         return hh + ":" + mm + ":" + ss;
2086     }
2087 }
2088 
2089 
2090 
2091 
2092 
2093 /**
2094  * 用半角的特殊符号代替全角的特殊符号
2095  * 防止特殊字符在传输参数时出现错误
2096  *
2097  */
2098 
2099 public class ReplaceStrE{
2100     public static String rightToError(String ss){
2101         String strs;
2102         String strs1;
2103         String strs2;
2104         String strs3;
2105         String strs4;
2106         try{
2107             strs = ss.replace('＃','#');
2108         }
2109         catch(Exception ex){
2110             return ss;
2111         }
2112 
2113         try{
2114             strs1 = strs.replace('＂','"');
2115         }
2116         catch(Exception ex){
2117             return strs;
2118         }
2119 
2120         try{
2121             strs2 = strs1.replace('  ','&');
2122         }
2123         catch(Exception ex){
2124             return strs1;
2125         }
2126 
2127         try{
2128             strs3 = strs2.replace('＋','+');
2129         }
2130         catch(Exception ex){
2131             return strs2;
2132         }
2133 
2134         try{
2135             strs4 = strs3.replace('＇','\'');
2136         }
2137         catch(Exception ex){
2138             return ss;
2139         }
2140         return strs4;
2141     }
2142 }
2143 
2144 
2145 
2146 
2147 /**
2148  * Big5字与Unicode的互换
2149  * 转换后的正常字型
2150  */
2151 
2152 import java.io.*;
2153 
2154 public class MyUtil{
2155     public static String big5ToUnicode(String s){
2156         try{
2157             return new String(s.getBytes("ISO8859_1"), "Big5");
2158         }
2159         catch (UnsupportedEncodingException uee){
2160             return s;
2161         }
2162     }
2163 
2164     public static String UnicodeTobig5(String s){
2165         try{
2166             return new String(s.getBytes("Big5"), "ISO8859_1");
2167         }
2168         catch (UnsupportedEncodingException uee){
2169             return s;
2170         }
2171     }
2172 
2173     public static String toHexString(String s){
2174         String str="";
2175         for (int i=0; i){
2176             int ch=(int)s.charAt(i);
2177             String s4="0000"+Integer.toHexString(ch);
2178             str=str+s4.substring(s4.length()-4)+" ";
2179         }
2180         return str;
2181     }
2182 }
2183 
2184 
2185 
2186 
2187 
2188 import java.io.*;
2189 import java.util.ArrayList;
2190 import java.util.List;
2191 public class FileCopy {
2192     private String message = "";
2193     public String getMessage() {
2194         return message;
2195     }
2196     public void setMessage(String message) {
2197         this.message = message;
2198     }
2199     /**
2200      * 将源文件拷贝到目标文件
2201      *
2202      * @param src
2203      *            写源文件地址，需文件名
2204      * @param des
2205      *            写目标文件地址，无需文件名
2206      */
2207     public boolean copyFile(String src, String des) {
2208         File srcFile = new File(src);
2209         File desDir = new File(des);
2210         File desFile = new File(des + "/" + srcFile.getName());
2211         // 判断源文件是否存在
2212         if (!srcFile.exists()) {
2213             this.setMessage("源文件不存在！");
2214             return false;
2215         } else if (!srcFile.isFile()) {
2216             this.setMessage("源文件格式错！");
2217             return false;
2218         }
2219         // 判断源文件是否存在
2220         if (!desDir.exists()) {
2221             this.setMessage("目标目录不存在！");
2222             return false;
2223         } else if (!desDir.isDirectory()) {
2224             this.setMessage("不是有效的目录！");
2225             return false;
2226         }
2227         BufferedReader reader = null;
2228         BufferedWriter writer = null;
2229         String str;
2230         try {
2231             reader = new BufferedReader(new FileReader(srcFile));
2232             writer = new BufferedWriter(new FileWriter(desFile));
2233             // 判断目标文件是否存在及其格式，不存在就创建，格式不对先删除，存在就替代
2234             if (!desFile.exists() || !desFile.isFile()) {
2235                 if (desFile.exists()) {
2236                     desFile.delete();
2237                 }
2238                 desFile.createNewFile();
2239             }
2240             // 从源文件读取数据，并写入目标文件
2241             str = reader.readLine();
2242             while (str != null) {
2243                 writer.write(str);
2244                 writer.newLine();
2245                 str = reader.readLine();
2246             }
2247         } catch (IOException e) {
2248             this.setMessage(e.getMessage());
2249             return false;
2250         } finally {
2251             if (reader != null) {
2252                 try {
2253                     reader.close();
2254                 } catch (IOException e) {
2255                     this.setMessage(e.getMessage());
2256                 }
2257             }
2258             if (writer != null) {
2259                 try {
2260                     writer.close();
2261                 } catch (IOException e) {
2262                     this.setMessage(e.getMessage());
2263                 }
2264             }
2265         }
2266         return true;
2267     }
2268     private List fileList = new ArrayList();
2269 
2270     /**
2271      * 列出所有文件
2272      * @param srcFile
2273      */
2274     private void file(File srcFile) {
2275         if (srcFile.isDirectory()) {
2276             String[] files = srcFile.list();
2277 
2278             for (int i = 0; i < files.length; i++) {
2279                 File f = new File(srcFile + "/" + files);
2280                 // 如果是文件加入列表，否则递归列出
2281                 if (f.isFile()) {
2282                     fileList.add(f);
2283                 } else
2284                     file(f);
2285             }
2286         }else this.setMessage(srcFile.getAbsolutePath()+"不是目录");
2287     }
2288     /**
2289      * 建立目录
2290      * @param des
2291      * @throws IOException
2292      */private void mkdir(File des) {
2293          if (!des.exists() || !des.isDirectory()) {
2294              mkdir(des.getParentFile());
2295              if (des.exists()) {
2296                  des.delete();
2297              }
2298              des.mkdir();
2299          }
2300      }
2301      /**
2302       * 复制目录  将源目录下所有文件拷贝到目标目录下
2303       * @param src  源目录
2304       * @param des  目标目录
2305       */
2306      public boolean copyDir(String src, String des) {
2307          File srcFile = new File(src);
2308          if (!srcFile.exists()) {
2309              this.setMessage("源目录不存在！");
2310              return false;
2311          } else if (!srcFile.isDirectory()) {
2312              this.setMessage(src+"不是有效的目录！");
2313              return false;
2314          }
2315          file(srcFile);
2316 
2317          for (int i = 0; i < fileList.size(); i++) {
2318              String srcName = ((File) fileList.get(i)).getPath();
2319              String desName = srcName.substring(src.length(), srcName.length());
2320              desName = des + desName;
2321              File dir=new File(desName).getParentFile();
2322              mkdir(dir);
2323 
2324              if(!copyFile(srcName, dir.getPath())){
2325                  return false;
2326              }
2327          }
2328          return true;
2329      }
2330      public static void main(String[] args) {
2331 
2332          FileCopy t = new FileCopy();
2333          System.out.println(t.copyFile("D:/aaa.txt","E:"));
2334          String src="D:/asdf";
2335          String des="E:/adf";
2336          System.out.println(t.copyDir(src, des));
2337          System.out.println(t.getMessage());
2338      }
2339 
2340 }
2341 
2342 
2343 
2344 
2345 /**
2346  * Description: 获取GMT8时间
2347  * @return 将当前时间转换为GMT8时区后的Date
2348  */
2349 public static Date getGMT8Time(){
2350     Date gmt8 = null;
2351     try {
2352         Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT+8"),Locale.CHINESE);
2353         Calendar day = Calendar.getInstance();
2354         day.set(Calendar.YEAR, cal.get(Calendar.YEAR));
2355         day.set(Calendar.MONTH, cal.get(Calendar.MONTH));
2356         day.set(Calendar.DATE, cal.get(Calendar.DATE));
2357         day.set(Calendar.HOUR_OF_DAY, cal.get(Calendar.HOUR_OF_DAY));
2358         day.set(Calendar.MINUTE, cal.get(Calendar.MINUTE));
2359         day.set(Calendar.SECOND, cal.get(Calendar.SECOND));
2360         gmt8 = day.getTime();
2361     } catch (Exception e) {
2362         System.out.println("获取GMT8时间 getGMT8Time() error !");
2363         e.printStackTrace();
2364         gmt8 = null;
2365     }
2366     return  gmt8;
2367 }
2368 
2369 
2370 
2371 
2372 import java.io.File;
2373 import java.io.FileInputStream;
2374 import java.io.FileNotFoundException;
2375 import java.io.IOException;
2376 import java.util.Properties;
2377 /**
2378  * ReadProperties.java
2379  * Description: 读取操作属性配置文件
2380  * @author li.b
2381  * @version 2.0
2382  * Jun 26, 2008
2383  */
2384 public class ReadProperties {
2385 
2386     /**
2387      * Description: 获取属性配置文件
2388      * @param path 资源文件路径
2389      * @return    Properties Object
2390      * @throws FileNotFoundException
2391      * @throws IOException
2392      */
2393     public static Properties getProperties(String path) throws FileNotFoundException, IOException{
2394         Properties props = null;
2395         File file = new File(path);
2396         if(file.exists() && file.isFile()){
2397             props = new Properties();
2398             props.load(new FileInputStream(file));
2399         }else{
2400             System.out.println(file.toString() + "不存在！");
2401         }
2402         return props;
2403     }
2404 
2405     /**
2406      * Description: 从属性文件获取值
2407      * @param props Properties Object
2408      * @param key
2409      * @return 通过key匹配到的value
2410      */
2411     public static String getValue(Properties props,String key,String encod){
2412         String result = "";
2413         String en = "";
2414         String localEN = System.getProperty("file.encoding");
2415         if(encod !=null && !encod.equals("") ){
2416             en = encod;
2417         }else{
2418             en = localEN;
2419         }
2420         try {
2421             key = new String(key.getBytes(en),"ISO-8859-1");
2422             result = props.getProperty(key);
2423             if(!result.equals("")){
2424                 result = new String(result.getBytes("ISO-8859-1"),en);               
2425             }
2426         } catch (Exception e) {
2427         }finally{
2428             if(result == null)result = "";
2429             return result;
2430         }
2431     }
2432 
2433     public static String getValue(Properties props,String key){
2434         return getValue(props, key, "");
2435     }
2436 
2437 }
2438 
2439 
2440 
2441 
2442 
2443 
2444 import java.lang.reflect.Array;
2445 import java.util.Date;
2446 
2447 public class TestCast {
2448 
2449     /**
2450      * @param args
2451      */
2452     //public static void main(String[] args) {
      
2453     /** *//**
2454      *
2455      * 一般情况下数组和数组是不能直接进行转换的,例如:
2456      * Object[] t1={"1","2"};
2457      * String[] t2=(String[])t1;//这里会出现转换错误
2458      *
2459      * 下面提供了一种方式进行转换
2460      */
2461 
2462     //1.0测试一般基础类
2463     /*        Object[] t1={"1","2","3","4","5"};
2464             String[] m1=(String[])TestCast.cast(t1,String.class);
2465              for(int i=0;i*/
2473     //    }
2474 
2475 
2476     /** *//**
2477      * 将数组array转换成clss代表的类型后返回
2478      * @param array 需要转换的数组
2479      * @param clss  要转换成的类型
2480      * @return  转换后的数组
2481      */
2482     public  static Object cast(Object array,Class clss){
2483         if(null==clss)
2484             throw new IllegalArgumentException("argument clss cannot be null");
2485         if(null==array)
2486             throw new IllegalArgumentException("argument array cannot be null");
2487         if(false==array.getClass().isArray())
2488             throw new IllegalArgumentException("argument array must be array");
2489 
2490         Object[] src=(Object[])array;
2491         Object[] dest=(Object[])Array.newInstance(clss, src.length);
2492         System.arraycopy(src, 0, dest, 0, src.length);
2493         return dest;
2494     }
2495 }
2496 
2497 
2498 
2499 
2500 
2501 处理特殊符号的工具类，这个类是从sturts源码里挖出来的
2502 /**
2503  * DealingCharacter.java
2504  * Description:
2505  * @author li.b
2506  * @version 2.0
2507  * Jun 27, 2008
2508  */
2509 public class DealingCharacter {
2510 
2511     /**
2512      * Description: 转译特殊符号标签
2513      * @param value 需要处理的字符串
2514      * @return
2515      */
2516     public static String filter(String value)
2517     {
2518         if(value == null || value.length() == 0)
2519             return value;
2520         StringBuffer result = null;
2521         String filtered = null;
2522         for(int i = 0; i < value.length(); i++)
2523         {
2524             filtered = null;
2525             switch(value.charAt(i))
2526             {
2527             case 60: // '<'
2528             filtered = "<";
2529             break;
2530 
2531             case 62: // '>'
2532             filtered = ">";
2533             break;
2534 
2535             case 38: // '&'
2536                 filtered = "&";
2537                 break;
2538 
2539             case 34: // '"'
2540                 filtered = """;
2541                 break;
2542 
2543             case 39: // '\''
2544                 filtered = "'";
2545                 break;
2546             }
2547             if(result == null)
2548             {
2549                 if(filtered != null)
2550                 {
2551                     result = new StringBuffer(value.length() + 50);
2552                     if(i > 0)
2553                         result.append(value.substring(0, i));
2554                     result.append(filtered);
2555                 }
2556             } else
2557                 if(filtered == null)
2558                     result.append(value.charAt(i));
2559                 else
2560                     result.append(filtered);
2561         }
2562 
2563         return result != null ? result.toString() : value;
2564     }
2565 
2566     public static void main(String[] args) {
2567         System.out.println(DealingCharacter.filter("sdfasfas"));
2568     }
2569 }
2570 
2571 
2572 
2573 
2574 
2575 小标签
2576 import java.io.IOException;
2577 import java.util.List;
2578 
2579 import javax.servlet.jsp.JspException;
2580 import javax.servlet.jsp.tagext.TagSupport;
2581 
2582 import com.formcontent.show.ShowFormTypeOperateDb;
2583 import com.forum.hibernatePrj.Space;
2584 public class OutPrintForumType extends TagSupport{
2585     public int doStartTag() throws JspException
2586     {
2587         String printStr="";
2588         ShowFormTypeOperateDb showtype=new ShowFormTypeOperateDb();
2589         List list=showtype.getForumType();
2590         if(list!=null&&list.size()>0)
2591         {
2592 
2593             for(int i=0;i )
2594             {
2595                 Space space=(Space)list.get(i);
2596                 if(space!=null)
2597                 {
2598                     printStr+="  "+" 
"+
2599 
2600       space.getSpaceName()+"  "+space.getSpaceDescription()+" 
目前登陆总人数:"+i+"    人访问数:"+i+"人 
  "
2601       +"    ";
2602                 }
2603             }
2604         }
2605         try {
2606             pageContext.getOut().write(printStr);
2607         } catch (IOException e) {
2608             e.printStackTrace();
2609         }
2610         return super.doStartTag();
2611     }
2612 
2613 }
2614 
2615 
2616 
2617 
2618 
2619 
2620 正则表达式用于字符串处理、表单验证等场合，实用高效。现将一些常用的表达式收集于此，以备不时之需。
2621 
2622 匹配中文字符的正则表达式： [\u4e00-\u9fa5]
2623         评注：匹配中文还真是个头疼的事，有了这个表达式就好办了
2624 
2625         匹配双字节字符(包括汉字在内)：[^\x00-\xff]
2626                 评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
2627 
2628                 匹配空白行的正则表达式：\n\s*\r
2629                 评注：可以用来删除空白行
2630 
2631                 匹配HTML标记的正则表达式： <(\S*?)[^>]*>.*?  | <.*? />
2632                 评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力
2633 
2634                 匹配首尾空白字符的正则表达式：^\s* |\s*$
2635                 评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式
2636 
2637                 匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
2638                 评注：表单验证时很实用
2639 
2640                 匹配网址URL的正则表达式：[a-zA-z]+://[^\s]*
2641                     评注：网上流传的版本功能很有限，上面这个基本可以满足需求
2642 
2643                     匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
2644                     评注：表单验证时很实用
2645 
2646                     匹配国内电话号码：\d{3}-\d{8} |\d{4}-\d{7}
2647                     评注：匹配形式如 0511-4405222 或 021-87888822
2648 
2649                     匹配腾讯QQ号：[1-9][0-9]{4,}
2650                     评注：腾讯QQ号从10000开始
2651 
2652                     匹配中国邮政编码：[1-9]\d{5}(?!\d)
2653                     评注：中国邮政编码为6位数字
2654 
2655                     匹配身份证：\d{15} |\d{18}
2656                     评注：中国的身份证为15位或18位
2657 
2658                     匹配ip地址：\d+\.\d+\.\d+\.\d+
2659                     评注：提取ip地址时有用
2660 
2661                     匹配特定数字：
2662                     ^[1-9]\d*$　 　 //匹配正整数
2663                     ^-[1-9]\d*$ 　 //匹配负整数
2664                     ^-?[1-9]\d*$　　 //匹配整数
2665                             ^[1-9]\d* |0$　 //匹配非负整数（正整数 + 0）
2666                             ^-[1-9]\d* |0$　　 //匹配非正整数（负整数 + 0）
2667                             ^[1-9]\d*\.\d* |0\.\d*[1-9]\d*$　　 //匹配正浮点数
2668                             ^-([1-9]\d*\.\d* |0\.\d*[1-9]\d*)$　 //匹配负浮点数
2669                             ^-?([1-9]\d*\.\d* |0\.\d*[1-9]\d* |0?\.0+ |0)$　 //匹配浮点数
2670                                     ^[1-9]\d*\.\d* |0\.\d*[1-9]\d* |0?\.0+ |0$　　 //匹配非负浮点数（正浮点数 + 0）
2671                                             ^(-([1-9]\d*\.\d* |0\.\d*[1-9]\d*)) |0?\.0+ |0$　　//匹配非正浮点数（负浮点数 + 0）
2672                                                     评注：处理大量数据时有用，具体应用时注意修正
2673 
2674                                                     匹配特定字符串：
2675                                                     ^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串
2676                                                     ^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串
2677                                                     ^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串
2678                                                     ^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串
2679                                                     ^\w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串
2680 
2681 
2682 
2683 
2684                                                     /**
2685                                                      * 将数组转成字符串 在调试或记录日志时用到
2686                                                      *
2687                                                      * @param array
2688                                                      * @return
2689                                                      */
2690                                                     public static String byte2string(byte[] array) {
2691                         StringBuilder sb = new StringBuilder();
2692 
2693                         sb.append("Length " + array.length + " Content ");
2694 
2695                         for (int i = 0; i < leng; i++) {
2696                             sb = sb.append(String.format("%02X", array)).append(":");
2697                         }
2698                         int ind = sb.lastIndexOf(":");
2699                         sb.delete(ind, ind + 1);
2700                         return sb.toString();
2701                     }
2702 
2703 
2704 
2705 
2706 
2707                     import java.util.Arrays;
2708                     import java.util.Random;
2709 
2710                     /**
2711                      * RandomUtil - Random Tool Class.
2712                      * @author SageZk
2713                      * @version 1.0
2714                      */
2715                     public class RandomUtil {
2716 
2717                         private RandomUtil() {}
2718 
2719                         private static Random rnd = null;
2720 
2721                         /**
2722                          * 初始化随机数发生器。
2723                          */
2724                         private static void initRnd() {
2725                             if (rnd == null) rnd = new Random();
2726                         }
2727 
2728                         /**
2729                          * 计算并返回无重复值的以 min 为下限 max 为上限的随机整数数组。
2730                          * @param min 随机整数下限（包含）
2731                          * @param max 随机整数上限（包含）
2732                          * @param len 结果数组长度
2733                          * @return 结果数组
2734                          */
2735                         public static int[] getLotteryArray(int min, int max, int len) {
2736                             //参数校验及性能优化
2737                             if (len < 0) return null;  //长度小于 0 的数组不存在
2738                             if (len == 0) return new int[0];  //返回长度为 0 的数组
2739                             if (min > max) {  //校正参数 min max
2740                                 int t = min;
2741                                 min = max;
2742                                 max = t;
2743                             }
2744                             final int LEN = max - min + 1;  //种子个数
2745                             if (len > LEN) return null;  //如果出现 35 选 36 的情况就返回 null
2746                             //计算无重复值随机数组
2747                             initRnd();  //初始化随机数发生器
2748                             int[] seed = new int[LEN];  //种子数组
2749                             for (int i = 0, n = min; i < LEN;) seed[i++] = n++;  //初始化种子数组
2750                             for (int i = 0, j = 0, t = 0; i < len; ++i) {
2751                                 j = rnd.nextInt(LEN - i) + i;
2752                                 t = seed;
2753                                 seed = seed[j];
2754                                 seed[j] = t;
2755                             }
2756                             return Arrays.copyOf(seed, len);  //注意：copyOf 需要 JRE1.6
2757                         }
2758 
2759                         //Unit Testing
2760                         public static void main(String[] args) {
2761                             final int N = 10000;  //测试次数
2762                             for (int i = 0; i < N; ++i) {
2763                                 int[] la = RandomUtil.getLotteryArray(1, 35, 7);
2764                                 if (la == null) continue;
2765                                 for (int v : la) System.out.printf("%0$02d ", v);
2766                                 System.out.println();
2767                             }
2768                         }
2769 
2770                     }
2771 
2772 
2773 
2774 
2775 
2776                     /*
2777 操作属性文件，可以为我们的程序带来更方便的移植性，下面是一个示例，可以读、写、更改属性
2778 读采用了两种方式，一种是采用Properties类，另外一种是采用资源绑定类ResourceBundle类，
2779 下面是源程序，里面有详细的注释：
2780                      */
2781                     import java.io.FileInputStream;
2782                     import java.io.FileOutputStream;
2783                     import java.io.InputStream;
2784                     import java.util.Properties;
2785                     import java.util.ResourceBundle;
2786                     /**
2787                      *对属性文件（xx.properties）的操作
2788                      *注：属性文件一定要放在当前工程的根目录下，也就是放在与src目录在同一个目录下（我的JDevelop
2789                      *是这样的）
2790                      */
2791                     public class OperatePropertiesFile {
2792                         public OperatePropertiesFile() {
2793                         }
2794                         /**
2795                          *采用Properties类取得属性文件对应值
2796                          *@parampropertiesFileNameproperties文件名，如a.properties
2797                          *@parampropertyName属性名
2798                          *@return根据属性名得到的属性值，如没有返回""
2799                          */
2800                         public static String getValueByPropertyName(String propertiesFileName,String propertyName) {
2801                             String s="";
2802                             Properties p=new Properties();//加载属性文件读取类
2803                             FileInputStream in;
2804                             try {
2805                                 //propertiesFileName如test.properties
2806                                 in = new FileInputStream(propertiesFileName);//以流的形式读入属性文件
2807                                 p.load(in);//属性文件将该流加入的可被读取的属性中
2808                                 in.close();//读完了关闭
2809                                 s=p.getProperty(propertyName);//取得对应的属性值
2810                             } catch (Exception e) {
2811                                 e.printStackTrace();
2812                             }
2813                             return s;
2814                         }
2815                         /**
2816                          *采用ResourceBundel类取得属性文件对应值，这个只能够读取，不可以更改及写新的属性
2817                          *@parampropertiesFileNameWithoutPostfixproperties文件名，不带后缀
2818                          *@parampropertyName属性名
2819                          *@return根据属性名得到的属性值，如没有返回""
2820                          */
2821                         public static String getValueByPropertyName_(String propertiesFileNameWithoutPostfix,String propertyName) {
2822                             String s="";
2823                             //如属性文件是test.properties，那此时propertiesFileNameWithoutPostfix的值就是test
2824                             ResourceBundle bundel = ResourceBundle.getBundle(propertiesFileNameWithoutPostfix);
2825                             s=bundel.getString(propertyName);
2826                             return s;
2827                         }
2828                         /**
2829                          *更改属性文件的值，如果对应的属性不存在，则自动增加该属性
2830                          *@parampropertiesFileNameproperties文件名，如a.properties
2831                          *@parampropertyName属性名
2832                          *@parampropertyValue将属性名更改成该属性值
2833                          *@return是否操作成功
2834                          */
2835                         public static boolean changeValueByPropertyName(String propertiesFileName,String propertyName,String propertyValue) {
2836                             boolean writeOK=true;
2837                             Properties p=new Properties();
2838                             InputStream in;
2839                             try {
2840 
2841                                 in = new FileInputStream(propertiesFileName);
2842                                 p.load(in);//
2843                                 in.close();
2844                                 p.setProperty(propertyName,propertyValue);//设置属性值，如不属性不存在新建
2845                                 //p.setProperty("testProperty","testPropertyValue");
2846                                 FileOutputStream out=new FileOutputStream(propertiesFileName);//输出流
2847                                 p.store(out,"");//设置属性头，如不想设置，请把后面一个用""替换掉
2848                                 out.flush();//清空缓存，写入磁盘
2849                                 out.close();//关闭输出流
2850                             } catch (Exception e) {
2851                                 e.printStackTrace();
2852                             }
2853                             return writeOK;
2854                         }
2855                     }
2856 
2857 
2858 
2859 
2860                     /**
2861                      * 如果是null，则返回空字符串，如果是非空值则返回该字符串头尾不为空白字符的字符串
2862                      *
2863                      * @param str
2864                      */
2865                     public static String toNoNullTrimedString(String str) {
2866                         if (str == null) {
2867                             return "";
2868                         }
2869                         return new String(str.trim());
2870                     }
2871 
2872                     /**
2873                      * 如果是null，则返回空字符串，如果是非空值则返回该对象所toString后的字符串
2874                      *
2875                      * @param obj
2876                      */
2877                     public static String toNoNullString(Object obj) {
2878                         if (obj == null)
2879                             return "";
2880                         return obj.toString();
2881                     }
2882 
2883                     /**
2884                      * 本方法把一个Throwable的StackTrace作为一个字符串输出，以利于对StackTrace的操作。

2885                      * 通常用于把抛出的Exception转化成字符串进行后续操作。
2886                      */
2887                     public static String exceptionToStackTrace(Throwable throwable) {
2888                         StringBuffer retu = new StringBuffer();
2889                         StackTraceElement[] traces = throwable.getStackTrace();
2890                         for (StackTraceElement ste : traces) {
2891                             retu.append("\n").append(ste.toString());
2892                         }
2893                         return retu.substring(1);
2894                     }
2895 
2896 
2897 
2898 
2899 
2900                     package com.sipgl.eam.utils;
2901 
2902                     import java.text.SimpleDateFormat;
2903                     import java.util.ArrayList;
2904                     import java.util.Calendar;
2905                     import java.util.Date;
2906                     import java.util.GregorianCalendar;
2907                     import java.util.LinkedHashMap;
2908 
2909                     /**
2910                      * 日期公用处理类
2911                      *
2912                      * @author SongJun
2913                      * @version 1.3
2914                      */
2915                     public class DateUtil {
2916                         /**
2917                          * 解析一个日期之间的所有月份
2918                          *
2919                          * @param beginDateStr
2920                          * @param endDateStr
2921                          * @return
2922                          */
2923                         public static ArrayList getMonthList(String beginDateStr, String endDateStr) {
2924                             // 指定要解析的时间格式
2925                             SimpleDateFormat f = new SimpleDateFormat("yyyy-MM");
2926                             // 返回的月份列表
2927                             String sRet = "";
2928 
2929                             // 定义一些变量
2930                             Date beginDate = null;
2931                             Date endDate = null;
2932 
2933                             GregorianCalendar beginGC = null;
2934                             GregorianCalendar endGC = null;
2935                             ArrayList list = new ArrayList();
2936 
2937                             try {
2938                                 // 将字符串parse成日期
2939                                 beginDate = f.parse(beginDateStr);
2940                                 endDate = f.parse(endDateStr);
2941 
2942                                 // 设置日历
2943                                 beginGC = new GregorianCalendar();
2944                                 beginGC.setTime(beginDate);
2945 
2946                                 endGC = new GregorianCalendar();
2947                                 endGC.setTime(endDate);
2948 
2949                                 // 直到两个时间相同
2950                                 while (beginGC.getTime().compareTo(endGC.getTime()) <= 0) {
2951                                     sRet = beginGC.get(Calendar.YEAR) + "-"
2952                                             + (beginGC.get(Calendar.MONTH) + 1);
2953                                     list.add(sRet);
2954                                     // 以月为单位，增加时间
2955                                     beginGC.add(Calendar.MONTH, 1);
2956                                 }
2957                                 return list;
2958                             } catch (Exception e) {
2959                                 e.printStackTrace();
2960                                 return null;
2961                             }
2962                         }
2963 
2964                         /**
2965                          * 解析一个日期段之间的所有日期
2966                          *
2967                          * @param beginDateStr
2968                          *            开始日期
2969                          * @param endDateStr
2970                          *            结束日期
2971                          * @return
2972                          */
2973                         public static ArrayList getDayList(String beginDateStr, String endDateStr) {
2974                             // 指定要解析的时间格式
2975                             SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");
2976 
2977                             // 定义一些变量
2978                             Date beginDate = null;
2979                             Date endDate = null;
2980 
2981                             Calendar beginGC = null;
2982                             Calendar endGC = null;
2983                             ArrayList list = new ArrayList();
2984 
2985                             try {
2986                                 // 将字符串parse成日期
2987                                 beginDate = f.parse(beginDateStr);
2988                                 endDate = f.parse(endDateStr);
2989 
2990                                 // 设置日历
2991                                 beginGC = Calendar.getInstance();
2992                                 beginGC.setTime(beginDate);
2993 
2994                                 endGC = Calendar.getInstance();
2995                                 endGC.setTime(endDate);
2996                                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
2997 
2998                                 // 直到两个时间相同
2999                                 while (beginGC.getTime().compareTo(endGC.getTime()) <= 0) {
3000 
3001                                     list.add(sdf.format(beginGC.getTime()));
3002                                     // 以日为单位，增加时间
3003                                     beginGC.add(Calendar.DAY_OF_MONTH, 1);
3004                                 }
3005                                 return list;
3006                             } catch (Exception e) {
3007                                 e.printStackTrace();
3008                                 return null;
3009                             }
3010                         }
3011 
3012                         public static ArrayList getYearList() {
3013                             ArrayList list = new ArrayList();
3014                             Calendar c = null;
3015                             c = Calendar.getInstance();
3016                             c.setTime(new Date());
3017                             int currYear = Calendar.getInstance().get(Calendar.YEAR);
3018 
3019                             int startYear = currYear - 5;
3020                             int endYear = currYear + 10;
3021                             for (int i = startYear; i < endYear; i++) {
3022                                 list.add(new Integer(i));
3023                             }
3024                             return list;
3025                         }
3026 
3027                         public static int getCurrYear() {
3028                             return Calendar.getInstance().get(Calendar.YEAR);
3029                         }
3030 
3031                         /**
3032                          * 得到某一年周的总数
3033                          *
3034                          * @param year
3035                          * @return
3036                          */
3037                         public static LinkedHashMap getWeekList(int year) {
3038                             LinkedHashMap map = new LinkedHashMap();
3039                             Calendar c = new GregorianCalendar();
3040                             c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
3041                             int count = getWeekOfYear(c.getTime());
3042 
3043                             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
3044                             String dayOfWeekStart = "";
3045                             String dayOfWeekEnd = "";
3046                             for (int i = 1; i <= count; i++) {
3047                                 dayOfWeekStart = sdf.format(getFirstDayOfWeek(year, i));
3048                                 dayOfWeekEnd = sdf.format(getLastDayOfWeek(year, i));
3049                                 map.put(new Integer(i), "第"+i+"周(从"+dayOfWeekStart + "至" + dayOfWeekEnd+")");
3050                             }
3051                             return map;
3052 
3053                         }
3054 
3055                         /**
3056                          * 得到一年的总周数
3057                          * @param year
3058                          * @return
3059                          */
3060                         public static int getWeekCountInYear(int year){
3061                             Calendar c = new GregorianCalendar();
3062                             c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
3063                             int count = getWeekOfYear(c.getTime());
3064                             return count;
3065                         }
3066 
3067                         /**
3068                          * 取得当前日期是多少周
3069                          *
3070                          * @param date
3071                          * @return
3072                          */
3073                         public static int getWeekOfYear(Date date) {
3074                             Calendar c = new GregorianCalendar();
3075                             c.setFirstDayOfWeek(Calendar.MONDAY);
3076                             c.setMinimalDaysInFirstWeek(7);
3077                             c.setTime(date);
3078 
3079                             return c.get(Calendar.WEEK_OF_YEAR);
3080                         }
3081 
3082                         /**
3083                          * 得到某年某周的第一天
3084                          *
3085                          * @param year
3086                          * @param week
3087                          * @return
3088                          */
3089                         public static Date getFirstDayOfWeek(int year, int week) {
3090                             Calendar c = new GregorianCalendar();
3091                             c.set(Calendar.YEAR, year);
3092                             c.set(Calendar.MONTH, Calendar.JANUARY);
3093                             c.set(Calendar.DATE, 1);
3094 
3095                             Calendar cal = (GregorianCalendar) c.clone();
3096                             cal.add(Calendar.DATE, week * 7);
3097 
3098                             return getFirstDayOfWeek(cal.getTime());
3099                         }
3100 
3101                         /**
3102                          * 得到某年某周的最后一天
3103                          *
3104                          * @param year
3105                          * @param week
3106                          * @return
3107                          */
3108                         public static Date getLastDayOfWeek(int year, int week) {
3109                             Calendar c = new GregorianCalendar();
3110                             c.set(Calendar.YEAR, year);
3111                             c.set(Calendar.MONTH, Calendar.JANUARY);
3112                             c.set(Calendar.DATE, 1);
3113 
3114                             Calendar cal = (GregorianCalendar) c.clone();
3115                             cal.add(Calendar.DATE, week * 7);
3116 
3117                             return getLastDayOfWeek(cal.getTime());
3118                         }
3119 
3120                         /**
3121                          * 得到某年某月的第一天
3122                          * @param year
3123                          * @param month
3124                          * @return
3125                          */
3126                         public static Date getFirestDayOfMonth(int year,int month){
3127                             month = month-1;
3128                             Calendar   c   =   Calendar.getInstance();   
3129                             c.set(Calendar.YEAR, year);
3130                             c.set(Calendar.MONTH, month);
3131 
3132                             int day = c.getActualMinimum(c.DAY_OF_MONTH);
3133 
3134                             c.set(Calendar.DAY_OF_MONTH, day);
3135                             return c.getTime();
3136 
3137                         }
3138 
3139                         /**
3140                          * 提到某年某月的最后一天
3141                          * @param year
3142                          * @param month
3143                          * @return
3144                          */
3145                         public static Date getLastDayOfMonth(int year,int month){
3146                             month = month-1;
3147                             Calendar   c   =   Calendar.getInstance();   
3148                             c.set(Calendar.YEAR, year);
3149                             c.set(Calendar.MONTH, month);
3150                             int day = c.getActualMaximum(c.DAY_OF_MONTH);
3151                             c.set(Calendar.DAY_OF_MONTH, day);
3152                             return c.getTime();
3153                         }
3154 
3155                         /**
3156                          * 取得当前日期所在周的第一天
3157                          *
3158                          * @param date
3159                          * @return
3160                          */
3161                         public static Date getFirstDayOfWeek(Date date) {
3162                             Calendar c = new GregorianCalendar();
3163                             c.setFirstDayOfWeek(Calendar.MONDAY);
3164                             c.setTime(date);
3165                             c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday
3166                             return c.getTime();
3167                         }
3168 
3169                         /**
3170                          * 取得当前日期所在周的最后一天
3171                          *
3172                          * @param date
3173                          * @return
3174                          */
3175                         public static Date getLastDayOfWeek(Date date) {
3176                             Calendar c = new GregorianCalendar();
3177                             c.setFirstDayOfWeek(Calendar.MONDAY);
3178                             c.setTime(date);
3179                             c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6); // Sunday
3180                             return c.getTime();
3181                         }
3182 
3183                     }
3184 
3185 
3186 
3187 
3188 
3189 
3190                     /**
3191                      * 为RootPaneContainer组件添加键盘事件
3192                      * @param rpc RootPaneContainer组件
3193                      * @param action 需要执行的动作
3194                      * @param keyName 键的名称
3195                      * @param keyCode 键的数字代码
3196                      * @param modifiers 任意修饰符的按位或组合
3197                      */
3198                     public static void registerKeyEvent(RootPaneContainer rpc, Action action, String keyName, int keyCode, int modifiers)
3199                     {
3200                         JRootPane rp = rpc.getRootPane();
3201                         InputMap inputMap = rp.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
3202                         inputMap.put(KeyStroke.getKeyStroke(keyCode, modifiers), keyName);
3203                         rp.getActionMap().put(keyName, action);
3204                     }
3205 
3206                     // 判断一个文件是否为二进制文件
3207                     public static boolean isBinary(File file) {
3208                         boolean isBinary = false;
3209                         try {
3210                             FileInputStream fin = new FileInputStream(file);
3211                             long len = file.length();
3212                             for (int j = 0; j < (int) len; j++) {
3213                                 int t = fin.read();
3214                                 if (t < 32 && t != 9 && t != 10 && t != 13) {
3215                                     isBinary = true;
3216                                     break;
3217                                 }
3218                             }
3219                         } catch (Exception e) {
3220                             e.printStackTrace();
3221                         }
3222                         return isBinary;
3223                     }

 

转载于:https://www.cnblogs.com/lichone2010/archive/2013/06/08/3127835.html