<rt id="bn8ez"></rt>
<label id="bn8ez"></label>

  • <span id="bn8ez"></span>

    <label id="bn8ez"><meter id="bn8ez"></meter></label>

    tinguo002

     

    軟件工程中的圖(轉(zhuǎn))

    軟件工程中的圖

    我們通常都是對圖形化的東西情有獨(dú)鐘,我們小時候的啟蒙教育基本上也都是從圖形化開始的,我們曾經(jīng)看過的連環(huán)畫、漫畫、看圖識字等等。因?yàn)閳D形能將一個抽象的東西具體化、形象化,圖形化的表述能將一個用文字語言無法表達(dá)清楚或很難表達(dá)的觀點(diǎn)、事物、科學(xué)概念等清晰的呈現(xiàn)出來。這就是為什么我們相比晦澀難懂文字更喜歡形象生動的圖形的原因。

      軟件工程導(dǎo)論作為軟件工程中非常重要的一門課程,通常因?yàn)槠淦目菩浴⒗碚撔浴⒏拍钚远貌坏饺藗兊闹匾暎疫\(yùn)的是在軟件工程導(dǎo)論中有我們非常易于接受、理解的東西——圖,否則我們自己會把自己害得很慘(軟件工程導(dǎo)論真的很重要哦!)。

      軟件工程導(dǎo)論中一般把軟件的開發(fā)分為八個階段:1.問題定義 2.可行性研究 3.需求分析 4.總體設(shè)計(概要設(shè)計) 5.詳細(xì)設(shè)計 6.編碼和單元測試 7.綜合測試 8.軟件維護(hù)。下面我們就說說各個階段中與圖的難解難分。

      1. 問題定義

      問題定義階段主要是根據(jù)用戶的需求來定義用戶需要解決的問題,用戶要實(shí)現(xiàn)哪些功能。                        

      2. 可行性研究

      可行性研究階段就是看是否有一種使其在最小的代價,盡可能短的時間內(nèi),利益最大化的情況下解決問題的方案。這個階段的分析主要涉及以下幾個圖形工具。

      2.1 系統(tǒng)流程圖

      系統(tǒng)流程圖是描述系統(tǒng)物理模型的一種傳統(tǒng)工具。它是表達(dá)數(shù)據(jù)在系統(tǒng)各部件之間流動的情況,而不是對數(shù)據(jù)加工處理的控制過程,它是物理數(shù)據(jù)流圖而不是程序流程圖。系統(tǒng)流程圖形象的呈現(xiàn)了軟件的功能,即使不懂軟件的人也可以輕松的看懂,可以說它是軟件設(shè)計師與用戶之間溝通、交流的有效工具。

      2.2 數(shù)據(jù)流圖

      數(shù)據(jù)流圖是從數(shù)據(jù)傳遞和加工角度,以圖形方式來表達(dá)系統(tǒng)的邏輯功能、數(shù)據(jù)在系統(tǒng)內(nèi)部的邏輯流向和邏輯變換過程,是結(jié)構(gòu)化系統(tǒng)分析方法的主要表達(dá)工具及用于表示軟件模型的一種圖示方法。如果說系統(tǒng)流程圖能讓用戶更好的明白系統(tǒng)的功能,那么數(shù)據(jù)流圖則讓用戶更加明白系統(tǒng)的工作原理。

      2.3 數(shù)據(jù)字典

      數(shù)據(jù)字典就是數(shù)據(jù)的信息的集合,也可以說就是對上面提到的數(shù)據(jù)流圖中的所有元素的定義的集合。數(shù)據(jù)字典的主要作用就是在軟件的分析與設(shè)計階段方便我們查閱不甚了解的數(shù)據(jù)的描述信息。

      3. 需求分析

      需求分析階段主要確定系統(tǒng)必須做什么。比如用戶對系統(tǒng)的要求,確定目標(biāo)系統(tǒng)所有的功能,確定系統(tǒng)運(yùn)行的硬件和軟件環(huán)境,系統(tǒng)性能要求,出錯處理要求,接口需求,驗(yàn)證軟件需求等等。

      3.1 E-r圖

      E-r圖的主要作用就是把用戶的數(shù)據(jù)要求用可視化的圖形呈現(xiàn)出來。

      3.2 狀態(tài)轉(zhuǎn)換圖

      狀態(tài)轉(zhuǎn)換圖說白了就是系統(tǒng)的行為建模,就是通過描述系統(tǒng)的狀態(tài)以及引起狀態(tài)變化的事件來表示系統(tǒng)的行為,將系統(tǒng)運(yùn)行時詳細(xì)的狀態(tài)變化呈現(xiàn)給用戶。

      3.3 層次方框圖

      層次方框圖像用戶呈現(xiàn)的是數(shù)據(jù)的層次結(jié)構(gòu)。

      3.4 Warnier圖

      Warnier圖的作用和層次方框圖的作用基本相同,只不過Warnier圖的描述手段更多。

      3.5 IPO圖

      IPO圖是輸入、處理和輸出圖的簡稱,它清楚的描述了輸入數(shù)據(jù)、處理數(shù)據(jù)、輸出數(shù)據(jù)之間的關(guān)系。

      4. 總體設(shè)計

      需求分析階段已經(jīng)確定了系統(tǒng)要做什么的問題,而總體設(shè)計就是要弄明白怎么做的問題,總體設(shè)計的目的就是從宏觀上概括的說系統(tǒng)應(yīng)該怎樣實(shí)現(xiàn),具體一點(diǎn)就是要明確系統(tǒng)有哪些模塊組成,以及這些模塊之間的關(guān)系是怎樣的。

      4.1 層次圖

      層次圖是用來描述軟件的層次結(jié)構(gòu)的。

      4.2 HIPO圖

      HIPO圖 = 層次圖+輸入+處理+輸出

      4.3 結(jié)構(gòu)圖

      結(jié)構(gòu)圖和層次圖類似,都是描述軟件結(jié)構(gòu)的圖形工具。

      5. 詳細(xì)設(shè)計

      詳細(xì)設(shè)計階段就是在總體設(shè)計的基礎(chǔ)上要確定怎樣具體的詳細(xì)的實(shí)現(xiàn)系統(tǒng)所要求的功能,要對系統(tǒng)進(jìn)行精確的描述。

      5.1 程序流程圖

      程序流程圖是對程序控制流程的直觀描述。

      5.2 盒圖

      出于要有種不允許違背結(jié)構(gòu)設(shè)計精神圖形工具考慮Nassi和shneiderman提出了盒圖又稱為N—S圖。

      5.3 問題分析PAD圖

      PAD圖就是用二維樹形結(jié)構(gòu)圖來表示程序的控制流。

      6. 編碼和單元測試

      編碼和單元測試階段主要是對詳細(xì)設(shè)計階段的詳細(xì)描述給以具體的實(shí)現(xiàn)和模塊的測試。  

      7. 綜合測試

      綜合測試包括對系統(tǒng)的各個組件和功能的測試,要求覆蓋軟件系統(tǒng)的各個功能點(diǎn),并根據(jù)被測軟件的需求測試軟件的性能、易用性等方面的內(nèi)容,達(dá)到對軟件全方面測試的目的。

      8. 軟件維護(hù)

      軟件維護(hù)階段是軟件生命周期中最后的一個階段,也是最長的一個階段,軟件維護(hù)主要任務(wù)是指根據(jù)需求變化或硬件環(huán)境的變化對應(yīng)用程序進(jìn)行部分或全部的修改,修改時應(yīng)充分利用源程序。修改后要填寫程序改登記表,并在程序變更通知書上寫明新舊程序的不同之處。

      參考文獻(xiàn):

      1. 文中的部分定義參考于百度百科http://baike.baidu.com/

      2. 文中的一部分圖片來源于《軟件工程導(dǎo)論》第五版(張海藩 編著),一部分來源于互聯(lián)網(wǎng)。

    http://kb.cnblogs.com/page/107286/

    posted @ 2013-05-07 17:16 一堣而安 閱讀(271) | 評論 (0)編輯 收藏

    JAVA中去掉空格

    JAVA中去掉空格     

    1. String.trim()     trim()是去掉首尾空格          

    2.str.replace(" ", ""); 去掉所有空格,包括首尾、中間   

    String str = " hell o ";   String str2 = str.replaceAll(" ", "");
      System.out.println(str2);          

    3.或者replaceAll(" +",""); 去掉所有空格         

    4.str = .replaceAll("\\s*", "");   

    可以替換大部分空白字符, 不限于空格    \s 可以匹配空格、制表符、換頁符等空白字符的其中任意一個         

    5.或者下面的代碼也可以去掉所有空格,包括首尾、中間    

    public String remove(String resource,char ch) 
    {                    
        StringBuffer buffer
    =new StringBuffer();      
        int position=0;      
        char currentChar;                           
        while(position<resource.length())      {                                          
            currentChar
    =resource.charAt(position++);                                  
            if(currentChar!=ch) buffer.append(currentChar); 
        }

        return buffer.toString();       
    }
       


             


        

    posted @ 2013-04-25 23:09 一堣而安 閱讀(196) | 評論 (0)編輯 收藏

    java中如何把一個array復(fù)制到arrayList里 (轉(zhuǎn))

    http://blog.csdn.net/yangyi22/article/details/5329750/


    list.addAll(otherList);直接把要復(fù)制的list添加到目的list中就可以了。


    public static void  main(string[]  args)

    {

    int[] arrayInt=new int[] {1,2,3,4,5}

         ArrayList  alist =ArrayList();

        //方法一

        for(int i:alist)

        {

            alist.Add(i);

         }  

        System.out.println(al[2].ToString());//輸出

       //方法二 ArrayList.Adapter 方法是為特定的List 創(chuàng)建ArrayList包裝

        ArrayList alist2=new ArrayList();

        alist2=ArrayList.Adapter(arrayInt);

        System.out.println(alist2[2].ToString());//輸出

       //方法三逆向轉(zhuǎn)換

       Array resultArr=(int[] )alist2.ToArray(tyoeof(int));

      System.out.println(resulArr.GetValue(2));//輸出3

    }

    最常用法

    string[] arrA = new string[]{"學(xué)","習(xí)","中"};
    ArrayList arrB = new ArrayList();
    for(string a : arrA)
    {
    arrB.Add(a);
    }
    for(string b :arrB)
    {
    System.out.println(b);
    }


    posted @ 2013-04-24 17:00 一堣而安 閱讀(537) | 評論 (0)編輯 收藏

    Java數(shù)組的復(fù)制(轉(zhuǎn)) 紅黑聯(lián)盟

    初學(xué)Java的時候,需要復(fù)制數(shù)組的時候,一下子就想到使用賦值語句“=”,例如:array1 = array2;
    但后來慢慢發(fā)現(xiàn),這個語句并不能將array2的內(nèi)容復(fù)制給array1,而是將array2的引用傳給了array1.使用array1 = array2 這個語句之后,array1,array2指向了同一個數(shù)組,如下圖所示:
     
             
    這樣,array2之前所引用的數(shù)組不能再引用了,變成了垃圾,會被JVM自動回收的。所以使用“=”是不能進(jìn)行數(shù)組的復(fù)制,它實(shí)際上是將=右邊的數(shù)組的引用傳給了=左邊的數(shù)組變量,達(dá)到兩個數(shù)組變量指向同樣的內(nèi)存地址。
    常用的數(shù)組復(fù)制的方法有以下3種:
    1.使用循環(huán)語句逐個復(fù)制數(shù)組的元素(最簡單的方法)
    public class ArrayCopy_1 {

        public static void main(String[] args) {
          final int ARRAY_MAX = 12;
          int[] sourceArray = new int[ARRAY_MAX];
          int[] targetArray = new int[sourceArray.length];
          
          for(int i = 0;i<sourceArray.length;i++){
                sourceArray[i]=i;
            }
          
          for(int j = 0;j<targetArray.length;j++){
                targetArray[j] = sourceArray[j];
            }
          
          for(int k = 0;k < sourceArray.length;k++){
              System.out.print(targetArray[k]+" ");
          }
       }
    }
    輸出的結(jié)果:
    2.使用System類中的靜態(tài)方法arrayCopy
    public class ArrayCopy_2 
    {
           public static void main(String[] args) {
              final int ARRAY_MAX = 12;
              int[] sourceArray = new int[ARRAY_MAX];
              int[] targetArray = new int[sourceArray.length];
              
              for(int i=0;i<sourceArray.length;i++){
                    sourceArray[i]=i;
                }
              
            //使用System中的靜態(tài)方法arraycopy復(fù)制數(shù)組  
            System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);
            
            for(int j=0;j<targetArray.length;j++){
                System.out.print(targetArray[j]+" ");
            }
        }
    }
    輸出的結(jié)果:
    3.使用clone方法復(fù)制數(shù)組
    public class ArrayCopy_3 {

        public static void main(String[] args) {
              final int ARRAY_MAX = 12;
              int[] sourceArray = new int[ARRAY_MAX];
              int[] targetArray = new int[sourceArray.length];
              
              for(int i = 0;i<sourceArray.length;i++){
                    sourceArray[i]=i;
                }
              
              targetArray = (int[])sourceArray.clone();//使用clone方法將int[]型數(shù)組
                                                       //將sourceArray復(fù)制到targetArray
                                                       //注意:由于clone方法返回值的類型是對象Object
                                                       //所以要使用(int[])強(qiáng)制轉(zhuǎn)換為int[]
                                                       
               for(int k = 0;k < sourceArray.length;k++){
                  System.out.print(targetArray[k]+" ");    //輸出復(fù)制后的結(jié)果
              }
         }
    }
    輸出的結(jié)果:
    本文出自 “IT的點(diǎn)點(diǎn)滴滴” 博客

    posted @ 2013-04-24 14:38 一堣而安 閱讀(217) | 評論 (0)編輯 收藏

    Java 截取反斜杠 replaceAll和split (“\”)轉(zhuǎn)

    轉(zhuǎn):http://blog.csdn.net/scy411082514/article/details/7987852

    Java 截取反斜杠 replaceAll和split (“\”) 問題解決辦法

    2009年07月15日 星期三 上午 11:26
    xxx.split("\\") 顯然得不到想要的結(jié)果

    正確方法

    xxx.split("\\\\");

    原因如下:

    在Java中處理一些路徑相關(guān)的問題的時候,如要取出ie瀏覽器上傳文件的文件名,由于ie會把整個文件路徑都作為文件名上傳,需要用java.lang.String中的replaceAll或者split來處理。如:

    上傳文件路徑為:C:\Documents and Settings\collin\My Documents\111-lazyloading.gif,欲取出文件名:111-lazyloading.gif。可以

    String temp[] = name.split("\\\\");
    if (temp.length > 1) {
    name = temp[temp.length - 1];
    }

    regex為\\\\,因?yàn)樵趈ava中\(zhòng)\表示一個\,而regex中\(zhòng)\也表示\,所以當(dāng)\\\\解析成regex的時候?yàn)閈\。

    由于unix中file.separator為斜杠"/",下面這段代碼可以處理windows和unix下的所有情況:

    String temp[] = name.replaceAll("\\\\","/").split("/");
    if (temp.length > 1) {
        name = temp[temp.length - 1];
    }


    在使用java中的split拆分特殊字符的時候,會發(fā)現(xiàn)達(dá)不到自己想要的結(jié)果。比如

    Java代碼  收藏代碼
    1. "1234567891^1234567890".split("^")[1

    會提示數(shù)組下標(biāo)越界異常,說明根本沒有拆分成功。究其原因,原來^是特殊字符,split中的參數(shù)為正則表達(dá)式,所以要想讓split識別特殊字符,就需要把參數(shù)轉(zhuǎn)變?yōu)檎齽t,即在參數(shù)前加上"\\"即可。

    Java代碼  收藏代碼
    1. "1234567891^1234567890".split("\\^")[1

    posted @ 2013-04-23 14:53 一堣而安 閱讀(659) | 評論 (0)編輯 收藏

    關(guān)于 oracle between and的用法!

    http://linhan8888.blog.163.com/blog/static/40020680201201811323793/

    oracle date等類型是帶時間部分的,所以你這個2011-07-05 只是相當(dāng)于2011-07-05 
    00:00:00這個時刻,按你的寫法大于這個時刻的是不會刪除的。如果你確實(shí)要刪除2011-07-05的建議你用以下寫法:
    delete from
    jf_syslog where  inputtime >=date'2011-07-01' and
    nputtime<date'2011-07-06'

    如果不擔(dān)心2011-07-06  00:00:00的也可以
    delete
    from jf_syslog where  inputtime between date'2011-07-01' and date'2011-07-06'


    如果效率可以接受,可以先轉(zhuǎn)換成字符串
    delete from jf_syslog where 
    to_char(inputtime,'yyyymmdd') between '20110701' and '20110705'


    你可以考慮連接上一個固定的字符串這樣的,但是因?yàn)闀r間上是沒有24:00:00的,所以還是會有問題的,不如直接在日期上加一天好用




    a) months_between(date1,date2):算date1和date2之間的月的數(shù)量,可以是小數(shù)可以是負(fù)數(shù)

      months_between(’01-sep-95’,’11-jan-94’)=1.9774194

    b)
    add_months(date,n):為date加上N個月,N只可以是整數(shù)
      
    c)
    next_date(date,’char’):查找date的下一個星期N

      next_date(’01-sep-95’,’FRIDAY’)=08-SEP-95
      
    d)
    last_day(date):查找date月的最后一天。
      
    e) rount(date):把日期四舍五入
      
    f)
    rount(25-MAY-95’,’MONTH’)=01-JUN-95
      
    g)
    rount(25-MAY-95’,’YEAR’)=01-JAN-95
      
    h) trunc(date):把日期截斷
      
    i)
    trunc (25-MAY-95’,’MONTH’)=01-MAY-95
      
    j) trunc
    (25-MAY-95’,’YEAR’)=01-JAN-95

    k)
    日期中RR與YY的區(qū)別,RR格式對日期作類似于舍入的操作,YY格式對日期作類似于截取的操作
      RR  YY
      1995 27-oct-95
    1995 1995
      1995 27-oct-17 2017 1917
      2001 27-oct-17 2017 2017

      2001 27-oct-95 1995 2095
      用法:select to_char(sysdate, 'YY') from dual;

      select to_char(to_date('95-11-27', 'RR-MM-DD'), 'YYYY-MM-DD') from dual;

      select to_char(to_date('95-11-27', 'YY-MM-DD'), 'YYYY-MM-DD') from dual;

    posted @ 2013-04-15 10:15 一堣而安 閱讀(2462) | 評論 (0)編輯 收藏

    java N次方

    Math.pow(double   m,   double  n)

    posted @ 2013-04-12 18:51 一堣而安 閱讀(179) | 評論 (0)編輯 收藏

    js替換(轉(zhuǎn))

    <script language="javascript">
    function check()
    {
    var str=document.getElementById("input1").value
    var s="^正則表達(dá)式$"
    var re = new RegExp(s, "ig");
    alert(re.test(str))
    }
    </script>
    <input id="input1" value="正則表達(dá)式">
    <input type="button" value="確定" onclick="check()">

     
    ============================

     
    <script language="javascript">
    function check2()
    {
    var str2=document.getElementById("input2").value
    var s2="正則表達(dá)式"
    var re = eval("/^"+s2+"$/ig")
    alert(re.test(str2))
    }
    </script>
    <input id="input2" value="正則表達(dá)式">
    <input type="button" value="確定" onclick="check2()">
    詳細(xì)出處參考:http://www.jb51.net/article/2823.htm



     

    最近項(xiàng)目任務(wù)繁重,更新博客會較慢,不過有時間希望可以把自己的積累分享出來。


     
    JavaScript正則實(shí)戰(zhàn)(會根據(jù)最近寫的不斷更新)


    1、javascript
    正則對象替換創(chuàng)建 和用法: /pattern/flags
    先簡單案例學(xué)習(xí)認(rèn)識下replace能干什么


        正則表達(dá)式構(gòu)造函數(shù): new
    RegExp("pattern"[,"flags"]);


       
    正則表達(dá)式替換變量函數(shù):stringObj.replace(RegExp,replace Text);


    參數(shù)說明:
    pattern
    -- 一個正則表達(dá)式文本
    flags -- 如果存在,將是以下值:
    g: 全局匹配
    i: 忽略大小寫
    gi:
    以上組合


    //下面的例子用來獲取url的兩個參數(shù),并返回urlRewrite之前的真實(shí)Url
    var
    reg=new RegExp("(http://www.qidian.com/BookReader/)(\\d+),(\\d+).aspx","gmi");
    var url="http://www.qidian.com/BookReader/1017141,20361055.aspx";

    //方式一,最簡單常用的方式
    var rep=url.replace(reg,"$1ShowBook.aspx?bookId=$2&chapterId=$3");
    alert(rep);

    //方式二
    ,采用固定參數(shù)的回調(diào)函數(shù)

    var rep2=url.replace(reg,function(m,p1,p2,p3){return p1+"ShowBook.aspx?bookId="+p3+"&chapterId="+p3});
    alert(rep2);

    //方式三,采用非固定參數(shù)的回調(diào)函數(shù)
    var rep3=url.replace(reg,function(){var args=arguments; return args[1]+"ShowBook.aspx?bookId="+args[2]+"&chapterId="+args[3];});
    alert(rep3);


    //方法四
    //方式四和方法三很類似,
    除了返回替換后的字符串外,還可以單獨(dú)獲取參數(shù)

    var bookId;
    var chapterId;
    function capText()
    {
        var args=arguments;
       
    bookId=args[2];
       
    chapterId=args[3];
        return args[1]+"ShowBook.aspx?bookId="+args[2]+"&chapterId="+args[3];
    }

    var rep4=url.replace(reg,capText);
    alert(rep4);
    alert(bookId);
    alert(chapterId);


    //使用test方法獲取分組
    var reg3=new RegExp("(http://www.qidian.com/BookReader/)(\\d+),(\\d+).aspx","gmi");
    reg3.test("http://www.qidian.com/BookReader/1017141,20361055.aspx");
    //獲取三個分組
    alert(RegExp.$1);
    alert(RegExp.$2);
    alert(RegExp.$3);



    2、 學(xué)習(xí)最常用的 test exec match search  replace 
    split 6個方法


    1) test  檢查指定的字符串是否存在
    var data = “123123″;
    var
    reCat = /123/gi;
    alert(reCat.test(data));  //true
    //檢查字符是否存在  g 繼續(xù)往下走  i
    不區(qū)分大小寫


    2) exec 返回查詢值
    var data =
    “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
    var reCat =
    /cat/i;
    alert(reCat.exec(data));  //Cat


    3)match  得到查詢數(shù)組
    var data =
    “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
    var reCat = /cat/gi;
    var
    arrMactches = data.match(reCat)
    for (var i=0;i < arrMactches.length ;
    i++)
    {
    alert(arrMactches[i]);   //Cat  cat
    }


    4) search  返回搜索位置  類似于indexof
    var data =
    “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
    var reCat =
    /cat/gi;
    alert(data.search(reCat));  //23


    5) replace  替換字符  利用正則替換
    var data =
    “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
    var reCat =
    /cat/gi;
    alert(data.replace(reCat,”libinqq”));


    6)split   利用正則分割數(shù)組
    var data =
    “123123,213,12312,312,3,Cat,cat,dsfsdfs,”;
    var reCat = /\,/;
    var arrdata =
    data.split(reCat);
    for (var i = 0; i < arrdata.length;
    i++)
    {
    alert(arrdata[i]);
    }

    3、常用表達(dá)式收集:


    "^\\d+$"  //非負(fù)整數(shù)(正整數(shù) +
    0)

    "^[0-9]*[1-9][0-9]*$"  //正整數(shù)
    "^((-\\d+)|(0+))$"  //非正整數(shù)(負(fù)整數(shù) +
    0)

    "^-[0-9]*[1-9][0-9]*$"  //負(fù)整數(shù)
    "^-?\\d+$"    //整數(shù)
    "^\\d+(\\.\\d+)?$"  //非負(fù)浮點(diǎn)數(shù)(正浮點(diǎn)數(shù) +
    0)

    "^(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*))$"
    //正浮點(diǎn)數(shù)
    "^((-\\d+(\\.\\d+)?)|(0+(\\.0+)?))$"  //非正浮點(diǎn)數(shù)(負(fù)浮點(diǎn)數(shù)
    + 0)

    "^(-(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*)))$"
    //負(fù)浮點(diǎn)數(shù)
    "^(-?\\d+)(\\.\\d+)?$"  //浮點(diǎn)數(shù)
    "^[A-Za-z]+$"  //由26個英文字母組成的字符串
    "^[A-Z]+$"  //由26個英文字母的大寫組成的字符串
    "^[a-z]+$"  //由26個英文字母的小寫組成的字符串
    "^[A-Za-z0-9]+$"  //由數(shù)字和26個英文字母組成的字符串
    "^\\w+$"  //由數(shù)字、26個英文字母或者下劃線組成的字符串
    "^[\\w-]+(\\.[\\w-]+)*@[\\w-]+(\\.[\\w-]+)+$"    //email地址
    "^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$"  //url
    "^[A-Za-z0-9_]*$"。


    ============================================正則表達(dá)式基礎(chǔ)知識==============================================


    ^
    匹配一個輸入或一行的開頭,/^a/匹配"an A",而不匹配"An a"

    $
    匹配一個輸入或一行的結(jié)尾,/a$/匹配"An a",而不匹配"an A"

    *
    匹配前面元字符0次或多次,/ba*/將匹配b,ba,baa,baaa

    +
    匹配前面元字符1次或多次,/ba+/將匹配ba,baa,baaa

    ?
    匹配前面元字符0次或1次,/ba?/將匹配b,ba

    (x)
    匹配x保存x在名為$1...$9的變量中

    x|y
    匹配x或y

    {n}
    精確匹配n次

    {n,}
    匹配n次以上

    {n,m}
    匹配n-m次

    [xyz]
    字符集(character set),匹配這個集合中的任一一個字符(或元字符)

    [^xyz]
    不匹配這個集合中的任何一個字符

    [\b]
    匹配一個退格符

    \b
    匹配一個單詞的邊界

    \B
    匹配一個單詞的非邊界

    \cX
    這兒,X是一個控制符,/\cM/匹配Ctrl-M

    \d
    匹配一個字?jǐn)?shù)字符,/\d/ = /[0-9]/

    \D
    匹配一個非字?jǐn)?shù)字符,/\D/ = /[^0-9]/

    \n
    匹配一個換行符

    \r
    匹配一個回車符

    \s
    匹配一個空白字符,包括\n,\r,\f,\t,\v等

    \S
    匹配一個非空白字符,等于/[^\n\f\r\t\v]/

    \t
    匹配一個制表符

    \v
    匹配一個重直制表符

    \w
    匹配一個可以組成單詞的字符(alphanumeric,這是我的意譯,含數(shù)字),包括下劃線,如[\w]匹配"$5.98"中的5,等于[a-zA-Z0-9]

    \W
    匹配一個不可以組成單詞的字符,如[\W]匹配"$5.98"中的$,等于[^a-zA-Z0-9]。

    (轉(zhuǎn))

    http://m.tkk7.com/pingpang/archive/2012/08/12/385342.html


    posted @ 2013-04-12 18:49 一堣而安 閱讀(206) | 評論 (0)編輯 收藏

    js數(shù)組操作大全(轉(zhuǎn))

    js數(shù)組操作大全(轉(zhuǎn))

    shift:刪除原數(shù)組第一項(xiàng),并返回刪除元素的值;如果數(shù)組為空則返回undefined
    var a = [1,2,3,4,5];
    var b = a.shift(); //a:[2,3,4,5] b:1

    unshift:將參數(shù)添加到原數(shù)組開頭,并返回數(shù)組的長度
    var a = [1,2,3,4,5];
    var b = a.unshift(-2,-1); //a:[-2,-1,1,2,3,4,5] b:7
    注:在IE6.0下測試返回值總為undefined,F(xiàn)F2.0下測試返回值為7,所以這個方法的返回值不可靠,需要用返回值時可用splice代替本方法來使用。

    pop:刪除原數(shù)組最后一項(xiàng),并返回刪除元素的值;如果數(shù)組為空則返回undefined
    var a = [1,2,3,4,5];
    var b = a.pop(); //a:[1,2,3,4] b:5

    push:將參數(shù)添加到原數(shù)組末尾,并返回數(shù)組的長度
    var a = [1,2,3,4,5];
    var b = a.push(6,7); //a:[1,2,3,4,5,6,7] b:7

    concat:返回一個新數(shù)組,是將參數(shù)添加到原數(shù)組中構(gòu)成的
    var a = [1,2,3,4,5];
    var b = a.concat(6,7); //a:[1,2,3,4,5] b:[1,2,3,4,5,6,7]

    splice(start,deleteCount,val1,val2,...):從start位置開始刪除deleteCount項(xiàng),并從該位置起插入val1,val2,...
    var a = [1,2,3,4,5];
    var b = a.splice(2,2,7,8,9); //a:[1,2,7,8,9,5] b:[3,4]
    var b = a.splice(0,1); //同shift
    a.splice(0,0,-2,-1); var b = a.length; //同unshift
    var b = a.splice(a.length-1,1); //同pop
    a.splice(a.length,0,6,7); var b = a.length; //同push

    reverse:將數(shù)組反序
    var a = [1,2,3,4,5];
    var b = a.reverse(); //a:[5,4,3,2,1] b:[5,4,3,2,1]

    sort(orderfunction):按指定的參數(shù)對數(shù)組進(jìn)行排序
    var a = [1,2,3,4,5];
    var b = a.sort(); //a:[1,2,3,4,5] b:[1,2,3,4,5]

    slice(start,end):返回從原數(shù)組中指定開始下標(biāo)到結(jié)束下標(biāo)之間的項(xiàng)組成的新數(shù)組
    var a = [1,2,3,4,5];
    var b = a.slice(2,5); //a:[1,2,3,4,5] b:[3,4,5]

    join(separator):將數(shù)組的元素組起一個字符串,以separator為分隔符,省略的話則用默認(rèn)用逗號為分隔符
    var a = [1,2,3,4,5];
    var b = a.join("|"); //a:[1,2,3,4,5] b:"1|2|3|4|5"

    數(shù)組是JavaScript提供的一個內(nèi)部對象,它是一個標(biāo)準(zhǔn)的集合,我們可以添加(push)、刪除(shift)里面元素,我們還可以通過for循環(huán)遍歷里面的元素,那么除了數(shù)組我們在JavaScript里還可以有別的集合嗎?

      由于JavaScript的語言特性,我們可以向通用對象動態(tài)添加和刪除屬性。所以O(shè)bject也可以看成是JS的一種特殊的集合。下面比較一下Array和Object的特性:

      Array:

    新建:var ary = new Array(); 或 var ary = [];
    增加:ary.push(value);
    刪除:delete ary[n];
    遍歷:for ( var i=0 ; i < ary.length ; ++i ) ary[i];

      Object:

    新建:var obj = new Object(); 或 var obj = {};
    增加:obj[key] = value; (key為string)
    刪除:delete obj[key];
    遍歷:for ( var key in obj ) obj[key];

      從上面的比較可以看出Object完全可以作為一個集合來使用,在使用Popup窗口創(chuàng)建無限級Web頁菜單(3)中我介紹過Eric實(shí)現(xiàn)的那個__MenuCache__,它也就是一個模擬的集合對象。

      如果我們要在Array中檢索出一個指定的值,我們需要遍歷整個數(shù)組:

      
    代碼:
    var keyword = ;
      for ( var i=0 ; i < ary.length ; ++i )
      {
      if ( ary[i] == keyword )
      {
      // todo
      }
      }

      而我們在Object中檢索一個指定的key的條目,只需要是要使用:

      
    代碼:
    var key = '';
      var value = obj[key];
      // todo

     Object的這個特性可以用來高效的檢索Unique的字符串集合,遍歷Array的時間復(fù)雜度是O(n),而遍歷Object的時間復(fù)雜度是O(1)。雖然對于10000次集合的for檢索代價也就幾十ms,可是如果是1000*1000次檢索或更多,使用Object的優(yōu)勢一下就體現(xiàn)出來了。在此之前我做了一個mapping,把100個Unique的字符mapping到1000個字符串?dāng)?shù)組上,耗時25-30s!后來把for遍歷改成了Object模擬的集合的成員引用,同樣的數(shù)據(jù)量mapping,耗時僅1.7-2s!!!

      對于集合的遍歷效率(從高到低):var value = obj[key]; > for ( ; ; ) > for ( in )。效率最差的就是for( in )了,如果集合過大,盡量不要使用for ( in )遍歷。

    posted @ 2013-04-12 18:00 一堣而安 閱讀(205) | 評論 (0)編輯 收藏

    淺談Java正則表達(dá)式中的Pattern類與Matcher類(轉(zhuǎn))

    Pattern類說明

    指定為字符串的Java正則表達(dá)式必須首先被編譯為pattern類的實(shí)例。然后,可將得到的模式用于創(chuàng)建 Matcher
    對象,依照J(rèn)ava正則表達(dá)式,該對象可以與任意字符序列匹配。執(zhí)行匹配所涉及的所有狀態(tài)都駐留在匹配器中,所以多個匹配器可以共享同一模式。

    (轉(zhuǎn))http://developer.51cto.com/art/200906/131761.htm

    因此,典型的調(diào)用順序是

    1. Pattern p = Pattern.compile("a*b");
    2. Matcher m = p.matcher("aaaaab");
    3. boolean b = m.matches();

    在僅使用一次正則表達(dá)式時,可以方便地通過pattern類定義 matches 方法。此方法編譯表達(dá)式并在單個
    調(diào)用中將輸入序列與其匹配。語句

    boolean b = Pattern.matches("a*b", "aaaaab");


    等效于上面的三個語句,盡管對于重復(fù)的匹配而言它效率不高,因?yàn)樗辉试S重用已編譯的模式。

    此類的實(shí)例是不可變的,可供多個并發(fā)線程安全使用。Matcher 類的實(shí)例用于此目的則不安全。


    Matcher類說明


    通過調(diào)用模式的 matcher 方法從模式創(chuàng)建匹配器。創(chuàng)建匹配器后,可以使用它執(zhí)行三種不同的匹配操作:


    1  matches   方法嘗試將整個輸入序列與該模式匹配。


    (注:當(dāng)調(diào)用String的matches()方法時,實(shí)際上是調(diào)用Pattern的靜態(tài)方法matches().也就是相當(dāng)于調(diào)Matcher的matches(),所以是整個輸入序列與模式匹配.)


    2  lookingAt  嘗試將輸入序列從頭開始與該模式匹配。


    3  find     方法掃描輸入序列以查找與該模式匹配的下一個子序列。 


    此類的實(shí)例用于多個并發(fā)線程是不安全的。


    測試代碼


    package test;  

    1. import java.util.regex.Matcher;
    2. import java.util.regex.Pattern;
    3. /**
    4. * java中運(yùn)用正則表達(dá)式的兩個重要類:Pattern與Matcher
    5. * @author fhd001
    6. */
    7. public class PatternAndMatcherTest {
    8. public static void main(String[] args) {
    9. /*
    10. * 常用的調(diào)用
    11. */
    12. Pattern p1 = Pattern.compile("a*b");
    13. String str1 = "aaaab";
    14. Matcher m1 = p1.matcher(str1);
    15. boolean b1 = m1.matches();
    16. System.out.println(b1);
    17. String str2 = "b";
    18. Matcher m2 = p1.matcher(str2);
    19. boolean b2 = m2.matches();
    20. System.out.println(b2);
    21. /*
    22. * 另一種調(diào)用
    23. * 等效于上面的語句,盡管對于重復(fù)的匹配而言它效率不高,因?yàn)樗辉试S重用已編譯的模式。
    24. * 但它可供多個并發(fā)線程安全使用,而上面的調(diào)用則就不是安全的.
    25. */
    26. boolean b3 = Pattern.matches("a*b", "aaab");
    27. System.out.println(b3);
    28. //Pattern類的pattern方法:從pattern類的實(shí)例中返回匹配模式的字符串表示
    29. String pattern1 = p1.pattern();
    30. System.out.println(pattern1);
    31. //Pattern類的split方法
    32. String[]arr1 = p1.split("rrrrraaabccccaaaaab");
    33. for (String string : arr1) {
    34. System.out.println(string+">>>>");
    35. }
    36. /*
    37. * Matcher類
    38. *
    39. * matches方法: 方法嘗試將整個輸入序列與該模式匹配
    40. * lookingAt方法: 嘗試將輸入序列從頭開始與該模式匹配,與 matches 方法類似,
    41. * 此方法始終從區(qū)域的開頭開始;與之不同的是,它不需要匹配整個區(qū)域。
    42. * find方法: 方法掃描輸入序列以查找與該模式匹配的下一個子序列
    43. */
    44. String str3 = "aabbcccaaaaaeeeaaaaaaaaagggga";
    45. Pattern p3 = Pattern.compile("a+");
    46. Matcher m3 = p3.matcher(str3);
    47. boolean bo4 = m3.matches();
    48. System.out.println("matches方法: "+bo4);
    49. /*
    50. * lookingAt方法,從開頭第一個字符進(jìn)行匹配,匹配成功了不再繼續(xù)匹配,
    51. * 從第一個字符開始,匹配失敗了,也不繼續(xù)匹配.不需要匹配整個序列
    52. */
    53. boolean bo5 = m3.lookingAt();
    54. if(bo5){
    55. //group方法(不帶參數(shù))返回的就是匹配的子字符串.
    56. System.out.println("lookingAt方法: "+m3.group());
    57. }
    58. //find方法:找到一個匹配的子串,還會繼續(xù)找下一個子串.
    59. while(m3.find()){
    60. System.out.println("find方法: "+m3.group());
    61. }
    62. /*
    63. * 帶參數(shù)的group方法與不帶參數(shù)的group方法區(qū)別
    64. * 不帶參數(shù)的group方法:find方法與lookingAt方法匹配出來的子序列(上面有演示)
    65. * 帶參數(shù)的group方法: 返回在以前匹配操作期間由給定組捕獲的輸入子序列。
    66. */
    67. String str6 = "aaabbbccc";
    68. Pattern p5 = Pattern.compile("(a+)(b+)(c+)");
    69. Matcher m5 = p5.matcher(str6);
    70. boolean boo = m5.matches();
    71. if(boo){
    72. int k = m5.groupCount()+1;//加1就是把0下標(biāo)的整個字符序列加上,它也作為一組放在0下標(biāo)的位置.
    73. if(k>0){
    74. for(int i=0;i System.out.println(m5.group(i));
    75. }
    76. }
    77. }
    78. }
    79. }
    80. package test;
    81. import java.util.regex.Matcher;
    82. import java.util.regex.Pattern;
    83. /**
    84. * java中運(yùn)用正則表達(dá)式的兩個重要類:Pattern與Matcher
    85. * @author fhd001
    86. */
    87. public class PatternAndMatcherTest {
    88. public static void main(String[] args) {
    89. /*
    90. * 常用的調(diào)用
    91. */
    92. Pattern p1 = Pattern.compile("a*b");
    93. String str1 = "aaaab";
    94. Matcher m1 = p1.matcher(str1);
    95. boolean b1 = m1.matches();
    96. System.out.println(b1);
    97. String str2 = "b";
    98. Matcher m2 = p1.matcher(str2);
    99. boolean b2 = m2.matches();
    100. System.out.println(b2);
    101. /*
    102. * 另一種調(diào)用
    103. * 等效于上面的語句,盡管對于重復(fù)的匹配而言它效率不高,因?yàn)樗辉试S重用已編譯的模式。
    104. * 但它可供多個并發(fā)線程安全使用,而上面的調(diào)用則就不是安全的.
    105. */
    106. boolean b3 = Pattern.matches("a*b", "aaab");
    107. System.out.println(b3);
    108. //Pattern類的pattern方法:從pattern類的實(shí)例中返回匹配模式的字符串表示
    109. String pattern1 = p1.pattern();
    110. System.out.println(pattern1);
    111. //Pattern類的split方法
    112. String[]arr1 = p1.split("rrrrraaabccccaaaaab");
    113. for (String string : arr1) {
    114. System.out.println(string+">>>>");
    115. }
    116. /*
    117. * Matcher類
    118. *
    119. * matches方法: 方法嘗試將整個輸入序列與該模式匹配
    120. * lookingAt方法: 嘗試將輸入序列從頭開始與該模式匹配,與 matches 方法類似,
    121. * 此方法始終從區(qū)域的開頭開始;與之不同的是,它不需要匹配整個區(qū)域。
    122. * find方法: 方法掃描輸入序列以查找與該模式匹配的下一個子序列
    123. */
    124. String str3 = "aabbcccaaaaaeeeaaaaaaaaagggga";
    125. Pattern p3 = Pattern.compile("a+");
    126. Matcher m3 = p3.matcher(str3);
    127. boolean bo4 = m3.matches();
    128. System.out.println("matches方法: "+bo4);
    129. /*
    130. * lookingAt方法,從開頭第一個字符進(jìn)行匹配,匹配成功了不再繼續(xù)匹配,
    131. * 從第一個字符開始,匹配失敗了,也不繼續(xù)匹配.不需要匹配整個序列
    132. */
    133. boolean bo5 = m3.lookingAt();
    134. if(bo5){
    135. //group方法(不帶參數(shù))返回的就是匹配的子字符串.
    136. System.out.println("lookingAt方法: "+m3.group());
    137. }
    138. //find方法:找到一個匹配的子串,還會繼續(xù)找下一個子串.
    139. while(m3.find()){
    140. System.out.println("find方法: "+m3.group());
    141. }
    142. /*
    143. * 帶參數(shù)的group方法與不帶參數(shù)的group方法區(qū)別
    144. * 不帶參數(shù)的group方法:find方法與lookingAt方法匹配出來的子序列(上面有演示)
    145. * 帶參數(shù)的group方法: 返回在以前匹配操作期間由給定組捕獲的輸入子序列。
    146. */
    147. String str6 = "aaabbbccc";
    148. Pattern p5 = Pattern.compile("(a+)(b+)(c+)");
    149. Matcher m5 = p5.matcher(str6);
    150. boolean boo = m5.matches();
    151. if(boo){
    152. int k = m5.groupCount()+1;//加1就是把0下標(biāo)的整個字符序列加上,它也作為一組放在0下標(biāo)的位置.
    153. if(k>0){
    154. for(int i=0;i System.out.println(m5.group(i));
    155. }
    156. }
    157. }
    158. }
    159. }

    結(jié)果代碼

    1. true
    2. true
    3. true
    4. a*b
    5. rrrrr>>>>
    6. cccc>>>>
    7. matches方法: false
    8. lookingAt方法: aa
    9. find方法: aaaaa
    10. find方法: aaaaaaaaa
    11. find方法: a
    12. aaabbbccc
    13. aaa
    14. bbb
    15. ccc

    【編輯推

    posted @ 2013-04-11 17:44 一堣而安 閱讀(336) | 評論 (0)編輯 收藏

    僅列出標(biāo)題
    共17頁: First 上一頁 7 8 9 10 11 12 13 14 15 下一頁 Last 

    導(dǎo)航

    統(tǒng)計

    常用鏈接

    留言簿(1)

    隨筆分類

    隨筆檔案

    收藏夾

    搜索

    最新評論

    閱讀排行榜

    評論排行榜

    主站蜘蛛池模板: 四虎一区二区成人免费影院网址| 亚洲香蕉网久久综合影视| 免费看黄视频网站| 131美女爱做免费毛片| 伊人久久免费视频| 99在线在线视频免费视频观看| 成人电影在线免费观看| 国产成人免费ā片在线观看老同学| 99精品免费视频| 成人免费av一区二区三区| 两个人日本免费完整版在线观看1| 久久久久久国产a免费观看不卡| 精品国产免费一区二区三区| 中文字幕免费在线视频| 99精品视频在线观看免费| 国产免费无码一区二区| 99久久免费中文字幕精品| 3344免费播放观看视频| 国产大片线上免费观看| 全免费一级午夜毛片| 国产a不卡片精品免费观看| 国产综合亚洲专区在线| 图图资源网亚洲综合网站| 亚洲午夜国产精品| 亚洲欧美第一成人网站7777| 边摸边吃奶边做爽免费视频99| 一级毛片a免费播放王色电影| 中文字幕不卡高清免费| 99久久免费精品高清特色大片| 黄色成人网站免费无码av| 四虎AV永久在线精品免费观看| 亚洲精品亚洲人成在线观看下载| 亚洲日韩激情无码一区| 亚洲色成人网一二三区| 亚洲国产美女精品久久久| 亚洲免费一区二区| 99精品免费观看| 国产自产拍精品视频免费看| 亚洲国产成人片在线观看无码 | 久久免费国产视频| 欧美男同gv免费网站观看|