tinguo002

 

软件工程中的图(转)

软件工程中的图

我们通常都是对图形化的东西情有独钟,我们小时候的启蒙教育基本上也都是从图形化开始的,我们曾经看过的连环画、漫画、看图识字等等。因为图形能将一个抽象的东西具体化、形象化,图形化的表述能将一个用文字语言无法表达清楚或很难表达的观点、事物、科学概念等清晰的呈现出来。这就是为什么我们相比晦涩难懂文字更喜欢形象生动的图形的原因。

  软件工程导论作为软件工程中非常重要的一门课程,通常因为其偏文科性、理论性、概念性而得不到人们的重视,但幸运的是在软件工程导论中有我们非常易于接受、理解的东西——图,否则我们自己会把自己害得很惨(软件工程导论真的很重要哦!)。

  软件工程导论中一般把软件的开发分为八个阶段:1.问题定义 2.可行性研究 3.需求分析 4.总体设计(概要设计) 5.详细设计 6.编码和单元测试 7.综合测试 8.软件维护。下面我们就说说各个阶段中与图的难解难分。

  1. 问题定义

  问题定义阶段主要是根据用户的需求来定义用户需要解决的问题,用户要实现哪些功能。                        

  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. 总体设计

  需求分析阶段已经确定了系统要做什么的问题,而总体设计就是要弄明白怎么做的问题,总体设计的目的就是从宏观上概括的说系统应该怎样实现,具体一点就是要明确系统有哪些模块组成,以及这些模块之间的关系是怎样的。

  4.1 层次图

  层次图是用来描述软件的层次结构的。

  4.2 HIPO图

  HIPO图 = 层次图+输入+处理+输出

  4.3 结构图

  结构图和层次图类似,都是描述软件结构的图形工具。

  5. 详细设计

  详细设计阶段就是在总体设计的基础上要确定怎样具体的详细的实现系统所要求的功能,要对系统进行精确的描述。

  5.1 程序流程图

  程序流程图是对程序控制流程的直观描述。

  5.2 盒图

  出于要有种不允许违背结构设计精神图形工具考虑Nassi和shneiderman提出了盒图又称为N—S图。

  5.3 问题分析PAD图

  PAD图就是用二维树形结构图来表示程序的控制流。

  6. 编码和单元测试

  编码和单元测试阶段主要是对详细设计阶段的详细描述给以具体的实现和模块的测试。  

  7. 综合测试

  综合测试包括对系统的各个组件和功能的测试,要求覆盖软件系统的各个功能点,并根据被测软件的需求测试软件的性能、易用性等方面的内容,达到对软件全方面测试的目的。

  8. 软件维护

  软件维护阶段是软件生命周期中最后的一个阶段,也是最长的一个阶段,软件维护主要任务是指根据需求变化或硬件环境的变化对应用程序进行部分或全部的修改,修改时应充分利用源程序。修改后要填写程序改登记表,并在程序变更通知书上写明新旧程序的不同之处。

  参考文献:

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

  2. 文中的一部分图片来源于《软件工程导论》第五版(张海藩 编著),一部分来源于互联网。

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

posted @ 2013-05-07 17:16 一堣而安 阅读(262) | 评论 (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 一堣而安 阅读(191) | 评论 (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 一堣而安 阅读(532) | 评论 (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 一堣而安 阅读(212) | 评论 (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 一堣而安 阅读(649) | 评论 (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 一堣而安 阅读(2432) | 评论 (0)编辑 收藏

java N次方

Math.pow(double   m,   double  n)

posted @ 2013-04-12 18:51 一堣而安 阅读(176) | 评论 (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.blogjava.net/pingpang/archive/2012/08/12/385342.html


posted @ 2013-04-12 18:49 一堣而安 阅读(200) | 评论 (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 一堣而安 阅读(203) | 评论 (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 一堣而安 阅读(332) | 评论 (0)编辑 收藏

仅列出标题
共17页: First 上一页 7 8 9 10 11 12 13 14 15 下一页 Last 

导航

统计

常用链接

留言簿(1)

随笔分类

随笔档案

收藏夹

搜索

最新评论

阅读排行榜

评论排行榜