|
|
2006年7月18日
package cc.dynasoft.struts.action;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFFooter;
import org.apache.poi.hssf.usermodel.HSSFHeader;
import org.apache.poi.hssf.usermodel.HSSFPrintSetup;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.hssf.util.Region;
import cc.dynasoft.bean.Department;
///import org.apache.poi.hssf.record.HeaderRecorder;
public class OutputExcel {
public static boolean outputExcel(ExcelArgs args, List title, List list) {
try {
int cellNum = args.getCellNum(); // workbook
int rowNum = args.getRowNum();
/**
* 建立表格设置。
*/
HSSFWorkbook wb = new HSSFWorkbook(); // create the new Workbook
HSSFSheet sheet = wb.createSheet(args.getSheetName()); // create
/**
* 打印设置
*/
HSSFPrintSetup hps = sheet.getPrintSetup();
hps.setPaperSize((short) 9); // 设置A4纸
// hps.setLandscape(true); // 将页面设置为横向打印模式
sheet.setHorizontallyCenter(true); // 设置打印页面为水平居中
// sheet.setVerticallyCenter(true); // 设置打印页面为垂直居中
wb.setPrintArea(0, "$A$2:$e$" + rowNum + 2);// 打印区域设置.
/**
* 设置表的Footer
*/
HSSFFooter footer = sheet.getFooter();
// 设置footer的位置和显示的内容
footer.setCenter("Time:" + HSSFFooter.date());
footer.setRight("Page " + HSSFFooter.page() + " of "
+ HSSFFooter.numPages());
/**
* 设置表的Header
*/
// 设置header的位置,共有三种位置和相应的显示设置
HSSFHeader header = sheet.getHeader();
// header.setRight("Center Header");
// header.setLeft("Left Header");
header.setCenter(HSSFHeader.font("Stencil-Normal", "Italic")
+ HSSFHeader.fontSize((short) 30) + args.getHeaderTitle());
// header.endDoubleUnderline();
header.startUnderline();
/**
* 设置列的宽度
*/
sheet.setColumnWidth((short) 2,
(short) ((30 * 8) / ((double) 1 / 10)));
sheet.setColumnWidth((short) 3,
(short) ((40 * 8) / ((double) 1 / 10)));
sheet.setColumnWidth((short) 4,
(short) ((50 * 8) / ((double) 1 / 20)));
/**
* 创建第一行,也就是显示的标题, 可以高置的高度,单元格的格式,颜色,字体等设置. 同时可以合并单元格.
*/
HSSFRow row0 = sheet.createRow(0); // 创建0行
row0.setHeight((short) 0x300); // 设直行的高度.
HSSFFont font2 = wb.createFont(); // 创建字体格式
font2.setColor(HSSFFont.SS_NONE); // 设置单元格字体的颜色.
font2.setFontHeight((short) 700); // 设置字体大小
font2.setFontName("Courier New"); // 设置单元格字体
HSSFCell cell0 = row0.createCell((short) 0); // 创建0行0列.
HSSFCellStyle style3 = wb.createCellStyle(); // 创建单元格风格.
style3.setAlignment(HSSFCellStyle.VERTICAL_CENTER); // 垂直居中
style3.setAlignment(HSSFCellStyle.ALIGN_CENTER); // /水平居中
style3.setFont(font2); // 将字体格式加入到单元格风格当中
// cell0.setCellType()
cell0.setCellStyle(style3); // 设置单元格的风格.
cell0.setCellValue(args.getHeaderTitle()); // 设置单元的内容.
sheet.addMergedRegion(new Region(0, (short) 0, 0,
(short) (cellNum - 1)));// 指定合并区域,前二个参数为开始处X,Y坐标.后二个为结束的坐标.
/**
* 设置其它数据 设置风格
*/
HSSFCellStyle style = wb.createCellStyle();
style.setBorderBottom(HSSFCellStyle.BORDER_THIN); // 设置单无格的边框为粗体
style.setBottomBorderColor(HSSFColor.BLACK.index); // 设置单元格的边框颜色．
style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
style.setLeftBorderColor(HSSFColor.BLACK.index);
style.setBorderRight(HSSFCellStyle.BORDER_THIN);
style.setRightBorderColor(HSSFColor.BLACK.index);
style.setBorderTop(HSSFCellStyle.BORDER_THIN);
style.setTopBorderColor(HSSFColor.BLACK.index);
// style.setWrapText(true);//文本区域随内容多少自动调整
// style.setFillForegroundColor(HSSFColor.LIME.index);
// style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
/**
* 设置风格1
*/
HSSFCellStyle style1 = wb.createCellStyle();
style1.setBorderBottom(HSSFCellStyle.BORDER_THIN); // 设置单无格的边框为粗体
style1.setBottomBorderColor(HSSFColor.BLACK.index); // 设置单元格的边框颜色．
style1.setBorderLeft(HSSFCellStyle.BORDER_THIN);
style1.setLeftBorderColor(HSSFColor.BLACK.index);
style1.setBorderRight(HSSFCellStyle.BORDER_THIN);
style1.setRightBorderColor(HSSFColor.BLACK.index);
style1.setBorderTop(HSSFCellStyle.BORDER_MEDIUM);
style1.setTopBorderColor(HSSFColor.BLACK.index);
style1.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);// 最好的设置Pattern
// 单元格背景的显示模式．
style1.setFillForegroundColor(new HSSFColor.RED().getIndex()); // 设置单元格背景色;
style1.setAlignment(HSSFCellStyle.ALIGN_CENTER); // 水平对齐方式
// style1.setWrapText(true);//文本区域随内容多少自动调整
// style.setFillPattern(HSSFCellStyle.//);
// 设置字体Color,首先创建Font对象,后对font设置,然后做为参数传给style
HSSFFont font = wb.createFont();
font.setColor(HSSFFont.SS_NONE);
// font.setFontHeightInPoints((short)24);
font.setFontName("Courier New");
// font.setItalic(true);
// font.setStrikeout(true);//给字体加上删除线
font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
style1.setFont(font);
/**
*
* 设置第零行表格说明行
*
*
*
*/
HSSFRow row1 = sheet.createRow((short) 1);
for (int j = 0; j < cellNum; j++) {
HSSFCell cell = row1.createCell((short) j);
cell.setCellValue((String) title.get(j));
cell.setCellStyle(style1);
}
// style.setFillPattern(HSSFCellStyle.NO_FILL);
/**
* 设置表的内容主体
*/
Iterator iter = list.iterator();
for (int i = 2; iter.hasNext(); i++) {
Department dep = (Department) iter.next();
HSSFRow row = sheet.createRow((short) i);
HSSFCell cell5 = row.createCell((short) 0);
HSSFCell cell1 = row.createCell((short) 1);
HSSFCell cell2 = row.createCell((short) 2);
HSSFCell cell3 = row.createCell((short) 3);
HSSFCell cell4 = row.createCell((short) 4);
cell5.setCellValue(dep.getId());
cell5.setCellStyle(style);
cell1.setCellValue(dep.getParentId());
cell1.setCellStyle(style);
cell2.setCellValue(dep.getName());
cell2.setCellStyle(style);
cell3.setCellValue(dep.getDescription());
cell3.setCellStyle(style);
cell4.setCellValue(dep.getImagePath());
cell4.setCellStyle(style);
}
// Write the output to a file}
// FileOutputStream fileOut = new
// FileOutputStream(args.getPath()+args.getFileName());
/**
* 对文件进行输出操作。
*/
FileOutputStream fileOut = new FileOutputStream(args
.getPathAndName());
wb.write(fileOut);
// fileOut.close();
} catch (IOException ex) {
ex.printStackTrace();
} catch (Exception ex) {
ex.printStackTrace();
}
return true;
}
}
mkdir /home/u1 创建文件夹/home/u1
chown oracle /home/u1 表示改变目录所有者为oracle账户;
chgrp dba /home/u1 改变/home/u1目录为dba所有;
chmod 755 /home/u1 表示oracle账户对/home/u1目录有755权限;
rmdir /home/u1 表示删除/home/u1目录
hostname可以查看linux的计算机名;
whoami可以查看当前用户;
pwd显示当前路径;
df查看系统的硬件信息
ls -lrt l表示显示详细列表，-t表示按时间排序,-r反向排序
cat orcl_ora_3436.trc|grep bucket
以下查看相关文件内容:
more /etc/oratab
cat /etc/passwd
cat /etc/group
copy命令
该命令的功能是将给出的文件或目录拷贝到另一文件或目录中，同MSDOS下的copy命令一样，功能十分强大。
语法： cp [选项] 源文件或目录 目标文件或目录
说明：该命令把指定的源文件复制到目标文件或把多个源文件复制到目标目录中。
该命令的各选项含义如下：
- a 该选项通常在拷贝目录时使用。它保留链接、文件属性，并递归地拷贝目录，其作用等于dpR选项的组合。
- d 拷贝时保留链接。
- f 删除已经存在的目标文件而不提示。
- i 和f选项相反，在覆盖目标文件之前将给出提示要求用户确认。回答y时目标文件将被覆盖，是交互式拷贝。
- p 此时cp除复制源文件的内容外，还将把其修改时间和访问权限也复制到新文件中。
- r 若给出的源文件是一目录文件，此时cp将递归复制该目录下所有的子目录和文件。此时目标文件必须为一个目录名。
- l 不作拷贝，只是链接文件。
需要说明的是，为防止用户在不经意的情况下用cp命令破坏另一个文件，如用户指定的目标文件名已存在，用cp命令拷贝文件后，这个文件就会被新源文件覆盖，因此，建议用户在使用cp命令拷贝文件时，最好使用i选项。
对于rownum来说它是oracle系统顺序分配为从查询返回的行的编号，返回的第一行分配的是1，第二行是2，依此类推，这个伪字段可以用于限制查询返回的总行数，而且rownum不能以任何表的名称作为前缀。
举例说明：
例如表：student(学生)表，表结构为：
ID char(6) --学号
name VARCHAR2(10) --姓名
create table student (ID char(6), name VARCHAR2(100));
insert into sale values('200001',‘张一’);
insert into sale values('200002',‘王二’);
insert into sale values('200003',‘李三’);
insert into sale values('200004',‘赵四’);
commit;
(1) rownum 对于等于某值的查询条件
如 果希望找到学生表中第一条学生的信息，可以使用rownum=1作为条件。但是想找到学生表中第二条学生的信息，使用rownum=2结果查不到数据。因 为rownum都是从1开始，但是1以上的自然数在rownum做等于判断是时认为都是false条件，所以无法查到rownum = n（n>1的自然数）。
SQL> select rownum,id,name from student where rownum=1;（可以用在限制返回记录条数的地方，保证不出错，如：隐式游标）
SQL> select rownum,id,name from student where rownum=1;
ROWNUM ID NAME
---------- ------ ---------------------------------------------------
1 200001 张一
SQL> select rownum,id,name from student where rownum =2;
ROWNUM ID NAME
---------- ------ ---------------------------------------------------
（2）rownum对于大于某值的查询条件
如果想找到从第二行记录以后的记录，当使用rownum>2是查不出记录的，原因是由于rownum是一个总是从1开始的伪列，Oracle 认为rownum> n(n>1的自然数)这种条件依旧不成立，所以查不到记录
SQL> select rownum,id,name from student where rownum >2;
ROWNUM ID NAME
---------- ------ ---------------------------------------------------
那如何才能找到第二行以后的记录呀。可以使用以下的子查询方法来解决。注意子查询中的rownum必须要有别名，否则还是不会查出记录来，这是因为rownum不是某个表的列，如果不起别名的话，无法知道rownum是子查询的列还是主查询的列。
SQL>select * from(select rownum no ,id,name from student) where no>2;
NO ID NAME
---------- ------ ---------------------------------------------------
3 200003 李三
4 200004 赵四
SQL> select * from(select rownum,id,name from student)where rownum>2;
ROWNUM ID NAME
---------- ------ ---------------------------------------------------
（3）rownum对于小于某值的查询条件
如果想找到第三条记录以前的记录，当使用rownum<3是能得到两条记录的。显然rownum对于rownum<n（(n>1的自然数）的条件认为是成立的，所以可以找到记录。
SQL> select rownum,id,name from student where rownum <3;
ROWNUM ID NAME
---------- ------ ---------------------------------------------------
1 200001 张一
2 200002 王二
综 上几种情况，可能有时候需要查询rownum在某区间的数据，那怎么办呀从上可以看出rownum对小于某值的查询条件是人为true的，rownum对 于大于某值的查询条件直接认为是false的，但是可以间接的让它转为认为是true的。那就必须使用子查询。例如要查询rownum在第二行到第三行之 间的数据，包括第二行和第三行数据，那么我们只能写以下语句，先让它返回小于等于三的记录行，然后在主查询中判断新的rownum的别名列大于等于二的记 录行。但是这样的操作会在大数据集中影响速度。
SQL> select * from (select rownum no,id,name from student where rownum<=3 ) where no >=2;
NO ID NAME
---------- ------ ---------------------------------------------------
2 200002 王二
3 200003 李三
（4）rownum和排序
Oracle中的rownum的是在取数据的时候产生的序号，所以想对指定排序的数据去指定的rowmun行数据就必须注意了。
SQL> select rownum ,id,name from student order by name;
ROWNUM ID NAME
---------- ------ ---------------------------------------------------
3 200003 李三
2 200002 王二
1 200001 张一
4 200004 赵四
可以看出，rownum并不是按照name列来生成的序号。系统是按照记录插入时的顺序给记录排的号，rowid也是顺序分配的。为了解决这个问题，必须使用子查询
SQL> select rownum ,id,name from (select * from student order by name);
ROWNUM ID NAME
---------- ------ ---------------------------------------------------
1 200003 李三
2 200002 王二
3 200001 张一
4 200004 赵四
这样就成了按name排序，并且用rownum标出正确序号（有小到大）
//ArrayList
{
ArrayList arraylist=new ArrayList();
arraylist.add(0,"end");//指定索引加入值
//需注意的是，如果现有2个值，我加入索引为5的那么就会出现异常
for(int i=0;i<2;i++){
arraylist.add(i,String.valueOf(i));
}
System.out.println("ArrayList:");
for(int i=0;i<arraylist.size();i++){
System.out.print(arraylist.get(i)+";");
}
arraylist.add("0");//直接加入值到ArrayList的最后
arraylist.add("0");
System.out.print("\nArrayList\'s lastIndexOf(\"0\") is "+arraylist.lastIndexOf("0"));
}
//Arrays
{
String []array=new String[]{"a","b","c"};
List list=Arrays.asList(array);
System.out.println("\nArrays:");
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+";");
}
System.out.print("\nArrays\'s length is "+array.length);//打印数组的长度
}
//Collections
{
String []array=new String[]{"a","b","c"};
List list=Arrays.asList(array);
Collections.fill(list,"Fill");//用Fill填充全部元素
System.out.println("\nCollections:");
for(int i=0;i<list.size();i++){
System.out.print(list.get(i)+";");
}
array=new String[]{"1","2","3"};
List list2=Arrays.asList(array);
Collections.copy(list,list2);//拷贝list2的数据进list
System.out.println("\n"+list);
Collections.swap(list,2,1);//调换索引为1和2的元素的位置
System.out.println(list);
}
//EventObject
{
String s="hello";
String s2=s;
EventObject eventobject=new EventObject(s);//一个准容器类型，确切的归类它不是容器
System.out.println("EventObject:");
System.out.println(eventobject.getSource());
System.out.println(eventobject.equals(s2));
}
//HashMap
{
HashMap hashmap=new HashMap();//一个速度最快的容器
hashmap.put("0","c");
hashmap.put("1","a");
hashmap.put("2","b");
hashmap.put("3","a");
System.out.println("HashMap:");
System.out.println(hashmap);//该容器有其内部的排序方式
Set set=hashmap.keySet();//获取全部键
Iterator iterator=set.iterator();
while(iterator.hasNext()){
System.out.print(hashmap.get(iterator.next())+";");
}
}
//HashSet
{
HashSet hashset=new HashSet();//一个绝对不能重复的类型
hashset.add("c");
hashset.add("b");
hashset.add("a");
hashset.add("a");
hashset.add("b");
System.out.println("\nHashSet:");
System.out.println(hashset);
Iterator iterator=hashset.iterator();//取出元素
while(iterator.hasNext()){
System.out.print(iterator.next()+";");
}
}
//Hashtable
{
Hashtable hashtable=new Hashtable();//一个完全可以由其他容器替换的老容器类型
hashtable.put("0","c");
hashtable.put("1","a");
hashtable.put("3","c");
hashtable.put("2","b");
System.out.println("\nHashtable:");
Enumeration enumeration=hashtable.elements();//获取元素，Enumeration已经不是主流，Iterator是它的下一代替代品
while(enumeration.hasMoreElements()){
System.out.print(enumeration.nextElement()+";");
}
}
//IdentityHashMap
{
IdentityHashMap identityhashmap=new IdentityHashMap();
identityhashmap.put("0","c");
identityhashmap.put("1","a");
identityhashmap.put("3","b");
identityhashmap.put("2","a");
System.out.println("\nIdentityHashMap:");
System.out.println(identityhashmap);
System.out.println(identityhashmap.containsKey("3"));//是否包含这个键
System.out.println(identityhashmap.containsValue("a"));//是否包含值
Set set=identityhashmap.entrySet();//传为Set类型
System.out.println(set);
set=identityhashmap.keySet();//全部键
System.out.println(set);
}
//LinkedHashMap
{
LinkedHashMap linkedhashmap=new LinkedHashMap();
linkedhashmap.put("0","b");
linkedhashmap.put("2","a");
linkedhashmap.put("1","c");
linkedhashmap.put("3","b");
System.out.println("LinkedHashMap:");
System.out.println(linkedhashmap);
System.out.println(linkedhashmap.containsKey("2"));//是否包含这个键
System.out.println(linkedhashmap.containsValue("c"));//是否包含值
Set set=linkedhashmap.keySet();
Iterator iterator=set.iterator();
while(iterator.hasNext()){
System.out.print(linkedhashmap.get(iterator.next())+";");
}
}
//LinkedHashSet
{
LinkedHashSet linkedhashset=new LinkedHashSet();//它包含了几种Set的属性但却没有自己的特色
linkedhashset.add("c");
linkedhashset.add("a");
linkedhashset.add("a");
linkedhashset.add("b");
System.out.println("\nLinkedHashSet:");
System.out.println(linkedhashset);
System.out.println(linkedhashset.contains("a"));//是否包含对象
Iterator iterator=linkedhashset.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next()+";");
}
}
//LinkedList
{
LinkedList linkedlist=new LinkedList();//自由使用是它的特色
linkedlist.add("a");
linkedlist.add(1,"c");
linkedlist.addLast("b");
linkedlist.addFirst("d");
System.out.println("\nLinkedList:");
System.out.println(linkedlist);
//linkedlist.clear();//该方法清空容器
//linkedlist.remove(0);//删除索引为0的元素
//linkedlist.remove("d");//删除值为d的元素
//linkedlist.removeFirst();//删除第一个元素
//linkedlist.removeLast();//删除最后一个元素
for(int i=0;i<linkedlist.size();i++){
System.out.print(linkedlist.get(i)+";");
}
}
//Stack
{
Stack stack=new Stack();//堆栈
stack.add("b");
stack.add(0,"c");
stack.push("d");
stack.add("e");
stack.push("a");
Enumeration enumeration=stack.elements();
System.out.println("\nStack:");
while(enumeration.hasMoreElements()){
System.out.print(enumeration.nextElement()+";");
}
//后进先出
System.out.println("\n"+stack.peek());
System.out.println(stack.pop());
System.out.println(stack.contains("d")+";"+stack.contains("a"));//是否包含该元素,有趣的事情发生了
System.out.println(stack.search("c"));//非常有用的属性，检索，但是由后向前的排列
}
//TreeMap
{
TreeMap treemap=new TreeMap();
treemap.put("0","d");
treemap.put("2","a");
treemap.put("1","b");
treemap.put("3","c");
System.out.println("\nTreeMap:");//可以对键排序
System.out.println(treemap);
System.out.println(treemap.firstKey());//返回第一个键
Set set=treemap.keySet();
Iterator iterator=set.iterator();
while(iterator.hasNext()){
System.out.print(treemap.get(iterator.next())+";");
}
}
//TreeSet
{
TreeSet treeset=new TreeSet();//自动排序内容
treeset.add("b");
treeset.add("a");
treeset.add("c");
treeset.add("d");
System.out.println("\nTreeSet:");
System.out.println(treeset);
System.out.println(treeset.first());//返回第一个元素
Iterator iterator=treeset.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next()+";");
}
}
//Vector
{
Vector vector=new Vector();
vector.add(0,"b");
vector.add("a");
vector.addElement("d");
vector.add("c");
System.out.println("\nVector:");
System.out.println(vector);
vector.set(2,"h");//替换掉指定索引的元素
System.out.println(vector);
Object []str=vector.toArray();
for(int i=0;i<str.length;i++){
System.out.print(str[i]+";");
}
vector.setSize(2);//重新设置大小为2
System.out.println("\n"+vector);
}
//WeakHashMap
{
WeakHashMap weakhashmap=new WeakHashMap();
weakhashmap.put("1","b");
weakhashmap.put("2","c");
weakhashmap.put("0","d");
weakhashmap.put("3","a");
System.out.println("\nWeakHashMap:");
System.out.println(weakhashmap);
System.out.println(weakhashmap.containsKey("3"));//是否包含键
System.out.println(weakhashmap.containsValue("d"));//是否包含值
Set set=weakhashmap.entrySet();
Iterator iterator=set.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next()+";");
}
//weakhashmap.remove("2");//删除该键对应的值
//weakhashmap.get("1");//获取指定键的值
}
}
在JAVA的util包中有两个所有集合的父接口Collection和Map,它们的父子关系：
java.util
+Collection 这个接口extends自 --java.lang.Iterable接口
+List 接口
-ArrayList 类
-LinkedList 类
-Vector 类 此类是实现同步的
+Queue 接口
+不常用，在此不表.
+Set 接口
+SortedSet 接口
-TreeSet 类
-HashSet
+Map 接口
-HashMap 类 (除了不同步和允许使用 null 键/值之外,与 Hashtable 大致相同.)
-Hashtable 类 此类是实现同步的,不允许使用 null 键值
+SortedMap 接口
-TreeMap 类
以下对众多接口和类的简单说明：首先不能不先说一下数组（Array）
一、Array ， Arrays
Java所有“存储及随机访问一连串对象”的做法，array是最有效率的一种。
1、
效率高，但容量固定且无法动态改变。
array还有一个缺点是，无法判断其中实际存有多少元素，length只是告诉我们array的容量。
2、Java中有一个Arrays类，专门用来操作array。
arrays中拥有一组static函数，
equals()：比较两个array是否相等。array拥有相同元素个数，且所有对应元素两两相等。
fill()：将值填入array中。
sort()：用来对array进行排序。
binarySearch()：在排好序的array中寻找元素。
System.arraycopy()：array的复制。
二、Collection ， Map
若撰写程序时不知道究竟需要多少对象，需要在空间不足时自动扩增容量，则需要使用容器类库，array不适用。
1、Collection 和 Map 的区别
容器内每个为之所存储的元素个数不同。
Collection类型者，每个位置只有一个元素。
Map类型者，持有 key-value pair，像个小型数据库。
2、Java2容器类类库的用途是“保存对象”，它分为两类，各自旗下的子类关系
Collection
--List：将以特定次序存储元素。所以取出来的顺序可能和放入顺序不同。
--ArrayList / LinkedList / Vector
--Set ： 不能含有重复的元素
--HashSet /TreeSet
Map
--HashMap
--HashTable
--TreeMap
Map----一组成对的“键值对”对象，即其元素是成对的对象，最典型的应用就是数据字典，并且还有其它广泛的应用。另外，Map可以返回其所有键组成的Set和其所有值组成的Collection，或其键值对组成的Set，并且还可以像数组一样扩展多维Map，只要让Map中键值对的每个“值”是一个Map即可。
Collection下 1.迭代器
迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。
Java中的Iterator功能比较简单，并且只能单向移动：
(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。
(2) 使用next()获得序列中的下一个元素。
(3) 使用hasNext()检查序列中是否还有元素。
(4) 使用remove()将迭代器新返回的元素删除。
Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。
2.List的功能方法
List(interface): 次序是List最重要的特点；它确保维护元素特定的顺序。List为Collection添加了许多方法，使得能够向List中间插入与移除元素(只推荐LinkedList使用)。一个List可以生成ListIterator，使用它可以从两个方向遍历List，也可以从List中间插入和删除元素。
ArrayList: 由数组实现的List。它允许对元素进行快速随机访问，但是向List中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历ArrayList，而不是用来插入和删除元素，因为这比LinkedList开销要大很多。
LinkedList: 由列表实现的List。对顺序访问进行了优化，向List中间插入与删除得开销不大，随机访问则相对较慢(可用ArrayList代替)。它具有方法addFirst()、addLast()、getFirst()、getLast()、removeFirst()、removeLast()，这些方法(没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。
3.Set的功能方法
Set(interface): 存入Set的每个元素必须是唯一的，这也是与List不同的，因为Set不保存重复元素。加入Set的Object必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。
HashSet: HashSet能快速定位一个元素，存入HashSet的对象必须定义hashCode()。
TreeSet: 保持次序的Set，底层为树结构。使用它可以从Set中提取有序的序列。
LinkedHashSet: 具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。
HashSet采用散列函数对元素进行排序，这是专门为快速查询而设计的；TreeSet采用红黑树的数据结构进行排序元素；LinkedHashSet内部使用散列以加快查询速度，同时使用链表维护元素的次序，使得看起来元素是以插入的顺序保存的。需要注意的是，生成自己的类时，Set需要维护元素的存储顺序，因此要实现Comparable接口并定义compareTo()方法。
3、其他特征
* List，Set，Map将持有对象一律视为Object型别。
* Collection、List、Set、Map都是接口，不能实例化。
继承自它们的 ArrayList, Vector, HashTable, HashMap是具象class，这些才可被实例化。
* vector容器确切知道它所持有的对象隶属什么型别。vector不进行边界检查。
三、Collections
Collections是针对集合类的一个帮助类。提供了一系列静态方法实现对各种集合的搜索、排序、线程完全化等操作。
相当于对Array进行类似操作的类——Arrays。
如，Collections.max(Collection coll); 取coll中最大的元素。
Collections.sort(List list); 对list中元素排序
四、如何选择？
1、容器类和Array的区别、择取
* 容器类仅能持有对象引用（指向对象的指针），而不是将对象信息copy一份至数列某位置。
* 一旦将对象置入容器内，便损失了该对象的型别信息。
2、
* 在各种Lists中，最好的做法是以ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList()；
Vector总是比ArrayList慢，所以要尽量避免使用。
* 在各种Sets中，HashSet通常优于HashTree（插入、查找）。只有当需要产生一个经过排序的序列，才用TreeSet。
HashTree存在的唯一理由：能够维护其内元素的排序状态。
* 在各种Maps中
HashMap用于快速查找。
* 当元素个数固定，用Array，因为Array效率是最高的。
结论：最常用的是ArrayList，HashSet，HashMap，Array。而且，我们也会发现一个规律，用TreeXXX都是排序的。
注意：
1、Collection没有get()方法来取得某个元素。只能通过iterator()遍历元素。
2、Set和Collection拥有一模一样的接口。
3、List，可以通过get()方法来一次取出一个元素。使用数字来选择一堆对象中的一个，get(0)...。(add/get)
4、一般使用ArrayList。用LinkedList构造堆栈stack、队列queue。
5、Map用 put(k,v) / get(k)，还可以使用containsKey()/containsValue()来检查其中是否含有某个key/value。
HashMap会利用对象的hashCode来快速找到key。
* hashing
哈希码就是将对象的信息经过一些转变形成一个独一无二的int值，这个值存储在一个array中。
我们都知道所有存储结构中，array查找速度是最快的。所以，可以加速查找。
发生碰撞时，让array指向多个values。即，数组每个位置上又生成一个梿表。
6、Map中元素，可以将key序列、value序列单独抽取出来。
使用keySet()抽取key序列，将map中的所有keys生成一个Set。
使用values()抽取value序列，将map中的所有values生成一个Collection。
为什么一个生成Set，一个生成Collection？那是因为，key总是独一无二的，value允许重复。
1、项目经理必须关注项目成功的三个标准
简单地说，一是准时；二是预算控制在既定的范围内；三是质量得到经理和用户们的赞许。项目经理必须保证项目小组的每一位成员都能对照上面三个标准来进行工作。
2、任何事都应当先规划再执行
就项目管理而言，很多专家和实践人员都同意这样一个观点：需要项目经理投入的最重要的一件事就是规划。只有详细而系统的由项目小组成员参与的规划才是项目成功的唯一基础。当现实的世界出现了一种不适于计划生存的环境时，项目经理应制定一个新的计划来反映环境的变化。规划、规划、再规划就是项目经理的一种生活方式。
3、项目经理必须以自己的实际行动向项目小组成员传递一种紧迫感
由于项目在时间、资源和经费上都是有限的，项目最终必须完成。但项目小组成员大多有自己的爱好，项目经理应让项目小组成员始终关注项目的目标和截止期限。例如，可以定期检查，可以召开例会，可以制作一些提醒的标志置于项目的场所。
4、成功的项目应使用一种可以度量且被证实的项目生命周期
标准的信息系统开发模型可以保证专业标准和成功的经验能够融入项目计划。这类模型不仅可以保证质量，还可以使重复劳动降到最低程度。因此，当遇到时间和预算压力需要削减项目时，项目经理应确定一种最佳的项目生命周期。
5、所有项目目标和项目活动必须生动形象地得以交流和沟通
项目经理和项目小组在项目开始时就应当形象化地描述项目的最终目标，以确保与项目有关的每一个人都能记住。项目成本的各个细节都应当清楚、明确、毫不含糊，并确保每个人对此都达成了一致的意见。
6、采用渐进的方式逐步实现目标
如果试图同时完成所有的项目目标，只会造成重复劳动，既浪费时间又浪费钱。俗话说，一口吃不成个胖子。项目目标只能一点一点地去实现，并且每实现一个目标就进行一次评估，确保整个项目能得以控制。
7、项目应得到明确的许可，并由投资方签字实施
在实现项目目标的过程中获得明确的许可是非常重要的。应将投资方的签字批准视为项目的一个出发点。道理很简单：任何有权拒绝或有权修改项目目标的人都应当在项目启动时审查和批准这些项目目标。
8、要想获得项目成功必须对项目目标进行透彻的分析
研究表明，如果按照众所周知记录在案的业务需求来设计项目的目标，则该项目多半会成功。所以，项目经理应当坚持这样一个原则，即在组织机构启动项目之前，就应当为该项目在业务需求中找到充分的依据。
9、项目经理应当责权对等
项目经理应当对项目的结果负责，这一点并不过分。但与此相对应，项目经理也应被授予足够的权利以承担相应的责任。在某些时候，权利显得特别重要，如获取或协调资源，要求得到有关的中小企业的配合，做相应的对项目成功有价值的决策等等。
10、项目投资方和用户应当主动介入，不能被动地坐享其成
多数项目投资方和用户都能正确地要求和行使批准（全部或部分）项目目标的权力。但伴随这个权力的是相应的责任——主动地介入项目的各个阶段。例如，在项目早期要帮助确定项目目标；在项目进行中，要对完成的阶段性目标进行评估，以确保项目能顺利进行。项目投资方应帮助项目经理去访问有关的中小企业和目标顾客的成员，并帮助项目经理获得必要的文件资料。
11、项目的实施应当采用市场运作机制
在多数情况下，项目经理应将自己看成是卖主，以督促自己完成投资方和用户交付的任务。项目计划一旦批准项目经理应当定期提醒项目小组成员该项目必须满足的业务需求是什么，以及该怎样工作才能满足这些业务需求。
12、项目经理应当获得项目小组成员的最佳人选
最佳人选是指受过相应的技能培训，有经验，素质高。对于项目来说，获得最佳人选往往能弥补时间、经费或其它方面的不足。项目经理应当为这些最佳的项目成员创造良好的工作环境，如帮助他们免受外部干扰，帮助他们获得必要的工具和条件以发挥他们的才能。
在开始正文之前，我想先讲两个故事——关于软件项目的故事。
故事一
有两个软件项目（姑且称之为“项目 A”和“项目 B”），它们在开始时的预算都是 50 个人月，时间是 5 个月。
项目 A 在 5 个月后完工，耗费成本 50 人月
项目 B 在 6 个月后完工，耗费成本 70 人月
在软件圈子里摸爬滚打多年的读者们对这个故事一定有自己的判断——而且我可以大致猜出是什么样的判断。不过先别着急，我们还有另一个故事。
故事二
有两个软件项目（仍然姑且称之为“项目 A”和“项目 B”），它们在开始时的计划都是交付 200 项功能。
项目 A 在项目结束时一次性交付了最初计划的 200 项功能，但客户发现其中大约 30 项功能没有太大用处，而另外 30 项有用的功能要等到下一个项目才能实现。
项目 B 在第一个月结束时交付了第一个版本，此后每两周交付一个新的版本。在项目进行的过程中，客户进行了一次业务调整，加入了 90 项新的功能，并搁置了 50 项用处不大的功能。最终该项目交付了 240 项功能。
聪明的读者大概注意到了，前后两个故事讲的是同一回事，同样的两个项目。现在我的问题来了：请问哪个项目是更成功的项目？
这个问题并不容易回答——实际上它没有标准答案。站在很多软件企业的立场上，项目 A 是一个理想的成功项目：按时间、按成本完成预先约定的任务。请注意，我用了“理想的”这个词，稍后我还会解释这个有趣的词，因为实际上的软件项目往往没有那么理想。
而如果换一个角度，站在客户的立场上呢？也许付钱购买软件的客户会有一些不同的想法。项目 B 从开始之后一个月便交付了第一个可工作的版本，从那时起客户就开始使用这个软件的部分功能，并且不断地把自己使用的感受反馈给开发团队。在真实的业务运营过程中，客户甚至发现了一种新的盈利模式，并进行了一次大规模的业务调整，这次调整的结果也直观地体现在软件项目中。虽然项目B的整体交付速率低于项目 A，但它提供的所有功能都是客户真正需要的，它们为客户提供实实在在的价值——更不用说，客户提前好几个月就开始使用这个软件。
实际上，这是一篇关于软件价值的文章。和“成功项目”一样，对于“软件的价值”，不同的人也会有不同的定义。不过作为付钱购买软件的客户，他对于软件价值的定义是一目了然的：他能够从使用软件中创造多少价值，软件能够为他的业务提供多少价值，这就是软件的价值。或者说得更简明一点：
软件价值源自使用
这正是为什么很多客户青睐“项目 B”的原因——我并不打算声称所有客户都有同样的观点，稍后我也会举出反例，但至少支持这一观点的客户不在少数。因为他们处在一个残酷而快速变化的商业环境中：他们的供应商在变化，他们的客户在变化，他们所处的经济环境和政策环境也在变化。这一切的变化迫使他们的业务也要随之变化。更要命的是，今天这个经济全球化的时代是一个“快鱼吃慢鱼”的时代，客户迫切希望新的软件系统为他们带来竞争优势——哪怕这个软件系统尚未完成，只要能够投入使用。最后，客户对于新的软件系统究竟应该是什么样子并没有百分之百的把握，他们的想法往往要在真正使用软件之后才会浮现成型。几方面的因素加在一起，使得这些客户更愿意尽快开始使用软件、提出反馈、并不断完善软件，而不是提出一组需求、然后坐等几个月之后原封不动地拿到这些功能。
一个真实的案例
在 ThoughtWorks 的一个项目中，开发者们在项目开始之后一个月内就发布了第一个版本——只有一些简单的数据采集功能。在发布展示会上，发生了这样的对话……
开发者：这是我们的第一个功能。我们从文本文件、Excel 数据表和遗留数据库采集数据，现在我们的数据库中有这些数据……（展示数据库结构）
客户：唔……有意思。要是你能做这样一个查询（写出查询要求），得到的结果可能会有用。
开发者：可是我们的界面上没有地方做这样的查询操作。
客户：啊，我不需要操作界面，只要每天深夜做一次查询，把报表发到我的信箱就可以了。
开发者：这样吗……另一个问题是，这需要花我们几天时间。
客户：不要紧，把别的任务往后放几天好了，我很想看到这份报表。
开发者：那好吧，下周我们就会开始提供这个报表。
猜猜结果怎么样？一周之后客户就开始每天接收这份报表，并根据报表内容做一些分析和决策。仅仅几个月之后，这份报表给客户带来的收益就已经超过了整个项目的投资——这时项目其他部分的开发甚至还没有完成。
想想这个客户会怎么定义一个“成功的软件项目”？好吧，也许这个项目超过了预期的时间，也许投入了更多的人力，但这些并不意味着“项目失败”——只是付出更高的成本。关键在于，他投入的这些成本能够带来多大的收益，他的投资回报率是否划算。对于这个客户而言，如果项目能够随时给他提供可用的、能够创造最大价值的软件，能够随时让——就像故事中提到的——这种有价值的想法得以实现，这就是一个成功的项目。
所以，亲爱的读者，请你忘记本文标题上出现的“敏捷”二字，我们在这里所说的不是别的，就是一种为客户创造最大化价值的软件开发方法。这样的方法有很多种，但它们有一个共同的特点：尽快、尽可能频繁地交付可以工作的软件，让客户尽快开始使用软件，从使用中创造价值、厘清思路、提出反馈。仍然以 ThoughtWorks 的项目为例，这些项目通常在启动开发阶段之后一个月内就会发布第一个版本，随后每一周或每两周发布一个新版本——每个版本都是一个可以工作的软件，每个版本都比前一个版本具有更丰富的功能，并且每个版本都包含客户认为迄今为止最有价值的那些功能。用软件开发的“黑话”，“开发下一个版本”的过程叫做“迭代”，这些开发方法最大的共同点就是“迭代式开发”——不是一股脑地交付全部功能，而是每次增加一点、渐进地交付最有价值的功能。
软件开发的梦想与真实
回到文章开始处的两个故事。我曾经说过，对于很多软件企业而言，项目 A 是一个“理想的”成功项目。那么，是什么让情况变得不那么理想？
答案是一个所有软件开发者耳熟能详的词：需求变更。在真实的项目中，客户通常不会等到最后一天再照单全收整个项目，因为他知道自己的业务正在发生变化。这时需求变更就出现了，伴随着来回的扯皮和讨价还价。更糟的是，大量的需求变更发生在项目晚期——因为直到这时客户才真正看到、使用到这个软件，他的很多想法才真正浮现成型。随着这种“最后一分钟的需求变更”，项目超期、超出预算也就成了家常便饭。能够像项目A这样完工交付的，实在是凤毛麟角的幸运儿。
为了对付需求变更这个噩梦，软件开发者们还发明了另一个词：变更控制。这个有趣的词暗示着：需求变更是一种“不好”的东西，是需要“控制”的东西。然而站在客户的角度上想想，他在亲身使用了软件之后提出的要求，难道不是最有价值的东西吗？把这种真正创造业务价值的要求“控制”起来，难道是合理的吗？
在前面我也暗示过，并非所有的客户都一定青睐迭代式开发。那么，哪些软件项目不一定需要迭代式开发呢？从整篇文章的内容不难看出，如果客户的业务绝对不会变化，如果客户的需求巨细靡遗非常明确，如果客户不需要尽快开始使用软件以便收回成本，那么迭代式开发对他的帮助就会小得多。不过，如果读者认真思考的话，这样的例子也许并不多——也许比你最初认为的要少得多。一个很好的例子是“神州六号”火箭使用的计算机控制系统。还有多少这样的例子？读者不妨试着自己想想。
如果我足够幸运的话，也许一些读者已经被这篇文章吊起了胃口：既然有这么好的软件开发方法，既然它能够为我们创造更大的价值，那还等什么呢，我们马上就动手吧。事情不会那么简单。为了让迭代式开发能够成为现实，为了确保尽快、尽可能频繁地交付，为了确保每次交付的都是最有价值的功能，我们——包括软件开发者、软件企业和客户——需要很多的改变。这里既有职责与权利的划分，也有开发过程和团队的重组，还有技术层面的实践指导。这些正是敏捷方法学所涵盖的内容。缺少了这些东西，“为客户创造最大价值”就只能成为一句空话。在后续的文章里，我们将结合 ThoughtWorks 的实践经验，逐步介绍敏捷方法的方方面面。
最开始时微软公司将Java当做一种能解决C和C++中存在的问题的语言，并不在意，并继续维持和培训着其C和C++技术和编程人员。接下来不幸的是，正当微软尽力在Visual J++基础上拓展Java功能，并使之与Windows操作系统紧密结合在一起的时候，Sun公司对微软提出法律诉讼说其违反了许可证协议中的条款，最终的结果是微软公司不得不停止其Visual J++产品的开发。（微软公司仍然销售Visual J++，但是从1998年10月以来就没有新的版本发布，并且在.Net平台上也没有Visual J++的位置了）接下来的事情就很清楚了，微软公司开发了C#语言。接下来的一部分将讨论C#与Java的相似性。
C#与Java的区别
C#最引人的地方是它与Java的区别而不是其相似性。下面主要来介绍C#区别于Java的不同的运行特点及Java完全没有的特点。
中间语言
当MSIL被编译成最终的机器码时，微软公司在如何选择上是非常灵活的。微软公司很谨慎的对外宣称说MSIL不是解释型的，而是被编译成机器码。因为开发人员都有这样一个观念：Java程序天生就比C程序运行慢，所以这暗示着基于MSIL的程序优于解释型的Java字节码。当然，既然C#和其它MSIL产品编译器还未发布，那么这一点就还未证明，但是Java无处不在的即时编译器使得C#和Java在效能上是一样的。象“C#是编译型的，Java是解释型的”这样话只是销售中的技巧。Java的字节码和MSIL码都是的类似汇编的中间语言，在运行时执行这些中间码。
与COM的整合
对于基于Windows的C#开发人员来说，最大的收获是对COM的无损整合，COM是微软Win32的组件技术。实际上，任何一种.Net体系结构上的语言最终都可能去写COM的客户端和服务器端程序。用C#编写的类也会作为COM组件的子类；结果类（resulting class）也能作为COM组件使用，并作为COM组件的子类。
微软公司的目标是使越来越多的语言都能访问组件，并使这些组件能整合到.Net体系结构中。已有几个厂商开始着手开发支持.Net功能的编程语言，如COBOL和Haskell。开发人员能选择不同的语言解决不同问题，更重要的是，开发人员不必为采用.Net体系结构而必须学习新语言，可以选择一种他们熟悉的语言。
总结
本文的第一、二部分对C#做了一肤浅的总体介绍，主要是其产生动机及与Java的相似性。第三部分则涵概了C#的语言特点。用范例说明了C#与Java两者在相似性外，它们又是非常不同的，有许多细微的语义和设计区别，适合不同的技术和市场环境，又谈到了微软公司对C#进行标准化方面的尝试，及其对Java的影响。
c#与java的区别
1.属性：
java中定义和访问均要用get和set方法，可以不成对出现。
c#中是真正的属性，定义时get和set必须同时出现,房问时用.号即可。不用get,set
2.对象索引
就是对象数组
public Story this [int index] {
3.C#中,不用任何范围修饰符时,默认的是protect,因而不能在类外被访问.
4.因为JAVA规定,在一个文件中只能有一个public类,而且这个类的名称必须与文件名一模一样,这是一个区别
5.在C#中,它是以Main方法来定位入口的.如果一个程序中没有一个名为Main的方法,就会出"找不到入口的错误".不要把Main写成main哟
6.C#预定义的简单数据类型比Java多。例如，C#有unit，即无符号整数
7.忘掉Java中的static final修饰符。在C#中，常量可以用const关键词声明
C#的设计者还增加了readonly关键词,readonly域只能通过初始化器或类的构造函数设置
8.公用类的入口点:c#是可以对Main进行重载（java中是main）,允许有int返回值和空参数的Main
9.在Java中，switch语句只能处理整数。但C#中的switch语句不同，它还能够处理字符变量。请考虑下面用switch语句处理字符串变量的C#代码
10.C#没有>>>移位操作符
11.goto关键词:
Java不用goto关键词。在C#中，goto允许你转到指定的标签。不过，C#以特别谨慎的态度对待goto，比如它不允许goto转入到语句块的内部。在Java中，你可以用带标签的语句加上break或continue取代C#中的goto。
12.int[] x = { 0, 1, 2, 3 };
int x[] = { 0, 1, 2, 3 };
但在C#中，只有第一行代码合法，[]不能放到变量名字之后。
13.与Java不同的是，C#允许为名称空间或者名称空间中的类指定别名：
using TheConsole = System.Console;
14.在Java中，包的名字同时也是实际存在的实体，它决定了放置.java文件的目录结构。在C#中，物理的包和逻辑的名称之间是完全分离的
.NET中包的实体称为程序集（Assembly）。每一个程序集包含一个manifest结构。manifest列举程序集所包含的文件，控制哪些类型和资源被显露到程序集之外，并把对这些类型和资源的引用映射到包含这些类型与资源的文件。程序集是自包含的，一个程序集可以放置到单一的文件之内，也可以分割成多个文件。.NET的这种封装机制解决了DLL文件所面临的问题，即臭名昭著的DLL Hell问题。
15.在Java中，java.lang包是默认的包,C#中不存在默认的包
16.C#中的访问修饰符与Java中的基本对应，但多出了一个internal。简而言之，C#有5种类型的可访问性，如下所示：
public：成员可以从任何代码访问。
protected：成员只能从派生类访问。
internal：成员只能从同一程序集的内部访问。
protected internal：成员只能从同一程序集内的派生类访问。
private：成员只能在当前类的内部访问。
17.由于C#中不存在final关键词，如果想要某个类不再被派生，你可以使用sealed关键词
18.与Java不同，C#中的接口不能包含域（Field）。
另外还要注意，在C#中，接口内的所有方法默认都是公用方法。在Java中，方法声明可以带有public修饰符（即使这并非必要），但在C#中，显式为接口的方法指定public修饰符是非法的。例如，下面的C#接口将产生一个编译错误。
19.C#中的is操作符与Java中的instanceof操作符一样，两者都可以用来测试某个对象的实例是否属于特定的类型。在Java中没有与C#中的as操作符等价的操作符。as操作符与is操作符非常相似，但它更富有“进取心”：如果类型正确的话，as操作符会尝试把被测试的对象引用转换成目标类型；否则，它把变量引用设置成null。
20.C#仍旧保留了C++的内存手工管理方法，它适合在速度极端重要的场合使用，而在Java中这是不允许的
21.在C#中，所有的异常都从一个名为Exception的类派生
22.枚举器即enum类型(java无),把它作为一个变量值的类型使用，从而把变量可能的取值范围限制为枚举器中出现的值。
23.结构（Struct）与类很相似,而结构是一种值类型，它存储在栈中或者是嵌入式的,结构可以实现接口，可以象类一样拥有成员，但结构不支持继承
24.属性声明语法的第一部分与域声明很相似，第二部分包括一个set过程和/或一个get过程
25.传值方式：
在java中简单数据类型的值传参时，都以传值方式;
在c#中如果加ref则会以引用的方式传值（方法内部改变该参数，则外部变量一起跟着变）;
加out与ref基本相同，但out不要求参数一定要初始化.
26.c#保留了指针。unsafe
27.代理：代理（delegate）可以看作C++或者其他语言中的函数指针
代理用来封装可调用方法。你可以在类里面编写方法并在该方法上创建代理，此后这个代理就可以被传递到第二个方法。这样，第二个方法就可以调用第一个方法。
代理是从公共基类System.Delegate派生的引用类型。定义和使用代理包括三个步骤：声明，创建实例，调用。代理用delegate声明语法声明。
初学 Java 有段时间了，感觉似乎开始入了门，有了点儿感觉
但是发现很多困惑和疑问而且均来自于最基础的知识
折腾了一阵子又查了查书，终于对 String 这个特殊的对象有了点感悟
大家先来看看一段奇怪的程序：
public class TestString {
public static void main(String[] args) {
String s1 = "Monday";
String s2 = "Monday";
}
}
这个程序真是简单啊！可是有什么问题呢？
1. 来自 String 的忧虑
上面这段程序中，到底有几个对象呢？
可能很多人脱口而出：两个，s1 和 s2
为什么？
String 是 final 类，它的值不可变。
看起来似乎很有道理，那么来检测一下吧，稍微改动一下程序
就可以看到结果了：
public class TestString {
public static void main(String[] args) {
String s1 = "Monday";
String s2 = "Monday";
if (s1 == s2)
System.out.println("s1 == s2");
else
System.out.println("s1 != s2");
}
}
呵呵，很多人都会说已经不止两个对象了
编译并运行程序，输出：s1 == s2
啊！
为什么 s1 == s2 ?
== 分明是在说：s1 与 s2 引用同一个 String 对象 -- "Monday"!
2. 千变万化的 String
再稍微改动一下程序，会有更奇怪的发现：
public class TestString {
public static void main(String[] args) {
String s1 = "Monday";
String s2 = new String("Monday");
if (s1 == s2)
System.out.println("s1 == s2");
else
System.out.println("s1 != s2");
if (s1.equals(s2))
System.out.println("s1 equals s2");
else
System.out.println("s1 not equals s2");
}
}
我们将 s2 用 new 操作符创建
程序输出：
s1 != s2
s1 equals s2
嗯，很明显嘛
s1 s2分别引用了两个"Monday"String对象
可是为什么两段程序不一样呢？
3. 在 String 的游泳池中游泳
哈哈，翻了翻书终于找到了答案：
原来，程序在运行的时候会创建一个字符串缓冲池
当使用 s2 = "Monday" 这样的表达是创建字符串的时候，程序首先会
在这个String缓冲池中寻找相同值的对象，在第一个程序中，s1先被
放到了池中，所以在s2被创建的时候，程序找到了具有相同值的 s1
将 s2 引用 s1 所引用的对象"Monday"
第二段程序中，使用了 new 操作符，他明白的告诉程序：
“我要一个新的！不要旧的！”与是一个新的"Monday"Sting对象被创
建在内存中。他们的值相同，但是位置不同，一个在池中游泳
一个在岸边休息。哎呀，真是资源浪费，明明是一样的非要分开做什么呢？
4. 继续潜水
再次更改程序：
public class TestString {
public static void main(String[] args) {
String s1 = "Monday";
String s2 = new String("Monday");
s2 = s2.intern();
if (s1 == s2)
System.out.println("s1 == s2");
else
System.out.println("s1 != s2");
if (s1.equals(s2))
System.out.println("s1 equals s2");
else
System.out.println("s1 not equals s2");
}
}
这次加入：s2 = s2.intern();
哇！程序输出：
s1 == s2
s1 equals s2
原来，程序新建了 s2 之后，又用intern()把他打翻在了池里
哈哈，这次 s2 和 s1 有引用了同样的对象了
我们成功的减少了内存的占用
5. == 与 equals() 的争斗
String 是个对象，要对比两个不同的String对象的值是否相同
明显的要用到 equals() 这个方法
可是如果程序里面有那么多的String对象，有那么多次的要用到 equals ，
哦，天哪，真慢啊
更好的办法：
把所有的String都intern()到缓冲池去吧
最好在用到new的时候就进行这个操作
String s2 = new String("Monday").intern();
嗯，大家都在水池里泡着了吗？哈哈
现在我可以无所顾忌的用 == 来比较 String 对象的值了
真是爽啊，又快又方便！
关于String :)
String 啊 String ，让我说你什么好呢？
你为我们 Java 程序员带来所有的困扰还不够吗？
看看 String 这一次又怎么闹事儿吧
1. 回顾一下坏脾气的 String 老弟
例程1：
class Str {
public static void main(String[] args) {
String s = "Hi!";
String t = "Hi!";
if (s == t)
System.out.println("equals");
else
System.out.println("not equals");
}
}
程序输出什么呢？
如果看客们看过我的《来自 String 的困惑》之一
相信你很快会做出正确的判断：
程序输出：equals
2. 哦，天哪，它又在搅混水了
例程2：
class Str {
public static void main(String[] args) {
String s = "HELLO";
String t = s.toUpperCase();
if (s == t)
System.out.println("equals");
else
System.out.println("not equals");
}
}
那么这个程序有输出什么呢？
慎重！再慎重！不要被 String 这个迷乱的家伙所迷惑！
它输出：equals
WHY!!!
把程序简单的更改一下：
class Str2 {
public static void main(String[] args) {
String s = "Hello";
String t = s.toUpperCase();
if (s == t)
System.out.println("equals");
else
System.out.println("not equals");
}
}
你可能会说：不是一样吗？
不！千真万确的，不一样！这一次输出：not equals
Oh MyGOD!!!
谁来教训一下这个 String 啊！
3. 你了解你的马吗？
“要驯服脱缰的野马，就要了解它的秉性”牛仔们说道。
你了解 String 吗？
解读 String 的 API ，可以看到：
toUpperCase() 和 toLowerCase() 方法返回一个新的String对象，
它将原字符串表示字符串的大写或小写形势；
但是要注意：如果原字符串本身就是大写形式或小写形式，那么返回原始对象。
这就是为什么第二个程序中 s 和 t 纠缠不清的缘故
对待这个淘气的、屡教不改的 String ，似乎没有更好的办法了
让我们解剖它，看看它到底有什么结构吧：
(1) charAt(int n) 返回字符串内n位置的字符，第一个字符位置为0，
最后一个字符的位置为length()-1，访问错误的位置会扔出一块大砖头：
StringIndexOutOfBoundsException 真够大的
(2) concat(String str) 在原对象之后连接一个 str ，但是返回一个新的 String 对象
(3) EqualsIgnoreCase(String str) 忽略大小写的 equals 方法
这个方法的实质是首先调用静态字符方法toUpperCase() 或者 toLowerCase()
将对比的两个字符转换，然后进行 == 运算
(4) trim() 返回一个新的对象，它将原对象的开头和结尾的空白字符切掉
同样的，如果结果与原对象没有差别，则返回原对象
(5) toString() String 类也有 toString() 方法吗？
真是一个有趣的问题，可是如果没有它，你的 String 对象说不定真的不能用在
System.out.println() 里面啊
小心，它返回对象自己
String 类还有很多其他方法，掌握他们会带来很多方便
也会有很多困惑，所以坚持原则，是最关键的
4. 我想买一匹更好的马
来购买更驯服温和的 String 的小弟 StringBuffer 吧
这时候会有人反对：它很好用，它效率很高，它怎么能够是小弟呢？
很简单，它的交互功能要比 String 少，如果你要编辑字符串
它并不方便，你会对它失望
但这不意味着它不强大
public final class String implements Serializable, Comparable, CharSequence
public final class StringBuffer implements Serializable, CharSequence
很明显的，小弟少了一些东东，不过这不会干扰它的前途
StringBuffer 不是由 String 继承来的
不过要注意兄弟它也是 final 啊，本是同根生
看看他的方法吧，这么多稳定可靠的方法，用起来比顽皮的 String 要有效率的多
?br /> Java 为需要改变的字符串对象提供了独立的 StringBuffer 类
它的实例不可变（final），之所以要把他们分开
是因为，字符串的修改要求系统的开销量增大，
占用更多的空间也更复杂，相信当有10000人挤在一个狭小的游泳池里游泳
而岸边又有10000人等待进入游泳池而焦急上火
又有10000人在旁边看热闹的时候，你这个 String 游泳池的管理员也会焦头烂额
在你无需改变字符串的情况下，简单的 String 类就足够你使唤的了，
而当要频繁的更改字符串的内容的时候，就要借助于宰相肚里能撑船的
StringBuffer 了
5. 宰相肚里能撑船
(1) length() 与 capacity()
String 中的 length() 返回字符串的长度
兄弟 StringBuffer 也是如此，他们都由对象包含的字符长度决定
capacity()呢？
public class TestCapacity {
public static void main(String[] args)｛
StringBuffer buf = new StringBuffer("it was the age of wisdom,");
System.out.println("buf = " + buf);
System.out.println("buf.length() = " + buf.length());
System.out.println("buf.capacity() = " + buf.capacity());
String str = buf.toString();
System.out.println("str = " + str);
System.out.println("str.length() = " + str.length());
buf.append(" " + str.substring(0,18)).append("foolishness,");
System.out.println("buf = " + buf);
System.out.println("buf.length() = " + buf.length());
System.out.println("buf.capacity() = " + buf.capacity());
System.out.println("str = " + str);
}
}
程序输出：
buf = it was the age of wisdom.
buf.length() = 25
buf.capacity() = 41
str = it was the age of wisdom
str.length() = 25
buf = it was the age of wisdom, it was the age of foolishness,
buf.length() = 56
buf.capacity() = 84
str = it was the age of wisdom,
可以看到，在内容更改之后，capacity也随之改变了
长度随着向字符串添加字符而增加
而容量只是在新的长度超过了现在的容量之后才增加
StringBuffer 的容量在操作系统需要的时候是自动改变的
程序员们对capacity所能够做的仅仅是可以在初始化 StringBuffer对象的时候
以上片断引用自http://bbs.blueidea.com/viewthread.php?tid=945875&page=###
解释得比较形象和经典。具体的比较，要亲自动手运行一下程序才行，如下为网上找到的专门研究equals和==的关系的程序，相信可从中体会出他们的深刻不同：
String s1 = null;
String s2 = null;
System.out.println(s1==s2);//true
//System.out.println(s1.equals(s2));//NullPointerException
s1 = s2;
System.out.println(s1==s2);//true
//System.out.println(s1.equals(s2));//NullPointerException
System.out.println("***1***");
s1 = null;
s2 = "";
System.out.println(s1==s2);//false
//System.out.println(s1.equals(s2));//NullPointerException
s1 = s2;
System.out.println(s1==s2);//true
System.out.println(s1.equals(s2));//true
System.out.println("***2***");
s1 = "";
s2 = null;
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//false
s1 = s2;
System.out.println(s1==s2);//true
//System.out.println(s1.equals(s2));//NullPointerException
System.out.println("***3***");
s1 = "";
s2 = "";
System.out.println(s1==s2);//true
System.out.println(s1.equals(s2));//true
s1 = s2;
System.out.println(s1==s2);//true
System.out.println(s1.equals(s2));//true
System.out.println("***4***");
s1 = new String("");
s2 = new String("");
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true
s1 = s2;
System.out.println(s1==s2);//true
System.out.println(s1.equals(s2));//true
System.out.println("***5***");
s1 = "null";
s2 = "null";
System.out.println(s1==s2);//ture
System.out.println(s1.equals(s2));//true
s1 = s2;
System.out.println(s1==s2);//true
System.out.println(s1.equals(s2));//true
System.out.println("***6***");
s1 = new String("null");
s2 = new String("null");
System.out.println(s1==s2);//flase
System.out.println(s1.equals(s2));//true
s1 = s2;
System.out.println(s1==s2);//true
System.out.println(s1.equals(s2));//true
System.out.println("***7***");
s1 = "abc";
s2 = "abc";
System.out.println(s1==s2);//ture
System.out.println(s1.equals(s2));//true
s1 = s2;
System.out.println(s1==s2);//true
System.out.println(s1.equals(s2));//true
System.out.println("***8***");
s1 = new String("abc");
s2 = new String("abc");
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true
s1 = s2;
System.out.println(s1==s2);//true
System.out.println(s1.equals(s2));//true
System.out.println("***9***");
总结： 多数情况下这两者的区别就是究竟是对对象的引用进行比较还是对对象的值进行比较（其他特殊情况此处不予考虑）。==操作符是比较的对象的引用而不是对象的值。
但在最初的Object对象中的equals方法与==操作符完成功能是相同的。
源码：
java.lang.Object.equals()方法：
-------------------------------------------------------------
public boolean equalss(Object obj) {
return (this = = obj);
}
-------------------------------------------------------------
jdk文档中给出如下解释：
-------------------------------------------------------------
The equalss method implements an equivalence relation:
· It is reflexive: for any reference value x, x.equalss(x) should return true.
· It is symmetric: for any reference values x and y, x.equalss(y) should return true if and only if y.equalss(x) returns true.
· It is transitive: for any reference values x, y, and z, if x.equalss(y) returns true and y.equalss(z) returns true, then x.equalss(z) should return true.
· It is consistent: for any reference values x and y, multiple invocations of x.equalss(y) consistently return true or consistently return false, provided no information used in equalss comparisons on the object is modified.
· For any non-null reference value x, x.equalss(null) should return false.
The equalss method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any reference values x and y, this method returns true if and only if x and y refer to the same object (x==y has the value true).
Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equals objects must have equals hash codes.
-------------------------------------------------------------
对于String类的equals方法是对什么内容进行比较的呢？下面我们来看它的代码和注释：
源代码：
-------------------------------------------------------------
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
}
-------------------------------------------------------------
此方法的注释为：
-------------------------------------------------------------
Compares this string to the specified object. The result is true if and only if the argument is not null and is a String object that represents the same sequence of characters as this object.
-------------------------------------------------------------
由上面的代码和注释可以得到String类的equal方法是对对象的值进行比较。
根据以上的讨论可以得出结论：equal方法和==操作符是否存在区别要个别对待，要根据equal的每个实现情况来具体判断。
tomcat5.5.9 jdbc 连接池配置时常会出现两个错误:
1.***not bound
2.Cannot create JDBC driver of class '' for connect URL 'null'
可以通过以下的方法达到正确的配置:
1.现在%tomcat home%/conf/catalina/localhost 下面添加一段独立的context xml段,命名为jasper.xml,例如
<?xml version="1.0" encoding="UTF-8"?>
<Context path="/jasper" docBase="jasper" debug="1" reloadable="true" crossContext="true">
</Context>
2.通过admin的界面(或手动在server.xml界面里进行配置)数据源,以sql2k为例,配置后的server.xml应该为
<?xml version="1.0" encoding="UTF-8"?>
<Server>
<Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener"/>
<Listener className="org.apache.catalina.storeconfig.StoreConfigLifecycleListener"/>
<Listener className="org.apache.catalina.mbeans.ServerLifecycleListener"/>
<GlobalNamingResources>
<Environment
name="simpleValue"
type="java.lang.Integer"
value="30"/>
<Resource
auth="Container"
description="User database that can be updated and saved"
name="UserDatabase"
type="org.apache.catalina.UserDatabase"
pathname="conf/tomcat-users.xml"
factory="org.apache.catalina.users.MemoryUserDatabaseFactory"/>
<Resource
name="jdbc/Northwind"
type="javax.sql.DataSource"
password="*****"
driverClassName="com.microsoft.jdbc.sqlserver.SQLServerDriver"
maxIdle="2"
maxWait="5000"
username="sa"
url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=Northwind"
maxActive="20"/>
</GlobalNamingResources>
<Service
name="Catalina">
<Connector
port="80"
redirectPort="8443"
minSpareThreads="25"
connectionTimeout="20000"
maxSpareThreads="75"
maxThreads="150"
maxHttpHeaderSize="8192">
</Connector>
<Connector
port="8009"
redirectPort="8443"
protocol="AJP/1.3">
</Connector>
<Engine
defaultHost="localhost"
name="Catalina">
<Realm className="org.apache.catalina.realm.UserDatabaseRealm"/>
<Host
appBase="webapps"
name="localhost">
</Host>
</Engine>
</Service>
</Server>
3.在conf下面的context.xml文件中,</Context>之前加入
<ResourceLink name="jdbc/Northwind" global="jdbc/Northwind" type="javax.sql.DataSourcer"/>
4.在你的web文件夹下面的WEB-INF中找到web.xml,在最后</web-app>之前加入
<resource-ref>
<description>Northwind Connection</description>
<res-ref-name>jdbc/Northwind</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
5.保存,重启tomcat,这样,通过测试页面,就可以发现已经可以通过数据库连接池连上sql2k
test1.jsp
<%@ page contentType="text/html; charset=gb2312" language="java" import="java.sql.*" errorPage="" %>
<%@page import="javax.naming.*"%>
<%@page import="javax.sql.*"%>
<%
Context initContext = new InitialContext();
Context envContext = (Context)initContext.lookup("java:/comp/env");
DataSource ds = (DataSource)envContext.lookup("jdbc/Northwind");
Connection conn = ds.getConnection();
int counts=0;
String sql="select count(*) from orders";
PreparedStatement pst=conn.prepareStatement(sql);
ResultSet rst=pst.executeQuery();
while(rst.next()){
counts=rst.getInt(1);
}
%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>JNDI 测试</title>
</head>
<body>
<%=sql%><br>
pnrreg talbe's count is:<%=counts%>
</body>
</html>
摘要: JS的正则表达式
//校验是否全由数字组成
function isDigit(s)
{
var patrn=/^[0-9]{1,20}$/;
if (!patrn.exec(s)) return false
return true
}
//校验登录名：只能输入5-20个以字母开头、可带数字、“_”... 阅读全文
原著：Steve Mansour
sman@scruznet.com
Revised: June 5, 1999
(copied by jm /at/ jmason.org from http://www.scruz.net/%7esman/regexp.htm, after the original disappeared! )
翻译：Neo Lee
neo.lee@gmail.com
2004年10月16日
英文版原文
译者按：原文因为年代久远，文中很多链接早已过期（主要是关于vi、sed等工具的介绍和手册），本译文中已将此类链接删除，如需检查这些链接可以查看上面链接的原文。除此之外基本照原文直译，括号中有“译者按”的部分是译者补充的说明。如有内容方面的问题请直接和Steve Mansor联系，当然，如果你只写中文，也可以和我联系。
目 录
什么是正则表达式
范例
简单
中级（神奇的咒语）
困难（不可思议的象形文字）
不同工具中的正则表达式
什么是正则表达式
一个正则表达式，就是用某种模式去匹配一类字符串的一个公式。很多人因为它们看上去比较古怪而且复杂所以不敢去使用——很不幸，这篇文章也不能够改变这一点，不过，经过一点点练习之后我就开始觉得这些复杂的表达式其实写起来还是相当简单的，而且，一旦你弄懂它们，你就能把数小时辛苦而且易错的文本处理工作压缩在几分钟（甚至几秒钟）内完成。正则表达式被各种文本编辑软件、类库（例如Rogue Wave的tools.h++）、脚本工具（像awk/grep/sed）广泛的支持，而且像Microsoft的Visual C++这种交互式IDE也开始支持它了。
我们将在如下的章节中利用一些例子来解释正则表达式的用法，绝大部分的例子是基于vi中的文本替换命令和grep文件搜索命令来书写的，不过它们都是比较典型的例子，其中的概念可以在sed、awk、perl和其他支持正则表达式的编程语言中使用。你可以看看不同工具中的正则表达式这一节，其中有一些在别的工具中使用正则表达式的例子。还有一个关于vi中文本替换命令（s）的简单说明附在文后供参考。
正则表达式基础
正则表达式由一些普通字符和一些 元字符（metacharacters）组成。普通字符包括大小写的字母和数字，而元字符则具有特殊的含义，我们下面会给予解释。
在最简单的情况下，一个正则表达式看上去就是一个普通的查找串。例如，正则表达式"testing"中没有包含任何元字符，，它可以匹配"testing"和"123testing"等字符串，但是不能匹配"Testing"。
要想真正的用好正则表达式，正确的理解元字符是最重要的事情。下表列出了所有的元字符和对它们的一个简短的描述。
| 元字符 |
|
描述 |
|
|
|
|
. |
|
匹配任何单个字符。例如正则表达式r.t匹配这些字符串：rat、rut、r t，但是不匹配root。 |
|
$ |
|
匹配行结束符。例如正则表达式weasel$ 能够匹配字符串"He's a weasel"的末尾，但是不能匹配字符串"They are a bunch of weasels."。 |
|
^ |
|
匹配一行的开始。例如正则表达式^When in能够匹配字符串"When in the course of human events"的开始，但是不能匹配"What and When in the"。 |
|
* |
|
匹配0或多个正好在它之前的那个字符。例如正则表达式.*意味着能够匹配任意数量的任何字符。 |
|
\ |
|
这是引用府，用来将这里列出的这些元字符当作普通的字符来进行匹配。例如正则表达式\$被用来匹配美元符号，而不是行尾，类似的，正则表达式\.用来匹配点字符，而不是任何字符的通配符。 |
[ ]
[c1-c2]
[^c1-c2] |
|
匹配括号中的任何一个字符。例如正则表达式r[aou]t匹配rat、rot和rut，但是不匹配ret。可以在括号中使用连字符-来指定字符的区间，例如正则表达式[0-9]可以匹配任何数字字符；还可以制定多个区间，例如正则表达式[A-Za-z]可以匹配任何大小写字母。另一个重要的用法是“排除”，要想匹配除了指定区间之外的字符——也就是所谓的补集——在左边的括号和第一个字符之间使用^字符，例如正则表达式[^269A-Z] 将匹配除了2、6、9和所有大写字母之外的任何字符。 |
|
\< \> |
|
匹配词（word）的开始（\<）和结束（\>）。例如正则表达式\<the能够匹配字符串"for the wise"中的"the"，但是不能匹配字符串"otherwise"中的"the"。注意：这个元字符不是所有的软件都支持的。 |
|
\( \) |
|
将 \( 和 \) 之间的表达式定义为“组”（group），并且将匹配这个表达式的字符保存到一个临时区域（一个正则表达式中最多可以保存9个），它们可以用 \1 到\9 的符号来引用。 |
|
| |
|
将两个匹配条件进行逻辑“或”（Or）运算。例如正则表达式(him|her) 匹配"it belongs to him"和"it belongs to her"，但是不能匹配"it belongs to them."。注意：这个元字符不是所有的软件都支持的。 |
|
+ |
|
匹配1或多个正好在它之前的那个字符。例如正则表达式9+匹配9、99、999等。注意：这个元字符不是所有的软件都支持的。 |
|
? |
|
匹配0或1个正好在它之前的那个字符。注意：这个元字符不是所有的软件都支持的。 |
\{i\}
\{i,j\} |
|
匹配指定数目的字符，这些字符是在它之前的表达式定义的。例如正则表达式A[0-9]\{3\} 能够匹配字符"A"后面跟着正好3个数字字符的串，例如A123、A348等，但是不匹配A1234。而正则表达式[0-9]\{4,6\} 匹配连续的任意4个、5个或者6个数字字符。注意：这个元字符不是所有的软件都支持的。 |
最简单的元字符是点，它能够匹配任何单个字符（注意不包括新行符）。假定有个文件test.txt包含以下几行内容：
he is a rat
he is in a rut
the food is Rotten
I like root beer
我们可以使用grep命令来测试我们的正则表达式，grep命令使用正则表达式去尝试匹配指定文件的每一行，并将至少有一处匹配表达式的所有行显示出来。命令
在test.txt文件中的每一行中搜索正则表达式 r.t，并打印输出匹配的行。正则表达式 r.t匹配一个 r接着任何一个字符再接着一个 t。所以它将匹配文件中的 rat和 rut，而不能匹配 Rotten中的 Rot，因为正则表达式是大小写敏感的。要想同时匹配大写和小写字母，应该使用字符区间元字符（方括号）。正则表达式 [Rr]能够同时匹配 R和 r。所以，要想匹配一个大写或者小写的 r接着任何一个字符再接着一个 t就要使用这个表达式： [Rr].t。
要想匹配行首的字符要使用抑扬字符（^）——又是也被叫做插入符。例如，想找到text.txt中行首"he"打头的行，你可能会先用简单表达式he，但是这会匹配第三行的the，所以要使用正则表达式^he，它只匹配在行首出现的h。
有时候指定“除了×××都匹配”会比较容易达到目的，当抑扬字符（^）出现在方括号中是，它表示“排除”，例如要匹配he ，但是排除前面是t or s的情性（也就是the和she），可以使用：[^st]he。
可以使用方括号来指定多个字符区间。例如正则表达式[A-Za-z]匹配任何字母，包括大写和小写的；正则表达式[A-Za-z][A-Za-z]* 匹配一个字母后面接着0或者多个字母（大写或者小写）。当然我们也可以用元字符+做到同样的事情，也就是：[A-Za-z]+ ，和[A-Za-z][A-Za-z]*完全等价。但是要注意元字符+ 并不是所有支持正则表达式的程序都支持的。关于这一点可以参考后面的正则表达式语法支持情况。
要指定特定数量的匹配，要使用大括号（注意必须使用反斜杠来转义）。想匹配所有100和1000的实例而排除10和10000，可以使用：10\{2,3\}，这个正则表达式匹配数字1后面跟着2或者3个0的模式。在这个元字符的使用中一个有用的变化是忽略第二个数字，例如正则表达式0\{3,\} 将匹配至少3个连续的0。
简单的例子
这里有一些有代表性的、比较简单的例子。
| vi 命令 |
作用 |
|
|
| :%s/ */ /g |
把一个或者多个空格替换为一个空格。 |
| :%s/ *$// |
去掉行尾的所有空格。 |
| :%s/^/ / |
在每一行头上加入一个空格。 |
| :%s/^[0-9][0-9]* // |
去掉行首的所有数字字符。 |
| :%s/b[aeio]g/bug/g |
将所有的bag、beg、big和bog改为bug。 |
| :%s/t\([aou]\)g/h\1t/g |
将所有tag、tog和tug分别改为hat、hot和hug（注意用group的用法和使用\1引用前面被匹配的字符）。 |
|
|
中级的例子（神奇的咒语）
例1
将所有方法foo(a,b,c)的实例改为foo(b,a,c)。这里a、b和c可以是任何提供给方法foo()的参数。也就是说我们要实现这样的转换：
| 之前 |
|
之后 |
| foo(10,7,2) |
|
foo(7,10,2) |
| foo(x+13,y-2,10) |
|
foo(y-2,x+13,10) |
| foo( bar(8), x+y+z, 5) |
|
foo( x+y+z, bar(8), 5) |
下面这条替换命令能够实现这一魔法：
:%s/foo(\([^,]*\),\([^,]*\),\([^)]*\))/foo(\2,\1,\3)/g
现在让我们把它打散来加以分析。写出这个表达式的基本思路是找出foo()和它的括号中的三个参数的位置。第一个参数是用这个表达式来识别的：：\([^,]*\)，我们可以从里向外来分析它：
| [^,] |
|
除了逗号之外的任何字符 |
| [^,]* |
|
0或者多个非逗号字符 |
| \([^,]*\) |
|
将这些非逗号字符标记为\1，这样可以在之后的替换模式表达式中引用它 |
| \([^,]*\), |
|
我们必须找到0或者多个非逗号字符后面跟着一个逗号，并且非逗号字符那部分要标记出来以备后用。 |
现在正是指出一个使用正则表达式常见错误的最佳时机。为什么我们要使用[^,]*这样的一个表达式，而不是更加简单直接的写法，例如：.*，来匹配第一个参数呢？设想我们使用模式.*来匹配字符串"10,7,2"，它应该匹配"10,"还是"10,7,"？为了解决这个两义性（ambiguity），正则表达式规定一律按照最长的串来，在上面的例子中就是"10,7,"，显然这样就找出了两个参数而不是我们期望的一个。所以，我们要使用[^,]*来强制取出第一个逗号之前的部分。
这个表达式我们已经分析到了：foo(\([^,]*\)，这一段可以简单的翻译为“当你找到foo(就把其后直到第一个逗号之前的部分标记为\1”。然后我们使用同样的办法标记第二个参数为\2。对第三个参数的标记方法也是一样，只是我们要搜索所有的字符直到右括号。我们并没有必要去搜索第三个参数，因为我们不需要调整它的位置，但是这样的模式能够保证我们只去替换那些有三个参数的foo()方法调用，在foo()是一个重载（overoading）方法时这种明确的模式往往是比较保险的。然后，在替换部分，我们找到foo()的对应实例，然后利用标记好的部分进行替换，是的第一和第二个参数交换位置。
例2
假设有一个CSV（comma separated value）文件，里面有一些我们需要的信息，但是格式却有问题，目前数据的列顺序是：姓名，公司名，州名缩写，邮政编码，现在我们希望讲这些数据重新组织，以便在我们的某个软件中使用，需要的格式为：姓名，州名缩写-邮政编码，公司名。也就是说，我们要调整列顺序，还要合并两个列来构成一个新列。另外，我们的软件不能接受逗号前后面有任何空格（包括空格和制表符）所以我们还必须要去掉逗号前后的所有空格。
这里有几行我们现在的数据：
Bill Jones, HI-TEK Corporation , CA, 95011
Sharon Lee Smith, Design Works Incorporated, CA, 95012
B. Amos , Hill Street Cafe, CA, 95013
Alexander Weatherworth, The Crafts Store, CA, 95014
...
我们希望把它变成这个样子：
Bill Jones,CA 95011,HI-TEK Corporation
Sharon Lee Smith,CA 95012,Design Works Incorporated
B. Amos,CA 95013,Hill Street Cafe
Alexander Weatherworth,CA 95014,The Crafts Store
...
我们将用两个正则表达式来解决这个问题。第一个移动列和合并列，第二个用来去掉空格。
下面就是第一个替换命令：
:%s/\([^,]*\),\([^,]*\),\([^,]*\),\(.*\)/\1,\3 \4,\2/
这里的方法跟例1基本一样，第一个列（姓名）用这个表达式来匹配： \([^,]*\)，即第一个逗号之前的所有字符，而姓名内容被用 \1标记下来。公司名和州名缩写字段用同样的方法标记为 \2和 \3，而最后一个字段用 \(.*\)来匹配（"匹配所有字符直到行末"）。替换部分则引用上面标记的那些内容来进行构造。
下面这个替换命令则用来去除空格：
我们还是分解来看： [ \t]匹配空格/制表符， [ \t]* 匹配0或多个空格/制表符， [ \t]*,匹配0或多个空格/制表符后面再加一个逗号，最后， [ \t]*,[ \t]*匹配0或多个空格/制表符接着一个逗号再接着0或多个空格/制表符。在替换部分，我们简单的我们找到的所有东西替换成一个逗号。这里我们使用了结尾的可选的 g参数，这表示在每行中对所有匹配的串执行替换（而不是缺省的只替换第一个匹配串）。
例3
假设有一个多字符的片断重复出现，例如：
Billy tried really hard
Sally tried really really hard
Timmy tried really really really hard
Johnny tried really really really really hard 而你想把"really"、"really really"，以及任意数量连续出现的"really"字符串换成一个简单的"very"（simple is good!），那么以下命令：
:%s/\(really \)\(really \)*/very / 就会把上述的文本变成：
Billy tried very hard
Sally tried very hard
Timmy tried very hard
Johnny tried very hard 表达式 \(really \)*匹配0或多个连续的"really "（注意结尾有个空格），而 \(really \)\(really \)* 匹配1个或多个连续的"really "实例。
困难的例子（不可思议的象形文字）
Coming soon.
不同工具中的正则表达式
OK，你已经准备使用RE（regular expressions，正则表达式），但是你并准备使用vi。所以，在这里我们给出一些在其他工具中使用RE的例子。另外，我还会总结一下你在不同程序之间使用RE可能发现的区别。
当然，你也可以在Visual C++编辑器中使用RE。选择Edit->Replace，然后选择"Regular expression"选择框，Find What输入框对应上面介绍的vi命令:%s/pat1/pat2/g中的pat1部分，而Replace输入框对应pat2部分。但是，为了得到vi的执行范围和g选项，你要使用Replace All或者适当的手工Find Next and Replace（译者按：知道为啥有人骂微软弱智了吧，虽然VC中可以选中一个范围的文本，然后在其中执行替换，但是总之不够vi那么灵活和典雅）。
sed
Sed是Stream EDitor的缩写，是Unix下常用的基于文件和管道的编辑工具，可以在手册中得到关于sed的详细信息。
这里是一些有趣的sed脚本，假定我们正在处理一个叫做price.txt的文件。注意这些编辑并不会改变源文件，sed只是处理源文件的每一行并把结果显示在标准输出中（当然很容易使用重定向来定制）：
| sed脚本 |
|
描述 |
|
|
|
| sed 's/^$/d' price.txt |
|
删除所有空行 |
| sed 's/^[ \t]*$/d' price.txt |
|
删除所有只包含空格或者制表符的行 |
| sed 's/"//g' price.txt |
|
删除所有引号 |
awk
awk是一种编程语言，可以用来对文本数据进行复杂的分析和处理。可以在手册中得到关于awk的详细信息。这个古怪的名字是它作者们的姓的缩写（Aho，Weinberger和Kernighan）。
在Aho，Weinberger和Kernighan的书The AWK Programming Language中有很多很好的awk的例子，请不要让下面这些微不足道的脚本例子限制你对awk强大能力的理解。我们同样假定我们针对price.txt文件进行处理，跟sed一样，awk也只是把结果显示在终端上。
| awk脚本 |
|
描述 |
|
|
|
| awk '$0 !~ /^$/' price.txt |
|
删除所有空行 |
| awk 'NF > 0' price.txt |
|
awk中一个更好的删除所有行的办法 |
| awk '$2 ~ /^[JT]/ {print $3}' price.txt |
|
打印所有第二个字段是'J'或者'T'打头的行中的第三个字段 |
| awk '$2 !~ /[Mm]isc/ {print $3 + $4}' price.txt |
|
针对所有第二个字段不包含'Misc'或者'misc'的行，打印第3和第4列的和（假定为数字） |
| awk '$3 !~ /^[0-9]+\.[0-9]*$/ {print $0}' price.txt |
|
打印所有第三个字段不是数字的行，这里数字是指d.d或者d这样的形式，其中d是0到9的任何数字 |
| awk '$2 ~ /John|Fred/ {print $0}' price.txt |
|
如果第二个字段包含'John'或者'Fred'则打印整行 |
grep
grep是一个用来在一个或者多个文件或者输入流中使用RE进行查找的程序。它的name编程语言可以用来针对文件和管道进行处理。可以在手册中得到关于grep的完整信息。这个同样古怪的名字来源于vi的一个命令， g/re/p，意思是 global regular expression print。
下面的例子中我们假定在文件phone.txt中包含以下的文本，——其格式是姓加一个逗号，然后是名，然后是一个制表符，然后是电话号码：
Francis, John 5-3871
Wong, Fred 4-4123
Jones, Thomas 1-4122
Salazar, Richard 5-2522
| grep命令 |
|
描述 |
|
|
|
| grep '\t5-...1' phone.txt |
|
把所有电话号码以5开头以1结束的行打印出来，注意制表符是用\t表示的 |
| grep '^S[^ ]* R' phone.txt |
|
打印所有姓以S打头和名以R打头的行 |
| grep '^[JW]' phone.txt |
|
打印所有姓开头是J或者W的行 |
| grep ', ....\t' phone.txt |
|
打印所有姓是4个字符的行，注意制表符是用\t表示的 |
| grep -v '^[JW]' phone.txt |
|
打印所有不以J或者W开头的行 |
| grep '^[M-Z]' phone.txt |
|
打印所有姓的开头是M到Z之间任一字符的行 |
| grep '^[M-Z].*[12]' phone.txt |
|
打印所有姓的开头是M到Z之间任一字符，并且点号号码结尾是1或者2的行 |
egrep
egrep是grep的一个扩展版本，它在它的正则表达式中支持更多的元字符。下面的例子中我们假定在文件phone.txt中包含以下的文本，——其格式是姓加一个逗号，然后是名，然后是一个制表符，然后是电话号码：
Francis, John 5-3871
Wong, Fred 4-4123
Jones, Thomas 1-4122
Salazar, Richard 5-2522
| egrep command |
|
Description |
|
|
|
| egrep '(John|Fred)' phone.txt |
|
打印所有包含名字John或者Fred的行 |
| egrep 'John|22$|^W' phone.txt |
|
打印所有包含John 或者以22结束或者以W的行 |
| egrep 'net(work)?s' report.txt |
|
从report.txt中找到所有包含networks或者nets的行 |
正则表达式语法支持情况
| 命令或环境 |
. |
[ ] |
^ |
$ |
\( \) |
\{ \} |
? |
+ |
| |
( ) |
| vi |
X |
X |
X |
X |
X |
|
|
|
|
|
| Visual C++ |
X |
X |
X |
X |
X |
|
|
|
|
|
| awk |
X |
X |
X |
X |
|
|
X |
X |
X |
X |
| sed |
X |
X |
X |
X |
X |
X |
|
|
|
|
| Tcl |
X |
X |
X |
X |
X |
|
X |
X |
X |
X |
| ex |
X |
X |
X |
X |
X |
X |
|
|
|
|
| grep |
X |
X |
X |
X |
X |
X |
|
|
|
|
| egrep |
X |
X |
X |
X |
X |
|
X |
X |
X |
X |
| fgrep |
X |
X |
X |
X |
X |
|
|
|
|
|
| perl |
X |
X |
X |
X |
X |
|
X |
X |
X |
X |
vi替换命令简介
Vi的替换命令：
其中
网上有很多vi的在线手册，你可以访问他们以获得更加完整的信息。
已知: 字段A='F:\photo\Winter Leaves.jpg'
要求:分段截取每段字符[字段A不能为TEXT类型,否则报错]
解决方法:
+++++++++++++++++++++++++++++++++++++++++++++++++++
---截取字符串A的第一个\左边的字符串
select left(A,charindex('/',A)-1)
输出结果：F:
++++++++++++++++++++++++++++++++++++++++++++++++++++
---截取\中间的字符串
select left(stuff(A,1,charindex('/',A),''),charindex('/',stuff(A,1,charindex('/',A),''))-1)
输出结果：photo
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
---截取最后一个\后面的字符串
select reverse(left(reverse(A),charindex('/',reverse(A))-1))
输出结果：Winter Leaves.jpg
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
---截取字符串A的首字幕
select STUFF(A,1, 1, '')
输出结果：:\photo\Winter Leaves.jpg
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
把你的光标放到相应文字上查看效果
|
要注意光标的实际效果依赖于用户的系统设置，与你在这里看到的效果并不一定一致。
|
|
cursor: crosshair;
|
|
十字准心
|
The cursor render as a crosshair
游标表现为十字准线
|
|
cursor: pointer;
cursor: hand;
写两个是为了照顾IE5，它只认hand。
|
|
手
|
The cursor render as a pointer (a hand) that indicates a link
游标以暗示(手指)的形式来表明有一个连接
|
|
cursor: wait;
|
|
等待/沙漏
|
The cursor indicates that the program is busy (often a watch or an hourglass)
游标暗示当前程序正忙(一般为一块表或是一个沙漏)
|
|
cursor: help;
|
|
帮助
|
The cursor indicates that help is available (often a question mark or a balloon)
游标暗示当前位置可得到帮助(一般为问号或是气球)
|
|
cursor: no-drop;
|
|
无法释放
|
cursor: no-drop;
|
|
cursor: text;
|
|
文字/编辑
|
The cursor indicates text
游标暗示当前所处位置为文字内容
|
|
cursor: move;
|
|
可移动对象
|
The cursor indicates something that should be moved
游标暗示一些东西应该被移动
|
|
cursor: n-resize;
|
|
向上改变大小(North)
|
The cursor indicates that an edge of a box is to be moved up (north)
边缘可向上移动(北)
|
|
cursor: s-resize;
|
|
向下改变大小(South)
|
The cursor indicates that an edge of a box is to be moved down (south)
边缘可向下方移动(南)
|
|
cursor: e-resize;
|
|
向右改变大小(East)
|
The cursor indicates that an edge of a box is to be moved right (east)
box边缘可向右(东)边移动
|
|
cursor: w-resize;
|
|
向左改变大小(West)
|
The cursor indicates that an edge of a box is to be moved left (west)
边缘可向左移动(西)
|
|
cursor: ne-resize;
|
|
向上右改变大小(North East)
|
The cursor indicates that an edge of a box is to be moved up and right (north/east)
游标暗示box的边缘可向右上方移动(东北方向)
|
|
cursor: nw-resize;
|
|
向上左改变大小(North West)
|
The cursor indicates that an edge of a box is to be moved up and left (north/west)
边缘可向左上方移动(西北)
|
|
cursor: se-resize;
|
|
向下右改变大小(South East)
|
The cursor indicates that an edge of a box is to be moved down and right (south/east)
边缘可向右下方移动(东南)
|
|
cursor: sw-resize;
|
|
向下左改变大小(South West)
|
The cursor indicates that an edge of a box is to be moved down and left (south/west)
边缘可向左下方移动(西南)
|
|
cursor: auto;
|
|
自动
|
The browser sets a cursor
浏览器设置一个游标
|
|
cursor:not-allowed;
|
|
禁止
|
cursor:not-allowed;
|
|
cursor: progress;
|
|
处理中
|
cursor: progress;
|
|
cursor: default;
|
|
系统默认
|
The default cursor (often an arrow)
默认的游标状态（通常为一个箭头）
|
|
cursor: url(' # ');
# = 光标文件地址 (注意文件格式必须为：.cur 或 .ani)。
|
|
用户自定义（可用动画）
|
The url of a custom cursor to be used.
自定义游标的url位置
Note: Always define a generic cursor at the end of the list in case none of the url-defined cursors can be used
注意：在定义完自定义的游标之后在末尾加上一般性的游标，以防那些url所定义的游标不能使用
|
Logo生成网站:
天空秘书网,J/m!h._H K&Rq
强烈推荐:http://www.logomaker.cn
http://phorum.com.tw/Generator.aspx 天空秘书网,VK2V#J&t#W`*A
http://www.logoyes.com/lc_leftframe.htm 天空秘书网&jD-L|;X+O8c
http://cooltext.com/Default.aspx
Banner图片制作网站:
http://www.bannerbreak.com/index.php
在线图片生成网站:
http://www.streetsigngenerator.com/
%u` U l5e&Bt;Fd0http://www.letterjames.de/
图片分割器: http://www.html-kit.com/e/is.cgi
立体图片生成器: http://www.chami.com/html-kit/services/imge/
图片生成邮票: http://photo.stamps.com/PhotoStamps/?source=si00001331
个性拼图: http://www.jigcool.com/jigonline/jigonline1_sc.php
印章制作: http://caishu.sina.com.cn/
GIF图片的文字LOGO在线生成:http://www.3dtextmaker.com/cgi-bin/3dtext.pl
在线制作logo,bannar的网站:http://www.crazystudy.com
SAINT.Assess the Security of Computer Networks ：http://www.saintcorporation.com/saint/
Abacus.Intrusion Prevention System ：http://www.psionic.com/abacus/
Firewall Generator（在线生成简单的防火墙脚本）
http://www.citadec.com/FirewallGenerator.html
在线字体图片生成：http://www.youmade.com/font/
在线生成条码打印
http://www.027hc.com/y1.asp
[tG+|$M{~/@"dV0http://www.nlscan.com/soucecentre/demo.asp
#U|TA I%F Ts0http://www.gzbonny.com/asp/barcode.asp
在线图形特效生成：http://www.chami.com/
聊天工具在线状态生成器：http://www.onlinestatus.org/forum/usage.php
粉丝身份证：http://id.igogo8.com/
制作印章：http://www.makepic.com/print.php
邮址图片生成：http://www.makepic.com/email.php
条形码生成：http://www.makepic.com/barcode.php
Kiss学堂 颁发结业证：http://www.makepic.com/kiss/cert.php
生成头像：http://www.eoool.com/ImageDIY/DIYChooseImg.aspx?ImgSize=96x96x1
邮件：http://www.eoool.com/Sevice.aspx?TypeID=1
聊天图标：http://www.eoool.com/Sevice.aspx?TypeID=2
博客图标：http://www.eoool.com/Sevice.aspx?TypeID=3
网络书签：http://www.eoool.com/Sevice.aspx?TypeID=5
朋友圈：http://www.eoool.com/Sevice.aspx?TypeID=4
按扭：http://www.eoool.com/Sevice.aspx?TypeID=11
生成拼凑图：http://blog.outer-court.com/letters/
一个日本武士刀劈出你需要的字：
http://tools.fodey.com/generators/animated/ninjatext.asp
生成几种卡通人物对话动态图片：
http://tools.fodey.com/generators/animated/talking_squirrel.asp天空秘书网P R_9]H,|,x
^0g3pI#}5l;z.v `F0香烟盒生成，可以做警告图片：http://tools.fodey.com/generators/cigarette_packet/generator.cig
支持多种域名的Email图标的生成: http://www.nhacks.com/email/
两个地址支持两种风格任意文本的Email图标的生成:
http://sagittarius.dip.jp/~toshi/cgi-bin/designmail/designmail.html天空秘书网Q T2z6^9~ \8kZ g'IW
http://sagittarius.dip.jp/~toshi/cgi-bin/catmark/catmark.html
在线favicon生成器: http://www.html-kit.com/e/favicon.cgi
支持各种类型图片的生成，可以选择设置的条件非常灵活:
http://www.abi-station.com/tchinese/
支持大量中文字体签名图标生成: http://www.youmade.com/font/
Flickr杂志封面生成器: http://flagrantdisregard.com/flickr/magazine.php
动态生成有趣图片:
爱因斯坦：http://www.hetemeel.com/einsteinform.php
山姆大叔：http://www.hetemeel.com/unclesamform.php
辞典：http://www.hetemeel.com/dictionaryform.php
魔法师：http://www.imagegenerator.net/create/dumbledore/
Flickr Logo风格图片生成器:：http://flickr.nosv.org/
按钮生成网站：
http://kalsey.com/tools/buttonmaker/
%u"l*FdqLp X8K9A6Z ]0http://www.lucazappa.com/brilliantMaker/buttonImage.php天空秘书网A,W!s)[c{
http://www.feedforall.com/public/rss-graphic-tool.htm天空秘书网L |e"j*BP8kS0A
http://www.kalsey.com/tools/buttonmaker/
y$A Si1Y&N/Z0http://www.yugatech.com/make.php天空秘书网R SS2_ E ^9[.O
http://www.hkwebs.net/catalog/tools/buttonmaker/index.php
Email图标生成网站:：
http://email.playtime.uni.cc/
:y]~5d'[d3L Y+k$j0http://services.nexodyne.com/email/
6nPlesL0http://gizmo967.mgs3.org/Gmail/
R-GD kl3[z0http://www.hkwebs.net/catalog/tools/gmail/ 天空秘书网;N5ha5a*V`P3`
http://sagittarius.dip.jp/~toshi/cgi-bin/designmail/designmail.html
~z'Z'G K%h4cq0http://www.eoool.com/
匹配中文字符的正则表达式： [\u4e00-\u9fa5]
匹配双字节字符(包括汉字在内)：[^\x00-\xff]
应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
String.prototype.len=function(){return this.replace([^\x00-\xff]/g,"aa").length;}
匹配空行的正则表达式：\n[\s| ]*\r
匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/
匹配首尾空格的正则表达式：(^\s*)|(\s*$)
应用：javascript中没有像vbscript那样的trim函数，我们就可以利用这个表达式来实现，如下：
String.prototype.trim = function()
{
return this.replace(/(^\s*)|(\s*$)/g, "");
}
利用正则表达式分解和转换IP地址：
下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的Javascript程序：
function IP2V(ip)
{
re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //匹配IP地址的正则表达式
if(re.test(ip))
{
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
}
else
{
throw new Error("Not a valid IP address!")
}
}
不过上面的程序如果不用正则表达式，而直接用split函数来分解可能更简单，程序如下：
var ip="10.100.20.168"
ip=ip.split(".")
alert("IP值是："+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))
匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
匹配网址URL的正则表达式：http://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?
利用正则表达式去除字串中重复的字符的算法程序：
var s="abacabefgeeii"
var s1=s.replace(/(.).*\1/g,"$1")
var re=new RegExp("["+s1+"]","g")
var s2=s.replace(re,"")
alert(s1+s2) //结果为：abcefgi
我原来在CSDN上发贴寻求一个表达式来实现去除重复字符的方法，最终没有找到，这是我能想到的最简单的实现方法。思路是使用后向引用取出包括重复的字符，再以重复的字符建立第二个表达式，取到不重复的字符，两者串连。这个方法对于字符顺序有要求的字符串可能不适用。
得用正则表达式从URL地址中提取文件名的javascript程序，如下结果为page1
s="http://www.gzcynet/page1.htm"
s=s.replace(/(.*\/){0,}([^\.]+).*/ig,"$2")
alert(s)
利用正则表达式限制网页表单里的文本框输入内容：
用正则表达式限制只能输入中文：onkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\u4E00-\u9FA5]/g,''))"
用正则表达式限制只能输入全角字符： onkeyup="value=value.replace(/[^\uFF00-\uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\uFF00-\uFFFF]/g,''))"
用正则表达式限制只能输入数字：onkeyup="value=value.replace(/[^\d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"
用正则表达式限制只能输入数字和英文：onkeyup="value=value.replace(/[\W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"
下面四個都是檢查email的...
^([0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,9})$
^[\w-]+(?:\.[\w-]+)*@(?:[\w-]+\.)+[a-zA-Z]{2,7}$
^.+@[^\.].*\.[a-z]{2,}$
^[\w\.=-]+@[\w\.-]+\.[\w]{2,3}$
|
模型驱动架构（MDA）是一种独立于特定平台和软件供应商的软件体系结构设计和开发方法，它适用于设计、部署、集成等软件开发的整个生命周期。MDA 遵循的是诸如统一建模语言（UML）、可扩展标记语言（XML）和公共对象请求代理体系结构（CORBA）等一系列业界开放标准。
MDA 建模是基于功能，而非基于特定语言、平台或实现技术，它可以简化系统集成、缩短开发周期和节省企业资源。
模型通常以图和文字的形式来描述一个系统及其环境。模型驱动的方法就是利用模型来引导系统的设计、开发和维护。而模型驱动架构即是用系统的模型来生成系统的体系结构。
MDA 有三个视图。第一个视图叫“计算无关视图（CIV）”，其作用就是将系统基本处理逻辑同平台相关的技术规范分离开来。CIV视图关注于系统的环境和需求，而系统的具体结构和实现是隐藏的。
第二个视图是“平台无关视图（PIV）”。该视图关注于系统的操作而隐藏了平台相关的细节，该视图可能用一种通用的、平台无关的建模语言如UML来描述。
第三个视图叫“平台相关视图（PSV）”。该视图关注特定平台的实现细节。
以上三个视图都有其各自相应的模型：
- 计算无关模型（CIM）通常由业务分析人员创建，展示了系统的业务模型。
- 平台无关模型（PIM）是系统功能的模型，通常由系统架构师创建。
- 平台相关模型（PSM）对一个或多个平台的PIM模型的具体实现建模。
MDA 的真正价值在于 CIM 模型可以通过简单的映射转换成 PIM 模型。同样的，PIM 模型也可以映射成 PSM 模型，而 PSM 模型则可以最终转换成具体的实现代码。
如下图所示，右上角的 CIM 模型是整个模型转换过程的起点。CIM 模型转换成 PIM 模型后，系统架构师和设计师即可以创建系统其余部分的模型。设计完成之后，PIM 模型就转换成了一个或多个 PSM 模型。
|
|
模型驱动架构 （MDA）
|
|
MDA 提供了一种优雅而可靠的开发框架，这种框架使得系统架构师在没有考虑到有关系统实现的任何细节之前就可以事先定义好系统的模型。
MDA 的优势主要包括如下几点：
- 可移植性 －当你创建好一个 PIM 模型之后，创建一个新的基于该 PIM 模型的 PSM 模型是相当容易的。当然，你需要到目标平台的映射规则和一些连接代码。
- 跨平台的互操作性 － 除了可以将一个系统模型转化为不同的实现，你也可以使用一种特殊的映射规则将一个 PIM 模型转化为一个异构的 PSM 模型，在该异构模型中，最终的系统是由来自多个平台的组件构建而成的。
- 开发效率 － MDA 是一种极其高效的设计和开发方法。使用 MDA 方法可以以更少的人力来完成原先相同的工作量，或者以原先相同的人力来完成更多的工作，所有这些都无需对开发团队施加额外的压力。
- 软件质量 － 使用一种单一的模型来生成和导出系统的大部分代码可以极大地降低人为错误的发生。
MDA 还有其它更多的优势，如对新技术的快速包容、平台无关性、领域相关性、降低开发成本和缩短开发周期等等。
|
文件的建立/检查与删除
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>文件的建立、检查与删除</title>
</head>
<body>
<%
String path=request.getRealPath("");
//out.println(path);
File f=new File(path,"File.txt");
//out.println(f);
//out.println(f.exists());
if(f.exists()){//检查File.txt是否存在
f.delete();//删除File.txt文件
out.println(path + "\\File.txt 存在，已删除。");
}else{
f.createNewFile();//在当前目录下建立一个名为File.txt的文件
out.println(path + "\\File.txt 不存在，已建立。");//输出目前所在的目录路径
}
%>
目录的建立/检查与删除
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>目录的建立/检查与删除</title>
</head>
<body>
<%
String path=request.getRealPath("");
path=path + "\\Sub";//将要建立的目录路径
File d=new File(path);//建立代表Sub目录的File对象，并得到它的一个引用
if(d.exists()){//检查Sub目录是否存在
d.delete();
out.println("Sub目录存在，已删除");
}else{
d.mkdir();//建立Sub目录
out.println("Sub目录不存在，已建立");
}
%>
</body>
</html>
如何在JSP中处理虚拟目录
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>JSP中如何处理虚拟目录</title>
</head>
<body>
取得虚拟目录对应的磁盘路径<br>
Web站点主目录的位置为<font color=#ff0000><%=request.getRealPath("/")%></font><br>
JSP网页所在的目录位置<font color=#ff0000><%=request.getRealPath("./")%></font><br>
JSP网页所在目录上一层目录的位置<font color=#ff0000><%=request.getRealPath("../")%></font><br>
</body>
</html>
文件属性的取得
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.util.Date,java.io.*"%>
<html>
<head>
<title>文件属性的取得</title>
</head>
<body>
<%
String path=request.getRealPath("/");
File f=new File(path,"ReadData.txt");
if(f.exists()){
%>
<%=f.getName()%>的属性如下：<br><br>
文件长度为：<%=f.length()%>
<%=f.isFile()?"是文件":"不是文件"%><br>
<%=f.isDirectory()?"是目录":"不是目录"%><br>
<%=f.canRead()?"可读取":"不可读取"%><br>
<%=f.canWrite()?"可写入":"不可写入"%><br>
<%=f.isHidden()?"是隐藏文件":"不是隐藏文件"%><br>
文件的最后修改日期为：<%=new Date(f.lastModified())%><br>
<%
}else{
f.createNewFile();//在当前目录下建立一个名为ReaData.txt的文件
%>
<%=f.getName()%>的属性如下：<br><br>
文件长度为：<%=f.length()%>
<%=f.isFile()?"是文件":"不是文件"%><br>
<%=f.isDirectory()?"是目录":"不是目录"%><br>
<%=f.canRead()?"可读取":"不可读取"%><br>
<%=f.canWrite()?"可写入":"不可写入"%><br>
<%=f.isHidden()?"是隐藏文件":"不是隐藏文件"%><br>
文件的最后修改日期为：<%=new Date(f.lastModified())%><br>
<%
}
%>
</body>
</html>
取出目录中文件的方法
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>取出目录中文件的方法--列出目录中的文件</title>
</head>
<body>
<%
String path=request.getRealPath("/");
File d=new File(path);//建立当前目录中文件的File对象
File list[]=d.listFiles();//取得代表目录中所有文件的File对象数组
out.println("<font color=#ff0000>" + path + "目录下的文件：</font><br>");
for(int i=0;i<list.length;i++){
if(list<I>.isFile()){
out.println(list<I>.getName() + "<br>");
}
}
out.println("<br><font color=#ff0000>" + path + "目录下的目录：</font><br>");
for(int i=0;i<list.length;i++){
if(list<I>.isDirectory()){
out.println(list<I>.getName() + "<br>");
}
}
%>
</body>
</html>
判断是否为空白文件
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>判断是否为空白文件</title>
</head>
<body>
<%
String path=request.getRealPath("/");
out.println(path);
FileReader fr=new FileReader(path + "\\AtEnd.txt");//建立FileReader对象，并实例化为fr
//对FileReader类生成的对象使用read()方法，可以从字符流中读取下一个字符。
if(fr.read()==-1)//判断是否已读到文件的结尾
{
out.print("AtEnd.txt文件中没有数据<br>");
}else{
out.println("AtEnd.txt文件中有数据");
}
fr.close();
%>
</body>
</html>
读取所有的文件数据
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*,java.lang.*"%>
<html>
<head>
<title>读取所有的文件数据</title>
</head>
<body>
<%
String path=request.getRealPath(".");
FileReader fr=new FileReader(path + "\\ReadData.txt");
//关键在于读取过程中，要判断所读取的字符是否已经到了文件的末尾，并且这个字符是不是文件中的断行符，即判断该字符值是否为13。
int c=fr.read();//从文件中读取一个字符
//判断是否已读到文件结尾
while(c!=-1){
out.print((char)c);//输出读到的数据
c=fr.read();//从文件中继续读取数据
if(c==13){//判断是否为断行字符
out.print("<br>");//输出分行标签
fr.skip(1);//略过一个字符
//c=fr.read();//读取一个字符
}
}
fr.close();
%>
</body>
</html>
一行一行读取数据
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>文件读取</title>
</head>
<body>
<%
String path=request.getRealPath("");//取得当前目录的路径
FileReader fr=new FileReader(path + "\\file\\inc\\t.txt");//建立FileReader对象，并实例化为fr
BufferedReader br=new BufferedReader(fr);//建立BufferedReader对象，并实例化为br
String Line=br.readLine();//从文件读取一行字符串
//判断读取到的字符串是否不为空
while(Line!=null){
out.println(Line + "<br>");//输出从文件中读取的数据
Line=br.readLine();//从文件中继续读取一行数据
}
br.close();//关闭BufferedReader对象
fr.close();//关闭文件
%>
</body>
</html>
略过文件中的字符不读取
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>略过字节不读取</title>
</head>
<body>
<%
String path=request.getRealPath(".");
FileReader fr=new FileReader(path + "\\ReadData.txt");
fr.skip(2);//跳过2个字节
int c=fr.read();//读取一个字节
while(c!=-1){
out.print((char)c);
c=fr.read();
}
fr.close();
%>
</body>
</html>
将数据写入文件
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>将数据写入文件</title>
</head>
<body>
<%
String path=request.getRealPath(".");
FileWriter fw=new FileWriter(path + "\\WriteData.txt");//建立FileWriter对象，并实例化fw
//将字符串写入文件
fw.write("大家好！");
fw.write("本书是《JSP编程技巧》");
fw.write("请多多指教！");
fw.write("email:stride@sina.com");
fw.close();
FileReader fr=new FileReader(path + "\\WriteData.txt");
BufferedReader br=new BufferedReader(fr);//建立BufferedReader对象，并实例化为br
String Line=br.readLine();
//读取一行数据
out.println(Line + "<br>");
br.close();//关闭BufferedReader对象
fr.close();
%>
</body>
</html>
将写入文件的数据分行
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>将写入文件的数据分行</title>
</head>
<body>
<%
String path=request.getRealPath(".");
FileWriter fw=new FileWriter(path + "\\WriteData.txt");
BufferedWriter bw=new BufferedWriter(fw);
bw.write("大家好！");
bw.write("本书是《JSP编程技巧》。");
bw.newLine();//断行
bw.write("请多多指教！");
bw.newLine();//断行
bw.write("email: stride@sina.com");
bw.flush();//将数据更新至文件
fw.close();//关闭文件流
out.println("写入文件内容为：<br>");
FileReader fr=new FileReader(path + "\\WriteData.txt");
BufferedReader br=new BufferedReader(fr);
String Line=br.readLine();//读取一行数据
while(Line!=null){
out.println(Line + "<br>");
Line=br.readLine();
}
fr.close();
%>
</body>
</html>
如何将数据追加写入到文件
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>将写入文件的数据分行</title>
</head>
<body>
<%
String path=request.getRealPath(".");
RandomAccessFile rf=new RandomAccessFile(path + "\\WriteData.txt","rw");//定义一个类RandomAccessFile的对象，并实例化
rf.seek(rf.length());//将指针移动到文件末尾
rf.writeBytes("\nAppend a line to the file!");
rf.close();//关闭文件流
out.println("写入文件内容为：<br>");
FileReader fr=new FileReader(path + "\\WriteData.txt");
BufferedReader br=new BufferedReader(fr);//读取文件的BufferedRead对象
String Line=br.readLine();
while(Line!=null){
out.println(Line + "<br>");
Line=br.readLine();
}
fr.close();//关闭文件
%>
</body>
</html></I></I></I></I>
JDK1.5 令我们期待很久,可是当他发布的时候却更换版本号为5.0。这说明Java已经有大幅度的变化。本文将讲解JDK5.0支持的新功能-----Java的 泛型. 1、Java泛型 其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样，方法是这样的 method( String str1,String str2 ),方法中参数str1、str2的值是可变的。而泛型也是一样的，这样写 class Java_Generics＜K,V＞，这里边的K和V就象方法中的参数str1和str2,也是可变。下面看看例子：
//code list 1
import Java.util.Hashtable;
class TestGen0＜K,V＞{
public Hashtable＜K,V＞ h=new Hashtable＜K,V＞();
public void put(K k, V v) {
h.put(k,v);
}
public V get(K k) {
return h.get(k);
}
public static void main(String args[]){
TestGen0＜String,String＞ t=new TestGen0＜String,String＞();
t.put("key", "value");
String s=t.get("key");
System.out.println(s);
}
} |
正确输出:value 这只是个例子（Java中集合框架都泛型化了，这里费了2遍事.），不过看看是不是创建一个用类型作为参数的类，参数是K，V，传入的“值”是String类型。这个类他没有特定的待处理型别，以前我们 定义好了一个类，在输入输入参数有所固定，是什么型别的有要求，但是现在编写程序，完全可以不制定参数的类型，具体用的时候来确定，增加了程序的通用性，像是一个 模板。 呵呵，类似C++的模板（类似）。 1.1. 泛型通配符 下面我们先看看这些程序：
//Code list 2
void TestGen0Medthod1(List l) {
for (Object o : l)
System.out.println(o);
} |
看看这个方法有没有异议，这个方法会通过编译的，假如你传入String，就是这样List＜String＞。 接着我们调用它,问题就出现了，我们将一个List＜String＞当作List传给了方法，JVM会给我们一个警告，说这个破坏了 类型安全，因为从List中返回的都是Object类型的，而让我们再看看下面的方法。
//Code list 3
void TestGen0Medthod1(List＜String＞ l) {
for (Object o : l)
System.out.println(o);
} |
因为这里的List＜String＞不是List＜Object＞的子类,不是String与Object的关系，就是说List＜String＞不隶属于list＜Object＞,他们不是继承关系，所以是不行的，这里的extends是表示限制的。 类型通配符是很神奇的，List＜?＞这个你能为他做什么呢?怎么都是“？”，它似乎不确定，他总不能返回一个？作为类型的数据吧，是啊他是不会返回一个“？”来问程序员的？JVM会做简单的思考的，看看代码吧，更直观些。
//code list 4
List＜String＞ l1 = new ArrayList＜String＞();
li.add(“String”);
List＜?＞ l2 = l1;
System.out.println(l1.get(0)); |
这段代码没问题的，l1.get(0)将返回一个Object。 1.2. 编写泛型类要注意： 1) 在定义一个泛型类的时候，在 “＜＞”之间定义形式类型参数，例如：“class TestGen＜K,V＞”，其中“K” , “V”不代表值，而是表示类型。 2) 实例化泛型对象的时候，一定要在类名后面指定类型参数的值（类型），一共要有两次书写。例如： TestGen＜String,String＞ t=new TestGen＜String,String＞()； 3) 泛型中＜K extends Object＞,extends并不代表继承，它是类型范围限制。 2、泛型与数据类型转换 2.1. 消除类型转换 上面的例子大家看到什么了，数据类型转换的代码不见了。在以前我们经常要书写以下代码，如：
//code list 5
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable h = new Hashtable();
h.put("key", "value");
String s = (String)h.get("key");
System.out.println(s);
}
} |
这个我们做了类型转换，是不是感觉很烦的，并且强制类型转换会带来潜在的危险，系统可能会抛一个ClassCastException异常信息。在JDK5.0中我们完全可以这么做，如：
//code list 6
import Java.util.Hashtable;
class Test {
public static void main(String[] args) {
Hashtable＜String,Integer＞ h = new Hashtable＜String,Integer＞ ();
h.put("key", new Integer(123));
int s = h.get("key").intValue();
System.out.println(s);
}
} |
这里我们使用泛化版本的HashMap,这样就不用我们来编写类型转换的代码了，类型转换的过程交给编译器来处理，是不是很方便，而且很安全。上面是String映射到String，也可以将Integer映射为String，只要写成HashTable＜Integer,String＞ h=new HashTable＜Integer,String＞();h.get(new Integer(0))返回value。果然很方便。 2.2 自动解包装与自动包装的功能 从上面有没有看到有点别扭啊，h.get(new Integer(123))这里的new Integer(123);好烦的，在JDK5.0之前我们只能忍着了，现在这种问题已经解决了，请看下面这个方法。我们传入一个int这一基本型别，然后再将i的值直接添加到List中，其实List是不能储存基本型别的，List中应该存储对象，这里编译器将int包装成Integer，然后添加到List中去。接着我们用List.get(0);来检索数据，并返回对象再将对象解包装成int。恩，JDK5.0给我们带来更多方便与安全。
//Code list 7
public void autoBoxingUnboxing(int i) {
ArrayList＜Integer＞ L= new ArrayList＜Integer＞();
L.add(i);
int a = L.get(0);
System.out.println("The value of i is " + a);
} |
2.3 限制泛型中类型参数的范围 也许你已经发现在code list 1中的TestGen＜K,V＞这个泛型类,其中K,V可以是任意的型别。也许你有时候呢想限定一下K和V当然范围，怎么做呢？看看如下的代码：
//Code list 8
class TestGen2＜K extents String,V extends Number＞
{
private V v=null;
private K k=null;
public void setV(V v){
this.v=v;
}
public V getV(){
return this.v;
}
public void setK(K k){
this.k=k;
}
public V getK(){
return this.k;
}
public static void main(String[] args)
{
TestGen2＜String,Integer＞ t2=new TestGen2＜String,Integer＞();
t2.setK(new String("String"));
t2.setV(new Integer(123));
System.out.println(t2.getK());
System.out.println(t2.getV());
}
} |
上边K的范围是＜=String ，V的范围是＜=Number，注意是“＜=”,对于K可以是String的，V当然也可以是Number，也可以是Integer,Float,Double,Byte等。看看下图也许能直观些请看上图A是上图类中的基类，A1，A2分别是A的子类，A2有2个子类分别是A2_1，A2_2。 然后我们定义一个受限的泛型类class MyGen＜E extends A2＞,这个泛型的范围就是上图中兰色部分。 这个是单一的限制，你也可以对型别多重限制，如下：
| class C＜T extends Comparable＜? super T＞ & Serializable＞ |
我们来分析以下这句，T extends Comparable这个是对上限的限制，Comparable＜ super T＞这个是下限的限制，Serializable是第2个上限。一个指定的类型参数可以具有一个或多个上限。具有多重限制的类型参数可以用于访问它的每个限制的方法和域。 2.4. 多态方法
//Code list 9
class TestGen {
＜T extends Object＞ public static List＜T＞ make(T first) {
return new List＜T＞(first);
}
} |
摘要: 摘要
Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例如Object）、实现之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于... 阅读全文
首先它需要一个装箱单，把你的所有资源文件包括html,img文件还有WEB-INF文件夹等等。然后在这个文件夹内建一个新的文件夹META-INF。在META-INF文件夹内建一个txt文件，输入Manifest-Version: 1.0并保存为MANIFEST.MF。然后将你这个文件夹压，注意压成zip格式。完成后将后缀名改为war就可以了。 你也可以通过相关工具打包，比如JBuilder。 关于Tomcat发布和普通的web发布一样。 嘗試上面方法沒成功 我把jar.exeCOPY到目錄裡用下面方法可以了，
(1):打包war :进入 工程 应用的根目录,
比如: <CATALINA_HOME>/webapps/myjspweb ；
(2)把整个 web 应用打包为 myjspwar.war 文件，命令如下： jar cvf myjspweb.war *.*
(3)：解包： jar xvf helloapp.war
1.document.write(""); 输出语句
2.JS中的注释为//
3.传统的HTML文档顺序是:document->html->(head,body)
4.一个浏览器窗口中的DOM顺序是:window->(navigator,screen,history,location,document)
5.得到表单中元素的名称和值:document.getElementById("表单中元素的ID号").name(或value)
6.一个小写转大写的JS: document.getElementById("output").value = document.getElementById("input").value.toUpperCase();
7.JS中的值类型:String,Number,Boolean,Null,Object,Function
8.JS中的字符型转换成数值型:parseInt(),parseFloat()
9.JS中的数字转换成字符型:(""+变量)
10.JS中的取字符串长度是:(length)
11.JS中的字符与字符相连接使用+号.
12.JS中的比较操作符有:==等于,!=不等于,>,>=,<.<=
13.JS中声明变量使用:var来进行声明
14.JS中的判断语句结构:if(condition){}else{}
15.JS中的循环结构:for([initial expression];[condition];[upadte expression]) {inside loop}
16.循环中止的命令是:break
17.JS中的函数定义:function functionName([parameter],...){statement[s]}
18.当文件中出现多个form表单时.可以用document.forms[0],document.forms[1]来代替.
19.窗口:打开窗口window.open(), 关闭一个窗口:window.close(), 窗口本身:self
20.状态栏的设置:window.status="字符";
21.弹出提示信息:window.alert("字符");
22.弹出确认框:window.confirm();
23.弹出输入提示框:window.prompt();
24.指定当前显示链接的位置:window.location.href="URL"
25.取出窗体中的所有表单的数量:document.forms.length
26.关闭文档的输出流:document.close();
27.字符串追加连接符:+=
28.创建一个文档元素:document.createElement(),document.createTextNode()
29.得到元素的方法:document.getElementById()
30.设置表单中所有文本型的成员的值为空:
var form = window.document.forms[0]
for (var i = 0; i<form.elements.length;i++){
if (form.elements[i].type == "text"){
form.elements[i].value = "";
}
}
31.复选按钮在JS中判断是否选中:document.forms[0].checkThis.checked (checked属性代表为是否选中返回TRUE或FALSE)
32.单选按钮组(单选按钮的名称必须相同):取单选按钮组的长度document.forms[0].groupName.length
33.单选按钮组判断是否被选中也是用checked.
34.下拉列表框的值:document.forms[0].selectName.options[n].value (n有时用下拉列表框名称加上.selectedIndex来确定被选中的值)
35.字符串的定义:var myString = new String("This is lightsword");
36.字符串转成大写:string.toUpperCase(); 字符串转成小写:string.toLowerCase();
37.返回字符串2在字符串1中出现的位置:String1.indexOf("String2")!=-1则说明没找到.
38.取字符串中指定位置的一个字符:StringA.charAt(9);
39.取出字符串中指定起点和终点的子字符串:stringA.substring(2,6);
40.数学函数:Math.PI(返回圆周率),Math.SQRT2(返回开方),Math.max(value1,value2)返回两个数中的最在值,Math.pow(value1,10)返回value1的十次方,Math.round(value1)四舍五入函数,Math.floor(Math.random()*(n+1))返回随机数
41.定义日期型变量:var today = new Date();
42.日期函数列表:dateObj.getTime()得到时间,dateObj.getYear()得到年份,dateObj.getFullYear()得到四位的年份,dateObj.getMonth()得到月份,dateObj.getDate()得到日,dateObj.getDay()得到日期几,dateObj.getHours()得到小时,dateObj.getMinutes()得到分,dateObj.getSeconds()得到秒,dateObj.setTime(value)设置时间,dateObj.setYear(val)设置年,dateObj.setMonth(val)设置月,dateObj.setDate(val)设置日,dateObj.setDay(val)设置星期几,dateObj.setHours设置小时,dateObj.setMinutes(val)设置分,dateObj.setSeconds(val)设置秒 [注意:此日期时间从0开始计]
43.FRAME的表示方式: [window.]frames[n].ObjFuncVarName,frames["frameName"].ObjFuncVarName,frameName.ObjFuncVarName
44.parent代表父亲对象,top代表最顶端对象
45.打开子窗口的父窗口为:opener
46.表示当前所属的位置:this
47.当在超链接中调用JS函数时用:(Javascript:)来开头后面加函数名
48.在老的浏览器中不执行此JS:<!-- //-->
49.引用一个文件式的JS:<script type="text/Javascript" src="aaa.js"></script>
50.指定在不支持脚本的浏览器显示的HTML:<noscript></noscript>
51.当超链和ONCLICK事件都有时,则老版本的浏览器转向a.html,否则转向b.html.例:<a href="a.html" onclick="location.href='b.html';return false">dfsadf</a>
52.JS的内建对象有:Array,Boolean,Date,Error,EvalError,Function,Math,Number,Object,RangeError,ReferenceError,RegExp,String,SyntaxError,TypeError,URIError
53.JS中的换行:\n
54.窗口全屏大小:<script>function fullScreen(){ this.moveTo(0,0);this.outerWidth=screen.availWidth;this.outerHeight=screen.availHeight;}window.maximize=fullScreen;</script>
55.JS中的all代表其下层的全部元素
56.JS中的焦点顺序:document.getElementByid("表单元素").tabIndex = 1
57.innerHTML的值是表单元素的值:如<p id="para">"how are <em>you</em>"</p>,则innerHTML的值就是:how are <em>you</em>
58.innerTEXT的值和上面的一样,只不过不会把<em>这种标记显示出来.
59.contentEditable可设置元素是否可被修改,isContentEditable返回是否可修改的状态.
60.isDisabled判断是否为禁止状态.disabled设置禁止状态
61.length取得长度,返回整型数值
62.addBehavior()是一种JS调用的外部函数文件其扩展名为.htc
63.window.focus()使当前的窗口在所有窗口之前.
64.blur()指失去焦点.与FOCUS()相反.
65.select()指元素为选中状态.
66.防止用户对文本框中输入文本:onfocus="this.blur()"
67.取出该元素在页面中出现的数量:document.all.tags("div(或其它HTML标记符)").length
68.JS中分为两种窗体输出:模态和非模态.window.showModaldialog(),window.showModeless()
69.状态栏文字的设置:window.status='文字',默认的状态栏文字设置:window.defaultStatus = '文字.';
70.添加到收藏夹:external.AddFavorite("http://www.xrss.cn","jaskdlf");
71.JS中遇到脚本错误时不做任何操作:window.onerror = doNothing; 指定错误句柄的语法为:window.onerror = handleError;
72.JS中指定当前打开窗口的父窗口:window.opener,支持opener.opener...的多重继续.
73.JS中的self指的是当前的窗口
74.JS中状态栏显示内容:window.status="内容"
75.JS中的top指的是框架集中最顶层的框架
76.JS中关闭当前的窗口:window.close();
77.JS中提出是否确认的框:if(confirm("Are you sure?")){alert("ok");}else{alert("Not Ok");}
78.JS中的窗口重定向:window.navigate("http://www.sina.com.cn");
79.JS中的打印:window.print()
80.JS中的提示输入框:window.prompt("message","defaultReply");
81.JS中的窗口滚动条:window.scroll(x,y)
82.JS中的窗口滚动到位置:window.scrollby
83.JS中设置时间间隔:setInterval("expr",msecDelay)或setInterval(funcRef,msecDelay)或setTimeout
84.JS中的模态显示在IE4+行,在NN中不行:showModalDialog("URL"[,arguments][,features]);
85.JS中的退出之前使用的句柄:function verifyClose(){event.returnValue="we really like you and hope you will stay longer.";}} window.onbeforeunload=verifyClose;
86.当窗体第一次调用时使用的文件句柄:onload()
87.当窗体关闭时调用的文件句柄:onunload()
88.window.location的属性: protocol(http:),hostname(www.example.com),port(80),host(www.example.com:80),pathname("/a/a.html"),hash("#giantGizmo",指跳转到相应的锚记),href(全部的信息)
89.window.location.reload()刷新当前页面.
89-1.parent.location.reload()刷新父亲对象（用于框架）
89-2.opener.location.reload()刷新父窗口对象（用于单开窗口）
89-3.top.location.reload()刷新最顶端对象（用于多开窗口）
90.window.history.back()返回上一页,window.history.forward()返回下一页,window.history.go(返回第几页,也可以使用访问过的URL)
91.document.write()不换行的输出,document.writeln()换行输出
92.document.body.noWrap=true;防止链接文字折行.
93.变量名.charAt(第几位),取该变量的第几位的字符.
94."abc".charCodeAt(第几个),返回第几个字符的ASCii码值.
95.字符串连接:string.concat(string2),或用+=进行连接
96.变量.indexOf("字符",起始位置),返回第一个出现的位置(从0开始计算)
97.string.lastIndexOf(searchString[,startIndex])最后一次出现的位置.
98.string.match(regExpression),判断字符是否匹配.
99.string.replace(regExpression,replaceString)替换现有字符串.
100.string.split(分隔符)返回一个数组存储值.
101.string.substr(start[,length])取从第几位到指定长度的字符串.
102.string.toLowerCase()使字符串全部变为小写.
103.string.toUpperCase()使全部字符变为大写.
104.parseInt(string[,radix(代表进制)])强制转换成整型.
105.parseFloat(string[,radix])强制转换成浮点型.
106.isNaN(变量):测试是否为数值型.
107.定义常量的关键字:const,定义变量的关键字:var
<button onClick="add()">add</button>
<button onClick="del()">del</button>
<button onClick="test()">test</button>
<table id="t1" border="1"></table>
<script language="JavaScript">
var n=0;
function add(){
n++;
t1.insertRow().insertCell().innerHTML = '<input type="radio" name="tt"><input name="test'+n+'"><button onclick="deleteRow(this)">delthis</button>';
//t1.insertRow().insertCell().innerHTML = '<input type="radio" name="tt"><input name="test'+t1.rows.length+'">';
}
function del(){
var c = document.getElementsByName('tt');
for(var i=0; i<c.length; i++)
if(c[i].checked)
t1.deleteRow(i);
}
function deleteRow(obj){
alert(obj.parentElement.parentElement.parentElement.parentElement.id);
alert(obj.parentElement.parentElement.rowIndex);
//t1.deleteRow(obj.parentElement.parentElement.rowIndex);
}
function test(){
for(i=0;i<t1.rows.length;i++) alert(t1.rows[i].cells[0].innerHTML);
}
</SCRIPT>
<html>
<body>
<form id="myForm">
<table id="table1">
<tr id="tr1">
<td id="td1">
<input id="myButton"
type="button" value="Show my parent" onclick="function1();">
</td>
</tr>
</table>
</form>
<script language="JavaScript">
function function1() {
var m = document.all.myButton.parentElement.parentElement.parentElement.parentElement.id;
alert("Parent element: <FORM>, ID = "+'"'+m+'"');
}
</script>
cloneNode()方法克隆表格：
<input type=button value=clone name=ok onclick=add()>
<table border=1>
<tr id=a1 name=a1>
<td><input></td><td><input></td>
</tr>
</table>
<script language=JavaScript>
i=1
function add(){
++i;
var newTR = a1.cloneNode(true);
newTR.id="a"+i;
newTR.name="a"+i;
a1.parentNode.insertAdjacentElement("beforeEnd",newTR);
//alert(a1.parentElement.innerHTML);
}
</script>
appendChild() & removeChild()方法：(firefox only)
<div id="oTest">1234 </div>
<button onclick="oT=document.getElementById('oTest');oS=document.createElement('span');oS.textContent='1234 ';oT.appendChild(oS)">append +</button><button onclick="oT=document.getElementById('oTest');oT.removeChild(oT.lastChild)">remove -</button>
public int compareTo(String anotherString) 按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此 String 对象在参数字符串之前，则比较结果为一个负整数。如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。如果这两个字符串相等，则结果为 0；compareTo 只有在方法 equals(Object) 返回 true 时才返回 0。 这是字典排序的定义。如果这两个字符串不同，则要么它们在某个索引处具有不同的字符，该索引对二者均为有效索引，要么它们的长度不同，或者同时具备上述两种情况。如果它们在一个或多个索引位置上具有不同的字符，假设 k 是这类索引的最小值；则按照 < 运算符确定的那个字符串在位置 k 上具有较小的值，其字典顺序在其他字符串之前。这种情况下，compareTo 返回这两个字符串在位置 k 处的两个不同的 char 值，即值： this.charAt(k)-anotherString.charAt(k) 如果它们没有不同的索引位置，则较短字符串在字典顺序上位于较长字符串的前面。这种情况下，compareTo 返回这两个字符串长度的不同，即值： this.length()-anotherString.length() 指定者： 接口 Comparable<String> 中的 compareTo 参数： anotherString - 要比较的 String。 返回： 如果参数字符串等于此字符串，则返回 0 值；如果按字典顺序此字符串小于字符串参数，则返回一个小于 0 的值；如果按字典顺序此字符串大于字符串参数，则返回一个大于 0 的值。 http://gceclub.sun.com.cn/download/Java_Docs/html/zh_CN/api/index.html 这个是jdk中文文档
//字符串初始化
public String toString(String str){
if(str == null){
str = "";
}
if(str.equals("null")){
str = "";
}
str = str.trim();
return str;
}
//編碼轉換
public String toGBK(String str){
try{
if(str == null){
str = "";
}else{
str = new String(str.getBytes("ISO-8859-1"),"GBK");
}
}catch(Exception e){
System.out.println("DealString::toGBK(String)運行時出錯："+e;
}
}
//UTF轉換
public String to Utf8String(String src){
byte[] b = src.getBytes();
char[] c = new char[b.length];
for(int i = 0; i < b.length; i++){
c[i] = (char)(b[i]&0x00FF);
}
return new String(c);
}
//字符分隔
public String[] splitStr(String str,char c){
str += c;
int n = 0;
for(int i = 0; i < str.length();i++){
if(str.charAt(i) == c){
n ++;
}
}
String out[] = new String[n];
for(int i = 0; i < n; i++){
int index = str.indexOf(c);
out[i] = str.substring(0,index);
str = str.substring(index+1),str.length());
}
return out;
}
//取得系統時間
public String getDateTime(){
java.text.SimpleDateFormat f = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String time = f.format(new java.util.Date());
return time;
}
//字符串替換
public String Replace(String source,String oldString,String newString){
StringBuffer output = new StringBuffer();
int lengthOfSource = source.length();
int lengthOfOld = oldString.length();
int posStart = 0;
int pos;
while((pos = source.indexOf(oldString,posStart)) >= 0){
output.append(source.substring(posStart,pos));
output.append(newString);
posStart = pos + lengthOfOld;
}
if(posStart < lengthOfSource){
output.append(source.substring(posStart));
}
return output.toString();
}
//日期之差
public long getDaysInterval(Date d1,Date d2){
return (d2.getTime() - d1.getTime())/86400000;
}
//字符串右格式化
public String toLengthStr(String instr,int len){
int n = instr.length();
for(int i = 0; i < (len - n); i++){
instr = " " + instr;
}
return instr;
}
//字符串左格式化
public String toLengthStr(String instr,int len){
int n = instr.length();
for(int i = 0; i < (len - n); i++){
instr = instr + " ";
}
return instr;
}
//字符串位長度
public int byteLength(String str){
return ((str.getBytes()).length);
}
//字符串位截取
public String strByteCopy(String str,int nEnd){
if(nEnd == 0){
return "";
}
byte[] byteStr = str.getBytes();
int k = byteStr.length;
String strSub = new String(byteStr,0,End<k?nEnd:k)
if(strSub.length() == 0){
strSub = new String(byteStr,0,nEnd-1);
}
return strSub;
}
摘要: 理論上說
,Ajax
由
HTML
、
JavaScript
™
技術、
DHTML
和
DOM
組成
.
... 阅读全文
什么是 AJAX?
AJAX (异步 JavaScript 和 XML) 是个新产生的术语,专为描述JavaScript的两项强大性能.这两项性能在多年来一直被网络开发者所忽略,直到最近Gmail, Google suggest和google Maps的横空出世才使人们开始意识到其重要性.
这两项被忽视的性能是:
* 无需重新装载整个页面便能向服务器发送请求.
* 对XML文档的解析和处理．
步骤 1 – "请!" --- 如何发送一个HTTP请求
为了用JavaScript向服务器发送一个HTTP请求, 需要一个具备这种功能的类实例.
这样的类首先由Internet Explorer以ActiveX对象引入, 被称为XMLHTTP. 后来Mozilla, Safari 和其他
浏览器纷纷仿效, 提供了XMLHttpRequest类,它支持微软的ActiveX对象所提供的方法和属性.
因此, 为了创建一个跨浏览器的这样的类实例(对象), 可以应用如下代码:
if (window.XMLHttpRequest) { // Mozilla, Safari, ...
http_request = new XMLHttpRequest();
} else if (window.ActiveXObject) { // IE
http_request = new ActiveXObject("Microsoft.XMLHTTP");
}
(上例对代码做了一定简化,这是为了解释如何创建XMLHTTP类实例.
实际的代码实例可参阅本篇步骤3.)
如果服务器的响应没有XML mime-type header,某些Mozilla浏览器可能无法正常工作. 为了解决这个
问题, 如果服务器响应的header不是text/xml,可以调用其它方法修改该header.
http_request = new XMLHttpRequest();
http_request.overrideMimeType('text/xml');
接下来要决定当收到服务器的响应后,需要做什么.这需要告诉HTTP请求对象用哪一个JavaScript函数
处理这个响应.可以将对象的onreadystatechange属性设置为要使用的JavaScript的函数名,如下所示:
http_request.onreadystatechange = nameOfTheFunction;
注意:在函数名后没有括号,也无需传递参数.另外还有一种方法,可以在扉页(fly)中定义函数及其对
响应要采取的行为,如下所示:
http_request.onreadystatechange = function(){
// do the thing
};
在定义了如何处理响应后,就要发送请求了.可以调用HTTP请求类的open()和send()方法, 如下所示:
http_request.open('GET', 'http://www.example.org/some.file', true);
http_request.send(null);
* open()的第一个参数是HTTP请求方式 – GET, POST, HEAD 或任何服务器所支持的您想调用的方式
. 按照HTTP规范,该参数要大写;否则,某些浏览器(如Firefox)可能无法处理请求.有关HTTP请求方法的详
细信息可参考http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html W3C specs
* 第二个参数是请求页面的URL.由于自身安全特性的限制,该页面不能为第三方域名的页面.同时一定
要保证在所有的页面中都使用准确的域名,否则调用open()会得到"permission denied"的错误提示.一个
常见的错误是访问站点时使用domain.tld,而当请求页面时,却使用www.domain.tld.
* 第三个参数设置请求是否为异步模式.如果是TRUE, JavaScript函数将继续执行,而不等待服务器响
应.这就是"AJAX"中的"A".
如果第一个参数是"POST",send()方法的参数可以是任何想送给服务器的数据. 这时数据要以字符串
的形式送给服务器,如下所示:
name=value&anothername=othervalue&so=on
步骤 2 – "收到!" --- 处理服务器的响应
当发送请求时,要提供指定处理响应的JavaScript函数名.
http_request.onreadystatechange = nameOfTheFunction;
我们来看看这个函数的功能是什么.首先函数会检查请求的状态.如果状态值是4,就意味着一个完整的
服务器响应已经收到了,您将可以处理该响应.
if (http_request.readyState == 4) {
// everything is good, the response is received
} else {
// still not ready
}
readyState的取值如下:
* 0 (未初始化)
* 1 (正在装载)
* 2 (装载完毕)
* 3 (交互中)
* 4 (完成)
(Source)
接着,函数会检查HTTP服务器响应的状态值. 完整的状态取值可参见 W3C site. 我们着重看值为200
OK的响应.
if (http_request.status == 200) {
// perfect!
} else {
// there was a problem with the request,
// for example the response may be a 404 (Not Found)
// or 500 (Internal Server Error) response codes
}
在检查完请求的状态值和响应的HTTP状态值后, 您就可以处理从服务器得到的数据了.有两种方式可
以得到这些数据:
* http_request.responseText – 以文本字符串的方式返回服务器的响应
* http_request.responseXML –
以XMLDocument对象方式返回响应.处理XMLDocument对象可以用JavaScript DOM函数
步骤 3 – "万事俱备!" - 简单实例
我们现在将整个过程完整地做一次,发送一个简单的HTTP请求. 我们用JavaScript请求一个HTML文件,
test.html, 文件的文本内容为"I'm a test.".然后我们"alert()"test.html文件的内容.
style="cursor: pointer; text-decoration: underline"
onclick="makeRequest('test.html')">
Make a request
本例中:
* 用户点击浏览器上的"请求"链接;
* 接着函数makeRequest()将被调用.其参数 – HTML文件test.html在同一目录下;
* 这样就发起了一个请求.onreadystatechange的执行结果会被传送给alertContents();
* alertContents()将检查服务器的响应是否成功地收到,如果是,就会"alert()"test.html文件的内
容.
步骤 4 – "X-文档" --- 处理XML响应
在前面的例子中,当服务器对HTTP请求的响应被收到后,我们会调用请求对象的reponseText属性.该属
性包含了test.html文件的内容.现在我们来试试responseXML属性.
首先,我们新建一个有效的XML文件,后面我们将使用这个文件.该文件(test.xml)源代码如下所示:
I'm a test.
在该脚本中,我们只需修改请求部分:
...
onclick="makeRequest('test.xml')">
...
接着,在alertContents()中,我们将alert()的代码alert(http_request.responseText);换成:
var xmldoc = http_request.responseXML;
var root_node = xmldoc.getElementsByTagName('root').item(0);
alert(root_node.firstChild.data);
这里,我们使用了responseXML提供的XMLDocument对象并用DOM方法获取存于XML文件中的内容.
oop:使用Java开始面向对象的编程
你正在从传统的过程化的编程转向面向对象的开发模式吗?还是想要进入膨胀的Java世界呢?你不会感到孤单的.成千上万的开发者和你处在相同的情形之下.在这系列文章中,我们将使用Java语言带领你一步一步的学习面向对象的开发过程.
OOP: 理解类和对象
上一次在"使用Java开始面向对象的编程"这篇文章中,我们学习了一个编程语言要真正成为面向对象的,它应该支持信息隐藏/封装,多态,继承和动态绑定.另外,我们知道了Java完全支持这些功能,而且知道了因为Java是一种解释性的语言并运行在虚拟机的内部,所以由Java写成的任何程序都可以在任何支持 Java虚拟机(JVM)的操作系统上运行.我们还明白了对象是代表现实生活中事物的软件-编程模型以及对象是由它们的状态和行为定义的.最后,我们知道了Java中除了原始数据对象以外一切都是对象.
OOP: 继承以及多态
在"OOP简介:理解类和对象"这篇文章中,我们讨论了继承和多态性的好处.我们还粗略的学习了如何扩展基类定义子类,继承基类中合适的行为和属性而重载那些并不适合的行为和属性.这种方式能够削减代码宏余以及错误的堆积.
OOP: 限制对象属性的访问
这篇文章中,我们继续讨论了继承和多态性的好处.我们还学习了其它的东西: 虽然Java只支持从一个父类继承,但它使用接口的方式支持多重继承. 接口实现了多态,使得我们能够给与对象不同特性以满足不同的需要. 你可以使用多态机制让完成相似功能的不同的方法拥有相同的名字但是拥有不同的参数列表.动态/运行时的绑定机制允许一个对象在运行时被强制转化成你所需要的对象类型,前提是这个对象实现了必需的接口或者括展了特定的父类.
oop: 神奇的初始化
java在初始化的时候也有很多讲究，因为java中出现了类，所以在初始化的时候就有可能使用到创建新对象，所以，对于初始化的顺序要求的比较严格，请看下面一个程序，是thinking in java中的一个程序，被我稍加改编，这样可以更好的说明几个初始化的要点
虽然session机制在web应用程序中被采用已经很长时间了，但是仍然有很多人不清楚session机制的本质，以至不能正确的应用这一技术。本文将详细讨论session的工作机制并且对在Java web application中应用session机制时常见的问题作出解答。
一、术语session在我的经验里，session这个词被滥用的程度大概仅次于transaction，更加有趣的是transaction与session在某些语境下的含义是相同的。 session，中文经常翻译为会话，其本来的含义是指有始有终的一系列动作/消息，比如打电话时从拿起电话拨号到挂断电话这中间的一系列过程可以称之为一个 session。有时候我们可以看到这样的话“在一个浏览器会话期间，...”，这里的会话一词用的就是其本义，是指从一个浏览器窗口打开到关闭这个期间 ①。最混乱的是“用户（客户端）在一次会话期间”这样一句话，它可能指用户的一系列动作（一般情况下是同某个具体目的相关的一系列动作，比如从登录到选购商品到结账登出这样一个网上购物的过程，有时候也被称为一个transaction），然而有时候也可能仅仅是指一次连接，也有可能是指含义①，其中的差别只能靠上下文来推断②。 然而当session一词与网络协议相关联时，它又往往隐含了“面向连接”和/或“保持状态”这样两个含义， “面向连接”指的是在通信双方在通信之前要先建立一个通信的渠道，比如打电话，直到对方接了电话通信才能开始，与此相对的是写信，在你把信发出去的时候你并不能确认对方的地址是否正确，通信渠道不一定能建立，但对发信人来说，通信已经开始了。“保持状态”则是指通信的一方能够把一系列的消息关联起来，使得消息之间可以互相依赖，比如一个服务员能够认出再次光临的老顾客并且记得上次这个顾客还欠店里一块钱。这一类的例子有“一个TCP session”或者 “一个POP3 session”③。 而到了web服务器蓬勃发展的时代，session在web开发语境下的语义又有了新的扩展，它的含义是指一类用来在客户端与服务器之间保持状态的解决方案④。有时候session也用来指这种解决方案的存储结构，如“把xxx保存在session 里”⑤。由于各种用于web开发的语言在一定程度上都提供了对这种解决方案的支持，所以在某种特定语言的语境下，session也被用来指代该语言的解决方案，比如经常把Java里提供的javax.servlet.http.HttpSession简称为session⑥。 鉴于这种混乱已不可改变，本文中session一词的运用也会根据上下文有不同的含义，请大家注意分辨。 在本文中，使用中文“浏览器会话期间”来表达含义①，使用“session机制”来表达含义④，使用“session”表达含义⑤，使用具体的“HttpSession”来表达含义⑥ 二、HTTP协议与状态保持HTTP 协议本身是无状态的，这与HTTP协议本来的目的是相符的，客户端只需要简单的向服务器请求下载某些文件，无论是客户端还是服务器都没有必要纪录彼此过去的行为，每一次请求之间都是独立的，好比一个顾客和一个自动售货机或者一个普通的（非会员制）大卖场之间的关系一样。 然而聪明（或者贪心？）的人们很快发现如果能够提供一些按需生成的动态信息会使web变得更加有用，就像给有线电视加上点播功能一样。这种需求一方面迫使HTML逐步添加了表单、脚本、DOM等客户端行为，另一方面在服务器端则出现了CGI规范以响应客户端的动态请求，作为传输载体的HTTP协议也添加了文件上载、 cookie这些特性。其中cookie的作用就是为了解决HTTP协议无状态的缺陷所作出的努力。至于后来出现的session机制则是又一种在客户端与服务器之间保持状态的解决方案。 让我们用几个例子来描述一下cookie和session机制之间的区别与联系。笔者曾经常去的一家咖啡店有喝5杯咖啡免费赠一杯咖啡的优惠，然而一次性消费5杯咖啡的机会微乎其微，这时就需要某种方式来纪录某位顾客的消费数量。想象一下其实也无外乎下面的几种方案： 1、该店的店员很厉害，能记住每位顾客的消费数量，只要顾客一走进咖啡店，店员就知道该怎么对待了。这种做法就是协议本身支持状态。 2、发给顾客一张卡片，上面记录着消费的数量，一般还有个有效期限。每次消费时，如果顾客出示这张卡片，则此次消费就会与以前或以后的消费相联系起来。这种做法就是在客户端保持状态。 3、发给顾客一张会员卡，除了卡号之外什么信息也不纪录，每次消费时，如果顾客出示该卡片，则店员在店里的纪录本上找到这个卡号对应的纪录添加一些消费信息。这种做法就是在服务器端保持状态。 由于HTTP协议是无状态的，而出于种种考虑也不希望使之成为有状态的，因此，后面两种方案就成为现实的选择。具体来说cookie机制采用的是在客户端保持状态的方案，而session机制采用的是在服务器端保持状态的方案。同时我们也看到，由于采用服务器端保持状态的方案在客户端也需要保存一个标识，所以session机制可能需要借助于cookie机制来达到保存标识的目的，但实际上它还有其他选择。 三、理解cookie机制cookie机制的基本原理就如上面的例子一样简单，但是还有几个问题需要解决：“会员卡”如何分发；“会员卡”的内容；以及客户如何使用“会员卡”。 正统的cookie分发是通过扩展HTTP协议来实现的，服务器通过在HTTP的响应头中加上一行特殊的指示以提示浏览器按照指示生成相应的cookie。然而纯粹的客户端脚本如JavaScript或者VBScript也可以生成cookie。 而cookie 的使用是由浏览器按照一定的原则在后台自动发送给服务器的。浏览器检查所有存储的cookie，如果某个cookie所声明的作用范围大于等于将要请求的资源所在的位置，则把该cookie附在请求资源的HTTP请求头上发送给服务器。意思是麦当劳的会员卡只能在麦当劳的店里出示，如果某家分店还发行了自己的会员卡，那么进这家店的时候除了要出示麦当劳的会员卡，还要出示这家店的会员卡。 cookie的内容主要包括：名字，值，过期时间，路径和域。 其中域可以指定某一个域比如.google.com，相当于总店招牌，比如宝洁公司，也可以指定一个域下的具体某台机器比如www.google.com或者froogle.google.com，可以用飘柔来做比。 路径就是跟在域名后面的URL路径，比如/或者/foo等等，可以用某飘柔专柜做比。 路径与域合在一起就构成了cookie的作用范围。 如果不设置过期时间，则表示这个cookie的生命期为浏览器会话期间，只要关闭浏览器窗口，cookie就消失了。这种生命期为浏览器会话期的 cookie被称为会话cookie。会话cookie一般不存储在硬盘上而是保存在内存里，当然这种行为并不是规范规定的。如果设置了过期时间，浏览器就会把cookie保存到硬盘上，关闭后再次打开浏览器，这些cookie仍然有效直到超过设定的过期时间。 存储在硬盘上的cookie 可以在不同的浏览器进程间共享，比如两个IE窗口。而对于保存在内存里的cookie，不同的浏览器有不同的处理方式。对于IE，在一个打开的窗口上按 Ctrl-N（或者从文件菜单）打开的窗口可以与原窗口共享，而使用其他方式新开的IE进程则不能共享已经打开的窗口的内存cookie；对于 Mozilla Firefox0.8，所有的进程和标签页都可以共享同样的cookie。一般来说是用javascript的window.open打开的窗口会与原窗口共享内存cookie。浏览器对于会话cookie的这种只认cookie不认人的处理方式经常给采用session机制的web应用程序开发者造成很大的困扰。 下面就是一个goolge设置cookie的响应头的例子 HTTP/1.1 302 Found
Location: http://www.google.com/intl/zh-CN/
Set-Cookie: PREF=ID=0565f77e132de138:NW=1:TM=1098082649:LM=1098082649:S=KaeaCFPo49RiA_d8; expires=Sun, 17-Jan-2038 19:14:07 GMT; path=/; domain=.google.com
Content-Type: text/html  这是使用HTTPLook这个HTTP Sniffer软件来俘获的HTTP通讯纪录的一部分  浏览器在再次访问goolge的资源时自动向外发送cookie  用Firefox可以很容易的观察现有的cookie的值 使用HTTPLook配合Firefox可以很容易的理解cookie的工作原理。  IE也可以设置在接受cookie前询问 四、理解session机制session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构（也可能就是使用散列表）来保存信息。 当程序需要为某个客户端的请求创建一个session的时候，服务器首先检查这个客户端的请求里是否已包含了一个session标识 - 称为 session id，如果已包含一个session id则说明以前已经为此客户端创建过session，服务器就按照session id把这个 session检索出来使用（如果检索不到，可能会新建一个），如果客户端请求不包含session id，则为此客户端创建一个session并且生成一个与此session相关联的session id，session id的值应该是一个既不会重复，又不容易被找到规律以仿造的字符串，这个 session id将被在本次响应中返回给客户端保存。 保存这个session id的方式可以采用cookie，这样在交互过程中浏览器可以自动的按照规则把这个标识发挥给服务器。一般这个cookie的名字都是类似于SEEESIONID，而。比如weblogic对于web应用程序生成的cookie，JSESSIONID= ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764，它的名字就是 JSESSIONID。 由于cookie可以被人为的禁止，必须有其他机制以便在cookie被禁止时仍然能够把session id传递回服务器。经常被使用的一种技术叫做URL重写，就是把session id直接附加在URL路径的后面，附加方式也有两种，一种是作为URL路径的附加信息，表现形式为http://...../xxx;jsessionid= ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764 另一种是作为查询字符串附加在URL后面，表现形式为http://...../xxx?jsessionid=ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764 这两种方式对于用户来说是没有区别的，只是服务器在解析的时候处理的方式不同，采用第一种方式也有利于把session id的信息和正常程序参数区分开来。 为了在整个交互过程中始终保持状态，就必须在每个客户端可能请求的路径后面都包含这个session id。 另一种技术叫做表单隐藏字段。就是服务器会自动修改表单，添加一个隐藏字段，以便在表单提交时能够把session id传递回服务器。比如下面的表单 <form name="testform" action="/xxx">
<input type="text">
</form> 在被传递给客户端之前将被改写成 <form name="testform" action="/xxx">
<input type="hidden" name="jsessionid" value="ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764">
<input type="text">
</form> 这种技术现在已较少应用，笔者接触过的很古老的iPlanet6(SunONE应用服务器的前身)就使用了这种技术。 实际上这种技术可以简单的用对action应用URL重写来代替。 在谈论session机制的时候，常常听到这样一种误解“只要关闭浏览器，session就消失了”。其实可以想象一下会员卡的例子，除非顾客主动对店家提出销卡，否则店家绝对不会轻易删除顾客的资料。对session来说也是一样的，除非程序通知服务器删除一个session，否则服务器会一直保留，程序一般都是在用户做log off的时候发个指令去删除session。然而浏览器从来不会主动在关闭之前通知服务器它将要关闭，因此服务器根本不会有机会知道浏览器已经关闭，之所以会有这种错觉，是大部分session机制都使用会话cookie来保存session id，而关闭浏览器后这个 session id就消失了，再次连接服务器时也就无法找到原来的session。如果服务器设置的cookie被保存到硬盘上，或者使用某种手段改写浏览器发出的HTTP请求头，把原来的session id发送给服务器，则再次打开浏览器仍然能够找到原来的session。 恰恰是由于关闭浏览器不会导致session被删除，迫使服务器为seesion设置了一个失效时间，当距离客户端上一次使用session的时间超过这个失效时间时，服务器就可以认为客户端已经停止了活动，才会把session删除以节省存储空间。 五、理解javax.servlet.http.HttpSessionHttpSession是Java平台对session机制的实现规范，因为它仅仅是个接口，具体到每个web应用服务器的提供商，除了对规范支持之外，仍然会有一些规范里没有规定的细微差异。这里我们以BEA的Weblogic Server8.1作为例子来演示。 首先，Weblogic Server提供了一系列的参数来控制它的HttpSession的实现，包括使用cookie的开关选项，使用URL重写的开关选项，session持久化的设置，session失效时间的设置，以及针对cookie的各种设置，比如设置cookie的名字、路径、域， cookie的生存时间等。 一般情况下，session都是存储在内存里，当服务器进程被停止或者重启的时候，内存里的session也会被清空，如果设置了session的持久化特性，服务器就会把session保存到硬盘上，当服务器进程重新启动或这些信息将能够被再次使用， Weblogic Server支持的持久性方式包括文件、数据库、客户端cookie保存和复制。 复制严格说来不算持久化保存，因为session实际上还是保存在内存里，不过同样的信息被复制到各个cluster内的服务器进程中，这样即使某个服务器进程停止工作也仍然可以从其他进程中取得session。 cookie生存时间的设置则会影响浏览器生成的cookie是否是一个会话cookie。默认是使用会话cookie。有兴趣的可以用它来试验我们在第四节里提到的那个误解。 cookie的路径对于web应用程序来说是一个非常重要的选项，Weblogic Server对这个选项的默认处理方式使得它与其他服务器有明显的区别。后面我们会专题讨论。 关于session的设置参考[5] http://e-docs.bea.com/wls/docs70/webapp/weblogic_xml.html#1036869 六、HttpSession常见问题（在本小节中session的含义为⑤和⑥的混合） 1、session在何时被创建 一个常见的误解是以为session在有客户端访问时就被创建，然而事实是直到某server端程序调用 HttpServletRequest.getSession(true)这样的语句时才被创建，注意如果JSP没有显示的使用 <% @page session="false"%> 关闭session，则JSP文件在编译成Servlet时将会自动加上这样一条语句 HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的 session对象的来历。 由于session会消耗内存资源，因此，如果不打算使用session，应该在所有的JSP中关闭它。 2、session何时被删除 综合前面的讨论，session在下列情况下被删除a.程序调用HttpSession.invalidate();或b.距离上一次收到客户端发送的session id时间间隔超过了session的超时设置;或c.服务器进程被停止（非持久session） 3、如何做到在浏览器关闭时删除session 严格的讲，做不到这一点。可以做一点努力的办法是在所有的客户端页面里使用javascript代码window.oncolose来监视浏览器的关闭动作，然后向服务器发送一个请求来删除session。但是对于浏览器崩溃或者强行杀死进程这些非常规手段仍然无能为力。 4、有个HttpSessionListener是怎么回事 你可以创建这样的listener去监控session的创建和销毁事件，使得在发生这样的事件时你可以做一些相应的工作。注意是session的创建和销毁动作触发listener，而不是相反。类似的与HttpSession有关的listener还有 HttpSessionBindingListener，HttpSessionActivationListener和 HttpSessionAttributeListener。 5、存放在session中的对象必须是可序列化的吗 不是必需的。要求对象可序列化只是为了session能够在集群中被复制或者能够持久保存或者在必要时server能够暂时把session交换出内存。在 Weblogic Server的session中放置一个不可序列化的对象在控制台上会收到一个警告。我所用过的某个iPlanet版本如果 session中有不可序列化的对象，在session销毁时会有一个Exception，很奇怪。 6、如何才能正确的应付客户端禁止cookie的可能性 对所有的URL使用URL重写，包括超链接，form的action，和重定向的URL，具体做法参见[6] http://e-docs.bea.com/wls/docs70/webapp/sessions.html#100770 7、开两个浏览器窗口访问应用程序会使用同一个session还是不同的session 参见第三小节对cookie的讨论，对session来说是只认id不认人，因此不同的浏览器，不同的窗口打开方式以及不同的cookie存储方式都会对这个问题的答案有影响。 8、如何防止用户打开两个浏览器窗口操作导致的session混乱 这个问题与防止表单多次提交是类似的，可以通过设置客户端的令牌来解决。就是在服务器每次生成一个不同的id返回给客户端，同时保存在session里，客户端提交表单时必须把这个id也返回服务器，程序首先比较返回的id与保存在session里的值是否一致，如果不一致则说明本次操作已经被提交过了。可以参看《J2EE核心模式》关于表示层模式的部分。需要注意的是对于使用javascript window.open打开的窗口，一般不设置这个id，或者使用单独的id，以防主窗口无法操作，建议不要再window.open打开的窗口里做修改操作，这样就可以不用设置。 9、为什么在Weblogic Server中改变session的值后要重新调用一次session.setValue 做这个动作主要是为了在集群环境中提示Weblogic Server session中的值发生了改变，需要向其他服务器进程复制新的session值。 10、为什么session不见了 排除session正常失效的因素之外，服务器本身的可能性应该是微乎其微的，虽然笔者在iPlanet6SP1加若干补丁的Solaris版本上倒也遇到过；浏览器插件的可能性次之，笔者也遇到过3721插件造成的问题；理论上防火墙或者代理服务器在cookie处理上也有可能会出现问题。 出现这一问题的大部分原因都是程序的错误，最常见的就是在一个应用程序中去访问另外一个应用程序。我们在下一节讨论这个问题。 七、跨应用程序的session共享常常有这样的情况，一个大项目被分割成若干小项目开发，为了能够互不干扰，要求每个小项目作为一个单独的web应用程序开发，可是到了最后突然发现某几个小项目之间需要共享一些信息，或者想使用session来实现SSO(single sign on)，在session中保存login的用户信息，最自然的要求是应用程序间能够访问彼此的session。 然而按照Servlet规范，session的作用范围应该仅仅限于当前应用程序下，不同的应用程序之间是不能够互相访问对方的session的。各个应用服务器从实际效果上都遵守了这一规范，但是实现的细节却可能各有不同，因此解决跨应用程序session共享的方法也各不相同。 首先来看一下Tomcat是如何实现web应用程序之间session的隔离的，从 Tomcat设置的cookie路径来看，它对不同的应用程序设置的cookie路径是不同的，这样不同的应用程序所用的session id是不同的，因此即使在同一个浏览器窗口里访问不同的应用程序，发送给服务器的session id也可以是不同的。   根据这个特性，我们可以推测Tomcat中session的内存结构大致如下。  笔者以前用过的iPlanet也采用的是同样的方式，估计SunONE与iPlanet之间不会有太大的差别。对于这种方式的服务器，解决的思路很简单，实际实行起来也不难。要么让所有的应用程序共享一个session id，要么让应用程序能够获得其他应用程序的session id。 iPlanet中有一种很简单的方法来实现共享一个session id，那就是把各个应用程序的cookie路径都设为/（实际上应该是/NASApp，对于应用程序来讲它的作用相当于根）。 <session-info>
<path>/NASApp</path>
</session-info> 需要注意的是，操作共享的session应该遵循一些编程约定，比如在session attribute名字的前面加上应用程序的前缀，使得 setAttribute("name", "neo")变成setAttribute("app1.name", "neo")，以防止命名空间冲突，导致互相覆盖。 在Tomcat中则没有这么方便的选择。在Tomcat版本3上，我们还可以有一些手段来共享session。对于版本4以上的Tomcat，目前笔者尚未发现简单的办法。只能借助于第三方的力量，比如使用文件、数据库、JMS或者客户端cookie，URL参数或者隐藏字段等手段。 我们再看一下Weblogic Server是如何处理session的。   从截屏画面上可以看到Weblogic Server对所有的应用程序设置的cookie的路径都是/，这是不是意味着在Weblogic Server中默认的就可以共享session了呢？然而一个小实验即可证明即使不同的应用程序使用的是同一个session，各个应用程序仍然只能访问自己所设置的那些属性。这说明Weblogic Server中的session的内存结构可能如下  对于这样一种结构，在 session机制本身上来解决session共享的问题应该是不可能的了。除了借助于第三方的力量，比如使用文件、数据库、JMS或者客户端 cookie，URL参数或者隐藏字段等手段，还有一种较为方便的做法，就是把一个应用程序的session放到ServletContext中，这样另外一个应用程序就可以从ServletContext中取得前一个应用程序的引用。示例代码如下， 应用程序A context.setAttribute("appA", session); 应用程序B contextA = context.getContext("/appA");
HttpSession sessionA = (HttpSession)contextA.getAttribute("appA"); 值得注意的是这种用法不可移植，因为根据ServletContext的JavaDoc，应用服务器可以处于安全的原因对于context.getContext("/appA");返回空值，以上做法在Weblogic Server 8.1中通过。 那么Weblogic Server为什么要把所有的应用程序的cookie路径都设为/呢？原来是为了SSO，凡是共享这个session的应用程序都可以共享认证的信息。一个简单的实验就可以证明这一点，修改首先登录的那个应用程序的描述符weblogic.xml，把cookie路径修改为/appA 访问另外一个应用程序会重新要求登录，即使是反过来，先访问cookie路径为/的应用程序，再访问修改过路径的这个，虽然不再提示登录，但是登录的用户信息也会丢失。注意做这个实验时认证方式应该使用FORM，因为浏览器和web服务器对basic认证方式有其他的处理方式，第二次请求的认证不是通过 session来实现的。具体请参看[7] secion 14.8 Authorization，你可以修改所附的示例程序来做这些试验。 八、总结session机制本身并不复杂，然而其实现和配置上的灵活性却使得具体情况复杂多变。这也要求我们不能把仅仅某一次的经验或者某一个浏览器，服务器的经验当作普遍适用的经验，而是始终需要具体情况具体分析。 摘要：虽然session机制在web应用程序中被采用已经很长时间了，但是仍然有很多人不清楚session机制的本质，以至不能正确的应用这一技术。本文将详细讨论session的工作机制并且对在Java web application中应用session机制时常见的问题作出解答。
如果已有人發明了輪子。。。
我們就發明輪子的配件，讓輪子轉的更快
如果已有人發明了輪子。。。
我們就發明汽車，讓輪子得到最大限度的利用
如果已有人發明了輪子。。。
我們可以把很多的舊輪子創造出新輪子
當小喵在開發一個較為大型的系統時，會做以下的分析過程
- 系統需求分析：
- 與使用者詳談，訪問使用者須要的是什麼
- 條列需求：將訪談後的需求加以整理，並加以條列
- 需求確認：將整理條列出的需求，給使用者逐條加以確認，如有不足，追加並確認之
- 功能分析：
- 條列功能：將使用者以確認之條列需求，轉換為系統功能並條列之
- 功能、需求確認：將條列之功能與條列之需求逐一比對，確認使用者需求都有滿足
- 功能整併：將條列之功能，有類似、相關之功能，加以整併→合併撰寫
- 功能歸類：將條列之功能，加以分類整理
- 需求、功能再確認：將整併、歸類之功能，與需求再次確認，務必滿足每一個需求。
- 資料分析：
- 依據各需求所需的資料欄位、型態、加以條列
- 正規化資料：依據正規劃原則，將條列的欄位、型態、加以分類並正規劃
- 資料庫設計：依據結論，設計資料庫、資料表、欄位、型態、關聯等
- 畫面功能分析：
- 畫面規劃：依據需求分析與功能分析結果，規劃使用介面，畫面欄位、按鈕
- 功能樹狀圖、網頁地圖：依據各功能分類與畫面，歸類相關功能，做出畫面分類樹狀圖、網頁地圖
- 使用者再確認：依照功能樹狀圖、網頁地圖，在此與使用者討論，並依照需求條列逐一比對各需求與畫面關係→依使用者需求修改→再確認。直到確認無誤。
- 程式與撰寫規劃：
- 依照【畫面分析】、【資料分析】、【功能分析】規劃出各相關程式於N-Tiers中
- 畫面分析：介面層，處理各功能的介面、資料存取的介面
- 資料分析：資料層，處理資料庫的存取
- 功能分析：商業邏輯層，處理各功能所需運算、資料交換，並與介面曾、資料曾溝通
- 程式命名、Function命名、參數命名：
- 依據介面層、資料層、商業邏輯層條列出各程式名稱、Function名稱、以及所需傳遞的參數、型態名稱
- 各程式間的相互關係，並做出各程式間的相互關係圖
- 程式分配：依現有人力狀況，分組並分派相關人員各程式，並條列出各程式的時程規劃於各組Leader，由各組Leader安排程式完成時程
- 依據程式分配與時程，安排交叉測試時程
在這樣的分析過程中，分析完後的各程式可交由多人共同完成，只需將定義好的資料庫狀況、欄位、以及所需撰寫的程式名稱、參數說明給各分配到的程式設計師，就可開始分工的撰寫程式
其中介面層，小喵多數以Web作為介面，應用ASP/ASP.NET來開發；商業邏輯層、資料庫層則是透過COM+的元件來處理。
而介面層與商業邏輯層如何將之串聯起來呢，主要是透過以下的這樣方式來做
-----------------------------------------------------------------------------------------------------------------
1 ASP.NET--------------------------------COM+-----------------------------MS-SQL
2 Controls--ObjectDataSource------COM+元件------COM+元件-----------COM+元件--資料庫
3 ( 介面層 ) ( 商業邏輯層 ) ( 資料層 )
/*1.運用一維數組設計一個可計算多個數的平均的程序*/
// public static int i=0;//for循環計數變量
// public static float Number[] = new float[20];//存儲數據的浮點數數組
// public static float Summary;//數據總和變量
// public static float Average;//數據平均變量
// public static void main(String[] args) {
// TODO Auto-generated method stub
// System.out.println("HELLO JAVA...");
// Summary = 0;//數據總和變量初值化
// System.out.println("Please input the number of data:");//讀入最大可輸入數據個數
// ConsoleReader console = new ConsoleReader(System.in);
// int Max = console.readInt();
// System.out.println("");
//
// if(Max <= 20){//決定最大可輸入數
// for(i=0;i<Max;i++){
// System.out.println("Please input a number:");
// Number[i] = (float)console.readDouble();
// Summary += Number[i];
// }
// Average = Summary/Max;//平均值=總和/個數
// System.out.println("The average is:"+Average);
// }else{//如果輸入數字超出范圍
// System.out.println("Please input a number less than 20.");
// }
// }
/*2.運用一維數組設計一個簡易的員工工資管理系統(具有查詢與修改功能)*/
/*
* public static int[] Employee={27000,27111,27222,27333,27444,27555,27666,27777,27888,27999};
public static int Index;//數組下標變量
public static int NewSalary;//修改後工資變量
public static int Selection;//用戶選項變量
boolean Flag = false;
while(!Flag){
//用戶菜單
System.out.println("++++++++++++++++++++++++++++++++++++++");
System.out.println("1.Display employee salary =");
System.out.println("2.Modify employee salary =");
System.out.println("3.Quit");
System.out.println("++++++++++++++++++++++++++++++++++++++");
System.out.println("Please input your choose:");//讀取用戶選項
ConsoleReader console = new ConsoleReader(System.in);
int Selection = console.readInt();
if(Selection ==1 || Selection ==2){
System.out.println("Please input the employee number:");//讀取員工編號
Index = console.readInt();
if(Index <10){
System.out.println("**Employee Number is"+Index);
System.out.println("**The Salary is"+Employee[Index]);
}else{
System.out.println("##The error employee number!");
Flag = true;
}
}
switch(Selection){
case 1:
break;
case 2:
System.out.println("**Please enter new Salary:");//修改後的員工工資
NewSalary = console.readInt();
System.out.println("");
Employee[Index]=NewSalary;
break;
case 3:
Flag = true;
System.out.println("You leave from System.");
break;
}
System.out.println("");
}
*/
/*3.運用一維數組設計一個可存儲員工工資讓用戶輸入工資，然後輸出員工編號的程序*/
/*
public static int[] Employee={27000,27111,27222,27333,27444,27555,27666,27777,27888,27999};//預設10筆資料
public static int Salary;//用戶輸入工資變量
public static int Counter=0;//數據計數變量
int i;//for循環計數變量
System.out.println("Please input the employee salary:");
ConsoleReader console = new ConsoleReader(System.in);
Salary = console.readInt();
for(i=0;i<10;i++){//數組遍歷
if(Salary == Employee[i]){
System.out.println("Number"+i+"Employee's salary is"+Salary+"!");
Counter++;
}
}
if(Counter == 0){
System.out.println("No employee's salary is"+Salary+"!!");
}else{
System.out.println("Have"+Counter+"employee salary is"+Salary+"!!");
}
*/
/*4.設計一個可容納40位數的求n!的程序*/
/*
int Data[] = new int[40];
int Digit;
int i,j,r,k;
int N;
for(i=1;i<40;i++){
Data[i]=0;
}
Data[0]=1;
Data[1]=1;
Digit = 1;
System.out.println("Enter a number what you want to calculus:");
ConsoleReader console = new ConsoleReader(System.in);
N = console.readInt();
for(i=1;i<N+1;i++){
for(j=1;j<Digit+1;j++){
Data[j]*=i;
}
for(j=1;j<Digit+1;j++){
if(Data[j]>10){
for(r=1;r<Digit+1;r++){
if(Data[Digit]>10){
Digit ++;
}
Data[r+1] += Data[r]/10;
Data[r]=Data[r]%10;
}
}
}
System.out.print(i+"!=");
for(k=Digit;k>0;k--){
System.out.print(Data[k]);
}
System.out.println("");
}
*/
/*設計從二維轉一維數組(行轉列或列轉行)*/
/*
int[][] Data = {{1,2,3},{4,5,6},{7,8,9},{0,10,11}};
int RowData[] = new int[12];//存儲以行為主的數組
int ColData[] = new int[12];//存儲以列為主的數組
int i,j;
System.out.println("The Data of two dimensional array:");
for(i=0;i<4;i++){
for(j=0;j<3;j++){
System.out.println(" "+Data[i][j]+" ");
System.out.println("");
}
}
for(i=0;i<4;i++){
for(j=0;j<3;j++){
RowData[i*3+j] = Data[i][j];
}
}
System.out.println("");
System.out.println("The Row major Martrix:");
for(i=0;i<12;i++){
System.out.println(" "+RowData[i]+" ");
}
System.out.println("");
for(i=0;i<4;i++){
for(j=0;j<3;j++){
ColData[j*4+i] = Data[i][j];
}
}
System.out.println("");
System.out.println("The Column Major Matrix:");
for(i=0;i<12;i++){
System.out.println(" "+ColData[i]+" ");
}
System.out.println("");
*/
/*特殊的數組(稀疏數組)*/
/*
*int [][] Data = {{0,0,0,0,0,0,0}
,{0,3,0,0,0,0,0}
,{0,0,0,0,0,0,0}
,{1,4,0,0,0,0,0}
,{0,0,7,0,0,0,0}
,{0,0,0,0,0,5,0}
,{0,0,0,0,0,0,0}
,{0,0,0,0,0,0,0}
,{0,0,0,0,0,0,0}
,{0,0,0,0,0,0,0}};
int CompressData[][] = new int[10][3];//存儲壓縮後數據的數組
int Index;//壓縮數組的下標
int i,j;
Index = 0;
System.out.println("Two dimensional sparse array:");
for(i=0;i<9;i++){
for(j=0;j<7;j++){
System.out.print(" "+Data[i][j]+" ");
}
System.out.println("");
}
for(i=0;i<9;i++){
for(j=0;j<7;j++){
if(Data[i][j] != 0){
Index++;//增加下標值
CompressData [Index][0] = i;//元素行位置
CompressData [Index][1] = j;//元素列位置
CompressData [Index][2] = Data[i][j];//元素值
}
}
}
CompressData [0][0] = 9;//原數組的行數
CompressData [0][1] = 7;//原數組的列數
CompressData [0][2] = Index;//使用元素個數
System.out.println("Two dimensional compress array:");
for(i=0;i<Index;i++){
for(j=0;j<3;j++){
System.out.print(" "+CompressData[i][j]+" ");
}
System.out.println("");
}
*/
还不是很全，只有基本的内容： 1 Ant是什么？ Apache Ant 是一个基于 Java的生成工具。 生成工具在软件开发中用来将源代码和其他输入文件转换为可执行文件的形式（也有可能转换为可安装的产品映像形式）。随着应用程序的生成过程变得更加复杂，确保在每次生成期间都使用精确相同的生成步骤，同时实现尽可能多的自动化，以便及时产生一致的生成版本 2 下载、安装Ant 安装Ant 下载.zip文件，解压缩到c:\ant1.3(后面引用为%ANT_HOME%) 2.1 在你运行Ant之前需要做一些配置工作。 ? 将bin目录加入PATH环境变量。 ? 设定ANT_HOME环境变量，指向你安装Ant的目录。在一些OS上，Ant的脚本可以猜测ANT_HOME（Unix和Windos NT/2000）－但最好不要依赖这一特性。 ? 可选地，设定JAVA_HOME环境变量（参考下面的高级小节），该变量应该指向你安装JDK的目录。 注意：不要将Ant的ant.jar文件放到JDK/JRE的lib/ext目录下。Ant是个应用程序，而lib/ext目录是为JDK扩展使用的（如JCE，JSSE扩展）。而且通过扩展装入的类会有安全方面的限制。 2.2 运行Ant 运行Ant非常简单，当你正确地安装Ant后，只要输入ant就可以了。 ? 没有指定任何参数时，Ant会在当前目录下查询build.xml文件。如果找到了就用该文件作为buildfile。如果你用 -find 选项。Ant就会在上级目录中寻找buildfile，直至到达文件系统的根。要想让Ant使用其他的buildfile，可以用参数 -buildfile file，这里file指定了你想使用的buildfile。 ? 可以指定执行一个或多个target。当省略target时，Ant使用标签<project>的default属性所指定的target。 命令行选项总结： ant [options] [target [target2 [target3] ...]] Options: -help print this message -projecthelp print project help information -version print the version information and exit -quiet be extra quiet -verbose be extra verbose -debug print debugging information -emacs produce logging information without adornments -logfile file use given file for log output -logger classname the class that is to perform logging -listener classname add an instance of class as a project listener -buildfile file use specified buildfile -find file search for buildfile towards the root of the filesystem and use the first one found -Dproperty=value set property to value 例子 ant 使用当前目录下的build.xml运行Ant，执行缺省的target。 ant -buildfile test.xml 使用当前目录下的test.xml运行Ant，执行缺省的target。 ant -buildfile test.xml dist 使用当前目录下的test.xml运行Ant，执行一个叫做dist的target。 ant -buildfile test.xml -Dbuild=build/classes dist 使用当前目录下的test.xml运行Ant，执行一个叫做dist的target，并设定build属性的值为build/classes。 3 编写build.xml Ant的buildfile是用XML写的。每个buildfile含有一个project。 buildfile中每个task元素可以有一个id属性，可以用这个id值引用指定的任务。这个值必须是唯一的。（详情请参考下面的Task小节） 3.1 Projects project有下面的属性： Attribute Description Required name 项目名称. No default 当没有指定target时使用的缺省target Yes basedir 用于计算所有其他路径的基路径。该属性可以被basedir property覆盖。当覆盖时，该属性被忽略。如果属性和basedir property都没有设定，就使用buildfile文件的父目录。 No 项目的描述以一个顶级的<description>元素的形式出现（参看description小节）。 一个项目可以定义一个或多个target。一个target是一系列你想要执行的。执行Ant时，你可以选择执行那个target。当没有给定target时，使用project的default属性所确定的target。 3.2 Targets 一个target可以依赖于其他的target。例如，你可能会有一个target用于编译程序，一个target用于生成可执行文件。你在生成可执行文件之前必须先编译通过，所以生成可执行文件的target依赖于编译target。Ant会处理这种依赖关系。 然而，应当注意到，Ant的depends属性只指定了target应该被执行的顺序－如果被依赖的target无法运行，这种depends对于指定了依赖关系的target就没有影响。 Ant会依照depends属性中target出现的顺序（从左到右）依次执行每个target。然而，要记住的是只要某个target依赖于一个target，后者就会被先执行。 <target name="A"/> <target name="B" depends="A"/> <target name="C" depends="B"/> <target name="D" depends="C,B,A"/> 假定我们要执行target D。从它的依赖属性来看，你可能认为先执行C，然后B，最后A被执行。错了，C依赖于B，B依赖于A，所以先执行A，然后B，然后C，最后D被执行。 一个target只能被执行一次，即时有多个target依赖于它（看上面的例子）。 如果（或如果不）某些属性被设定，才执行某个target。这样，允许根据系统的状态（java version, OS, 命令行属性定义等等）来更好地控制build的过程。要想让一个target这样做，你就应该在target元素中，加入if（或unless）属性，带上target因该有所判断的属性。例如： <target name="build-module-A" if="module-A-present"/> <target name="build-own-fake-module-A" unless="module-A-present"/> 如果没有if或unless属性，target总会被执行。 可选的description属性可用来提供关于target的一行描述，这些描述可由-projecthelp命令行选项输出。 将你的tstamp task在一个所谓的初始化target是很好的做法，其他的target依赖这个初始化target。要确保初始化target是出现在其他target依赖表中的第一个target。在本手册中大多数的初始化target的名字是"init"。 target有下面的属性： Attribute Description Required name target的名字 Yes depends 用逗号分隔的target的名字列表，也就是依赖表。 No if 执行target所需要设定的属性名。 No unless 执行target需要清除设定的属性名。 No description 关于target功能的简短描述。 No 3.3 Tasks 一个task是一段可执行的代码。 一个task可以有多个属性（如果你愿意的话，可以将其称之为变量）。属性只可能包含对property的引用。这些引用会在task执行前被解析。 下面是Task的一般构造形式： <name attribute1="value1" attribute2="value2" ... /> 这里name是task的名字，attributeN是属性名，valueN是属性值。 有一套内置的（built-in）task，以及一些可选task，但你也可以编写自己的task。 所有的task都有一个task名字属性。Ant用属性值来产生日志信息。 可以给task赋一个id属性： <taskname id="taskID" ... /> 这里taskname是task的名字，而taskID是这个task的唯一标识符。通过这个标识符，你可以在脚本中引用相应的task。例如，在脚本中你可以这样： <script ... > task1.setFoo("bar"); </script> 设定某个task实例的foo属性。在另一个task中（用java编写），你可以利用下面的语句存取相应的实例。 project.getReference("task1"). 注意1：如果task1还没有运行，就不会被生效（例如：不设定属性），如果你在随后配置它，你所作的一切都会被覆盖。 注意2：未来的Ant版本可能不会兼容这里所提的属性，因为很有可能根本没有task实例，只有proxies。 3.4 Properties 一个project可以有很多的properties。可以在buildfile中用property task来设定，或在Ant之外设定。一个property有一个名字和一个值。property可用于task的属性值。这是通过将属性名放在"${"和"}"之间并放在属性值的位置来实现的。例如如果有一个property builddir的值是"build"，这个property就可用于属性值：${builddir}/classes。这个值就可被解析为build/classes。 内置属性 如果你使用了<property> task 定义了所有的系统属性，Ant允许你使用这些属性。例如，${os.name}对应操作系统的名字。 要想得到系统属性的列表可参考the Javadoc of System.getProperties。 除了Java的系统属性，Ant还定义了一些自己的内置属性： basedir project基目录的绝对路径 (与<project>的basedir属性一样)。 ant.file buildfile的绝对路径。 ant.version Ant的版本。 ant.project.name 当前执行的project的名字；由<project>的name属性设定. ant.java.version Ant检测到的JVM的版本； 目前的值有"1.1", "1.2", "1.3" and "1.4". 例子 <project name="MyProject" default="dist" basedir="."> <!-- set global properties for this build --> <property name="src" value="."/> <property name="build" value="build"/> <property name="dist" value="dist"/> <target name="init"> <!-- Create the time stamp --> <tstamp/> <!-- Create the build directory structure used by compile --> <mkdir dir="${build}"/> </target> <target name="compile" depends="init"> <!-- Compile the java code from ${src} into ${build} --> <javac srcdir="${src}" destdir="${build}"/> </target> <target name="dist" depends="compile"> <!-- Create the distribution directory --> <mkdir dir="${dist}/lib"/> <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file --> <jar jarfile="${dist}/lib/MyProject-${DSTAMP}.jar" basedir="${build}"/> </target> <target name="clean"> <!-- Delete the ${build} and ${dist} directory trees --> <delete dir="${build}"/> <delete dir="${dist}"/> </target> </project> 3.5 Path-like Structures 你可以用":"和";"作为分隔符，指定类似PATH和CLASSPATH的引用。Ant会把分隔符转换为当前系统所用的分隔符。 当需要指定类似路径的值时，可以使用嵌套元素。一般的形式是 <classpath> <pathelement path="${classpath}"/> <pathelement location="lib/helper.jar"/> </classpath> location属性指定了相对于project基目录的一个文件和目录，而path属性接受逗号或分号分隔的一个位置列表。path属性一般用作预定义的路径－－其他情况下，应该用多个location属性。 为简洁起见，classpath标签支持自己的path和location属性。所以： <classpath> <pathelement path="${classpath}"/> </classpath> 可以被简写作： <classpath path="${classpath}"/> 也可通过<fileset>元素指定路径。构成一个fileset的多个文件加入path-like structure的顺序是未定的。 <classpath> <pathelement path="${classpath}"/> <fileset dir="lib"> <include name="**/*.jar"/> </fileset> <pathelement location="classes"/> </classpath> 上面的例子构造了一个路径值包括：${classpath}的路径，跟着lib目录下的所有jar文件，接着是classes目录。 如果你想在多个task中使用相同的path-like structure，你可以用<path>元素定义他们（与target同级），然后通过id属性引用－－参考Referencs例子。 path-like structure可能包括对另一个path-like structurede的引用（通过嵌套<path>元素）： <path id="base.path"> <pathelement path="${classpath}"/> <fileset dir="lib"> <include name="**/*.jar"/> </fileset> <pathelement location="classes"/> </path> <path id="tests.path"> <path refid="base.path"/> <pathelement location="testclasses"/> </path> 前面所提的关于<classpath>的简洁写法对于<path>也是有效的，如： <path id="tests.path"> <path refid="base.path"/> <pathelement location="testclasses"/> </path> 可写成： <path id="base.path" path="${classpath}"/> 命令行变量 有些task可接受参数，并将其传递给另一个进程。为了能在变量中包含空格字符，可使用嵌套的arg元素。 Attribute Description Required value 一个命令行变量；可包含空格字符。 只能用一个 line 空格分隔的命令行变量列表。 file 作为命令行变量的文件名；会被文件的绝对名替代。 path 一个作为单个命令行变量的path-like的字符串；或作为分隔符，Ant会将其转变为特定平台的分隔符。 例子 <arg value="-l -a"/> 是一个含有空格的单个的命令行变量。 <arg line="-l -a"/> 是两个空格分隔的命令行变量。 <arg path="/dir;/dir2:\dir3"/> 是一个命令行变量，其值在DOS系统上为\dir;\dir2;\dir3；在Unix系统上为/dir:/dir2:/dir3 。 References buildfile元素的id属性可用来引用这些元素。如果你需要一遍遍的复制相同的XML代码块，这一属性就很有用－－如多次使用<classpath>结构。 下面的例子： <project ... > <target ... > <rmic ...> <classpath> <pathelement location="lib/"/> <pathelement path="${java.class.path}/"/> <pathelement path="${additional.path}"/> </classpath> </rmic> </target> <target ... > <javac ...> <classpath> <pathelement location="lib/"/> <pathelement path="${java.class.path}/"/> <pathelement path="${additional.path}"/> </classpath> </javac> </target> </project> 可以写成如下形式： <project ... > <path id="project.class.path"> <pathelement location="lib/"/> <pathelement path="${java.class.path}/"/> <pathelement path="${additional.path}"/> </path> <target ... > <rmic ...> <classpath refid="project.class.path"/> </rmic> </target> <target ... > <javac ...> <classpath refid="project.class.path"/> </javac> </target> </project> 所有使用PatternSets, FileSets 或 path-like structures嵌套元素的task也接受这种类型的引用。 4.1 File（Directory）类 4.1.1 Mkdir ? 创建一个目录，如果他的父目录不存在，也会被同时创建。 ? 例子： <mkdir dir="build/classes"/> ? 说明： 如果build不存在，也会被同时创建 4.1.2 Copy ? 拷贝一个（组）文件、目录 ? 例子： 1. 拷贝单个的文件： <copy file="myfile.txt" tofile="mycopy.txt"/> 2. 拷贝单个的文件到指定目录下 <copy file="myfile.txt" todir="../some/other/dir"/> 3. 拷贝一个目录到另外一个目录下 <copy todir="../new/dir"> <fileset dir="src_dir"/> </copy> 4. 拷贝一批文件到指定目录下 <copy todir="../dest/dir"> <fileset dir="src_dir"> <exclude name="**/*.java"/> </fileset> </copy> <copy todir="../dest/dir"> <fileset dir="src_dir" excludes="**/*.java"/> </copy> 5. 拷贝一批文件到指定目录下，将文件名后增加。Bak后缀 <copy todir="../backup/dir"> <fileset dir="src_dir"/> <mapper type="glob" from="*" to="*.bak"/> </copy> 6. 拷贝一组文件到指定目录下，替换其中的@标签@内容 <copy todir="../backup/dir"> <fileset dir="src_dir"/> <filterset> <filter token="TITLE" value="Foo Bar"/> </filterset> </copy> 4.1.3 Delete ? 删除一个（组）文件或者目录 ? 例子 1. 删除一个文件 <delete file="/lib/ant.jar"/> 2. 删除指定目录及其子目录 <delete dir="lib"/> 3. 删除指定的一组文件 <delete> <fileset dir="." includes="**/*.bak"/> </delete> 4. 删除指定目录及其子目录，包括他自己 <delete includeEmptyDirs="true"> <fileset dir="build"/> </delete> 4.1.4 Move ? 移动或重命名一个（组）文件、目录 ? 例子： 1. 移动或重命名一个文件 <move file="file.orig" tofile="file.moved"/> 2. 移动或重命名一个文件到另一个文件夹下面 <move file="file.orig" todir="dir/to/move/to"/> 3. 将一个目录移到另外一个目录下 <move todir="new/dir/to/move/to"> <fileset dir="src/dir"/> </move> 4. 将一组文件移动到另外的目录下 <move todir="some/new/dir"> <fileset dir="my/src/dir"> <include name="**/*.jar"/> <exclude name="**/ant.jar"/> </fileset> </move> 5. 移动文件过程中增加。Bak后缀 <move todir="my/src/dir"> <fileset dir="my/src/dir"> <exclude name="**/*.bak"/> </fileset> <mapper type="glob" from="*" to="*.bak"/> </move> 4.2 Java相关 4.2.1 Javac ? 编译java原代码 ? 例子 1. <javac srcdir="${src}" destdir="${build}" classpath="xyz.jar" debug="on" /> 编译${src}目录及其子目录下的所有。Java文件，。Class文件将放在$｛build｝指定的目录下，classpath表示需要用到的类文件或者目录，debug设置为on表示输出debug信息 2. <javac srcdir="${src}:${src2}" destdir="${build}" includes="mypackage/p1/**,mypackage/p2/**" excludes="mypackage/p1/testpackage/**" classpath="xyz.jar" debug="on" /> 编译${src}和${src2}目录及其子目录下的所有。Java文件，但是package/p1/**,mypackage/p2/**将被编译，而mypackage/p1/testpackage/**将不会被编译。Class文件将放在$｛build｝指定的目录下，classpath表示需要用到的类文件或者目录，debug设置为on表示输出debug信息 3. <property name="classpath" value=".;./xml-apis.jar;../lib/xbean.jar;./easypo.jar"/> <javac srcdir="${src}" destdir="${src}" classpath="${classpath}" debug="on" /> 路径是在property中定义的 4.2.2 java ? 执行指定的java类 ? 例子： 1. <java classname="test.Main"> <classpath> <pathelement location="dist/test.jar"/> <pathelement path="${java.class.path}"/> </classpath> </java> classname中指定要执行的类，classpath设定要使用的环境变量 2. <path id="project.class.path"> <pathelement location="lib/"/> <pathelement path="${java.class.path}/"/> <pathelement path="${additional.path}"/> </path> <target ... > <rmic ...> <classpath refid="project.class.path"/> </rmic> </target> 4.3 打包相关 4.3.1 jar ? 将一组文件打包 ? 例子： 1. <jar destfile="${dist}/lib/app.jar" basedir="${build}/classes"/> 将${build}/classes下面的所有文件打包到${dist}/lib/app.jar中 2. <jar destfile="${dist}/lib/app.jar" basedir="${build}/classes" includes="mypackage/test/**" excludes="**/Test.class" /> 将${build}/classes下面的所有文件打包到${dist}/lib/app.jar中，但是包括mypackage/test／所有文件不包括所有的Test.class 3. <jar destfile="${dist}/lib/app.jar" basedir="${build}/classes" includes="mypackage/test/**" excludes="**/Test.class" manifest=”my.mf” /> manifest属性指定自己的META-INF/MANIFEST.MF文件，而不是由系统生成 4.3.2 war ? 对Jar的扩展，用于打包Web应用 ? 例子： ? 假设我们的文件目录如下： thirdparty/libs/jdbc1.jar thirdparty/libs/jdbc2.jar build/main/com/myco/myapp/Servlet.class src/metadata/myapp.xml src/html/myapp/index.html src/jsp/myapp/front.jsp src/graphics/images/gifs/small/logo.gif src/graphics/images/gifs/large/logo.gif ? 下面是我们的任务的内容： <war destfile="myapp.war" webxml="src/metadata/myapp.xml"> <fileset dir="src/html/myapp"/> <fileset dir="src/jsp/myapp"/> <lib dir="thirdparty/libs"> <exclude name="jdbc1.jar"/> </lib> <classes dir="build/main"/> <zipfileset dir="src/graphics/images/gifs" prefix="images"/> </war> ? 完成后的结果： WEB-INF/web.xml WEB-INF/lib/jdbc2.jar WEB-INF/classes/com/myco/myapp/Servlet.class META-INF/MANIFEST.MF index.html front.jsp images/small/logo.gif images/large/logo.gif 4.3.3 ear ? 用于打包企业应用 ? 例子 <ear destfile="${build.dir}/myapp.ear" appxml="${src.dir}/metadata/application.xml"> <fileset dir="${build.dir}" includes="*.jar,*.war"/> </ear> 4.4 时间戳 在生成环境中使用当前时间和日期，以某种方式标记某个生成任务的输出，以便记录它是何时生成的，这经常是可取的。这可能涉及编辑一个文件，以便插入一个字符串来指定日期和时间，或将这个信息合并到 JAR 或 zip 文件的文件名中。 这种需要是通过简单但是非常有用的 tstamp 任务来解决的。这个任务通常在某次生成过程开始时调用，比如在一个 init 目标中。这个任务不需要属性，许多情况下只需 <tstamp/> 就足够了。 tstamp 不产生任何输出；相反，它根据当前系统时间和日期设置 Ant 属性。下面是 tstamp 设置的一些属性、对每个属性的说明，以及这些属性可被设置到的值的例子： 属性 说明 例子 DSTAMP 设置为当前日期，默认格式为yyyymmdd 20031217 TSTAMP 设置为当前时间，默认格式为 hhmm 1603 TODAY 设置为当前日期，带完整的月份 2003 年 12 月 17 日 例如，在前一小节中，我们按如下方式创建了一个 JAR 文件： <jar destfile="package.jar" basedir="classes"/> 在调用 tstamp 任务之后，我们能够根据日期命名该 JAR 文件，如下所示： <jar destfile="package-${DSTAMP}.jar" basedir="classes"/> 因此，如果这个任务在 2003 年 12 月 17 日调用，该 JAR 文件将被命名为 package-20031217.jar。 还可以配置 tstamp 任务来设置不同的属性，应用一个当前时间之前或之后的时间偏移，或以不同的方式格式化该字符串。所有这些都是使用一个嵌套的 format 元素来完成的，如下所示： <tstamp> <format property="OFFSET_TIME" pattern="HH:mm:ss" offset="10" unit="minute"/> </tstamp> 上面的清单将 OFFSET_TIME 属性设置为距离当前时间 10 分钟之后的小时数、分钟数和秒数。 用于定义格式字符串的字符与 java.text.SimpleDateFormat 类所定义的那些格式字符相同 4.5 执行SQL语句 ? 通过jdbc执行SQL语句 ? 例子： 1. <sql driver="org.gjt.mm.mysql.Driver" url="jdbc:mysql://localhost:3306/mydb" userid="root" password="root" src="data.sql" /> 2. <sql driver="org.database.jdbcDriver" url="jdbc:database-url" userid="sa" password="pass" src="data.sql" rdbms="oracle" version="8.1." > </sql> 只有在oracle、版本是8.1的时候才执行 4.6 发送邮件 ? 使用SMTP服务器发送邮件 ? 例子： <mail mailhost="smtp.myisp.com" mailport="1025" subject="Test build"> <from address="me@myisp.com"/> <to address="all@xyz.com"/> <message>The ${buildname} nightly build has completed</message> <fileset dir="dist"> <includes name="**/*.zip"/> </fileset> </mail> ? mailhost： SMTP服务器地址 ? mailport： 服务器端口 ? subject： 主题 ? from： 发送人地址 ? to： 接受人地址 ? message： 发送的消息 ? fileset： 设置附件
创建型模式
1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东
西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四
个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory
工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求
即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相
应的修改。如：如何创建及如何向客户端提供。
2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用
她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按
键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，
国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。（这一定比美军在伊
拉克用的翻译机好卖）
建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生
成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，
客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造
过程。
3、FACTORY METHOD—请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记
住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说
“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。
工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给
子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不
接触哪一个产品类应当被实例化这种细节。
4、PROTOTYPE—跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情
话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（
100块钱一份，你要不要）
原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制
这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减
少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任
何的等级结构。缺点是每一个类都必须配备一个克隆方法。
5、SINGLETON—俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公
Sigleton，她们只要说道“老公”，都是指的同一个人，那就是我(刚才做了个梦
啦，哪有这么好的事)
单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提
供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。
结构型模式
6、ADAPTER—在朋友聚会上碰到了一个美女Sarah，从香港来的，可我不会说粤语
，她不会说普通话，只好求助于我的朋友kent了，他作为我和Sarah之间的
Adapter，让我和Sarah可以相互交谈了(也不知道他会不会耍我)
适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，从而
使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据
参数返还一个合适的实例给客户端。
7、BRIDGE—早上碰到MM，要说早上好，晚上碰到MM，要说晚上好；碰到MM穿了件
新衣服，要说你的衣服好漂亮哦，碰到MM新做的发型，要说你的头发好漂亮哦。不
要问我“早上碰到MM新做了个发型怎么说”这种问题，自己用BRIDGE组合一下不就
行了
桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之
间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合
/聚合关系而不是继承关系，从而使两者可以独立的变化。
8、COMPOSITE—Mary今天过生日。“我过生日，你要送我一件礼物。”“嗯，好吧
，去商店，你自己挑。”“这件T恤挺漂亮，买，这条裙子好看，买，这个包也不
错，买。”“喂，买了三件了呀，我只答应送一件礼物的哦。”“什么呀，T恤加
裙子加包包，正好配成一套呀，小姐，麻烦你包起来。”“……”，MM都会用
Composite模式了，你会了没有？
合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合
成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构
表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成
对象同等看待。
9、DECORATOR—Mary过完轮到Sarly过生日，还是不要叫她自己挑了，不然这个月
伙食费肯定玩完，拿出我去年在华山顶上照的照片，在背面写上“最好的的礼物，
就是爱你的Fita”，再到街上礼品店买了个像框（卖礼品的MM也很漂亮哦），再找
隔壁搞美术设计的Mike设计了一个漂亮的盒子装起来……，我们都是Decorator，
最终都在修饰我这个人呀，怎么样，看懂了吗？
装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替
代方案，提供比继承更多的灵活性。动态给一个对象增加功能，这些功能可以再动
态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。
10、FACADE—我有一个专业的Nikon相机，我就喜欢自己手动调光圈、快门，这样
照出来的照片才专业，但MM可不懂这些，教了半天也不会。幸好相机有Facade设计
模式，把相机调整到自动档，只要对准目标按快门就行了，一切由相机自动调整，
这样MM也可以用这个相机给我拍张照片了。
门面模式：外部与一个子系统的通信必须通过一个统一的门面对象进行。门面
模式提供一个高层次的接口，使得子系统更易于使用。每一个子系统只有一个门面
类，而且此门面类只有一个实例，也就是说它是一个单例模式。但整个系统可以有
多个门面类。
11、FLYWEIGHT—每天跟MM发短信，手指都累死了，最近买了个新手机，可以把一
些常用的句子存在手机里，要用的时候，直接拿出来，在前面加上MM的名字就可以
发送了，再不用一个字一个字敲了。共享的句子就是Flyweight，MM的名字就是提
取出来的外部特征，根据上下文情况使用。
享元模式：FLYWEIGHT在拳击比赛中指最轻量级。享元模式以共享的方式高效
的支持大量的细粒度对象。享元模式能做到共享的关键是区分内蕴状态和外蕴状态
。内蕴状态存储在享元内部，不会随环境的改变而有所不同。外蕴状态是随环境的
改变而改变的。外蕴状态不能影响内蕴状态，它们是相互独立的。将可以共享的状
态和不可以共享的状态从常规类中区分开来，将不可以共享的状态从类里剔除出去
。客户端不可以直接创建被共享的对象，而应当使用一个工厂对象负责创建被共享
的对象。享元模式大幅度的降低内存中对象的数量。
12、PROXY—跟MM在网上聊天，一开头总是“hi,你好”,“你从哪儿来呀？”“你
多大了？”“身高多少呀？”这些话，真烦人，写个程序做为我的Proxy吧，凡是
接收到这些话都设置好了自动的回答，接收到其他的话时再通知我回答，怎么样，
酷吧。
代理模式：代理模式给某一个对象提供一个代理对象，并由代理对象控制对源
对象的引用。代理就是一个人或一个机构代表另一个人或者一个机构采取行动。某
些情况下，客户不想或者不能够直接引用一个对象，代理对象可以在客户和目标对
象直接起到中介的作用。客户端分辨不出代理主题对象与真实主题对象。代理模式
可以并不知道真正的被代理对象，而仅仅持有一个被代理对象的接口，这时候代理
对象不能够创建被代理对象，被代理对象必须有系统的其他角色代为创建并传入。
行为模式
13、CHAIN OF RESPONSIBLEITY—晚上去上英语课，为了好开溜坐到了最后一排，
哇，前面坐了好几个漂亮的MM哎，找张纸条，写上“Hi,可以做我的女朋友吗？如
果不愿意请向前传”，纸条就一个接一个的传上去了，糟糕，传到第一排的MM把纸
条传给老师了，听说是个老处女呀，快跑!
责任链模式：在责任链模式中，很多对象由每一个对象对其下家的引用而接
起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请
求。客户并不知道链上的哪一个对象最终处理这个请求，系统可以在不影响客户端
的情况下动态的重新组织链和分配责任。处理者有两个选择：承担责任或者把责任
推给下家。一个请求可以最终不被任何接收端对象所接受。
14、COMMAND—俺有一个MM家里管得特别严，没法见面，只好借助于她弟弟在我们
俩之间传送信息，她对我有什么指示，就写一张纸条让她弟弟带给我。这不，她弟
弟又传送过来一个COMMAND，为了感谢他，我请他吃了碗杂酱面，哪知道他说：“
我同时给我姐姐三个男朋友送COMMAND，就数你最小气，才请我吃面。”，:-(
命令模式：命令模式把一个请求或者操作封装到一个对象中。命令模式把发出
命令的责任和执行命令的责任分割开，委派给不同的对象。命令模式允许请求的一
方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不
必知道请求是怎么被接收，以及操作是否执行，何时被执行以及是怎么被执行的。
系统支持命令的撤消。
15、INTERPRETER—俺有一个《泡MM真经》，上面有各种泡MM的攻略，比如说去吃
西餐的步骤、去看电影的方法等等，跟MM约会时，只要做一个Interpreter，照着
上面的脚本执行就可以了。
解释器模式：给定一个语言后，解释器模式可以定义出其文法的一种表示，并
同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。解释
器模式将描述怎样在有了一个简单的文法后，使用模式设计解释这些语句。在解释
器模式里面提到的语言是指任何解释器对象能够解释的任何组合。在解释器模式中
需要定义一个代表文法的命令类的等级结构，也就是一系列的组合规则。每一个命
令对象都有一个解释方法，代表对命令对象的解释。命令对象的等级结构中的对象
的任何排列组合都是一个语言。
16、ITERATOR—我爱上了Mary，不顾一切的向她求婚。
Mary：“想要我跟你结婚，得答应我的条件”
我：“什么条件我都答应，你说吧”
Mary：“我看上了那个一克拉的钻石”
我：“我买，我买，还有吗？”
Mary：“我看上了湖边的那栋别墅”
我：“我买，我买，还有吗？”
Mary：“你的小弟弟必须要有50cm长”
我脑袋嗡的一声，坐在椅子上，一咬牙：“我剪，我剪，还有吗？”
……
迭代子模式：迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内
部表象。多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象
的容器对象。迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚集本身
隔开。迭代子模式简化了聚集的界面。每一个聚集对象都可以有一个或一个以上的
迭代子对象，每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚
集角色变化。
17、MEDIATOR—四个MM打麻将，相互之间谁应该给谁多少钱算不清楚了，幸亏当时
我在旁边，按照各自的筹码数算钱，赚了钱的从我这里拿，赔了钱的也付给我，一
切就OK啦，俺得到了四个MM的电话。
调停者模式：调停者模式包装了一系列对象相互作用的方式，使得这些对象不
必相互明显作用。从而使他们可以松散偶合。当某些对象之间的作用发生改变时，
不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。调
停者模式将多对多的相互作用转化为一对多的相互作用。调停者模式将对象的行为
和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。
18、MEMENTO—同时跟几个MM聊天时，一定要记清楚刚才跟MM说了些什么话，不然
MM发现了会不高兴的哦，幸亏我有个备忘录，刚才与哪个MM说了什么话我都拷贝一
份放到备忘录里面保存，这样可以随时察看以前的记录啦。
备忘录模式：备忘录对象是一个用来存储另外一个对象内部状态的快照的对象
。备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捉住，并外部化
，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。
19、OBSERVER—想知道咱们公司最新MM情报吗？加入公司的MM情报邮件组就行了，
tom负责搜集情报，他发现的新情报不用一个一个通知我们，直接发布给邮件组，
我们作为订阅者（观察者）就可以及时收到情报啦
观察者模式：观察者模式定义了一种一队多的依赖关系，让多个观察者对象同
时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对
象，使他们能够自动更新自己。
20、STATE—跟MM交往时，一定要注意她的状态哦，在不同的状态时她的行为会有
不同，比如你约她今天晚上去看电影，对你没兴趣的MM就会说“有事情啦”，对你
不讨厌但还没喜欢上的MM就会说“好啊，不过可以带上我同事么？”，已经喜欢上
你的MM就会说“几点钟？看完电影再去泡吧怎么样？”，当然你看电影过程中表现
良好的话，也可以把MM的状态从不讨厌不喜欢变成喜欢哦。
状态模式：状态模式允许一个对象在其内部状态改变的时候改变行为。这个对
象看上去象是改变了它的类一样。状态模式把所研究的对象的行为包装在不同的状
态对象里，每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是
让一个对象在其内部状态改变的时候，其行为也随之改变。状态模式需要对每一个
系统可能取得的状态创立一个状态类的子类。当系统的状态变化时，系统便改变所
选的子类。
21、STRATEGY—跟不同类型的MM约会，要用不同的策略，有的请电影比较好，有的
则去吃小吃效果不错，有的去海边浪漫最合适，单目的都是为了得到MM的芳心，我
的追MM锦囊中有好多Strategy哦。
策略模式：策略模式针对一组算法，将每一个算法封装到具有共同接口的独立
的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的
情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类，各
种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都不
会影响到环境和客户端。
22、TEMPLATE METHOD——看过《如何说服女生上床》这部经典文章吗？女生从认
识到上床的不变的步骤分为巧遇、打破僵局、展开追求、接吻、前戏、动手、爱抚
、进去八大步骤(Template method)，但每个步骤针对不同的情况，都有不一样的
做法，这就要看你随机应变啦(具体实现)；
模板方法模式：模板方法模式准备一个抽象类，将部分逻辑以具体方法以及具
体构造子的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的
子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先制
定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。
23、VISITOR—情人节到了，要给每个MM送一束鲜花和一张卡片，可是每个MM送的
花都要针对她个人的特点，每张卡片也要根据个人的特点来挑，我一个人哪搞得清
楚，还是找花店老板和礼品店老板做一下Visitor，让花店老板根据MM的特点选一
束花，让礼品店老板也根据每个人特点选一张卡，这样就轻松多了；
访问者模式：访问者模式的目的是封装一些施加于某种数据结构元素之上的操
作。一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。访问者
模式适用于数据结构相对未定的系统，它把数据结构和作用于结构上的操作之间的
耦合解脱开，使得操作集合可以相对自由的演化。访问者模式使得增加新的操作变
的很容易，就是增加一个新的访问者类。访问者模式将有关的行为集中到一个访问
者对象中，而不是分散到一个个的节点类中。当使用访问者模式时，要将尽可能多
的对象浏览逻辑放在访问者类中，而不是放到它的子类中。访问者模式可以跨过几
个类的等级结构访问属于不同的等级结构的成员类
|