tinguo002

           

          軟件工程中的圖(轉)

          軟件工程中的圖

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

            軟件工程導論作為軟件工程中非常重要的一門課程,通常因為其偏文科性、理論性、概念性而得不到人們的重視,但幸運的是在軟件工程導論中有我們非常易于接受、理解的東西——圖,否則我們自己會把自己害得很慘(軟件工程導論真的很重要哦!)。

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

           ?。? 問題定義

            問題定義階段主要是根據用戶的需求來定義用戶需要解決的問題,用戶要實現哪些功能。                        

            2. 可行性研究

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

            2.1 系統流程圖

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

            2.2 數據流圖

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

            2.3 數據字典

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

            3. 需求分析

            需求分析階段主要確定系統必須做什么。比如用戶對系統的要求,確定目標系統所有的功能,確定系統運行的硬件和軟件環境,系統性能要求,出錯處理要求,接口需求,驗證軟件需求等等。

            3.1 E-r圖

            E-r圖的主要作用就是把用戶的數據要求用可視化的圖形呈現出來。

            3.2 狀態轉換圖

            狀態轉換圖說白了就是系統的行為建模,就是通過描述系統的狀態以及引起狀態變化的事件來表示系統的行為,將系統運行時詳細的狀態變化呈現給用戶。

            3.3 層次方框圖

            層次方框圖像用戶呈現的是數據的層次結構。

            3.4 Warnier圖

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

            3.5 IPO圖

            IPO圖是輸入、處理和輸出圖的簡稱,它清楚的描述了輸入數據、處理數據、輸出數據之間的關系。

           ?。? 總體設計

            需求分析階段已經確定了系統要做什么的問題,而總體設計就是要弄明白怎么做的問題,總體設計的目的就是從宏觀上概括的說系統應該怎樣實現,具體一點就是要明確系統有哪些模塊組成,以及這些模塊之間的關系是怎樣的。

            4.1 層次圖

            層次圖是用來描述軟件的層次結構的。

            4.2 HIPO圖

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

            4.3 結構圖

            結構圖和層次圖類似,都是描述軟件結構的圖形工具。

           ?。? 詳細設計

            詳細設計階段就是在總體設計的基礎上要確定怎樣具體的詳細的實現系統所要求的功能,要對系統進行精確的描述。

            5.1 程序流程圖

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

            5.2 盒圖

            出于要有種不允許違背結構設計精神圖形工具考慮Nassi和shneiderman提出了盒圖又稱為N—S圖。

            5.3 問題分析PAD圖

            PAD圖就是用二維樹形結構圖來表示程序的控制流。

           ?。? 編碼和單元測試

            編碼和單元測試階段主要是對詳細設計階段的詳細描述給以具體的實現和模塊的測試。  

           ?。? 綜合測試

            綜合測試包括對系統的各個組件和功能的測試,要求覆蓋軟件系統的各個功能點,并根據被測軟件的需求測試軟件的性能、易用性等方面的內容,達到對軟件全方面測試的目的。

            8. 軟件維護

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

            參考文獻:

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

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

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

          posted @ 2013-05-07 17:16 一堣而安 閱讀(274) | 評論 (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 一堣而安 閱讀(200) | 評論 (0)編輯 收藏

          java中如何把一個array復制到arrayList里 (轉)

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


          list.addAll(otherList);直接把要復制的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 創建ArrayList包裝

              ArrayList alist2=new ArrayList();

              alist2=ArrayList.Adapter(arrayInt);

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

             //方法三逆向轉換

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

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

          }

          最常用法

          string[] arrA = new string[]{"學","習","中"};
          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 一堣而安 閱讀(539) | 評論 (0)編輯 收藏

          Java數組的復制(轉) 紅黑聯盟

          初學Java的時候,需要復制數組的時候,一下子就想到使用賦值語句“=”,例如:array1 = array2;
          但后來慢慢發現,這個語句并不能將array2的內容復制給array1,而是將array2的引用傳給了array1.使用array1 = array2 這個語句之后,array1,array2指向了同一個數組,如下圖所示:
           
                   
          這樣,array2之前所引用的數組不能再引用了,變成了垃圾,會被JVM自動回收的。所以使用“=”是不能進行數組的復制,它實際上是將=右邊的數組的引用傳給了=左邊的數組變量,達到兩個數組變量指向同樣的內存地址。
          常用的數組復制的方法有以下3種:
          1.使用循環語句逐個復制數組的元素(最簡單的方法)
          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]+" ");
                }
             }
          }
          輸出的結果:
          2.使用System類中的靜態方法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中的靜態方法arraycopy復制數組  
                  System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);
                  
                  for(int j=0;j<targetArray.length;j++){
                      System.out.print(targetArray[j]+" ");
                  }
              }
          }
          輸出的結果:
          3.使用clone方法復制數組
          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[]型數組
                                                             //將sourceArray復制到targetArray
                                                             //注意:由于clone方法返回值的類型是對象Object
                                                             //所以要使用(int[])強制轉換為int[]
                                                             
                     for(int k = 0;k < sourceArray.length;k++){
                        System.out.print(targetArray[k]+" ");    //輸出復制后的結果
                    }
               }
          }
          輸出的結果:
          本文出自 “IT的點點滴滴” 博客

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

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

          轉:http://blog.csdn.net/scy411082514/article/details/7987852

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

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

          正確方法

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

          原因如下:

          在Java中處理一些路徑相關的問題的時候,如要取出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為\\\\,因為在java中\\表示一個\,而regex中\\也表示\,所以當\\\\解析成regex的時候為\\。

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

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


          在使用java中的split拆分特殊字符的時候,會發現達不到自己想要的結果。比如

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

          會提示數組下標越界異常,說明根本沒有拆分成功。究其原因,原來^是特殊字符,split中的參數為正則表達式,所以要想讓split識別特殊字符,就需要把參數轉變為正則,即在參數前加上"\\"即可。

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

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

          關于 oracle between and的用法!

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

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

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


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


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




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

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

          b)
          add_months(date,n):為date加上N個月,N只可以是整數
            
          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的區別,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 一堣而安 閱讀(2468) | 評論 (0)編輯 收藏

          java N次方

          Math.pow(double   m,   double  n)

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

          js替換(轉)

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

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

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



           

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


           
          JavaScript正則實戰(會根據最近寫的不斷更新)


          1、javascript
          正則對象替換創建 和用法: /pattern/flags
          先簡單案例學習認識下replace能干什么


              正則表達式構造函數: new
          RegExp("pattern"[,"flags"]);


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


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


          //下面的例子用來獲取url的兩個參數,并返回urlRewrite之前的真實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);

          //方式二
          ,采用固定參數的回調函數

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

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


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

          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、 學習最常用的 test exec match search  replace 
          split 6個方法


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


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


          3)match  得到查詢數組
          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   利用正則分割數組
          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+$"  //非負整數(正整數 +
          0)

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

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

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

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


          ============================================正則表達式基礎知識==============================================


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

          $
          匹配一個輸入或一行的結尾,/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
          匹配一個字數字符,/\d/ = /[0-9]/

          \D
          匹配一個非字數字符,/\D/ = /[^0-9]/

          \n
          匹配一個換行符

          \r
          匹配一個回車符

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

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

          \t
          匹配一個制表符

          \v
          匹配一個重直制表符

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

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

          (轉)

          http://www.aygfsteel.com/pingpang/archive/2012/08/12/385342.html


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

          js數組操作大全(轉)

          js數組操作大全(轉)

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

          unshift:將參數添加到原數組開頭,并返回數組的長度
          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,FF2.0下測試返回值為7,所以這個方法的返回值不可靠,需要用返回值時可用splice代替本方法來使用。

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

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

          concat:返回一個新數組,是將參數添加到原數組中構成的
          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項,并從該位置起插入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:將數組反序
          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):按指定的參數對數組進行排序
          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):返回從原數組中指定開始下標到結束下標之間的項組成的新數組
          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):將數組的元素組起一個字符串,以separator為分隔符,省略的話則用默認用逗號為分隔符
          var a = [1,2,3,4,5];
          var b = a.join("|"); //a:[1,2,3,4,5] b:"1|2|3|4|5"

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

            由于JavaScript的語言特性,我們可以向通用對象動態添加和刪除屬性。所以Object也可以看成是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窗口創建無限級Web頁菜單(3)中我介紹過Eric實現的那個__MenuCache__,它也就是一個模擬的集合對象。

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

            
          代碼:
          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的時間復雜度是O(n),而遍歷Object的時間復雜度是O(1)。雖然對于10000次集合的for檢索代價也就幾十ms,可是如果是1000*1000次檢索或更多,使用Object的優勢一下就體現出來了。在此之前我做了一個mapping,把100個Unique的字符mapping到1000個字符串數組上,耗時25-30s!后來把for遍歷改成了Object模擬的集合的成員引用,同樣的數據量mapping,耗時僅1.7-2s!!!

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

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

          淺談Java正則表達式中的Pattern類與Matcher類(轉)

          Pattern類說明

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

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

          因此,典型的調用順序是

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

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

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


          等效于上面的三個語句,盡管對于重復的匹配而言它效率不高,因為它不允許重用已編譯的模式。

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


          Matcher類說明


          通過調用模式的 matcher 方法從模式創建匹配器。創建匹配器后,可以使用它執行三種不同的匹配操作:


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


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


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


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


          此類的實例用于多個并發線程是不安全的。


          測試代碼


          package test;  

          1. import java.util.regex.Matcher;
          2. import java.util.regex.Pattern;
          3. /**
          4. * java中運用正則表達式的兩個重要類:Pattern與Matcher
          5. * @author fhd001
          6. */
          7. public class PatternAndMatcherTest {
          8. public static void main(String[] args) {
          9. /*
          10. * 常用的調用
          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. * 另一種調用
          23. * 等效于上面的語句,盡管對于重復的匹配而言它效率不高,因為它不允許重用已編譯的模式。
          24. * 但它可供多個并發線程安全使用,而上面的調用則就不是安全的.
          25. */
          26. boolean b3 = Pattern.matches("a*b", "aaab");
          27. System.out.println(b3);
          28. //Pattern類的pattern方法:從pattern類的實例中返回匹配模式的字符串表示
          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. * 此方法始終從區域的開頭開始;與之不同的是,它不需要匹配整個區域。
          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方法,從開頭第一個字符進行匹配,匹配成功了不再繼續匹配,
          51. * 從第一個字符開始,匹配失敗了,也不繼續匹配.不需要匹配整個序列
          52. */
          53. boolean bo5 = m3.lookingAt();
          54. if(bo5){
          55. //group方法(不帶參數)返回的就是匹配的子字符串.
          56. System.out.println("lookingAt方法: "+m3.group());
          57. }
          58. //find方法:找到一個匹配的子串,還會繼續找下一個子串.
          59. while(m3.find()){
          60. System.out.println("find方法: "+m3.group());
          61. }
          62. /*
          63. * 帶參數的group方法與不帶參數的group方法區別
          64. * 不帶參數的group方法:find方法與lookingAt方法匹配出來的子序列(上面有演示)
          65. * 帶參數的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下標的整個字符序列加上,它也作為一組放在0下標的位置.
          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中運用正則表達式的兩個重要類:Pattern與Matcher
          85. * @author fhd001
          86. */
          87. public class PatternAndMatcherTest {
          88. public static void main(String[] args) {
          89. /*
          90. * 常用的調用
          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. * 另一種調用
          103. * 等效于上面的語句,盡管對于重復的匹配而言它效率不高,因為它不允許重用已編譯的模式。
          104. * 但它可供多個并發線程安全使用,而上面的調用則就不是安全的.
          105. */
          106. boolean b3 = Pattern.matches("a*b", "aaab");
          107. System.out.println(b3);
          108. //Pattern類的pattern方法:從pattern類的實例中返回匹配模式的字符串表示
          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. * 此方法始終從區域的開頭開始;與之不同的是,它不需要匹配整個區域。
          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方法,從開頭第一個字符進行匹配,匹配成功了不再繼續匹配,
          131. * 從第一個字符開始,匹配失敗了,也不繼續匹配.不需要匹配整個序列
          132. */
          133. boolean bo5 = m3.lookingAt();
          134. if(bo5){
          135. //group方法(不帶參數)返回的就是匹配的子字符串.
          136. System.out.println("lookingAt方法: "+m3.group());
          137. }
          138. //find方法:找到一個匹配的子串,還會繼續找下一個子串.
          139. while(m3.find()){
          140. System.out.println("find方法: "+m3.group());
          141. }
          142. /*
          143. * 帶參數的group方法與不帶參數的group方法區別
          144. * 不帶參數的group方法:find方法與lookingAt方法匹配出來的子序列(上面有演示)
          145. * 帶參數的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下標的整個字符序列加上,它也作為一組放在0下標的位置.
          153. if(k>0){
          154. for(int i=0;i System.out.println(m5.group(i));
          155. }
          156. }
          157. }
          158. }
          159. }

          結果代碼

          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)編輯 收藏

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

          導航

          統計

          常用鏈接

          留言簿(1)

          隨筆分類

          隨筆檔案

          收藏夾

          搜索

          最新評論

          閱讀排行榜

          評論排行榜

          主站蜘蛛池模板: 马尔康县| 乌鲁木齐县| 沙洋县| 竹溪县| 岳阳县| 九江市| 伊金霍洛旗| 柞水县| 北票市| 呈贡县| 满城县| 临沭县| 西城区| 和顺县| 阿尔山市| 南丹县| 赤壁市| 台前县| 宜春市| 讷河市| 黄浦区| 石嘴山市| 凤阳县| 宜城市| 古田县| 灯塔市| 温宿县| 禹城市| 古交市| 民丰县| 会昌县| 康平县| 墨竹工卡县| 中江县| 延庆县| 潜江市| 同德县| 阳原县| 溧阳市| 沐川县| 宁明县|