2012年7月12日

js通过ajax传给后台一个json数组字符串：

[{'prjcode':'4209222012A00','countyname':'大悟县','pro_1':'A','pro_2':'A','pro_3':'A','pro_4':'A','pro_5':'A','pro_6':'A','pro_7':'A','pro_8':'A','pro_9':'A','pro_10':'A','pro_11':'A','pro_12':'A','pro_13':'A','pro_14':'A','pro_15':'A'},{'prjcode':'4209222005A03','countyname':'大悟县','pro_1':'A','pro_2':'A','pro_3':'A','pro_4':'A','pro_5':'A','pro_6':'A','pro_7':'A','pro_8':'A','pro_9':'A','pro_10':'A','pro_11':'A','pro_12':'A','pro_13':'A','pro_14':'A','pro_15':'A'},{'prjcode':'4209222005B00','countyname':'大悟县','pro_1':'A','pro_2':'A','pro_3':'A','pro_4':'A','pro_5':'A','pro_6':'A','pro_7':'A','pro_8':'A','pro_9':'A','pro_10':'A','pro_11':'A','pro_12':'A','pro_13':'A','pro_14':'A','pro_15':'A'}]

后台接受进行遍历存储

String jsonstr = request.getParameter("jsonstr");
            JSONArray json = JSONArray.fromObject(jsonstr);
            Object[] obj=json.toArray();
            for(int i=0;i<obj.length;i++){
              JSONObject object = JSONObject.fromObject(obj[i]);
              String prjcode=object.get("prjcode").toString();
              String countyname=object.getString("countyname").toString();
              String pro_1=object.getString("pro_1").toString();
              String pro_2=object.getString("pro_2").toString();
              String pro_3=object.getString("pro_3").toString();
              String pro_4=object.getString("pro_4").toString();
              String pro_5=object.getString("pro_5").toString();
              String pro_6=object.getString("pro_6").toString();
              String pro_7=object.getString("pro_7").toString();
              String pro_8=object.getString("pro_8").toString();
              String pro_9=object.getString("pro_9").toString();
              String pro_10=object.getString("pro_10").toString();
              String pro_11=object.getString("pro_11").toString();
              String pro_12=object.getString("pro_12").toString();
              String pro_13=object.getString("pro_13").toString();
              String pro_14=object.getString("pro_14").toString();
              String pro_15=object.getString("pro_15").toString();
            }

posted @ 2012-08-16 22:36 zhanghu198901 阅读(2478) | 评论 (0) | 编辑收藏

DIV +CSS 系列详细教程（一）初识

CSS之所以会如此流行，是它具备以下的优点

      1、符合W3C标准。保证网站不会因为将来网络应用的升级而被淘汰。
    2、支持浏览器的向后兼容，也就是无论未来的浏览器大战，胜利的是IE、chrome或者是火狐，网站都能很好的兼容。
     3、搜索引擎更加友好。相对与传统的table, 采用DIV+CSS技术的网页，更加容易被搜索引擎找到。
     4、样式的调整更加方便。内容和样式的分离，使页面和样式的调整变得更加方便，可以一次性修改多个网页的样式，只修改样式不需要重新发布。
     5、降低网页大小，对于一个大型网站来说，可以节省大量带宽，大大提高用户体验，这是非常重要的一点——用户至上。

posted @ 2012-08-16 22:36 zhanghu198901 阅读(1113) | 评论 (0) | 编辑收藏

Struts2结合jquery autocomplet插件实现自动提示详解

在网上会有很多关于struts2结合autocomplet插件的实例，但是不怎么完整，让人感觉不清楚，刚刚在公司做了一个关于这个的项目，页面也用到了这个插件，所以把详细的步骤和注意事项贴出来和大家分享，废话不多说，贴铁代码：本文代码下载地址：http://download.csdn.net/detail/harderxin/4504612

一、我的资源中有autcomplet的json实例和autocomplet的源代码，也是copy网上的，大家可以免费下载，下载地址：http://download.csdn.net/detail/harderxin/4504288

二、开始我们的案例旅程

1、编写页面index.jsp

显示效果如下：

posted @ 2012-08-16 22:34 zhanghu198901 阅读(1253) | 评论 (0) | 编辑收藏

正则表达式学习--元字符的使用

PS：在所有例子中正则表达式匹配结果包含在源文本中的【和】之间，有的例子会使用java来实现，如果是java本身正则表达式的用法，会在相应的地方说明。所有java例子都在JDK1.6.0_13下测试通过。

一、对特殊字符进行转义

元字符是一些在正则表达式里有着特殊含义的字符。因为元字符在正则表达式里有着特殊的含义，所以这些字符就无法用来代表它们本身。在元字符前面加上一个反斜杠就可以对它进行转义，这样得到的转义序列将匹配那个字符本身而不是它特殊的元字符含义。如，如果想要匹配[和]，就必须对它进行转义：\[和\]。

对元字符转义需要用到斜杠\字符，这就意味着\字符本向也是一个元字符，要匹配\字符本身，必须转义成\\。如匹配windows文件路径。

二、匹配空白字符

元字符大致可以分为两种：一种是用来匹配文本的（如.），另一种是正则表达式的语法所要求的（如[和]）。

在进行正则表达式搜索的时候，我们经常会遇到需要对原始文本中里的非打印空白字符进行匹配的情况。比如说，我们可能需要把所有的制表符找出来，或者我们需要把换行符找出来，这类字符很难被直接输入到一个正则表达式里，这时我们可以使用如下列出的特殊元字符来输入它们：

\b 回退（并删除）一个字符（Backspace键）

\f 换页符

\n 换行符

\r 回车符

\t 制表符（Tab键）

\v 垂直制表符

来看一个例子，把文件中的空白行去掉：

文本：

8 5 4 1 6 3 2 7 9

7 6 2 9 5 8 3 4 1

9 3 1 4 2 7 8 5 6

6 9 3 8 7 5 1 2 4

5 1 8 3 4 2 6 9 7

2 4 7 6 1 9 5 3 8

3 26 7 8 4 9 1 5

4 8 9 5 3 1 7 6 2

1 7 5 2 9 6 4 8 3

正则表达式：\r\n\r\n

分析：\r\n匹配一个回车+换行组合，windows操作系统中把它作为文本行的结束标签。使用正则表达式\r\n\r\n进行的搜索将匹配两个连续的行尾标签，而这正好是空白行。

注意：Unix和Linux操作系统中只使用一个换行符来结束一个文本行，换句话说，在Unix或Linux系统中匹配空白行只使用\n\n即可，不需要加上\r。同时适用于windows和Unix/Linux的正则表达式应该包括一个可先的\r和一个必须匹配的\n，即\r?\n\r?\n，这将会在后面的文章中讲到。

