JAVA常用函数3

单例模式代码
public   class  Singleton
{
     private  Singleton()
    {
    }

     synchronized   public   static  Singleton getInstance()
    {
         if  (m_instance  ==   null )
        {
            m_instance  =   new  Singleton();
        }
         return  m_instance;
    }

     /**
     * @label Creates
      */
     private   static  Singleton m_instance  =   null ;
}

一个简单的字符串过滤函数，常用来判断字符串是否为空
public   static  String trim(String str)
{
    if (str == null )
      str = "" ;
    if ( ! str.equals( "" ))
      str = str.trim();
    return  str;
}


Java日期格式化及其使用例子 
1  SimpleDateFormat担当重任,怎样格式化都行 

import  java.util.Date; 
import  java.text.SimpleDateFormat; 
public   class  Demo 
{ 
public   static   void  main(String[] args) 
{ 
  Date now = new  Date(); 
  SimpleDateFormat f = newSimpleDateFormat( " 今天是 " + " yyyy年MM月dd日 E kk点mm分 " ); 
  System.out.println(f.format(now)); 
  
  f = new  SimpleDateFormat( " a hh点mm分ss秒 " ); 
  System.out.println(f.format(now)); 
  } 
} 


2  从字符串到日期类型的转换： 

import  java.util.Date; 
import  java.text.SimpleDateFormat; 
import  java.util.GregorianCalendar; 
import  java.text. * ; 
publicclass Demo 
{ 
public   static   void  main(String[] args) 
{ 
  String strDate = " 2005年04月22日 " ; 
   // 注意：SimpleDateFormat构造函数的样式与strDate的样式必须相符 
  SimpleDateFormat simpleDateFormat = new  SimpleDateFormat( " yyyy年MM月dd日 " ); 
   // 必须捕获异常 

   try  
  { 
  Date date = simpleDateFormat.parse(strDate); 
  System.out.println(date); 
  } 
   catch (ParseException px) 
  { 
  px.printStackTrace(); 
  } 
} 
} 


3  将毫秒数换转成日期类型 

import  java.util.Date; 
import  java.text.SimpleDateFormat; 
import  java.util.GregorianCalendar; 
import  java.text. * ; 
public   class  Demo 
{ 
public   static   void  main(String[] args) 
{ 
   long  now = System.currentTimeMillis(); 
  System.out.println( " 毫秒数： " + now); 
  Date dNow = new  Date(now); 
  System.out.println( " 日期类型： " + dNow); 
} 
} 


这3例源自http: // blog.csdn.net/zhoujian2003/archive/2005/04/22/358363.aspx 

