2012年4月18日
#
摘要: 转载：http://www.blogjava.net/qcyycom/archive/2013/07/11/401467.htmlSpring MVC 3 深入总结
一、前言：
大家好，Spring3 MVC是非常优秀的MVC框架，由其是在3.0版本发布后，现在有越来越多的团队选择了Spring3 MVC了。Spring3 MVC结构简单，应了那句话简单就是美，而且他强大不失灵活，性能...
阅读全文
1.delete from 表名 where ID in (select id from 表名 group by id having count(id) >1)
and rowid not in (select min(rowid) from 表名 group by id having count(id )>1)
使用POI对excel表数据进行操作时出现了该问题，从数据库导出数据到excel表中，datetime类型的数据以String类型存储，当对表内的该列数据做修改后，excel将自动修改单元格的格式，从而导致在重新读取时出现了以上错误。
解决办法：
判断读取的单元格是否为HSSFCell.CELL_TYPE_NUMERIC类型，然后利用cell.getNumericCellValue()，读取该单元格的数据。
getNumericCellValue()读出的数据类型是double型，
因此，需要重新进行数据转换：HSSFDateUtil.getJavaDate(d).toLocaleString()。其中d为读出的double类型数据。
至此，则成功的将excel表内的数据读取出来。
单元格的格式总共有以下几种：
HSSFCell.CELL_TYPE_BLANK;
HSSFCell.CELL_TYPE_BOOLEAN;
HSSFCell.CELL_TYPE_ERROR;
HSSFCell.CELL_TYPE_FORMULA;
HSSFCell.CELL_TYPE_NUMERIC;
HSSFCell.CELL_TYPE_STRING;
转载：
http://www.blogjava.net/zhanghu198901/archive/2012/08/12/385337.html
PS：在所有例子中正则表达式匹配结果包含在源文本中的【和】之间，有的例子会使用java来实现，如果是java本身正则表达式的用法，会在相应的地方说明。所有java例子都在JDK1.6.0_13下测试通过。
一、有多少个匹配
前面几篇讲的都是匹配一个字符，但是一个字符或字符集合要匹配多次，应该怎么做呢？比如要匹配一个电子邮件地址，用之前说到的方法，可能有人会写出像\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>
<b>gift</b>
四、总结
正则表达式的真下威力体现在重复次数匹配方面。这里介绍了+、*、?几种元字符的用法，如果要精确的确定匹配次数，使用{}。元字符分贪婪型和懒惰型两种，在需要防止过度匹配的场合下，请使用懒惰型元字符来构造正则表达式
转载：http://www.blogjava.net/zhanghu198901/archive/2012/08/12/385337.html
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]
一、final
根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
1、final类
final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。
2、final方法
如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
使用final方法的原因有二：
第一、把方法锁定，防止任何继承类修改它的意义和实现。
第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
例如：
public class Test1 {
public static void main(String[] args) {
// TODO 自动生成方法存根
}
public void f1() {
System.out.println("f1");
}
//无法被子类覆盖的方法
public final void f2() {
System.out.println("f2");
}
public void f3() {
System.out.println("f3");
}
private void f4() {
System.out.println("f4");
}
}
public class Test2 extends Test1 {
public void f1(){
System.out.println("Test1父类方法f1被覆盖!");
}
public static void main(String[] args) {
Test2 t=new Test2();
t.f1();
t.f2(); //调用从父类继承过来的final方法
t.f3(); //调用从父类继承过来的方法
//t.f4(); //调用失败，无法从父类继承获得
}
} |
3、final变量（常量）
用final修饰的成员变量表示常量，值一旦给定就无法改变！
final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。
另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。
package org.leizhimin;
public class Test3 {
private final String S="final实例变量S";
private final int A=100;
public final int B=90;
public static final int C=80;
private static final int D=70;
public final int E; //final空白,必须在初始化对象的时候赋初值
public Test3(int x){
E=x;
}
/**
* @param args
*/
public static void main(String[] args) {
Test3 t=new Test3(2);
//t.A=101; //出错,final变量的值一旦给定就无法改变
//t.B=91; //出错,final变量的值一旦给定就无法改变
//t.C=81; //出错,final变量的值一旦给定就无法改变
//t.D=71; //出错,final变量的值一旦给定就无法改变
System.out.println(t.A);
System.out.println(t.B);
System.out.println(t.C); //不推荐用对象方式访问静态字段
System.out.println(t.D); //不推荐用对象方式访问静态字段
System.out.println(Test3.C);
System.out.println(Test3.D);
//System.out.println(Test3.E); //出错,因为E为final空白,依据不同对象值有所不同.
System.out.println(t.E);
Test3 t1=new Test3(3);
System.out.println(t1.E); //final空白变量E依据对象的不同而不同
}
private void test(){
System.out.println(new Test3(1).A);
System.out.println(Test3.C);
System.out.println(Test3.D);
}
public void test2(){
final int a; //final空白,在需要的时候才赋值
final int b=4; //局部常量--final用于局部变量的情形
final int c; //final空白,一直没有给赋值.
a=3;
//a=4; 出错,已经给赋过值了.
//b=2; 出错,已经给赋过值了.
}
} |
4、final参数
当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。
public class Test4 {
public static void main(String[] args) {
new Test4().f1(2);
}
public void f1(final int i){
//i++; //i是final类型的,值不允许改变的.
System.out.print(i);
}
} |
二、static static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是
Java语言中没有全局变量的概念。
被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。
用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。
static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。
static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：
类名.静态方法名(参数列表...)
类名.静态变量名
用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。
1、static变量 按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：
对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。
2、静态方法 静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！
因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。
3、static代码块 static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如：
public class Test5 {
private static int a;
private int b;
static{
Test5.a=3;
System.out.println(a);
Test5 t=new Test5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static{
Test5.a=4;
System.out.println(a);
}
public static void main(String[] args) {
// TODO 自动生成方法存根
}
static{
Test5.a=5;
System.out.println(a);
}
public void f(){
System.out.println("hhahhahah");
}
} |
运行结果：
3
hhahhahah
1000
4
5
利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。
4、static和final一块用表示什么 static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
对于方法，表示不可覆盖，并且可以通过类名直接访问。
什么是ThreadLocal？
顾名思义它是local variable（线程局部变量）。它的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。
使用场景
- To keep state with a thread (user-id, transaction-id, logging-id)
- To cache objects which you need frequently
ThreadLocal类
它主要由四个方法组成initialValue()，get()，set(T)，remove()，其中值得注意的是initialValue()，该方法是一个protected的方法，显然是为了子类重写而特意实现的。该方法返回当前线程在该线程局部变量的初始值，这个方法是一个延迟调用方法，在一个线程第1次调用get()或者set(Object)时才执行，并且仅执行1次。ThreadLocal中的确实实现直接返回一个null：
ThreadLocal的原理
ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。比如下面的示例实现：
public class ThreadLocal
{
private Map values = Collections.synchronizedMap(new HashMap());
public Object get()
{
Thread curThread = Thread.currentThread();
Object o = values.get(curThread);
if (o == null && !values.containsKey(curThread))
{
o = initialValue();
values.put(curThread, o);
}
return o;
}
public void set(Object newValue)
{
values.put(Thread.currentThread(), newValue);
}
public Object initialValue()
{
return null;
}
}
ThreadLocal 的使用
使用方法一：
Hibernate的文档时看到了关于使ThreadLocal管理多线程访问的部分。具体代码如下
1. public static final ThreadLocal session = new ThreadLocal();
2. public static Session currentSession() {
3. Session s = (Session)session.get();
4. //open a new session,if this session has none
5. if(s == null){
6. s = sessionFactory.openSession();
7. session.set(s);
8. }
return s;
9. }
我们逐行分析
1。 初始化一个ThreadLocal对象，ThreadLocal有三个成员方法 get()、set()、initialvalue()。
如果不初始化initialvalue，则initialvalue返回null。
3。session的get根据当前线程返回其对应的线程内部变量，也就是我们需要的net.sf.hibernate.Session（相当于对应每个数据库连接）.多线程情况下共享数据库链接是不安全的。ThreadLocal保证了每个线程都有自己的s（数据库连接）。
5。如果是该线程初次访问，自然，s（数据库连接）会是null，接着创建一个Session，具体就是行6。
6。创建一个数据库连接实例 s
7。保存该数据库连接s到ThreadLocal中。
8。如果当前线程已经访问过数据库了，则从session中get()就可以获取该线程上次获取过的连接实例。
使用方法二
当要给线程初始化一个特殊值时，需要自己实现ThreadLocal的子类并重写该方法，通常使用一个内部匿名类对ThreadLocal进行子类化，EasyDBO中创建jdbc连接上下文就是这样做的：
public class JDBCContext{
private static Logger logger = Logger.getLogger(JDBCContext.class);
private DataSource ds;
protected Connection connection;
private boolean isValid = true;
private static ThreadLocal jdbcContext;
private JDBCContext(DataSource ds){
this.ds = ds;
createConnection();
}
public static JDBCContext getJdbcContext(javax.sql.DataSource ds)
{
if(jdbcContext==null)jdbcContext=new JDBCContextThreadLocal(ds);
JDBCContext context = (JDBCContext) jdbcContext.get();
if (context == null) {
context = new JDBCContext(ds);
}
return context;
}
private static class JDBCContextThreadLocal extends ThreadLocal {
public javax.sql.DataSource ds;
public JDBCContextThreadLocal(javax.sql.DataSource ds)
{
this.ds=ds;
}
protected synchronized Object initialValue() {
return new JDBCContext(ds);
}
}
}
使用单例模式，不同的线程调用getJdbcContext()获得自己的jdbcContext，都是通过JDBCContextThreadLocal 内置子类来获得JDBCContext对象的线程局部变量，这个变
1.目的
ThreadLocal目的是保存一些线程级别的全局变量，比如connection，或者事务上下文，避免这些值需要一直通过函数参数的方式一路传递。
2. 常见用法
举例其中一种常见用法：
public class Test2 {
public static void main(String[] args) throws InterruptedException {
testThreadLocal();
}
private static void testThreadLocal() {
Util.setGlobalName("zili.dengzl");
new Foo().printName();
}
}
class Foo{
public void printName(){
System.out.println("globalName="+Util.getGlobalName());
}
}
class Util {
private static final ThreadLocal<String> globalName = new ThreadLocal<String>();
public static String getGlobalName() {
return globalName.get();
}
public static void setGlobalName(String name) {
globalName.set(name);
}
}
3.实现分析
要实现上面这样的功能，最简单的想法是用一个Map<Thread,T>,如下：
class MockThreadLocal<T> {
private Map<Thread, T> map = new HashMap<Thread, T>();
public T get() {
return (T) map.get(Thread.currentThread());
}
public void set(T value) {
map.put(Thread.currentThread(), value);
}
}
这样也能实现ThreadLocal的效果，但是有一个问题，当对应的线程消失后，map中对应的线程值并不会被回收，从而造成内存泄露。
事实上ThreadLocal是这样做的：
每个Thread都有一个threadLocalMap，key是threadLocal对象，value是具体使用的值。ThreadLocal对象的get就是先取得当前的Thread，然后从这个Thread的threadLcoalMap中取出值。set类似。
下面看下具体代码：
/**
* Returns the value in the current thread's copy of this
* thread-local variable. If the variable has no value for the
* current thread, it is first initialized to the value returned
* by an invocation of the {@link #initialValue} method.
*
* @return the current thread's value of this thread-local
*/
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
return setInitialValue();
}
注意这里如果取到没有该线程对应的值，会调用setInitialValue();，最终调用initialValue()生成一个值，这也是我们很多场景下要override这个方法的原因；
下面看一下getMap(Thread t)方法：
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
在Thread类中：
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
由此可见，所有的ThreadLocal的信息，最终是关联到Thread上的，线程消失后，对应的Thread对象也被回收，这时对应的ThreadLocal对象(该线程部分)也会被回收。
这里为什么是一个ThreadLocalMap呢，因为一个线程可以有多个ThreadLocal变量，通过map.getEntry(this)取得对应的某个具体的变量。
private Entry getEntry(ThreadLocal key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}
最后要注意的一点是，ThreadLocalMap的Entry是一个weakReference：
/**
* The entries in this hash map extend WeakReference, using
* its main ref field as the key (which is always a
* ThreadLocal object). Note that null keys (i.e. entry.get()
* == null) mean that the key is no longer referenced, so the
* entry can be expunged from table. Such entries are referred to
* as "stale entries" in the code that follows.
*/
static class Entry extends WeakReference<ThreadLocal> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}
这里主要因为ThreadLocalMap的key是ThreadLocal对象，如果某个ThreadLocal对象所有的强引用没有了，会利用weakref的功能把他回收掉，然后复用这个entry。
考虑一下如果不用weakReference会出现什么情况：假设某个对象是这样引用的
private final ThreadLocal<String> globalName = new ThreadLocal<String>();
注意没有static，然后这个对象被不断的new出来，然后死掉，每次ThreadLocalmap中都会多出一个entry，然后这个entry强引用一个ThreadLocal对象，ThreadLocalMap本身就没有办法确定哪个entry是不用了的，如果恰好这个线程是线程池中的，会存活很久，那就杯具了。
ThreadLocalMap用了weakReference，失去强引用的ThreadLocal对象会在下次gc时被回收，然后ThreadLocalMap本身在get和set的时候会考察key为空的Entry，并复用它或者清除，从而避免内存泄露。
这样看来，HashMap也有一样的问题，但为什么hashMap不这样呢，因为hashMap的put是业务代码操作的，因此如果有长期存活的HashMap，（比如static的）业务代码put进去就有义务去remove，但ThreadLocal的put操作时ThreadLocal类干的，业务代码不知道，因此也不会去做remove，而ThreadLocalMap本身不知道引用他的某个entry的key的对象什么时候死掉了，那么如果不用弱引用，就不知道这个ThreadLocal对象什么时候需要回收了。
附：
这里补充一下weakReference的用法供参考（当强引用不存在时，下次垃圾回收会回收弱引用所引用的对象）：
Object o = new Object();
WeakReference<Object> ref = new WeakReference<Object>(o);
System.out.println(ref.get());
o=null;
System.gc();
System.out.println(ref.get());
结果输出：
java.lang.Object@de6ced
null
4. FAQ
4.1 为什么一般的ThreadLocal用法都要加static，如下：
class Test {
private static final ThreadLocal<String> globalName = new ThreadLocal<String>();
}
answer:事实上，不一定是要static，但使用它的对象在业务需要范围类一定要是单例。因为根据前面的分析，ThreadLocalMap是以ThreadLocal对象为key的，如果Test类不是static，也不是单例的，那么两个Test对象就有两个key，取出来的数据肯定不同
class TestThreadLocal{
public static void main(String[] args) {
Test t1 = new Test();
Test t2 = new Test();
t1.pool.set("a");
System.out.println(t1.pool.get());
System.out.println(t2.pool.get());
}
}
class Test{
public ThreadLocal pool = new ThreadLocal();
}
输出将会是：a，null
原因就无需多解释了。唯一需要啰嗦的一点是，就算一般情况都是单例，上面那个weakreference还是必要的，因为作为框架代码，不能保证正常使用的情况下一个线程有很多ThreadLocal，如果不用weakreference，就会有内存泄漏的风险，特别是针对线程池中的线程。
摘要: 转载：http://www.blogjava.net/f6k66ve/archive/2012/05/30/379516.htmlSpring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。
DataSource、TransactionManager这两部分只是会根...
阅读全文
本文系 www.javady.com网站原创
总接口：Iterable<T> 实现这个接口允许对象成为 "foreach" 语句的目标。
Collection<E> 层次结构 中的根接口。Collection 表示一组对象
一、 List ：实现 collection接口 有序的集合 可以允许重复
| ArrayList |
| 初始大小 |
10 |
| 扩容因子 |
(大小*3)/2 + 1 |
| 扩容例子 |
10 超过时之后扩容到 16 然后 25 然后 38... |
| 数据处理 |
删除其中一个元素后后面的元素会自动向前推 |
| 线程是否安全 |
不安全 |
| 优势 |
ArrayList的优势在于读取和表尾插入 |
| 多线程使用 |
List list = Collections.synchronizedList(new ArrayList(…)) |
| LinkedList |
| 说明 |
List接口的链接列表实现 。 |
| 初始大小 |
1 |
| 数据处理 |
删除其中一个元素后后面的元素会自动向前推，
LinkedList 中的链接关系是由 Entity实现的,
每个Entity都有 上一个Entity引用 下一个Entity引用
本身元素值Entry(E element, Entry<E> next, Entry<E> previous)
LinkedList 类还为在列表的开头及结尾 get、remove 和 insert
元素提供了统一的命名方法。
此类实现 Queue 接口，为 add、poll 等提供先进先出队列操作 |
| 优势 |
LinkedList的优势在于表中插入和删除 |
| 线程是否安全 |
不安全 ，可以使用如下进行安全处理
List list = Collections.synchronizedList(new LinkedList(...)); |
| Vector |
| 说明 |
Vector 类可以实现可增长的对象数组 |
| 初始大小 |
10 |
| 扩容因子 |
1 ， 默认扩容一倍 |
| 扩容例子 |
10 超过时之后扩容到 20 然后 40 然后 80… |
| 数据处理 |
删除其中一个元素后后面的元素会自动向前推 |
| 是否同步 |
Vector 是同步的 |
| 用法 |
一般在多线程中使用对于一般的数据存储直接用ArrayList |
| Stack |
| 类型解释 |
表示后进先出（LIFO）的对象堆栈 。
它通过五个操作对类 Vector 进行了扩展 ，
允许将向量视为堆栈。
它提供了通常的 push 和 pop 操作 |
| 几种方法 |
empty()
测试堆栈是否为空。
E peek()
查看栈顶对象而不移除它。
E pop()
移除栈顶对象并作为此函数的值返回该对象。
E push(E item)
把项压入栈顶。
int search(Object o)
返回对象在栈中的位置，以 1 为基数。 |
| Arrays |
| 说明 |
专门用来操作数组的辅助类 Array 固定个数效率最高 |
| 数据处理 |
Arrays中拥有一组static函数，
equals()： 比较两个array是否相等。array拥有相同元素个数，
且所有对应元素两两相等。
fill()： 将值填入array中。
sort()： 用来对array进行排序。
binarySearch()：在排好序的array中寻找元素。
System.arraycopy()：array的复制 |
| 优势 |
这个就是用来处理数组的，效率特别高
如果之前对Arrays没这么的重视，在J2SE 5.0之后，可以多关照它几眼
。如果有数组操作方面的相关需求，可以先查查 java.util.Arrays的API文
件说明，看看有没有现成的方法可以使用 |
二、Set ：一个不包含重复元素的 collection。
| HashSet |
| 说明 |
内部使用HashMap 来存储数据 |
| 初始大小 |
16 |
| 扩容因子 |
数据超过当前大小*0.75 容量扩一倍 |
| 扩容例子 |
当前容量16 如果插入13个数 超过了（16*0.75=12）
容量增加16 最后容量是 32。 |
| 优势 |
不允许有重复的元素 |
| 线程是否安全 |
不安全，可以使用如下进行安全处理
Set s = Collections.synchronizedSet(new HashSet(...)) |
| LinkedHashSet |
| 说明 |
内部使用HashMap 来存储数据 |
| 初始大小 |
16 |
| 扩容因子 |
数据超过当前大小*0.75 容量扩一倍 |
| 扩容例子 |
当前容量16 如果插入13个数 超过了（16*0.75=12）
容量增加16 最后容量是 32。 |
| 优势 |
不允许有重复的元素 、 查询足够快 、 有序 |
| 线程是否安全 |
不安全，可以使用如下进行安全处理
Set s = Collections.synchronizedSet(new HashSet(...)) |
三、Map ：一个不包含重复元素的 无序集合 键值对 。
| HashMap |
| 说明 |
内部使用Entity来存储数据，key可以为空
put方法：如果key为空，则替换换Key为空的值，
否则插入到第 O 位置上。
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
//null key都放在table[0]上
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
如果key不为空，先算出来key对象的hashcode ，
然后调用函数 hash（）在算一次，
最后把结果和当前hash大小进行计算找到存放该值的位置；
如果该位置有值 直接把当前值(entity)链接到该值最前面 ，
Entry<K,V> e = table[bucketIndex];
//这个地方获取当前位置的 e
//table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
//这个地方把要插入的entity的next属性指向 e，
然后把整个entity放入 hashMap的index位置，
如果没有值就直接放入，
数组位置每变大一次 里面每个对象的位置都要重新计算一下 |
| 初始大小 |
16 |
| 扩容因子 |
数据超过当前大小*0.75 容量扩一倍 |
| 扩容例子 |
当前容量16 如果插入13个数 超过了（16*0.75=12）
容量增加16 最后容量是 32 |
| 优势 |
查询足够快 |
| 线程是否安全 |
线程不安全 可以使用如下进行安全处理
Set s = Collections.synchronizedSet(new HashSet(...)) |
| Hashtable |
| 初始大小 |
11 |
| 扩容因子 |
大小 = 大小 * 2 + 1 |
| 扩容例子 |
11 然后 23 然后47 .... |
| 是否同步 |
hashtable是同步的. |
| 优势 |
查询足够快 |
| 说明 |
key 不允许为空
数据的put和get和hashMap基本上一致
里面的所有方法除了不需要同步的都有 synchronized |
| LinkedHashMap |
| 初始大小 |
16 |
| 扩容因子 |
数据超过当前大小*0.75 容量扩一倍 |
| 扩容例子 |
当前容量16 如果插入13个数 超过了（16*0.75=12）
容量增加16 最后容量是 32 |
| 是否同步 |
异步线程不安全 多线程使用可以如下
Map m = Collections.synchronizedMap(new LinkedHashMap(...)) |
| 优势 |
查询足够快的 有序 |
| 说明 |
链表的形式存储数据 使用的hash算法保持数据,但同样也维护了一个插入
顺序查询对象时，速度足够快 |
| TreeMap |
| 初始大小 |
0 |
| 扩容因子 |
1 |
| 扩容例子 |
每插入一个键值对,内部创建一个entity来存储 size + 1 |
| 是否同步 |
异步线程不安全 多线程使用可以如下
Map m = Collections.synchronizedMap(new TreeMap(...)); |
| 优势 |
能够维护其内元素的排序状态 |
| 说明 |
TreeMap 初始化为0 , 每插入一个键值对,内部创建一个entity来存储
内部实现和维护的是一颗红黑树,遍历的时候使用的是前序遍历法,但是
查询get方法的时候需要遍历,速度不如直接使用hash算法的快 |
| Properties |
| 初始大小 |
11 |
| 扩容因子 |
大小 = 大小 * 2 + 1 |
| 扩容例子 |
11 然后 23 然后47 .... |
| 是否同步 |
是同步的. |
| 优势 |
查询足够快 可保存在流中或从流中加载数据 |
| 说明 |
实现了 HashTable 表示了一个持久的属性集。
Properties 可保存在流中或从流中加载数据。
|
摘要: 今天需要把数据库的数据导出l，然后也可以从外面导入保存到数据库。
考虑导出的数据格式为xml或json。json的话可以用google的gson实现。
以前做过。导出为xml的话，以前都是用java拼装或jdom或dom4j。今天
发现xstream也很强大，既可以把java对象转化为xml，也可以从xml转化为java
对象。专业说法，就是可以序列化为xml，也可以凡序列化为java对象...
阅读全文
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<meta name="keywords" content="" />
<meta name="description" content="百度地图API自定义地图，帮助用户在可视化操作下生成百度地图" />
<title>百度地图API自定义地图</title>
<!--引用百度地图API-->
<style type="text/css">
html,body{margin:0;padding:0;}
.iw_poi_title {color:#CC5522;font-size:14px;font-weight:bold;overflow:hidden;padding-right:13px;white-space:nowrap}
.iw_poi_content {font:12px arial,sans-serif;overflow:visible;padding-top:4px;white-space:-moz-pre-wrap;word-wrap:break-word}
</style>
<script type="text/javascript" src="http://api.map.baidu.com/api?key=&v=1.1&services=true"></script>
</head>
<body>
<!--百度地图容器-->
<div style="width:697px;height:550px;border:#ccc solid 1px;" id="dituContent"></div>
</body>
<script type="text/javascript">
var opts = {
width : 100, // 信息窗口宽度
height: 50, // 信息窗口高度
title : "IBM中国股份有限公司" // 信息窗口标题
}
//创建和初始化地图函数：
function initMap() {
createMap(); //创建地图
setMapEvent(); //设置地图事件
addMapControl(); //向地图添加控件
}
//创建地图函数：
function createMap() {
var map = new BMap.Map("dituContent"); //在百度地图容器中创建一个地图
var point = new BMap.Point(104.114129, 37.550339); //定义一个中心点坐标
map.centerAndZoom(point, 5); //设定地图的中心点和坐标并将地图显示在地图容器中
window.map = map; //将map变量存储在全局
//向地图添加标注
var bounds = map.getBounds();
var point = new BMap.Point(116.326655,39.902095);
var marker = new BMap.Marker(point);
var label = new BMap.Label('IBM全球总部',{"offset":new BMap.Size(9,-15)});
marker.setLabel(label);
map.addOverlay(marker);
marker.addEventListener("click", function(){this.openInfoWindow(new BMap.InfoWindow("全球总部（北京）</br>Tel:010-10000000", opts));});
var point = new BMap.Point(103.809019, 30.850669);
var marker = new BMap.Marker(point);
var label = new BMap.Label('成都分公司',{"offset":new BMap.Size(9,-15)});
marker.setLabel(label);
map.addOverlay(marker);
marker.addEventListener("click", function(){this.openInfoWindow(new BMap.InfoWindow("成都分公司</br>Tel:暂无", opts));});
var point = new BMap.Point(114.059763,22.646821);
var marker = new BMap.Marker(point);
var label = new BMap.Label('香港分公司',{"offset":new BMap.Size(9,-15)});
marker.setLabel(label);
map.addOverlay(marker);
marker.addEventListener("click", function(){this.openInfoWindow(new BMap.InfoWindow("香港分公司</br>Tel:暂无", opts));});
var point = new BMap.Point(121.323246, 31.294085);
var marker = new BMap.Marker(point);
var label = new BMap.Label('上海分公司',{"offset":new BMap.Size(9,-15)});
marker.setLabel(label);
map.addOverlay(marker);
marker.addEventListener("click", function(){this.openInfoWindow(new BMap.InfoWindow("上海分公司</br>Tel:暂无", opts));});
}
// 编写自定义函数,创建标注
function addMarker(point, index) {
var myIcon = new BMap.Icon("http://api.map.baidu.com/img/markers.png", new BMap.Size(23, 25), {
offset: new BMap.Size(10, 25), // 指定定位位置
imageOffset: new BMap.Size(0, 0 - index * 25) // 设置图片偏移
});
var marker = new BMap.Marker(point, { icon: myIcon });
map.addOverlay(marker);
}
//地图事件设置函数：
function setMapEvent() {
map.enableDragging(); //启用地图拖拽事件，默认启用(可不写)
map.enableScrollWheelZoom(); //启用地图滚轮放大缩小
map.enableDoubleClickZoom(); //启用鼠标双击放大，默认启用(可不写)
map.enableKeyboard(); //启用键盘上下左右键移动地图
}
//地图控件添加函数：
function addMapControl() {
//向地图中添加缩放控件
var ctrl_nav = new BMap.NavigationControl({ anchor: BMAP_ANCHOR_TOP_LEFT, type: BMAP_NAVIGATION_CONTROL_LARGE });
map.addControl(ctrl_nav);
//向地图中添加缩略图控件
var ctrl_ove = new BMap.OverviewMapControl({ anchor: BMAP_ANCHOR_BOTTOM_RIGHT, isOpen: 1 });
map.addControl(ctrl_ove);
//向地图中添加比例尺控件
var ctrl_sca = new BMap.ScaleControl({ anchor: BMAP_ANCHOR_BOTTOM_LEFT });
map.addControl(ctrl_sca);
}
initMap(); //创建和初始化地图
</script>
</html>