Java代码如下：

  public static void matchBlankLine() throws Exception{
        BufferedReader br = new BufferedReader(new FileReader(new File("E:/九宫格.txt")));
        StringBuilder sb = new StringBuilder();
        char[] cbuf = new char[1024];
        int len = 0;
        while(br.ready() && (len = br.read(cbuf)) > 0){
            br.read(cbuf);
            sb.append(cbuf, 0, len);
        }
        String reg = "\r\n\r\n";
        System.out.println("原内容：\n" + sb.toString());
        System.out.println("处理后：-----------------------------");
        System.out.println(sb.toString().replaceAll(reg, "\r\n"));
    }

运行结果如下：

原内容：

8 5 4 1 6 3 2 7 9

7 6 2 9 5 8 3 4 1

9 3 1 4 2 7 8 5 6

6 9 3 8 7 5 1 2 4

5 1 8 3 4 2 6 9 7

2 4 7 6 1 9 5 3 8

3 2 6 7 8 4 9 1 5

4 8 9 5 3 1 7 6 2

1 7 5 2 9 6 4 8 3

处理后：-----------------------------

8 5 4 1 6 3 2 7 9

7 6 2 9 5 8 3 4 1

9 3 1 4 2 7 8 5 6

6 9 3 8 7 5 1 2 4

5 1 8 3 4 2 6 9 7

2 4 7 6 1 9 5 3 8

3 2 6 7 8 4 9 1 5

4 8 9 5 3 1 7 6 2

1 7 5 2 9 6 4 8 3

三、匹配特定的字符类别

字符集合（匹配多个字符中的某一个）是最常见的匹配形式，而一些常用的字符集合可以用特殊元字符来代替。这些元字符匹配的是某一类别的字符（类元字符），类元字符并不是必不可少的，因为可以通过逐一列举有关字符或通过定义一个字符区间来匹配某一类字符，但是使用它们构造出来的正则表达式简明易懂，在实际应用中很常用。

1、匹配数字与非数字

\d 任何一个数字，等价于[0-9]或[0123456789]

\D 任何一个非数字，等价于[^0-9]或[^0123456789]

2、匹配字母和数字与非字母和数字

字母（A-Z不区分大小写）、数字、下划线是一种常用的字符集合，可用如下类元字符：

\w 任何一个字母（不区分大小写）、数字、下划线，等价于[0-9a-zA-Z_]

\W 任何一个非字母数字和下划线，等价于[^0-9a-zA-Z_]

3、匹配空白字符与非空白字符

\s 任何一下空白字符，等价于[\f\n\r\t\v]

\S 任何一下空白字符，等价于[^\f\n\r\t\v]

注意：退格元字符\b没有不在\s的范围之内。

4、匹配十六进制或八进制数值

十六进制：用前缀\x来给出，如：\x0A对应于ASCII字符10（换行符），其效果等价于\n。

八进制：用前缀\0来给出，数值本身可以是两位或三位数字，如：\011对应于ASCII字符9（制表符），其效果等价于\t。

四、使用POSIX字符类

POSIX字符类是很多正则表达式实现都支持的一种简写形式。Java也支持它，但JavaScript不支持。POSIX字符如下所示：

[:alnum:] 任何一个字母或数字，等价于[a-zA-Z0-9]

[:alpha:] 任何一个字母，等价于[a-zA-Z]

[:blank:] 空格或制表符，等价于[\t]

[:cntrl:] ASCII控制字符（ASCII 0到31，再加上ASCII 127）

[:digit:] 任何一个数字，等价于[0-9]

[:graph:] 任何一个可打印字符，但不包括空格

[:lower:] 任何一个小写字母，等价于[a-z]

[:print:] 任何一个可打印字符

[:punct:] 既不属于[:alnum:]和[:cntrl:]的任何一个字符

[:space:] 任何一个空白字符，包括空格，等价于[^\f\n\r\t\v]

[:upper:] 任何一个大写字母，等价于[A-Z]

[:xdigit:] 任何一个十六进制数字，等价于[a-fA-F0-9]

POSIX字符和之前见过的元字符不太一样，我们来看一个前面利用正则表达式来匹配网页中的颜色的例子：

文本：<span style="background-color:#3636FF;height:30px;width:60px;">测试</span>

正则表达式：#[[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]]

结果：<span style="background-color:【#3636FF】;height:30px;width:60px;">测试</span>

注意：这里使用的模式以[[开头、以]]结束，这是使用POSIX字符类所必须的，POSIX字符必须括在[:和:]之间，外层[和]字符用来定义一个集合，内层的[和]字符是POSIX字符类本身的组成部分。

在java中的POSIX字符表示有所不同，不是包括在[:和:]之间，而是以\p开头，包括在{和}之间，且大小写有区别，同时增加了\p{ASCII}，如下所示：

\p{Alnum} 字母数字字符：[\p{Alpha}\p{Digit}]

\p{Alpha} 字母字符：[\p{Lower}\p{Upper}]

\p{ASCII} 所有 ASCII：[\x00-\x7F]

\p{Blank} 空格或制表符：[ \t]

\p{Cntrl} 控制字符：[\x00-\x1F\x7F]

\p{Digit} 十进制数字：[0-9]

\p{Graph} 可见字符：[\p{Alnum}\p{Punct}]

\p{Lower} 小写字母字符：[a-z]

\p{Print} 可打印字符：[\p{Graph}\x20]

\p{Punct} 标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

\p{Space} 空白字符：[ \t\n\x0B\f\r]

\p{Upper} 大写字母字符：[A-Z]

\p{XDigit} 十六进制数字：[0-9a-fA-F]

posted @ 2012-08-12 23:00 zhanghu198901 阅读(2087) | 评论 (2) | 编辑收藏

正则表达式学习---重复匹配

一、有多少个匹配

前面几篇讲的都是匹配一个字符，但是一个字符或字符集合要匹配多次，应该怎么做呢？比如要匹配一个电子邮件地址，用之前说到的方法，可能有人会写出像\w@\w\.\w这样的正则表达式，但这个只能匹配到像a@b.c这样的地址，明显是不正确的，接下来就来看看如何匹配电子邮件地址。

首先要知道电子邮件地址的组成：以字母数字或下划线开头的一组字符，后面跟@符号，再后面是域名，即用户名@域名地址。不过这也跟具体的邮箱服务提供商有关，有的在用户名中也允许.字符。

1、匹配一个或多个字符