4  获取系统时期和时间，转换成SQL格式后更新到数据库 
(http: // blog.csdn.net/netrope/archive/2005/11/19/532729.aspx) 

java.util.Date d = new  java.util.Date();     // 获取当前系统的时间 

// 格式化日期 

new  java.text.SimpleDateFormat s =   new  java.text.SimpleDateFormat( " yyyy-MM-dd HH:mm:ss " ); 

String dateStr  =  s.format(d);  // 转为字符串 

使用RS更新数据库，仍然要用rs.updateString，而不是rs.updateDade。 
rs.updateString( " regtime " ,dateStr);   // regtime字段为datetime类型的 
下面两例源自 http: // blog.csdn.net/kingter520/archive/2004/10/27/155435.aspx 

5  按本地时区输出当前日期 

Date myDate  =   new  Date(); 
System.out.println(myDate.toLocaleString()); 
输出结果为： 
2003 - 5 - 30  


6  如何格式化小数 

DecimalFormat df  =   new  DecimalFormat( " ,###.00 " );  
double  aNumber  =   33665448856.6568975 ; 
String result  =  df.format(aNumber);  
Sytem. out.println(result); 


输出结果为： 
33 , 665 , 448 , 856.66  

其他：获取毫秒时间 System.currentTimeMillis(); 

7  在数据库里的日期只以年 - 月 - 日的方式输出 
(http: // blog.csdn.net/zzsxvzzsxv/archive/2007/08/27/1761004.aspx) 
定义日期格式：SimpleDateFormat sdf  =   new  SimpleDateFormat(yy - MM - dd); 
sql语句为：String sqlStr  =   " select bookDate from roomBook where bookDate between '2007-4-10' and '2007-4-25' " ; 
输出： 
System.out.println(df.format(rs.getDate( " bookDate " )));

字符串 
1 、获取字符串的长度 
length() 
2  、判断字符串的前缀或后缀与已知字符串是否相同 
前缀 startsWith(String s) 
后缀 endsWith(String s) 
3 、比较两个字符串 
equals(String s) 
4 、把字符串转化为相应的数值 
int型 Integer.parseInt(字符串) 
long型 Long.parseLong(字符串) 
float型 Folat.valueOf(字符串).floatValue() 
double型 Double.valueOf(字符串).doubleValue() 
4 、将数值转化为字符串 
valueOf(数值) 
5 、字符串检索 
indexOf(Srting s) 从头开始检索 
indexOf(String s , int  startpoint) 从startpoint处开始检索 
如果没有检索到，将返回 - 1  
6 、得到字符串的子字符串 
substring( int  startpoint) 从startpoint处开始获取 
substring( int  start, int  end) 从start到end中间的字符 
7 、替换字符串中的字符,去掉字符串前后空格 
replace( char  old, char   new ) 用new替换old 
trim() 
8 、分析字符串 
StringTokenizer(String s) 构造一个分析器，使用默认分隔字符（空格，换行，回车，Tab，进纸符） 
StringTokenizer(String s,String delim) delim是自己定义的分隔符 
nextToken() 逐个获取字符串中的语言符号 
boolean  hasMoreTokens() 只要字符串还有语言符号将返回true，否则返回false 
countTokens() 得到一共有多少个语言符号 

Java中的鼠标和键盘事件 
1 、使用MouseListener借口处理鼠标事件 
鼠标事件有5种：按下鼠标键，释放鼠标键，点击鼠标键，鼠标进入和鼠标退出 
鼠标事件类型是MouseEvent，主要方法有： 
getX(),getY() 获取鼠标位置 
getModifiers() 获取鼠标左键或者右键 
getClickCount() 获取鼠标被点击的次数 
getSource() 获取鼠标发生的事件源 
事件源获得监视器的方法是addMouseListener()，移去监视器的方法是removeMouseListener() 
处理事件源发生的时间的事件的接口是MouseListener 接口中有如下的方法 
mousePressed(MouseEvent) 负责处理鼠标按下事件 
mouseReleased(MouseEvent) 负责处理鼠标释放事件 
mouseEntered(MouseEvent) 负责处理鼠标进入容器事件 
mouseExited(MouseEvent) 负责处理鼠标离开事件 
mouseClicked(MouseEvent) 负责处理点击事件 
2 、使用MouseMotionListener接口处理鼠标事件 
事件源发生的鼠标事件有2种：拖动鼠标和鼠标移动 
鼠标事件的类型是MouseEvent 
事件源获得监视器的方法是addMouseMotionListener() 
处理事件源发生的事件的接口是MouseMotionListener 接口中有如下的方法 
mouseDragged() 负责处理鼠标拖动事件 
mouseMoved() 负责处理鼠标移动事件 
3 、控制鼠标的指针形状 
setCursor(Cursor.getPreddfinedCursor(Cursor.鼠标形状定义)) 鼠标形状定义见（书 P  210 ） 
4 、键盘事件 
键盘事件源使用addKeyListener 方法获得监视器 
键盘事件的接口是KeyListener 接口中有3个方法 
public   void  keyPressed(KeyEvent e) 按下键盘按键 
public   void  keyReleased(KeyEvent e) 释放键盘按键 
public   void  keyTypde(KeyEvent e) 按下又释放键盘按键


  public   class  IsChineseOrEnglish {
  //   GENERAL_PUNCTUATION 判断中文的“号
  //   CJK_SYMBOLS_AND_PUNCTUATION 判断中文的。号
  //   HALFWIDTH_AND_FULLWIDTH_FORMS 判断中文的，号
    public   static   boolean  isChinese( char  c) {
      Character.UnicodeBlock ub  =  Character.UnicodeBlock.of(c);  
       if  (ub  ==  Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
         ||  ub  ==  Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
         ||  ub  ==  Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
         ||  ub  ==  Character.UnicodeBlock.GENERAL_PUNCTUATION 
         ||  ub  ==  Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
         ||  ub  ==  Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS){
        return   true ;
      }
       return   false ;
   }
    public   static   void  isChinese(String strName) {
       char [] ch  =  strName.toCharArray();
       for  ( int  i  =   0 ; i  <  ch.length; i ++ ) {
     char  c  =  ch[i];
     if (isChinese(c) == true ){
     System.out.println(isChinese(c));
     return ;
   } else {
     System.out.println(isChinese(c));
      return  ;
    }
   }
   }
   
    public   static   void  main(String[] args){

    isChinese( " zhongguo " );
    isChinese( " 中国 " );
  }

 }


MD5和一个可逆加密算法相接合的加密和解密程序 

import  java.security.MessageDigest; 
/**  
*先通过MD5加密之后，再来一次可逆的加密。 
*顺序可以调整，可以选择先用可逆加密，然后再用MD5加密 
*/  
public   class  MD5andKL{ 
// MD5加码。32位 
public   static  String MD5(String inStr) { 
MessageDigest md5  =   null ; 
try  { 
md5  =  MessageDigest.getInstance( " MD5 " ); 
}  catch  (Exception e) { 
System.out.println(e.toString()); 
e.printStackTrace(); 
return   "" ; 
} 
char [] charArray  =  inStr.toCharArray(); 
byte [] byteArray  =   new   byte [charArray.length]; 

for  ( int  i  =   0 ; i  <  charArray.length; i ++ ) 
byteArray[i]  =  ( byte ) charArray[i]; 

byte [] md5Bytes  =  md5.digest(byteArray); 

StringBuffer hexValue  =   new  StringBuffer(); 

for  ( int  i  =   0 ; i  <  md5Bytes.length; i ++ ) { 
int  val  =  (( int ) md5Bytes[i])  &   0xff ; 
if  (val  <   16 ) 
hexValue.append( " 0 " ); 
hexValue.append(Integer.toHexString(val)); 
} 

return  hexValue.toString(); 
} 

// 可逆的加密算法 
public   static  String KL(String inStr){ 
// String s = new String(inStr); 
char [] a  =  inStr.toCharArray();  
   for  ( int  i  =   0 ;i  < a.length;i ++ )  {  
  a[i]  =  ( char )(a[i] ^ ' t ' );  
  }  
  String s = new  String(a); 
   return  s;  
} 
// 加密后解密 
public   static  String JM(String inStr){ 
char [] a = inStr.toCharArray(); 
for  ( int  i  =   0 ;i  < a.length;i ++ )  {  
a[i] =  ( char )(a[i] ^ ' t ' );  
  }      
  String k = new  String(a); 
   return  k; 
} 
// 测试主函数 
public   static   void  main (String args[]){ 
String s  =   new  String( " admin " ); 
System.out.println( " 原始： " + s); 
System.out.println( " MD5后： " + MD5(s)); 
System.out.println( " MD5后再加密： " + KL(MD5(s))); 
System.out.println( " 解密为MD5后的： " + JM(KL(MD5(s)))); 
} 
} 


     import  java.beans.IntrospectionException;
     import  java.beans.Introspector;
     import  java.beans.PropertyDescriptor;
     import  java.math.BigDecimal;
     import  java.math.BigInteger;
     import  java.util.List;
     import  java.util.Map;
     import  java.util.Set;
     /**
     * 序列化对象为JSON格式 遵循JSON组织公布标准
     * 
     * @date 2008/05/07
     *  @version  1.0.0
      */
     public   class  Json {
         /**  Commons Logging instance.  */
         private   static  org.apache.commons.logging.Log log  =  org.apache.commons.logging.LogFactory.getLog(Json. class );
         /**
         *  @param  obj 任意对象
         *  @return  String
          */
         public   static  String object2json(Object obj) {
            StringBuilder json  =   new  StringBuilder();
             if  (obj  ==   null ) {
                json.append( " \ " \ "" );
            }  else   if  (obj  instanceof  String  ||  obj  instanceof  Integer  ||  obj  instanceof  Float  ||  obj  instanceof  Boolean
                     ||  obj  instanceof  Short  ||  obj  instanceof  Double  ||  obj  instanceof  Long  ||  obj  instanceof  BigDecimal
                     ||  obj  instanceof  BigInteger  ||  obj  instanceof  Byte) {
                json.append( " \ "" ).append(string2json(obj.toString())).append( " \ "" );
            }  else   if  (obj  instanceof  Object[]) {
                json.append(array2json((Object[]) obj));
            }  else   if  (obj  instanceof  List) {
                json.append(list2json((List <?> ) obj));
            }  else   if  (obj  instanceof  Map) {
                json.append(map2json((Map <? ,  ?> ) obj));
            }  else   if  (obj  instanceof  Set) {
                json.append(set2json((Set <?> ) obj));
            }  else  {
                json.append(bean2json(obj));
            }
             return  json.toString();
        }
         /**
         *  @param  bean bean对象
         *  @return  String
          */
         public   static  String bean2json(Object bean) {
            StringBuilder json  =   new  StringBuilder();
            json.append( " { " );
            PropertyDescriptor[] props  =   null ;
             try  {
                props  =  Introspector.getBeanInfo(bean.getClass(), Object. class ).getPropertyDescriptors();
            }  catch  (IntrospectionException e) {
            }
             if  (props  !=   null ) {
                 for  ( int  i  =   0 ; i  <  props.length; i ++ ) {
                     try  {
                        String name  =  object2json(props[i].getName());
                        String value  =  object2json(props[i].getReadMethod().invoke(bean));
                        json.append(name);
                        json.append( " : " );
                        json.append(value);
                        json.append( " , " );
                    }  catch  (Exception e) {
                    }
                }
                json.setCharAt(json.length()  -   1 ,  ' } ' );
            }  else  {
                json.append( " } " );
            }
             return  json.toString();
        }
         /**
         *  @param  list list对象
         *  @return  String
          */
         public   static  String list2json(List <?>  list) {
            StringBuilder json  =   new  StringBuilder();
            json.append( " [ " );
             if  (list  !=   null   &&  list.size()  >   0 ) {
                 for  (Object obj : list) {
                    json.append(object2json(obj));
                    json.append( " , " );
                }
                json.setCharAt(json.length()  -   1 ,  ' ] ' );
            }  else  {
                json.append( " ] " );
            }
             return  json.toString();
        }
         /**
         *  @param  array 对象数组
         *  @return  String
          */
         public   static  String array2json(Object[] array) {
            StringBuilder json  =   new  StringBuilder();
            json.append( " [ " );
             if  (array  !=   null   &&  array.length  >   0 ) {
                 for  (Object obj : array) {
                    json.append(object2json(obj));
                    json.append( " , " );
                }
                json.setCharAt(json.length()  -   1 ,  ' ] ' );
            }  else  {
                json.append( " ] " );
            }
             return  json.toString();
        }
         /**
         *  @param  map map对象
         *  @return  String
          */
         public   static  String map2json(Map <? ,  ?>  map) {
            StringBuilder json  =   new  StringBuilder();
            json.append( " { " );
             if  (map  !=   null   &&  map.size()  >   0 ) {
                 for  (Object key : map.keySet()) {
                    json.append(object2json(key));
                    json.append( " : " );
                    json.append(object2json(map.get(key)));
                    json.append( " , " );
                }
                json.setCharAt(json.length()  -   1 ,  ' } ' );
            }  else  {
                json.append( " } " );
            }
             return  json.toString();
        }
         /**
         *  @param  set 集合对象
         *  @return  String
          */
         public   static  String set2json(Set <?>  set) {
            StringBuilder json  =   new  StringBuilder();
            json.append( " [ " );
             if  (set  !=   null   &&  set.size()  >   0 ) {
                 for  (Object obj : set) {
                    json.append(object2json(obj));
                    json.append( " , " );
                }
                json.setCharAt(json.length()  -   1 ,  ' ] ' );
            }  else  {
                json.append( " ] " );
            }
             return  json.toString();
        }
         /**
         *  @param  s 参数
         *  @return  String
          */
         public   static  String string2json(String s) {
             if  (s  ==   null )
                 return   "" ;
            StringBuilder sb  =   new  StringBuilder();
             for  ( int  i  =   0 ; i  <  s.length(); i ++ ) {
                 char  ch  =  s.charAt(i);
                 switch  (ch) {
                 case   ' " ' :
                    sb.append( " \\\ "" );
                     break ;
                 case   ' \\ ' :
                    sb.append( " \\\\ " );
                     break ;
                 case   ' \b ' :
                    sb.append( " \\b " );
                     break ;
                 case   ' \f ' :
                    sb.append( " \\f " );
                     break ;
                 case   ' \n ' :
                    sb.append( " \\n " );
                     break ;
                 case   ' \r ' :
                    sb.append( " \\r " );
                     break ;
                 case   ' \t ' :
                    sb.append( " \\t " );
                     break ;
                 case   ' / ' :
                    sb.append( " \\/ " );
                     break ;
                 default :
                     if  (ch  >=   ' \u0000 '   &&  ch  <=   ' \u001F ' ) {
                        String ss  =  Integer.toHexString(ch);
                        sb.append( " \\u " );
                         for  ( int  k  =   0 ; k  <   4   -  ss.length(); k ++ ) {
                            sb.append( ' 0 ' );
                        }
                        sb.append(ss.toUpperCase());
                    }  else  {
                        sb.append(ch);
                    }
                }
            }
             return  sb.toString();
        }
    }