要想匹配同一个字符（或字符集合）的多次重复，只要简单地给这个字符（或字符集合）加上一个+字符作为后缀就可以了。+匹配一个或多个字符（至少一个）。如：a匹配a本身，a+将匹配一个或多个连续出现的a；[0-9]+匹配多个连续的数字。

注意：在给一个字符集合加上+后缀的时候，必须把+放在字符集合的外面，否则就不是重复匹配了。如[0-9+]这样就表示数字或+号了，虽然语法上正确，但不是我们想要的了。

文本：Hello, mhmyqn@qq.com or mhmyqn@126.com is my email.

正则表达式：\w+@(\w+\.)+\w+

结果：Hello, 【mhmyqn@qq.com】 or 【mhmyqn@126.com】 is my email.

分析：\w+可以匹配一个或多个字符，而子表达式(\w+\.)+可匹配像xxxx.edu.这样的字符串，而最后不会是.字符结尾，所以后面还会有一个\w+。像mhmyqn@xxxx.edu.cn这样的邮件地址也会匹配到。

2、匹配零个或多个字符

匹配零个或多个字符使用元符*，它的用法和+完全一样，只要把它放在一下字符或字符集合的后面，就可以匹配该字符（或字符集合）连续出现零次或多次。如正则表达式ab*c可以匹配ac、abc、abbbbbc等。

3、匹配零个或一个字符

匹配零个或一个字符使用元字符?。像上一篇说到的匹配一个空白行使用正则表达式\r\n\r\n，但在Unix和Linux中不需要\r，就可以使用元字符?，\r?\n\r?\n这样既可匹配windows中的空白行，也可匹配Unix和Linux中的空白行。下面来看一个匹配http或https协议的URL的例子：

文本：The URL is http://www.mikan.com, to connect securely use https://www.mikan.cominstead.

正则表达式：https?://(\w+\.)+\w+

结果：The URL is 【http://www.mikan.com】, to connect securely use 【https://www.mikan.com】 instead.

分析：这个模式以https?开头，表示?之前的一个字符可以有，也可以没有，所以它能匹配http或https，后面部分和前一个例子一样。

二、匹配的重复次数

正则表达式里的+、*和?解决了很多问题，但是：

1）+和*匹配的字符个数没有上限。我们无法为它们将匹配的字符个数设定一个最大值。

2）+、*和?至少匹配一个或零个字符。我们无法为它们将匹配的字符个数另行设定一个最小值。

3）如果只使用*和+，我们无法把它们将匹配的字符个数设定为一个精确的数字。

正则表达式里提供了一个用来设定重复次数的语法，重复次数要用{和}字符来给出，把数值写在它们中间。

1、为重复匹配次数设定一个精确值

如果想为重复匹配次数设定一个精确的值，把那个数字写在{和}之间即可。如{4}表示它前面的那个字符（或字符集合）必须在原始文本中连续重复出现4次才算是一个匹配，如果只出现了3次，也不算是一个匹配。

如前面几篇中说到的匹配页面中颜色的例子，就可以用重复次数来匹配：#[[:xdigit:]]{6}或#[0-9a-fA-F]{6}，POSIX字符在java中是#\\p{XDigit}{6}。

2、为重复匹配次数设定一个区间

{}语法还可以用来为重复匹配次数设定一个区间，也就是为重复匹配次数设定一个最小值和最大值。这种区间必须以{n, m}这样的形式给出，其中n>=m>=0。如检查日期格式是否正确（不检查日期的有效性）的正则表达式（如日期2012-08-12或2012-8-12）：\d{4}-\d{1,2}-\d{1,2}。

3、匹配至少重复多少次

{}语法的最后一种用法是给出一个最小的重复次数（但不必给出最大重复次数），如{3,}表示至少重复3次。注意：{3,}中一定要有逗号，而且逗号后不能有空格。否则会出错。

来看一个例子，使用正则表达式把所有金额大于$100的金额找出来：

文本：

$25.36

$125.36

$205.0

$2500.44

$44.30

正则表达式：$\d{3,}\.\d{2}

结果：

$25.36

【$125.36】

【$205.0】

【$2500.44】

$44.30

+、*、?可以表示成重复次数：

+等价于{1,}

*等价于{0,}

?等价于{0,1}

三、防止过度匹配

?只能匹配零个或一个字符，{n}和{n,m}也有匹配重复次数的上限，但是像*、+、{n,}都没有上限值，这样有时会导致过度匹配的现象。

来看匹配一个html标签的例子

文本：

Yesterday is <b>history</b>,tomorrow is a <B>mystery</B>, but today is a <b>gift</b>.

正则表达式：<[Bb]>.*</[Bb]>

结果：

Yesterday is 【<b>history</b>,tomorrow is a <B>mystery</B>, but today is a <b>gift</b>】.

分析：<[Bb]>匹配<b>标签（不区分大小写），</[Bb]>匹配</b>标签（不区分大小写）。但结果却不是预期的那样有三个，第一个</b>标签之后，一直到最后一个</b>之间的东西全部匹配出来了。

为什么会这样呢？因为*和+都是贪婪型的元字符，它们在匹配时的行为模式是多多益善，它们会尽可能从一段文本的开头一直匹配到这段文本的末尾，而不是从这段文本的开头匹配到碰到第一个匹配时为止。

当不需要这种贪婪行为时，可以使用这些元字符的懒惰型版本。懒惰意思是匹配尽可能少的字符，与贪婪型相反。懒惰型元字符只需要给贪婪型元字符加上一个?后缀即可。下面是贪婪型元字符的对应懒惰型版本：

* *?

+ +?

{n,} {n,}?

所以上面的例子中，正则表达式只需要改成<[Bb]>.*?</[Bb]>即可，结果如下：

<b>history</b>

<B>mystery</B>

四、总结

正则表达式的真下威力体现在重复次数匹配方面。这里介绍了+、*、?几种元字符的用法，如果要精确的确定匹配次数，使用{}。元字符分贪婪型和懒惰型两种，在需要防止过度匹配的场合下，请使用懒惰型元字符来构造正则表达式

posted @ 2012-08-12 23:00 zhanghu198901 阅读(13319) | 评论 (1) | 编辑收藏

开发经理（技术型）需要做的第一件事情

根据我近些年在IT行业的摸爬滚打，发现作为一个合格的开发经理需要做的第一件事情是：规范。

1、规范代码

每个公司都有自己的规范文档，但是很少有同学按照规范标准来写自己的代码。这样导致代码风格多元化、代码逻辑可爱化，更有甚者，会有人连自己的代码都看不懂。为什么？原因很简单，虽然写了规范文档，做了规范培训，但是没有强制的执行和跟踪。

我认为作为一个合格的开发经理，需要做如下三件事情。第一步，写代码规范文档，做培训。第二步，按照规范生成开发模版，规定手下的所有开发人员的开发工具中导入此模版。第三步，反复核查开发人员的代码（3-6个月），直到规范成为一种习惯。

2、规范文档

文档在中国IT公司几乎不受太大的重视。

在项目型的公司，要么就是没有文档，要么就是文档泛滥（要知道，有很多文档是做给QA看的，其实都是垃圾），我有时候就想，这样有意义吗？文档的目的是开发人员的辅助工具，尤其对于刚入职公司的新人而言，不会有几个“好心肠”的老员工去帮助新员工讲解项目架构和原理的，进来了就是靠自己摸索，那么文档对于新人就显得尤为重要了。所以，要么就建立一个好的培训机制，要么就写好文档，如果两者都做的很好为最佳。

在互联网公司，对于一些生命周期短暂的小项目不写文档我同意，毕竟需要时间成本。但是这样的项目代码规范一定严格，尽量精细到数据库字段的规范。因为这种类型的项目开发人员一般为1人，如果此人离开，后来人员交接时，能够更快的看懂对方的代码，以节省时间。此外，对于核心项目，一定需要一套完整的API文档，以供各项目组之间的互通，减少不必要的沟通。

总结：正是因为没有合理的规范，某个模块的开发人员离职，会消耗公司的巨大维护成本。如果能够做到以上两点规范，相信能够给公司带来更多的效能。

posted @ 2012-08-12 22:58 zhanghu198901 阅读(1883) | 评论 (1) | 编辑收藏

修改 mysql root 密码

如果 mysql 是刚安装，那么 root 的密码默认为空。可以使用以下方法修改密码：

Java代码  
mysqladmin -u root password PASSWORD  

如果 root 有密码，那么使用以下命令修改：

Java代码  
mysqladmin -u root -p'oldpassword' password newpass  

另外还可以通过登录 sql 控制台后修改：

Sql代码  
update user set password=PASSWORD("NEWPASSWORD") where User='root';  
flush privileges;  

posted @ 2012-07-21 22:16 zhanghu198901 阅读(847) | 评论 (0) | 编辑收藏

android push notification serfice android中的push机制

APNS 是什么?

APNS (Android Push Notification Service) 是一种在 android 上轻松实现 push notification 的功能的解决方案. 只需申请一个 API Key, 经过简单的步骤即可实现 push notification 的功能.

特点:

快速集成:提供一种比C2DM更加快捷的使用方式,避免各种限制.

无需架设服务器:通过使用"云服务",减少额外服务器负担.

可以同时推送消息到网站页面,android 手机

耗电少,占用流量少.

http://zen-mobi.com/get_api_key.php获取apikey

如何在 Android 应用中使用 Notification ？

a) 在应用中添加 APNS 功能

下载 libaray: com_apns.jar
将com_apns.jar添加到工程

在工程上右键打开“属性”,选择 “Java Build Path”, 在 Libraries 中选择 “Add External JARs”, 选择下载的 com_apns.jar.

接收 push notification

使用BroadcastReceiver接收系统广播:  public class MyBroadcastReceiver extends BroadcastReceiver { 	@Override 	public void onReceive(Context context, Intent intent) { 	     if (intent.getAction().equals(APNService.ON_NOTIFICATION)) { 			String str = intent.getStringExtra("data"); 			//todo, 处理收到的消息 		 }  	} }

启动 Push Notification Service

发送Intent 启动服务，将 chanel Id 以及 此设备的标识 (chanel中唯一表示此设备的字符串) 传递过去:       Intent intent = new Intent(APNService.START);     intent.putExtra("ch", chanel);     intent.putExtra("devId", devId);     startService(intent);

Notes

配置 AndroidManifest.xml

... <application android:icon="@drawable/icon"  	   ...  	 <service android:name="com.apns.APNSService" android:label="APNS">          <intent-filter>              <action android:name="com.apns.APNService.START" />              <action android:name="com.apns.APNService.STOP" />              <category android:name="android.intent.category.DEFAULT"/>          </intent-filter> 	 </service> 	 <receiver android:name="MyBroadcastReceiver"> 	      <intent-filter> 	          <action android:name="com.apnsd.APNService.NOTIFICATION" /> 	      </intent-filter> 	 </receiver>	 </application>	 <uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> ...

b) 发送 Notification 到设备

通过 rest 接口发送 Notification:
http://www.push-notification.org/handlers/apns_v1.php?ch=YourChannelId&devId=xxxxx&msg =hello world&random=0123&hash=HashCode

ch:Channel Id devId:接收设备 Id msg:消息 random:随机数 hash:md5(ch + devId + msg + random + apiKey)

posted @ 2012-07-21 22:15 zhanghu198901 阅读(1738) | 评论 (1) | 编辑收藏

android中置调用指定浏览器

默认的浏览器都列出让用户选择的

Java代码

Uri u = Uri.parse(url);

Intent it = new Intent(Intent.ACTION_VIEW, url); TestActivity.this.startActivity(it);

Uri u = Uri.parse(url);

Intent it = new Intent(Intent.ACTION_VIEW, url); TestActivity.this.startActivity(it);

指定浏览器的

Java代码

Uri u = Uri.parse(url);

it.setData(u);

it.setAction( Intent.ACTION_VIEW);

it.setClassName("com.android.browser","com.android.browser.BrowserActivity");

TestActivity.this.startActivity(it);

posted @ 2012-07-21 22:15 zhanghu198901 阅读(1657) | 评论 (1) | 编辑收藏

Java 多线程编程

1) 程序: 指令+数据的byte 序列, 如: qq.exe
2) 进程: 正在运行的程序, 是程序动态的执行过程(运行于主存储器)
3) 线程: 在进程内部, 并发运程的过程(方法)
4) 并发: 进程是并发运行的, OS 将时间划分为很多时间片段, 尽可能
均匀分配给正在运行的程序, 微观上进程走走停停, 宏观上都在运行
这种都运行的现象叫: 并发, 但是不是绝对意义上的"同时"

posted @ 2012-07-18 21:35 zhanghu198901 阅读(1064) | 评论 (2) | 编辑收藏

一种非递归深度遍历

算法比较简单，没有采用递归，javascript实现如下，可以轻易转为其他语言

posted @ 2012-07-18 21:34 zhanghu198901 阅读(724) | 评论 (0) | 编辑收藏

spring的三种注入方式

spring 的三种注入方式

1. 接口注入（不推荐）

2. getter ， setter 方式注入（比较常用）

3. 构造器注入（死的应用）

关于 getter 和 setter 方式的注入

· autowire="defualt"

· autowire=“byName”

· autowire="bytype"

详细解析注入方式

例如：有如下两个类需要注入

第一个类：

Java代码
package  org.jia;  
    
  public   class  Order {  
      private  String orderNum;  
      @SuppressWarnings ( "unused" )  
      private  OrderItem orderitem;  
    
      public  OrderItem getOrderitem() {  
          return  orderitem;  
     }  
   
     public   void  setOrderitem(OrderItem orderitem) {  
         this .orderitem = orderitem;  
     }  
   
     public  String getOrderNum() {  
         return  orderNum;  
     }  
   
     public   void  setOrderNum(String orderNum) {  
         this .orderNum = orderNum;  
     }       
 }  

第二个类：

Java代码
package  org.jia;  
   
 public   class  OrderItem {  
     private  String orderdec;  
   
     public  String getOrderdec() {  
         return  orderdec;  
     }  
   
     public   void  setOrderdec(String orderdec) {  
         this .orderdec = orderdec;  
     }  
 }  

常用getter&&setter方式介绍

方式第一种注入：

Html代码
<? xml   version = "1.0"   encoding = "UTF-8" ?>   
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
  
< beans >   
    < bean   id = "orderItem"   class = "org.jia.OrderItem" >   
        < property   name = "orderdec"   value = "item00001" > </ property >   
    </ bean >   
    < bean   id = "order"   class = "org.jia.Order"   >   
        <!-----注入变量 名字必须与类中的名字一样------->   
        < property   name = "orderNum"   value = "order000007" > </ property >   
         < ！--注入对象 名字为orderitem，所属的类的应用id为orderItem-- >   
        < property   name = "orderitem"   ref = "orderItem" > </ property >   
      
    --> </ bean >   
</ beans >   

方式第二种注入： byName

Html代码
<? xml   version = "1.0"   encoding = "UTF-8" ?>   
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
< beans >   
    <!--此时的id就必须与Order.java中所定义的OrderItem的对象名称一样了，不然就会找不到-->   
    < bean   id = "orderitem"   class = "org.jia.OrderItem" >   
        < property   name = "orderdec"   value = "item00001" > </ property >   
    </ bean >   
    < bean   id = "order"   class = "org.jia.Order" < span   style = "color: #ff0000;" >   autowire = "byName" </ span > >   
        < property   name = "orderNum"   value = "order000007" > </ property >   
    </ bean >   
</ beans >   

方式第三种注入： byType

Html代码
<? xml   version = "1.0"   encoding = "UTF-8" ?>   
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
< beans >   
    <!--按照byType注入则就与id没有关系，可以随便定义id ！！！但是不能出现多个此类的id-->   
    < bean   id = "orderitdfadafaem"   class = "org.jia.OrderItem" >   
        < property   name = "orderdec"   value = "item00001" > </ property >   
    </ bean >   
    < bean   id = "order"   class = "org.jia.Order"   < span   style = "color: #ff0000;" > autowire = "byType" </ span > >   
        < property   name = "orderNum"   value = "order000007" > </ property >   
    </ bean >   
</ beans >   

autowire="constructor"
需要在 Order.java 中加入一个构造器

Java代码
public  Order(OrderItem item )  
{   
      orderitem = item;  
}  

XML配置文件

Html代码
<? xml   version = "1.0"   encoding = "UTF-8" ?>   
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
< beans >   
    < bean   id = "orderItem"   class = "org.jia.OrderItem" >   
        < property   name = "orderdec"   value = "item00001" > </ property >   
    </ bean >   
    < bean   id = "order"   class = "org.jia.Order"   autowire = "constructor" >   
        < property   name = "orderNum"   value = "order000007" > </ property >   
    </ bean >   
</ beans >   

三种注入方式比较

接口注入：
接口注入模式因为具备侵入性，它要求组件必须与特定的接口相关联，因此并不被看好，实际使用有限。
Setter 注入：
对于习惯了传统 javabean 开发的程序员，通过 setter 方法设定依赖关系更加直观。
如果依赖关系较为复杂，那么构造子注入模式的构造函数也会相当庞大，而此时设值注入模式则更为简洁。
如果用到了第三方类库，可能要求我们的组件提供一个默认的构造函数，此时构造子注入模式也不适用。
构造器注入：
在构造期间完成一个完整的、合法的对象。
所有依赖关系在构造函数中集中呈现。
依赖关系在构造时由容器一次性设定，组件被创建之后一直处于相对“不变”的稳定状态。
只有组件的创建者关心其内部依赖关系，对调用者而言，该依赖关系处于“黑盒”之中。

总结

Spring使用注入方式，为什么使用注入方式，这系列问题实际归结起来就是一句话，Spring的注入和IoC （本人关于IoC的阐述）反转控制是一回事。

理论上：第三种注入方式（构造函数注入）在符合java使用原则上更加合理，第二种注入方式（setter注入）作为补充。

posted @ 2012-07-18 21:33 zhanghu198901 阅读(1326) | 评论 (0) | 编辑收藏

jquery学习心得（二）：一个很好的css和js函数调用的例子

统一目录下的资源结构图：

<html>
<head>
<link rel="stylesheet" href="gallery.css" type="text/css" media="screen" charset="utf-8"/>
<script type="text/javascript" src="script.js"></script>
</head>

<body>
    <div id="container">
        <div id="header">
            <h1>StarTrackr!</h1>
    </div>
        <div id="content">
            <h2>Around Town Last Night</h2>

            <div id="ajaxInProgress"></div>
            <div id="photos">
                <fieldset id="photoDetails">
                    <legend>Photo Tagging</legend>
                    <form id="details">
                        <p id="status"></p>
                        <p>
                            <label for="name">Name:</label><br/>
                            <input type="text" class="textField" name="name" id="name" />
                        </p>
                        <p>
                            <label for="tags">Tags:</label><br/>
                            <input type="text" class="textField" name="tags" id="tags" />
                        </p>
                        <p>
                            <input type="hidden" name="id" id="id">
                            <input type="button" value="update" id="update" />
                        </p>
                    </form>
                    <div id="gallery"></div>
                </fieldset>
            </div>
   </div>
</div>
</body>
</html>

posted @ 2012-07-18 21:32 zhanghu198901 阅读(873) | 评论 (0) | 编辑收藏

Java程序员不该有的6种陋习

只有在学会处理异常之后，我们才能说自己是一个合格的java程序员。只有在摆脱了以下六种异常处理的陋习之后，才能威慑一下刚毕业的小菜鸟。

　　现在就来测试一下大家对异常的掌握程度。不用担心，事实上，这些不合理的设计很容易看出来。那么，以下六种不合理的代码，大家能看出每一种的问题出在哪儿吗？

　　OutputStreamWriter out = ...

　　java.sql.Connection conn = ...

　　try { // ⑸

　　Statement stat = conn.createStatement();

　　ResultSet rs = stat.executeQuery(

　　"select uid, name from user");

　　while (rs.next())

　　{

　　out.println("ID：" + rs.getString("uid") // ⑹

　　+ "，姓名：" + rs.getString("name"));

　　}

　　conn.close(); // ⑶

　　out.close();

　　}

　　catch(Exception ex) // ⑵

　　{

　　ex.printStackTrace(); //⑴，⑷

　　}

　　作为一个Java程序员，你至少应该能够找出两个问题。但是，如果你不能找出全部六个问题，请继续阅读本文。

　　本文讨论的不是Java异常处理的一般性原则，因为这些原则已经被大多数人熟知。我们要做的是分析各种可称为“反例”(anti-pattern)的违背优秀编码规范的常见坏习惯，帮助读者熟悉这些典型的反面例子，从而能够在实际工作中敏锐地察觉和避免这些问题。

　　反例之一：丢弃异常

　　代码：15行-18行。

　　这段代码捕获了异常却不作任何处理，可以算得上Java编程中的杀手。从问题出现的频繁程度和祸害程度来看，它也许可以和C/C++程序的一个恶名远播的问题相提并论？？不检查缓冲区是否已满。如果你看到了这种丢弃(而不是抛出)异常的情况，可以百分之九十九地肯定代码存在问题(在极少数情况下，这段代码有存在的理由，但最好加上完整的注释，以免引起别人误解)。

　　这段代码的错误在于，异常(几乎)总是意味着某些事情不对劲了，或者说至少发生了某些不寻常的事情，我们不应该对程序发出的求救信号保持沉默和无动于衷。调用一下printStackTrace算不上“处理异常”。不错，调用printStackTrace对调试程序有帮助，但程序调试阶段结束之后，printStackTrace就不应再在异常处理模块中担负主要责任了。

　　丢弃异常的情形非常普遍。打开JDK的ThreadDeath类的文档，可以看到下面这段说明：“特别地，虽然出现ThreadDeath是一种‘正常的情形’，但ThreadDeath类是Error而不是Exception的子类，因为许多应用会捕获所有的Exception然后丢弃它不再理睬。”这段话的意思是，虽然ThreadDeath代表的是一种普通的问题，但鉴于许多应用会试图捕获所有异常然后不予以适当的处理，所以JDK把 ThreadDeath定义成了Error的子类，因为Error类代表的是一般的应用不应该去捕获的严重问题。可见，丢弃异常这一坏习惯是如此常见，它甚至已经影响到了Java本身的设计。

　　那么，应该怎样改正呢？主要有四个选择：

　　1、处理异常。针对该异常采取一些行动，例如修正问题、提醒某个人或进行其他一些处理，要根据具体的情形确定应该采取的动作。再次说明，调用printStackTrace算不上已经“处理好了异常”。

　　2、重新抛出异常。处理异常的代码在分析异常之后，认为自己不能处理它，重新抛出异常也不失为一种选择。

　　3、把该异常转换成另一种异常。大多数情况下，这是指把一个低级的异常转换成应用级的异常(其含义更容易被用户了解的异常)。

　　4、不要捕获异常。

　　结论一：既然捕获了异常，就要对它进行适当的处理。不要捕获异常之后又把它丢弃，不予理睬。

　　反例之二：不指定具体的异常

　　代码：15行。

　　许多时候人们会被这样一种“美妙的”想法吸引：用一个catch语句捕获所有的异常。最常见的情形就是使用catch(Exceptionex)语句。但实际上，在绝大多数情况下，这种做法不值得提倡。为什么呢？

　　要理解其原因，我们必须回顾一下catch语句的用途。catch语句表示我们预期会出现某种异常，而且希望能够处理该异常。异常类的作用就是告诉Java编译器我们想要处理的是哪一种异常。由于绝大多数异常都直接或间接从java.lang.Exception派生，catch(Exceptionex)就相当于说我们想要处理几乎所有的异常。

　　再来看看前面的代码例子。我们真正想要捕获的异常是什么呢？最明显的一个是SQLException，这是JDBC操作中常见的异常。另一个可能的异常是IOException，因为它要操作OutputStreamWriter.显然，在同一个catch块中处理这两种截然不同的异常是不合适的。如果用两个catch块分别捕获SQLException和IOException就要好多了。这就是说，catch语句应当尽量指定具体的异常类型，而不应该指定涵盖范围太广的Exception类。

　　另一方面，除了这两个特定的异常，还有其他许多异常也可能出现。例如，如果由于某种原因，executeQuery返回了null，该怎么办？答案是让它们继续抛出，即不必捕获也不必处理。实际上，我们不能也不应该去捕获可能出现的所有异常，程序的其他地方还有捕获异常的机会？？直至最后由 JVM处理。

　　结论二：在catch语句中尽可能指定具体的异常类型，必要时使用多个catch.不要试图处理所有可能出现的异常。

　　反例之三：占用资源不释放

　　代码：3行-14行。

　　异常改变了程序正常的执行流程。这个道理虽然简单，却常常被人们忽视。如果程序用到了文件、Socket、JDBC连接之类的资源，即使遇到了异常，也要正确释放占用的资源。为此，Java提供了一个简化这类操作的关键词finally.

　　finally是样好东西：不管是否出现了异常，Finally保证在try/catch/finally块结束之前，执行清理任务的代码总是有机会执行。遗憾的是有些人却不习惯使用finally.

　　当然，编写finally块应当多加小心，特别是要注意在finally块之内抛出的异常？？这是执行清理任务的最后机会，尽量不要再有难以处理的错误。

　　结论三：保证所有资源都被正确释放。充分运用finally关键词。

　　反例之四：不说明异常的详细信息

　　代码：3行-18行。

　　仔细观察这段代码：如果循环内部出现了异常，会发生什么事情？我们可以得到足够的信息判断循环内部出错的原因吗？不能。我们只能知道当前正在处理的类发生了某种错误，但却不能获得任何信息判断导致当前错误的原因。

　　printStackTrace的堆栈跟踪功能显示出程序运行到当前类的执行流程，但只提供了一些最基本的信息，未能说明实际导致错误的原因，同时也不易解读。

　　因此，在出现异常时，最好能够提供一些文字信息，例如当前正在执行的类、方法和其他状态信息，包括以一种更适合阅读的方式整理和组织printStackTrace提供的信息。

　　结论四：在异常处理模块中提供适量的错误原因信息，组织错误信息使其易于理解和阅读。

　　反例之五：过于庞大的try块

　　代码：3行-14行。

　　经常可以看到有人把大量的代码放入单个try块，实际上这不是好习惯。这种现象之所以常见，原因就在于有些人图省事，不愿花时间分析一大块代码中哪几行代码会抛出异常、异常的具体类型是什么。把大量的语句装入单个巨大的try块就象是出门旅游时把所有日常用品塞入一个大箱子，虽然东西是带上了，但要找出来可不容易。

　　一些新手常常把大量的代码放入单个try块，然后再在catch语句中声明Exception，而不是分离各个可能出现异常的段落并分别捕获其异常。这种做法为分析程序抛出异常的原因带来了困难，因为一大段代码中有太多的地方可能抛出Exception.

　　结论五：尽量减小try块的体积。

　　反例之六：输出数据不完整

　　代码：7行-11行。

　　不完整的数据是Java程序的隐形杀手。仔细观察这段代码，考虑一下如果循环的中间抛出了异常，会发生什么事情。循环的执行当然是要被打断的，其次，catch块会执行？？就这些，再也没有其他动作了。已经输出的数据怎么办？使用这些数据的人或设备将收到一份不完整的(因而也是错误的)数据，却得不到任何有关这份数据是否完整的提示。对于有些系统来说，数据不完整可能比系统停止运行带来更大的损失。

　　较为理想的处置办法是向输出设备写一些信息，声明数据的不完整性;另一种可能有效的办法是，先缓冲要输出的数据，准备好全部数据之后再一次性输出。

　　结论六：全面考虑可能出现的异常以及这些异常对执行流程的影响。

　　改写后的代码

　　根据上面的讨论，下面给出改写后的代码。也许有人会说它稍微有点？嗦，但是它有了比较完备的异常处理机制。

　　OutputStreamWriter out = ...

　　java.sql.Connection conn = ...

　　try {

　　Statement stat = conn.createStatement();

　　ResultSet rs = stat.executeQuery(

　　"select uid, name from user");

　　while (rs.next())

　　{

　　out.println("ID：" + rs.getString("uid") + "，姓名: " + rs.getString("name"));

　　}

　　catch(SQLException sqlex)

　　{

　　out.println("警告：数据不完整");

　　throw new ApplicationException("读取数据时出现SQL错误", sqlex);

　　}

　　catch(IOException ioex)

　　{

　　throw new ApplicationException("写入数据时出现IO错误", ioex);

　　}

　　finally

　　{

　　if (conn != null) {

　　try {

　　conn.close();

　　}

　　catch(SQLException sqlex2)

　　{

　　System.err(this.getClass().getName() + ".mymethod - 不能关闭数据库连接: " + sqlex2.toString());

　　}

　　if (out != null) {

　　try {

　　out.close();

　　}

　　catch(IOException ioex2)

　　{

　　System.err(this.getClass().getName() + ".mymethod - 不能关闭输出文件" + ioex2.toString());

　　}

　　本文的结论不是放之四海皆准的教条，有时常识和经验才是最好的老师。如果你对自己的做法没有百分之百的信心，务必加上详细、全面的注释。

　　另一方面，不要笑话这些错误，不妨问问你自己是否真地彻底摆脱了这些坏习惯。即使最有经验的程序员偶尔也会误入歧途，原因很简单，因为它们确确实实带来了“方便”。所有这些反例都可以看作Java编程世界的恶魔，它们美丽动人，无孔不入，时刻诱惑着你。也许有人会认为这些都属于鸡皮蒜毛的小事，不足挂齿，但请记住：勿以恶小而为之，勿以善小而不为。

posted @ 2012-07-16 22:20 zhanghu198901 阅读(1761) | 评论 (1) | 编辑收藏

Hibernate对象映射关系----继承映射

单表继承映射

每棵类继承树使用一个表。

映射文件Extends.hbm.xml。

<hibernate-mapping package="com.snail.hibernate">
    <class name="Animal" table="t_animal" lazy="false">
        <id name="id">
            <generator class="native"/>
        </id>
        <discriminator column="type" type="string"/>
        <property name="name"/>
        <property name="sex"/>
        <subclass name="Pig" discriminator-value="P">
             <property name="weight"/>
        </subclass>
        <subclass name="Brid" discriminator-value="B">
            <property name="height"/>
        </subclass>
    </class>
</hibernate-mapping>

因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤：

（一）父类用普通的<class>标签定义

（二）在父类中定义一个discriminator，即指定这个区分的字段的名称和类型

如：<discriminator column=”XXX” type=”string”/>

（三）子类使用<subclass>标签定义，在定义subclass的时候，需要注意如下几点：

1.Subclass标签的name属性是子类的全路径名；

2.在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）的值；

3.Subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值是父类的全路径名称。

4.子类的其它属性，像普通类一样，定义在subclass标签的内部。

具体表继承映射

每个具体类一张表。（同上例）

映射文件Extends.hbm.xml。

<hibernate-mapping package="com.snail.hibernate">
    <class name="Animal" table="t_animal" lazy="false" abstract="true">
        <id name="id">
            <generator class="assigned"/>
        </id>
        <property name="name"/>
        <property name="sex"/>
        <union-subclass name="Pig" table="t_pig">
            <property name="weight"/>
        </union-subclass>
        <union-subclass name="Brid" table="t_brid">
            <property name="height"/>
        </union-subclass>
    </class>
</hibernate-mapping>

这种策略是使用union-subclass标签来定义子类的。每个子类对应一张表，而且这个表的信息是完备的，即包含了所有从父类继承下来的属性映射的字段（这就是它跟joined-subclass的不同之处，joined-subclass定义的子类的表，只包含子类特有属性映射的字段）。实现这种策略的时候，有如下步骤：

（一）父类用普通<class>标签定义即可；

（二）子类用<union-subclass>标签定义，在定义union-subclass的时候，需要注意如下几点：

1.Union-subclass标签不再需要包含key标签（与joined-subclass不同）。

2.Union-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。当Union-subclass标签的定义与class标签平行的时候，需要在Union-subclass标签中，添加extends属性，里面的值是父类的全路径名称。

3.子类的其它属性，像普通类一样，定义在Union-subclass标签的内部。这个时候，虽然在union-subclass里面定义的只有子类的属性，但是因为它继承了父类，所以，不需要定义其它的属性，在映射到数据库表的时候，依然包含了父类的所有属性的映射字段。

注意：在保存对象的时候id不能重复（不能使用数据库的自增方式生成主键）

类表继承映射

每个类一张表。（同上例）

映射文件Extends.hbm.xml。

[html] view plain copy

<hibernate-mapping package="com.snail.hibernate">
<class name="Animal" table="t_animal" lazy="false">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<property name="sex"/>
<joined-subclass name="Pig" table="t_pig">
<key column="pid"/>
<property name="weight"/>
</joined-subclass>
<joined-subclass name="Brid" table="t_brid">
<key column="bid"/>
<property name="height"/>
</joined-subclass>
</class>
</hibernate-mapping>

这种策略是使用joined-subclass标签来定义子类的。父类、子类，每个类都对应一张数据库表。在父类对应的数据库表中，实际上会存储所有的记录，包括父类和子类的记录；在子类对应的数据库表中，这个表只定义了子类中所特有的属性映射的字段。子类与父类，通过相同的主键值来关联。实现这种策略的时候，有如下步骤：

（一）父类用普通的<class>标签定义即可，父类不再需要定义discriminator字段；

（二）子类用<joined-subclass>标签定义，在定义joined-subclass的时候，需要注意如下几点：

1.Joined-subclass标签的name属性是子类的全路径名

2．Joined-subclass标签需要包含一个key标签，这个标签指定了子类和父类之间是通过哪个字段来关联的。

如：<key column=”PARENT_KEY_ID”/>，这里的column，实际上就是父类的主键对应的映射字段名称。

3.Joined-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。当Joined-subclass标签的定义与class标签平行的时候，需要在Joined-subclass标签中，添加extends属性，里面的值是父类的全路径名称。

4.子类的其它属性，像普通类一样，定义在joined-subclass标签的内部。

posted @ 2012-07-16 22:16 zhanghu198901 阅读(997) | 评论 (0) | 编辑收藏

js把毫秒转换为 xx小时xx分钟xx秒的通用方法

posted @ 2012-07-12 22:30 zhanghu198901 阅读(2745) | 评论 (1) | 编辑收藏

Eclipse字符集设置方式

1、windows->Preferences...打开"首选项"对话框，左侧导航树，导航到general->Workspace，右侧Text file encoding，选择Other，改变为 utf-8(必须小写)，以后新建立工程其属性对话框中的Text file encoding即为UTF-8。

2、windows->Preferences...打开"首选项"对话框，左侧导航树，导航到general->Content Types，右侧Content Types树，点开Text，选择 Java Source File，在下面的Default encoding输入框中输入UTF-8，点Update，则设置Java文件编码为UTF-8。然后设置jsp、js、css等类型的Default encoding，设置方式同Java Source File。

3.windows->Preferences...打开"首选项"对话框，左侧导航树，导航到MyEclipse->Files and Editors->JSP,把Encoding改为UTF-8

posted @ 2012-07-12 22:30 zhanghu198901 阅读(6142) | 评论 (0) | 编辑收藏

Java的API你掌握程度去到哪呢，又需要掌握到哪呢

1、java.lang包下的80％以上的类的功能的灵活运用。

2、java.util包下的80％以上的类的灵活运用，特别是集合类体系、正规表达式、时间、属性、和Timer.

3、java.io包下的60％以上的类的使用，理解IO体系的基于管道模型的设计思路以及常用IO类的特性和使用场合。

4、java.math包下的100％的内容。

5、java.net包下的60％以上的内容，对各个类的功能比较熟悉。

6、java.text包下的60％以上的内容，特别是各种格式化类。

7、熟练运用JDBC.

8、java.security包下40％以上的内容，如果对于安全没有接触的话根本就不可能掌握java.

9、AWT的基本内容，包括各种组件事件、监听器、布局管理器、常用组件、打印。

10、Swing的基本内容，和AWT的要求类似。

11、XML处理，熟悉SAX、DOM以及JDOM的优缺点并且能够使用其中的一种完成XML的解析及内容处理。

posted @ 2012-07-12 22:30 zhanghu198901 阅读(1108) | 评论 (2) | 编辑收藏

浅谈SQL中的where 1=1 作用

where 1=1
最近看到很多sql里用到where 1=1，原来觉得这没用嘛，但是又想到如果没用为什么要写呢？于是在网上

查了查，在这里就浅谈一下：
1=1 永真， 1<>1 永假。

1<>1 的用处：
用于只取结构不取数据的场合
例如：
create table table_temp tablespace tbs_temp as
select * from table_ori where 1<>1
建成一个与table_ori 结构相同的表table_temp，但是不要table_ori 里的数据。（除了表结构，其它结

构也同理)

1=1的用处
用于动态SQL
例如 lv_string := 'select tbl_name,tbl_desc from tbl_test where 1=1 '||l_condition;
当用户选择了查询的名称'abc'时l_condition :='and tbl_name = ''abc'''';但是当用户没有

选择名称查询时l_condition就为空这样 lv_string = 'select tbl_name,tbl_desc from tbl_test

where 1=1 ' ，运行也不会出错，相当于没有限制名称条件。但是如果没有1=1的条件，则lv_string =

'select tbl_name,tbl_desc from tbl_test where ';这样就会报错。

除了1=1 或1<>1之外的其它永真永假的条件同理。

posted @ 2012-07-12 22:29 zhanghu198901 阅读(961) | 评论 (0) | 编辑收藏

浅谈Java对象的强、软、弱和虚引用

在JDK1.2以前的版本中，当一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于可触及状态，程序才能使用它。这就像在日常生活中，从商店购买了某样物品后，如果有用，就一直保留它，否则就把它扔到垃圾箱，由清洁工人收走。一般说来，如果物品已经被扔到垃圾箱，想再把它捡回来使用就不可能了。

但有时候情况并不这么简单，你可能会遇到类似鸡肋一样的物品，食之无味，弃之可惜。这种物品现在已经无用了，保留它会占空间，但是立刻扔掉它也不划算，因为也许将来还会派用场。对于这样的可有可无的物品，一种折衷的处理办法是：如果家里空间足够，就先把它保留在家里，如果家里空间不够，即使把家里所有的垃圾清除，还是无法容纳那些必不可少的生活用品，那么再扔掉这些可有可无的物品。从JDK1.2版本开始，把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

1．强引用

　　本章前文介绍的引用实际上都是强引用，这是使用最普遍的引用。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。

2．软引用（SoftReference）

　　如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

3．弱引用（WeakReference）

　　如果一个对象只具有弱引用，那就类似于可有可物的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

4．虚引用（PhantomReference）

　　"虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。

posted @ 2012-07-12 22:28 zhanghu198901 阅读(812) | 评论 (0) | 编辑收藏

APNS 是什么?

如何在 Android 应用中使用 Notification ？

spring 的三种注入方式

关于 getter 和 setter 方式的注入

详细解析注入方式

三种注入方式比较

总结

常用链接

留言簿

随笔档案

搜索

最新评论

阅读排行榜

评论排行榜