Web乱码与字符集的理解
小生最近学习Servlet和JSP处理中文时常常碰到乱码，所以在网上找了许多有关字符集方面的资料学习，但总觉得一知半懂，所以想得到前辈
们指教，以下是我的理解：
磁盘上件的存储形式：所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些
字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列.
字符编码(encoding)就是把字符按照某种映射标准（字符集）转换成字节。例如打开一个空记事本，然后在记事本中写入"hello world"--〉另
存为(默认的ASICC字符集)--->asc.txt ， 这时asc.txt就以ASCII编码的字节序列存储在磁盘上，如果要读这个文件，也就是将这个字节序列
按照原字符集转换成字符串(解码:decoding)，所以处理好编码<=>字符集<=>解码就是关键.
字符集就像棋盘，每个字符（棋子）用一个棋格（字节）映射。
ISO8859:8位的字符集，0~0x7F仍与ASCII字符集保持兼容，大于0x7F的是各种拉丁字符或欧洲字符的扩展。
GB2312: 8位的字符集，如果当前字节(8 bit)小于0X80，则仍当它为英文字符与(ASCII兼容)；如果它大于等于0x80，则它和紧接着它的下一个
字节构成一个汉字字符，这样，GB2312字符集可包含大约4000多个常用简体汉字和其他汉字中的特殊符号（如①㈠之类）。
GBK:GB2312的扩展集，和GB2312兼容.
Unicode: 16位的字符集,Unicode的主要目标是提供一个“通用字符集”。
UTF-8: Unicode的使用、存储与传输，都极其浪费空间，所以在此基础上出现了UTF-8字符编码的规范，在UTF-8中，属于US-ASCII中的字符，
仍用一个字节表示，且和US-ASCII兼容，编码其他的字符，则用1（大于0x7F部分）到3个字节. (编码中文用3个字节)
JVM编译器使用系统默认的字符集encoding/decoding.我的系统为win2000Server 默认字符集为GBK。编译过程如下
1.javac Test.java ===>编译器实际上执行了 javac -encoding GBK Test.java
2.在类装载器中加载这个Test.class文件，编译器再用GBK字符集解读这个Test.class
Java可以让你按自定义字符集编码你的文件,如下列
Utf.java
public class Utf {
public static void main(String [] args)
throws Exception
{
String s = "你好";
byte[] bytelist = s.getBytes("UTF-8");
}
}
..
javac Utf.java // 这时，在类文件Utf.class中，bytelist存储的是一块UTF-8编码"你好"的字节序列,而其他部分仍然是GBK编码的字节.
现在再加上对这些字节解码的过程
public class Utf {
public static void main(String [] args)
throws Exception
{
String s = "你好";
byte[] bytelist = s.getBytes("UTF-8");
//解码
String decodingString = new String(bytelist,"UTF-8");
//正确的读出这些UFT-8字符集编码的字节
System.out.println(decodingString);
}
}
现在讲JSP,Servlet了.
他们归根到底都是 xxx.class文件，所以我们抓住他们的编译器编码方式和上例 bytelist那样的字节序列就OK了.
以下是一个 JSP-Servlet-java Bean - JDBC 的实例.
JSP文件的编码解码过程如下(jsp引擎采用UTF-8 encoding/decoding):
JSP引擎(UTF-8) Servlet引擎(UTF-8)
xxx.jsp -----------------> xxx$jsp.java(UTF-8) -----------------------> xxx.class
1.在 xxx$jsp.java(UTF-8) ---> xxx.class 这一部分，Servlet编译器会正确的用 UTF-8来解读，所以我们可以不用管,
2.而关键在xxx.jsp这里，我们应该告诉jsp引擎某个区域的字符串用GB2312或GBK、UTF编码.
<%@ page pageEncoding="gb2312" %>
3.这样你所提交的表单实体数据就用gb2312编码了,数据提交到Servlet中,Servlet用gb2312来解读这些数据就可以正确的给bean了.
//将接受到的数据以GB2312字符集进行编码
req.setCharacterEncoding("GB2312");
//输出的信息以GB2312字符集编码,如果数据主要由Bean处理,charset=GB2312要不要都无所谓
res.setContentType("text/html;charset=GB2312");
因为servlet解码使用ISO-8859-1字符集, 这里setCharacterEncoding("GB2312")完成的功能其实就是一个转码过程，如果传来一个表单数据
为gb2312编码的"你好", 它处理的就是
byte[] bytelist = s.getByte("ISO-8859-1");
s = new String(bytelist,"GB2312");
后边一般没什么问题了
*************************************************************************************************************************888888
ASP具备管理不同语言脚本程序的能力，能够自动调用合适的脚本引擎以解释脚本代码和执行内置函数。ASP开发环境提供了两种脚本引擎，即VBScript（缺省）和JScript。不过，开发者并没有被限制于只能使用这两种语言，只要能够提供合适的ActiveX脚本引擎就能使用任何脚本语言。
脚本语言的选择往往基于许多不同原因：它可能是开发者最为熟悉的语言，可能是对给定工程来说能够提供最多特色支持的，也有可能是最具效率的。不同的环境和要求使得我们在选择脚本语言时注重不同的因素，同时也使得我们在某些时候面临选定的脚本语言不能直接提供其它语言固有的函数这一问题，或某个脚本已经写成但用的却是另外一种脚本语言。
此时应该怎么办？是否需要用当前所用的脚本语言重写这些脚本？或者说，是否有可能在一种脚本语言中调用其它脚本语言的内置函数？本文要说明的就是在ASP应用中如何让VBScript脚本和JScript脚本交互以最大限度地获得两种脚本语言的特色支持。
一、VBScript和JScript的内置函数
在VBScript和JScript中，有大量的内置函数功能是相同或类似的。然而，在一种脚本语言中内置的函数并非总是在另外一种脚本语言中也有对应的函数。例如，VBScript提供了许多用于操作字符串和格式化数据的函数，这些函数在JScript中并不存在。这些函数包括StrReverse()、Filter()以及FormatCurrency()等。在另一方面，JScript所提供的用于管理数组、字符串编码等的函数在VBScript中也没有定义，如join()、reverse()、pow()、位操作、escape()和unescape()等。
那么，如果在JScript程序中需要一个VBscript函数该怎么办呢?
二、异种脚本的互相调用
如果需要在JScript脚本中调用一个VBScript中内置的函数，则应该写一个VBScript用户定义函数（在这里调用VBScript内置函数），然后在JScript脚本中象调用公用JScript函数一样调用这个用户定义函数。
例如，如果要调用的VBSCript内置函数是FormatCurrency()，则可以声明如下自定义函数：
< SCRIPT LANGUAGE="VBSCRIPT" RUNAT="SERVER">
Function FormatValue(Value)
FormatValue = FormatCurrency(Value)
End Function
< /SCRIPT>
接下来在JScript代码中就可以象普通JScript函数一样调用FormatValue()了。用类似的方法也可以实现VBScript代码调用JScript函数。
应用同样的规则，我们可以在任何脚本内调用任何用户定义函数。不过，从JScript脚本内调用一个不带参数的VBScript过程（Sub）时应略加注意，此时在JScript中应该象调用一个不带参数的JScript函数一样调用它，如用foo()调用VBScript Sub foo过程。
三、数据共享
在某些情形下混合运用VBScript和JScript函数是非常有用的，但在不同语言脚本之间共享数据也可能很有用。实现这种共享的方法很简单：不管使用的是什么语言，只要是在页面级声明的变量就可以任意引用。
对象的使用方法也相似，可以任意选用合适的语言读取、修改属性或调用对象的方法。当然给定对象的属性和方法是由创建该对象实例的语言所定义的。正如上例VBScript的过程调用，当从JScript中调用一个不带参数的VBScript对象的方法时，其调用方法也遵从JScript的调用规则，反之亦然。
四、数组管理
数组共享问题稍微复杂一点。虽然数组也象其它变量一样可以在不同语言脚本之间共享，但必须注意兼容方面的问题。
VBScript数组在JScript下可以用VBScript的符号引用，即用myArray(2)引用数组元素而不是JScript的数组元素引用符号myArray[2]。此外，还可以使用一个特殊的JScript对象——VBArray对象将VBScript数组转换为JScript数组。下面的代码从VBScript数组myVBArray创建JScript数组myJSArray：
var Temp = new VBArray(myVBArray)
var myJSArray
myJSArray = Temp.toArray()
上述代码首先创建一个临时的VBArray对象，然后使用它的toArray()方法将自己转换为JScript数组。此后就可以象普通JScript数组一样使用myJSArray，如myJSArray[1]。但应当注意的是，toArray()方法将把一个多维的VBArray转换为一维的JScript数组。
从VBScript中引用JScript数组更为复杂。虽然在VBScript中我们可以直接访问JScript数组相关的方法和属性，但没有直接访问JScript数组的单个元素的方法。也就是说，我们可以在VBScript脚本中读取JScript数组的长度属性，如下所示：
x = myJSArray.length
但无法直接读取该数组的单个元素，下面的VBScript代码是不正确的：
x = myJSArray(3)
解决该问题的一个可行的方法是执行一个转换过程，如下面的代码所示，此处假定VBScript是缺省的脚本语言：
< %
Dim Temp
Dim myVBArray
Temp = myJSArray.join(", ")
myVBArray = Split(Temp, ", ")
%>
此处的JScript join()方法将数组myJSArray元素转换到一个以逗号为分割符的字符串，VBScript Split()函数将字符串转换为VBScript数组。注意这里我们是在VBScript环境下调用JScript的join方法。依照此例，我们可以通过自定义VBScript函数来模拟JScript的VBArray对象的toArray()方法以实现JScript数组到VBScript数组的转换。
、小结
在同一个ASP工程内灵活选用不同脚本语言具有许多优点，这些脚本之间的交互能力更为开发者集成不同语言所提供的内置函数和其它功能带来了更多的机会，同时也使得实现既可用于VBScript也可用于JScript环境的通用脚本库成为可能。
********************************************************************************************************************************************************************************************************************************************************************************************************************************
JavaScript的浏览器对象详解
使用浏览器的内部对象系统, 可实现与HTML文档进行交互。它的作用是将相关元素组织包装起来，提供给程序设计人员使用，从而减轻编程人的劳动，提高设计Web页面的能力。
一、浏览器对象层次及其主要作用
除了前面提到过的文档document对象外，Navigator浏览器中还提供了窗口（Window）对象以及历史（History）和位置（Location）对象。
●浏览器对象(Navigator)提供有关浏览器的信息
navigator中有用的属性包括：
※appName:提供字符串形式的浏览器名称。
※appVersion:反映浏览器的版本号。
※appCodeName:浏览器的代码名称。
※userAgent:用户代理标识。
※mineTypes:可以使用的mine类型信息。
※plugins:可以使用的插件信息。
※languages:语言设定。
※platform:浏览器适用的平台名称。
示例：你所使用的浏览器为：Microsoft Internet Explorer版本为：4.0 (compatible; MSIE 6.0; Windows NT 5.0)
<script>
document.write("你所使用的浏览器为："+navigator.appName);
document.write("版本为："+navigator.appVersion);
</script>
●窗口对象(Windows)
Window对象有以下方法：
※open(url,WindowName,parameterlist):创建一个新窗口。
※close():关闭一个窗口。
※alert(text):警告窗口。
※confirm(text):弹出确认域。
※promt(text,Defaulttext):弹出提示框。
※setTimeout(表达式，时间)定时设置。
※clearTimeout(timer)：取消以前的设定。
※setInterval(表达式，时间):设定一个时间间隔。
※clearInterval(timer):取消时间间隔设定。
※moveBy(水平位移，垂直位移):将窗口移支指定的位移。
※moveTo(x,y):将窗口移动到指定的坐标。
※resizeBy(水平位移，垂直位移):按给定的位移量重新设定窗口大小。
※resizeTo(x,y):将窗口设定为指定大小。
※scrollBy(水平位移，垂直位移):按给定的位移量滚动窗口。
※scrollTo(x,y):将窗口滚动到指定位置。
※find(["string",true|false][,true|false]):查找网页中的字符串。
※back():后退。
※forward():前进。
※home():返回主页。
※stop():停止装载网页。
※print():打印网页。
※frame:帧。
※status:状态栏信息。
※location:当前窗口URL信息。
※history:历史。
※closed:窗口是否已关闭的逻辑值。
※Parent 指明当前窗口或帧的父窗口。
※defaultstatus:默认状态，它的值显示在窗口的状态栏中。
※top:包括的是用以实现所有的下级窗口的窗口。
※window.指的是当前窗口
※self:引用当前窗口。
打开一个窗口的基本格式：
Window .open("URL","窗口名字","窗口属性"]
window属性参数是由一个字符串列表项它由逗号分隔，它指明了有关新创建窗口的属性。
参 数 设定值 含 义
toolbar yes/no 建立或不建立标准工具条
location yes/no 建立或不建立位置输入字段
directions yes/no 建立或不建立标准目录按钮
status yes/no 建立或不建立状态条
menubar yes/no 建立或不建立菜单条
scrollbar yes/no 建立或不建立滚动条
revisable yes/no 能否改变窗口大小
width yes/no 确定窗口的宽度
Height yes/no 确定窗口的高度。
在使用Open()方法时，需要注意以下点。
·通常浏览器窗中，总有一个文档是打开的。因而不需要为输出建立一个新文档。
·在完成对Web文档的写操作后，要使用或调用close()方法来实现对输出流的关闭。
·在使用open()来打开一个新流时，可为文档指定一个有效的文档类型，有效文档类型包括text/HTML、text/gif、text/xim、text/plugin等。
Window对象处于对象层次的最顶端，它提供了处理Navigator窗口的方法和属性。
●位置对象(Location)
Location对象提供了与当前打开的URL一起工作的方法和属性，它是一个静态的对象。
location对象有以下方法：
location=url
reload()
replace()
●历史对象(History)
History对象提供了与历史清单有关的信息。
利用history对象可以实现网页导航：
1) go:让浏览器载入指定的url.
history.go(-2) 可以装入浏览器访问过的倒数第二个URL.
history.go(0) 可以重新载入当前URL.
history.go(http://www.tastelife.net)
2) back:让浏览器载入历史记录前一个URL
3) forward:让浏览器载入历史记录后一个URL
●文档对象(Document)
document对象包含了与文档元素(elements)一起工作的对象，它将这些元素封装起来供编程人员使用。
编程人员利用这些对象，可以对WWW浏览器环境中的事件进行控制并作出处理。在JavaScript中提供了非常丰富的内部方法和属性,从而减轻了编程人员的工作,提高编程效率。这正是基于对象与面向对象的根本区别所在。在这些对象系统中,文档对象属于非常重要的,它位于最低层,但对于我们实现Web页面信息交互起作关键作用。因而它是对象系统的核心部分。
二、文档对象功能及其作用
在Navigator浏览器中，document文档对象是核心是，同时也是最重要的。见图6-1所示。
Links Anchor Form Method Prop
链接对象 锚对象 窗体对象 方法 对象
从图6-1中可以看出，document对象的主要作用就是把这些基本的元素（如links,anchor等）包装起来，提供给编程人员使用。从另一个角度看，document对象中又是由属性和方法组成。
１、document中三个主要的对象
在document中主要有：links,anchor,form等三个最重要的对象：
（１）anchor锚对象：
anchor对象指的是<A Name=...> </A>标识在HTML源码中存在时产生的对象。它包含着文档中所有的anchors信息。
（２）链接links对象
link对象指的是用<A Href=...> </A>标记的连接一个超文本或超媒体的元素作为一个特定的URL。
（３）窗体（Form）对象
窗体对象是文档对象的一个元素，它含有多种格式的对象储存信息，使用它可以在JavaScript脚本中编写程序进行文字输入，并可以用来动态改变文档的行为。通过document. Forms[]数组来使得在同一个页面上可以有多个相同的窗体,使用forms[]数组要比使用窗体名字要方便得多。
document对象有以下方法：
（1）write()、writeln()输出显示。
该方法主要用来实现在Web页面上显示输出信息。在实际使用中，需注意以下几点：
·writeln()与write()唯一不同之处在于在未尾加了一个换符。
·为了正常显示其输出信息，必须指明<pre> </Pre>标记，使之告诉编辑器。
·输出的文档类型，可以由浏览器中的有效的合法文本类型所确定。
（2）关闭文档流close()
在实现多个文档对象中，必须使用close()来关闭一个对象后，才能打开另一个文档对象。
（3）清除文档内容clear()
例:下面就是一个使用窗体数组和窗体名字的例子。该程序使得两个窗体中的字段内容保持一致。
Test6_1.htm
<Html>
<head>
</head>
<body>
<form >
<input type=text onChange="document.my.elements[0].value=this.value;" >
</form>
<form NAME="my">
<input type=text onChange="document.forms[0].elements[0].value=this.value;">
</form>
</body>
</html>
其中用了OnChnge事件(当窗体内容改变时激发)。第一个使用窗体名字标识my,第二个使用窗体数组Forms[]。其效果是一致。
２、文档对象中的attribute属性
document对象中的attribute属性，主要用于在引用Href标识时，控制着有关颜色的格式和有关文档标题、文档原文件的URL以及文档最后更新的日期。这部分元素的主要含义如下：
（１）链接颜色：alinkcolor
这个元素主要用于，当选取一个链接时，链接对象本身的颜色就按alinkcolo r指定改变。
（２）链接颜色：linkcolor
当用户使用<A Href=...> Text string </A>链接后，Textstring的颜色就会按Linkcolor所指定的颜色更新。
（３）浏览过后的颜色：VlinkColor
该属性表示的是已被浏览存储为已浏览过的链接颜色。
（４）背景颜色：bgcolor
该元素包含文档背景的颜色。
（５）前景颜色：Fgcolor
该元素包含HTML文档中文本的前景颜色。
３、文档对象的基本元素
（１）窗体属性：
窗体属性是与HTML文档中<Form>...</Form>相对应的一组对象在HTML文档所创建的窗体数，由length指定。通过document.forms.length反映该文档中所创建的窗体数目。
（２）锚属性：anchors
该属性中，包含了HTML文档的所有<A> </A>标记为Name=...的语句标识。所有“锚”的数目保存在document.anchors.length中。
（３）链接属性：links
链接属性是指在文档中<A>...</A>的由Href=...指定的数目，其链接数目保存在document.links.length中。
三、范例
例1:下面我们通过一个例子来说明文档对象的综合应用。
Test6_2.htm
<html>
<head>
</HEAD>
<BOdy>
<Form Name="mytable">
请输入数据：
<Input Type="text" Name="text1" Value="">
</Form>
<A name="Link1" href="test31.htm">链接到第一个文本</a><br>
<A name="Link2" href="test32.htm">链接到第二个文本</a><br>
<A name="Link2" href="test33.htm">链接到第三个文本</a><br>
<A href="#Link1">第一锚点</a>
<A href="#Link2">第二锚点</a>
<A Href="#Link3">第三锚点</a>
<BR>
<Script Language="JavaScript">
document.write("文档有"+document.links.length+"个链接"+"<br>");
document.write("文档有"+document.anchors.length+"个锚点"+"<br>");
document.write("文档有"+document.forms.length+"个窗体");
</script>
</body>
</HTML>
例子2：下列程序随机产生每日一语。
test6_3.html
<HTML>
<HEAD>
<script Language="JavaScript">
<!--
tips = new Array(6);
tips[0]="每日一语（1）";
tips[1]="每日一语（2）";
tips[2]="每日一语（3）";
tips[3]="每日一语（4）";
tips[4]="每日一语（5）";
tips[5]="每日一语（6）";
index = Math.floor(Math.random() * tips.length);
document.write("<FONT SIZE=8 COLOR=DARKBLUE>" + tips[index]+"</FONT>");
</Script>
</HEAD>
</BODY>
</HTML>
/********************************************************************************************************************************************************************************************/
Java性能的优化（下）(转)
转贴：Andy.m 日期：2003-07-26 人气：9
三．优化JAVA程序设计和编码，提高JAVA程序性能的一些方法。
通过使用一些前面介绍过的辅助性工具来找到程序中的瓶颈，然后就可以对瓶颈部分的代码进行优化。一般有两种方案：即优化代码或更改设计方法。我们一般会选择后者，因为不去调用以下代码要比调用一些优化的代码更能提高程序的性能。而一个设计良好的程序能够精简代码，从而提高性能。
下面将提供一些在JAVA程序的设计和编码中，为了能够提高JAVA程序的性能，而经常采用的一些方法和技巧。
1．对象的生成和大小的调整。
JAVA程序设计中一个普遍的问题就是没有好好的利用JAVA语言本身提供的函数，从而常常会生成大量的对象（或实例）。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响。
例1：关于String ,StringBuffer，+和append
JAVA语言提供了对于String类型变量的操作。但如果使用不当，会给程序的性能带来影响。如下面的语句：
String name=new String(“HuangWeiFeng”);
System.out.println(name+”is my name”);
看似已经很精简了，其实并非如此。为了生成二进制的代码，要进行如下的步骤和操作。
（1） 生成新的字符串 new String(STR_1);
（2） 复制该字符串。
（3） 加载字符串常量”HuangWeiFeng”(STR_2);
（4） 调用字符串的构架器（Constructor）;
（5） 保存该字符串到数组中（从位置0开始）
（6） 从java.io.PrintStream类中得到静态的out变量
（7） 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
（8） 复制该字符串缓冲变量
（9） 调用字符串缓冲的构架器（Constructor）;
（10） 保存该字符串缓冲到数组中（从位置1开始）
（11） 以STR_1为参数，调用字符串缓冲(StringBuffer)类中的append方法。
（12） 加载字符串常量”is my name”(STR_3);
（13） 以STR_3为参数，调用字符串缓冲(StringBuffer)类中的append方法。
（14） 对于STR_BUF_1执行toString命令。
（15） 调用out变量中的println方法，输出结果。
由此可以看出，这两行简单的代码，就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五个对象变量。这些生成的类的实例一般都存放在堆中。堆要对所有类的超类，类的实例进行初始化，同时还要调用类极其每个超类的构架器。而这些操作都是非常消耗系统资源的。因此，对对象的生成进行限制，是完全有必要的。
经修改，上面的代码可以用如下的代码来替换。
StringBuffer name=new StringBuffer(“HuangWeiFeng”);
System.out.println(name.append(“is my name.”).toString());
系统将进行如下的操作。
(1) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
(2) 复制该字符串缓冲变量
(3) 加载字符串常量”HuangWeiFeng”(STR_1);
(4) 调用字符串缓冲的构架器（Constructor）;
(5) 保存该字符串缓冲到数组中（从位置1开始）
(6) 从java.io.PrintStream类中得到静态的out变量
(7) 加载STR_BUF_1;
(8) 加载字符串常量”is my name”(STR_2);
(9) 以STR_2为参数，调用字符串缓冲(StringBuffer)实例中的append方法。
(10) 对于STR_BUF_1执行toString命令。(STR_3)
(11)调用out变量中的println方法，输出结果。
由此可以看出，经过改进后的代码只生成了四个对象变量：STR_1,STR_2,STR_3和STR_BUF_1.你可能觉得少生成一个对象不会对程序的性能有很大的提高。但下面的代码段2的执行速度将是代码段1的2倍。因为代码段1生成了八个对象，而代码段2只生成了四个对象。
代码段1：
String name= new StringBuffer(“HuangWeiFeng”);
name+=”is my”;
name+=”name”;
代码段2：
StringBuffer name=new StringBuffer(“HuangWeiFeng”);
name.append(“is my”);
name.append(“name.”).toString();
因此，充分的利用JAVA提供的库函数来优化程序，对提高JAVA程序的性能时非常重要的.其注意点主要有如下几方面；
（1） 尽可能的使用静态变量（Static Class Variables）
如果类中的变量不会随他的实例而变化，就可以定义为静态变量，从而使他所有的实例都共享这个变量。
例：
public class foo
{
SomeObject so=new SomeObject();
}
就可以定义为：
public class foo
{
static SomeObject so=new SomeObject();
}
（2） 不要对已生成的对象作过多的改变。
对于一些类(如：String类)来讲，宁愿在重新生成一个新的对象实例，而不应该修改已经生成的对象实例。
例：
String name=”Huang”;
name=”Wei”;
name=”Feng”;
上述代码生成了三个String类型的对象实例。而前两个马上就需要系统进行垃圾回收处理。如果要对字符串进行连接的操作，性能将得更差。因为系统将不得为此生成更多得临时变量。如上例1所示。
（3） 生成对象时，要分配给它合理的空间和大小
JAVA中的很多类都有它的默认的空间分配大小。对于StringBuffer类来讲，默认的分配空间大小是16个字符。如果在程序中使用StringBuffer的空间大小不是16个字符，那么就必须进行正确的初始化。
（4） 避免生成不太使用或生命周期短的对象或变量。
对于这种情况，因该定义一个对象缓冲池。以为管理一个对象缓冲池的开销要比频繁的生成和回收对象的开销小的多。
（5） 只在对象作用范围内进行初始化。
JAVA允许在代码的任何地方定义和初始化对象。这样，就可以只在对象作用的范围内进行初始化。从而节约系统的开销。
例：
SomeObject so=new SomeObject();
If(x==1) then
{
Foo=so.getXX();
}
可以修改为：
if(x==1) then
{
SomeObject so=new SomeObject();
Foo=so.getXX();
}
2．异常(Exceptions)
JAVA语言中提供了try/catch来发方便用户捕捉异常，进行异常的处理。但是如果使用不当，也会给JAVA程序的性能带来影响。因此，要注意以下两点。
(1) 避免对应用程序的逻辑使用try/catch
如果可以用if,while等逻辑语句来处理，那么就尽可能的不用try/catch语句
(2) 重用异常
在必须要进行异常的处理时，要尽可能的重用已经存在的异常对象。以为在异常的处理中，生成一个异常对象要消耗掉大部分的时间。
3. 线程(Threading)
一个高性能的应用程序中一般都会用到线程。因为线程能充分利用系统的资源。在其他线程因为等待硬盘或网络读写而 时，程序能继续处理和运行。但是对线程运用不当，也会影响程序的性能。
例2：正确使用Vector类
Vector主要用来保存各种类型的对象（包括相同类型和不同类型的对象）。但是在一些情况下使用会给程序带来性能上的影响。这主要是由Vector类的两个特点所决定的。第一，Vector提供了线程的安全保护功能。即使Vector类中的许多方法同步。但是如果你已经确认你的应用程序是单线程，这些方法的同步就完全不必要了。第二，在Vector查找存储的各种对象时，常常要花很多的时间进行类型的匹配。而当这些对象都是同一类型时，这些匹配就完全不必要了。因此，有必要设计一个单线程的，保存特定类型对象的类或集合来替代Vector类.用来替换的程序如下（StringVector.java）：
public class StringVector
{
private String [] data;
private int count;
public StringVector() { this(10); // default size is 10 }
public StringVector(int initialSize)
{
data = new String[initialSize];
}
public void add(String str)
{
// ignore null strings
if(str == null) { return; }
ensureCapacity(count + 1);
data[count++] = str;
}
private void ensureCapacity(int minCapacity)
{
int oldCapacity = data.length;
if (minCapacity > oldCapacity)
{
String oldData[] = data;
int newCapacity = oldCapacity * 2;
data = new String[newCapacity];
System.arraycopy(oldData, 0, data, 0, count);
}
}
public void remove(String str)
{
if(str == null) { return // ignore null str }
for(int i = 0; i < count; i++)
{
// check for a match
if(data[i].equals(str))
{
System.arraycopy(data,i+1,data,i,count-1); // copy data
// allow previously valid array element be gc'd
data[--count] = null;
return;
}
}
}
public final String getStringAt(int index) {
if(index < 0) { return null; }
else if(index > count)
{
return null; // index is > # strings
}
else { return data[index]; // index is good }
}
/* * * * * * * * * * * * * * * *StringVector.java * * * * * * * * * * * * * * * * */
因此，代码：
Vector Strings=new Vector();
Strings.add(“One”);
Strings.add(“Two”);
String Second=(String)Strings.elementAt(1);
可以用如下的代码替换：
StringVector Strings=new StringVector();
Strings.add(“One”);
Strings.add(“Two”);
String Second=Strings.getStringAt(1);
这样就可以通过优化线程来提高JAVA程序的性能。用于测试的程序如下（TestCollection.java）:
import java.util.Vector;
public class TestCollection
{
public static void main(String args [])
{
TestCollection collect = new TestCollection();
if(args.length == 0)
{
System.out.println(
"Usage: java TestCollection [ vector | stringvector ]");
System.exit(1);
}
if(args[0].equals("vector"))
{
Vector store = new Vector();
long start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++)
{
store.addElement("string");
}
long finish = System.currentTimeMillis();
System.out.println((finish-start));
start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++)
{
String result = (String)store.elementAt(i);
}
finish = System.currentTimeMillis();
System.out.println((finish-start));
}
else if(args[0].equals("stringvector"))
{
StringVector store = new StringVector();
long start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++) { store.add("string"); }
long finish = System.currentTimeMillis();
System.out.println((finish-start));
start = System.currentTimeMillis();
for(int i = 0; i < 1000000; i++) {
String result = store.getStringAt(i);
}
finish = System.currentTimeMillis();
System.out.println((finish-start));
}
}
}
/* * * * * * * * * * * * * * * *TestCollection.java * * * * * * * * * * * * * * * * */
测试的结果如下（假设标准的时间为１，越小性能越好）：
关于线程的操作，要注意如下几个方面。
(1) 防止过多的同步
如上所示，不必要的同步常常会造成程序性能的下降。因此，如果程序是单线程，则一定不要使用同步。
(2) 同步方法而不要同步整个代码段
对某个方法或函数进行同步比对整个代码段进行同步的性能要好。
(3) 对每个对象使用多”锁”的机制来增大并发。
一般每个对象都只有一个”锁”，这就表明如果两个线程执行一个对象的两个不同的同步方法时，会发生”死锁”。即使这两个方法并不共享任何资源。为了避免这个问题，可以对一个对象实行”多锁”的机制。如下所示：
class foo
{
private static int var1;
private static Object lock1=new Object();
private static int var2;
private static Object lock2=new Object();
public static void increment1()
{
synchronized(lock1)
{
var1++;
}
}
public static void increment2()
{
synchronized(lock2)
{
var2++;
}
}
}
4．输入和输出(I/O)
输入和输出包括很多方面，但涉及最多的是对硬盘，网络或数据库的读写操作。对于读写操作，又分为有缓存和没有缓存的；对于数据库的操作，又可以有多种类型的JDBC驱动器可以选择。但无论怎样，都会给程序的性能带来影响。因此，需要注意如下几点：
(1) 使用输入输出缓冲
尽可能的多使用缓存。但如果要经常对缓存进行刷新（flush）,则建议不要使用缓存。
(2) 输出流(Output Stream)和Unicode字符串
当时用Output Stream和Unicode字符串时，Write类的开销比较大。因为它要实现Unicode到字节(byte)的转换.因此，如果可能的话,在使用Write类之前就实现转换或用OutputStream类代替Writer类来使用。
(3) 当需序列化时使用transient
当序列化一个类或对象时，对于那些原子类型（atomic）或可以重建的原素要表识为transient类型。这样就不用每一次都进行序列化。如果这些序列化的对象要在网络上传输，这一小小的改变对性能会有很大的提高。
(4) 使用高速缓存（Cache）
对于那些经常要使用而又不大变化的对象或数据，可以把它存储在高速缓存中。这样就可以提高访问的速度。这一点对于从数据库中返回的结果集尤其重要。
(5) 使用速度快的JDBC驱动器（Driver）
JAVA对访问数据库提供了四种方法。这其中有两种是JDBC驱动器。一种是用JAVA外包的本地驱动器；另一种是完全的JAVA驱动器。具体要使用哪一种得根据JAVA布署的环境和应用程序本身来定。
5.一些其他的经验和技巧
(1) 使用局部变量
(2) 避免在同一个类中动过调用函数或方法(get或set)来设置或调用变量。
(3) 避免在循环中生成同一个变量或调用同一个函数（参数变量也一样）
(4) 尽可能的使用static,final,private等关键字
(5) 当复制大量数据时，使用System.arraycopy()命令。
/************************************************************************************************************************************************************************************************************************************************************8
我先来一帖!(很实用的精华)
在程序运行过程中,也可放在servlet里,获取bean里的相应要求的property的值,这个方法被我用在tag解析时获取用户setAttribute的值,供大家参考!!!
************************ Main.java ************************/
package reflect;
import java.io.*;
public class Main {
public static void main(String[] args) throws IOException{
Bean1 bean1 = new Bean1();
System.out.println( Reflect.get(bean1, "getName", 0) );
System.out.println( Reflect.get(bean1, "getOld", 0) );
System.out.println( Reflect.get(bean1, "getName", 1) );
System.out.println( Reflect.get(bean1, "getOld", 1) );
System.out.println( Reflect.get(bean1, "getName", 2) );
System.out.println( Reflect.get(bean1, "getOld", 2) );
System.out.println( Reflect.get(bean1, "getName", 3) );
System.out.println( Reflect.get(bean1, "getOld", 3) );
System.out.println( Reflect.get(bean1, "getName", 4) );
System.out.println( Reflect.get(bean1, "getOld", 4) );
Bean2 bean2 = new Bean2();
System.out.println( Reflect.get(bean2, "getMember", 0) );
System.out.println( Reflect.get(bean2, "getYear", 0) );
System.out.println( Reflect.get(bean2, "getMember", 1) );
System.out.println( Reflect.get(bean2, "getYear", 1) );
System.out.println( Reflect.get(bean2, "getMember", 2) );
System.out.println( Reflect.get(bean2, "getYear", 2) );
System.out.println( Reflect.get(bean2, "getMember", 3) );
System.out.println( Reflect.get(bean2, "getYear", 3) );
System.out.println( Reflect.get(bean2, "getMember", 4) );
System.out.println( Reflect.get(bean2, "getYear", 4) );
}
}
************************ Reflect.java ************************
package reflect;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class Reflect {
public static String get(Object object, String methodname, int i){
Class cls = object.getClass();
Object ret;
try {
Method method = cls.getMethod(methodname, null);
ret = method.invoke(cls.newInstance(), null);
ArrayList array = new ArrayList();
if (ret.getClass().isArray()) {
ret = Array.get(ret, i);
}
} catch (Exception e) {
ret = null;
}
if(ret == null){
return null;
}
return ret.toString();
}
}
************************ Bean1.java ************************
package reflect;
public class Bean1 {
String[] name = {"赵","钱","孙","李"};
int[] old = {28, 27, 32, 26};
public String[] getName(){
return name;
}
public int[] getOld(){
return old;
}
}
************************ Bean2.java ************************
package reflect;
public class Bean2 {
String[] member = {"张","刘","王","方"};
int[] year = {31, 28, 30, 36};
public String[] getMember(){
return member;
}
public int[] getYear(){
return year;
}
}
大家注意:主要是Reflect.java,你只要将bean的名字和getproperty的名字给他,他就能把数据传回给你,呵呵,很实用!希望大家喜欢!!!
/*******************************************************************************************************************************************************************
DES加密的，文件中共有两
个方法，即加密、解密两个方法。
*/
以下是该文件的详细代码：
package com.pechinsoft.util;
import java.security.*;
import javax.crypto.*;
public class WriteOffDES {
private String Algorithm = "DES";
public WriteOffDES() {
init();
}
public void init() {
Security.addProvider(new com.sun.crypto.provider.SunJCE());
try {
keygen = KeyGenerator.getInstance(Algorithm);
deskey = keygen.generateKey();
c = Cipher.getInstance(Algorithm);
}
catch(NoSuchAlgorithmException ex) {ex.printStackTrace();}
catch(NoSuchPaddingException ex) {ex.printStackTrace();}
}
public byte[] encrypt(String e) {
try {
c.init(Cipher.ENCRYPT_MODE, deskey);
cipherByte = c.doFinal(e.getBytes());
}
catch(java.security.InvalidKeyException ex){ex.printStackTrace();}
catch(javax.crypto.BadPaddingException ex){ex.printStackTrace();}
catch(javax.crypto.IllegalBlockSizeException ex){ex.printStackTrace();}
return cipherByte;
}
public String decrypt(byte[] d) {
try {
c.init(Cipher.DECRYPT_MODE, deskey);
cipherByte = c.doFinal(d);
}
catch(java.security.InvalidKeyException ex){ex.printStackTrace();}
catch(javax.crypto.BadPaddingException ex){ex.printStackTrace();}
catch(javax.crypto.IllegalBlockSizeException ex){ex.printStackTrace();}
return (new String(cipherByte));
}
public String byteTohex(byte[] b) {
String str = "";
String stmp = "";
for(int n=0;n<b.length;n++) {
stmp=(java.lang.Integer.toHexString(b[n] & 0XFF));
if(stmp.length()==1) str = str + "0" + stmp;
else str = str + stmp;
if(n<b.length-1) str = str + ":";
}
return str.toUpperCase();
}
private KeyGenerator keygen;
private SecretKey deskey;
private Cipher c;
private byte[] cipherByte;
}
附运用方法：
<%--TestDES.jsp--%>
<%@ page contentType="text/html; charset=gb2312" %>
<jsp:useBean id="DES" scope="page" class="com.pechinsoft.util.WriteOffDES" />
<html>
<head><title>TestDES File</title></head>
<body bgcolor="#FFFFFF">
<div align="center"><center>
<%
String Num = request.getParameter("Num");
if(Num==null || Num.equals("")) {
%>
<form name="form" action="TestDES.jsp" method="post">
<input type="text" name="Num" size="25" value=""/>
<input type="submit" name="button" value=" 确定 "/>
</form>
<%
}else{
out.println("加密前的数据："+Num +"<br/>");
out.println("加密后的数据："+DES.encrypt(Num) +"<br/>");
out.println("解密后的数据："+DES.decrypt(DES.encrypt(Num)) +"<br/>");
}
%>
</center></div>
</body>
</html>
/*********************************************************************************************************************************************************************
*/
一． Input和Output
1. 关于stream
stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。
在Java的IO中，所有的stream（包括Input和Out stream）都包括两种类型：
1.1 以字节为导向的stream
以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。
以字节为导向的stream包括下面几种类型：
1) Input stream：
(1) ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用
(2) StringBufferInputStream：把一个String对象作为InputStream
(3) FileInputStream：把一个文件作为InputStream，实现对文件的读取操作
(4) PipedInputStream：实现了pipe的概念，主要在线程中使用
(5) SequenceInputStream：把多个InputStream合并为一个InputStream
2) Out stream
(1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
(2) FileOutputStream：把信息存入文件中
(3) PipedOutputStream：实现了pipe的概念，主要在线程中使用
(4) SequenceOutputStream：把多个OutStream合并为一个OutStream
1.2 以Unicode字符为导向的stream
以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往st-
ream中写入信息。以Unicode字符为导向的stream包括下面几种类型：
1) Input Stream
(1) CharArrayReader：与ByteArrayInputStream对应
(2) StringReader：与StringBufferInputStream对应
(3) FileReader：与FileInputStream对应
(4) PipedReader：与PipedInputStream对应
2) Out Stream
(1) CharArrayWrite：与ByteArrayOutputStream对应
(2) StringWrite：无与之对应的以字节为导向的stream
(3) FileWrite：与FileOutputStream对应
(4) PipedWrite：与PipedOutputStream对应
以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实
现的功能相同， 只是在操作时的导向不同。如CharArrayReader：和ByteArrayInputStre-
am的作用都是把内存中的一个缓冲区作为InputStream使用，所不同的是前者每次从内存中
读取一个字节的信息，而后者每次从内存中读取一个字符。
1.3 两种不现导向的stream之间的转换
InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个
以字符为导向的stream。
2. stream添加属性
2.1 “为stream添加属性”的作用
运用上面介绍的Java中操作IO的API，我们就可完成我们想完成的任何操作了。但通过
FilterInputStream和FilterOutStream的子类，我们可以为stream添加属性。 下面以一个
例子来说明这种功能的作用。
如果我们要往一个文件中写入数据，我们可以这样操作：
FileOutStream fs = new FileOutStream(“test.txt”);
然后就可以通过产生的fs对象调用write()函数来往test.txt文件中写入数据了。但是，
如果我们想实现“先把要写入文件的数据先缓存到内存中，再把缓存中的数据写入文件中”
的功能时，上面的API就没有一个能满足我们的需求了。但是通过FilterInputStream和Fi-
lterOutStream的子类，为FileOutStream添加我们所需要的功能。
2.2 FilterInputStream的各种类型
2.2.1 用于封装以字节为导向的InputStream
(1) DataInputStream：从stream中读取基本类型（int、char等）数据。
(2) BufferedInputStream：使用缓冲区
(3) LineNumberInputStream：会记录input stream内的行数，然后可以调用getLineNumbe-
r()和setLineNumber(int)
(4) PushbackInputStream：很少用到，一般用于编译器开发
2.2.2 用于封装以字符为导向的InputStream
(1) 没有与DataInputStream对应的类。除非在要使用readLine()时改用BufferedReader，否
则使用DataInputStream
(2) BufferedReader：与BufferedInputStream对应
(3) LineNumberReader：与LineNumberInputStream对应
(4) PushBackReader：与PushbackInputStream对应
2.3 FilterOutStream的各种类型
2.3.1 用于封装以字节为导向的OutputStream
(1) DataIOutStream：往stream中输出基本类型（int、char等）数据。
(2) BufferedOutStream：使用缓冲区
(3) PrintStream：产生格式化输出
2.3.2 用于封装以字符为导向的OutputStream
(1) BufferedWrite：与对应
(2) PrintWrite：与对应
3. RandomAccessFile
(1) 可通过RandomAccessFile对象完成对文件的读写操作
(2) 在产生一个对象时，可指明要打开的文件的性质：r，只读；w，只写；rw可读写
(3) 可以直接跳到文件中指定的位置
4. I/O应用的一个例子
import java.io.*;
public class TestIO {
public static void main(String[] args) throws IOException{
//1a.以行为单位从一个文件读取数据
BufferedReader in =
new BufferedReader(new FileReader("F:\\nepalon\\TestIO.java"));
String s, s2 = new String();
while((s = in.readLine()) != null)
s2 += s + "\n";
in.close();
//1b. 接收键盘的输入
BufferedReader stdin =
new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter a line:");
System.out.println(stdin.readLine());
//2. 从一个String对象中读取数据
StringReader in2 = new StringReader(s2);
int c;
while((c = in2.read()) != -1)
System.out.println((char)c);
in2.close();
//3. 从内存取出格式化输入
try {
DataInputStream in3 =
new DataInputStream(new ByteArrayInputStream(s2.getBytes()));
while(true)
System.out.println((char)in3.readByte());
}
catch(EOFException e) {
System.out.println("End of stream");
}
//4. 输出到文件
try {
BufferedReader in4 =
new BufferedReader(new StringReader(s2));
PrintWriter out1 =
new PrintWriter(new BufferedWriter(new FileWriter("F:\\nepalon\\TestIO.out")));
int lineCount = 1;
while((s = in4.readLine()) != null)
out1.println(lineCount++ + "：" + s);
out1.close();
in4.close();
}catch(EOFException ex) {
System.out.println("End of stream");
}
//5. 数据的存储和恢复
try {
DataOutputStream out2 =
new DataOutputStream(new BufferedOutputStream(
new FileOutputStream("F:\\nepalon\\Data.txt")));
out2.writeDouble(3.1415926);
out2.writeChars("\nThas was pi:writeChars\n");
out2.writeBytes("Thas was pi:writeByte\n");
out2.close();
DataInputStream in5 =
new DataInputStream(new BufferedInputStream(
new FileInputStream("F:\\nepalon\\ Data.txt")));
BufferedReader in5br =
new BufferedReader(new InputStreamReader(in5));
System.out.println(in5.readDouble());
System.out.println(in5br.readLine());
System.out.println(in5br.readLine());
}catch(EOFException e) {
System.out.println("End of stream");
}
//6. 通过RandomAccessFile操作文件
RandomAccessFile rf =
new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");
for(int i=0; i<10; i++)
rf.writeDouble(i*1.414);
rf.close();
rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();
rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");
rf.seek(5*8);
rf.writeDouble(47.0001);
rf.close();
rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();
}
}
/**********************************************************************************************************************************
关于代码的解释（以区为单位）：
1a区中，当读取文件时，先把文件内容读到缓存中，当调用in.readLine()时，再从缓存中
以字符的方式读取数据（以下简称“缓存字节读取方式”）。
1b区中，由于想以缓存字节读取方式从标准IO（键盘）中读取数据，所以要先把标准IO（
System.in）转换成字符导向的stream，再进行BufferedReader封装。
2区中，要以字符的形式从一个String对象中读取数据，所以要产生一个StringReader类型
的stream。
4区中，对String对象s2读取数据时，先把对象中的数据存入缓存中，再从缓冲中进行读取；
对TestIO.out文件进行操作时，先把格式化后的信息输出到缓存中，再把缓存中的信息输
出到文件中。
5区中，对Data.txt文件进行输出时，是先把基本类型的数据输出屋缓存中，再把缓存中的
数据输出到文件中；对文件进行读取操作时，先把文件中的数据读取到缓存中，再从缓存
中以基本类型的形式进行读取。注意in5.readDouble()这一行。因为写入第一个writeDo-
uble()，所以为了正确显示。也要以基本类型的形式进行读取。
6区是通过RandomAccessFile类对文件进行操作。
/************************************************************************************************************************************************
做为小斑竹，我先来帖一个吧
这个类用来根据表结构生成INSERT和UPDATE语句，自己用的非常好用！
有很多不完善的地方需要修改，我没时间。在另一个ASP的项目里我采用这个思想写的比较完善~
希望大家学思想！！！也希望高手能把自己的好方法帖上来大家共享！！！
package ct.util;
import java.sql.ResultSet;
import java.sql.SQLException;
import pub.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import pub.DBConnect;
import java.util.Vector;
public class DbUtil {
public DbUtil() {
}
public static boolean CheckForType(String colType) {
if (colType.equals("LONG"))
return true;
else
return false;
}
public static String CheckForInsert(String colType, String parametervalue) {
if (CheckForType(colType))
return parametervalue;
else
return "'" + parametervalue + "'";
}
/*
*/
public static String BuildInsertSql(String tableName,
HttpServletRequest request,int head,int offal) {
try {
String bsql = "";
String sql = "select * from " + tableName + " limit 1";
DBConnect conn = new DBConnect();
ResultSet rs = conn.executeQuery(sql);
bsql = "insert into " + tableName +" (" ;
for (int i = head+1; i <= rs.getMetaData().getColumnCount()-offal; i++) {
bsql +=rs.getMetaData().getColumnName(i)+",";
}
bsql = bsql.substring(0, bsql.length() - 1);
bsql+=") values (";
for (int i = head+1; i <= rs.getMetaData().getColumnCount()-offal; i++) {
bsql +=
CheckForInsert(rs.getMetaData().getColumnTypeName(i),
request.
getParameter(rs.getMetaData().getColumnName(i))) +
",";
}
bsql = bsql.substring(0, bsql.length() - 1);
bsql += ")";
conn.close();
//System.out.println(bsql);
return bsql;
}
catch (Exception e) {
e.printStackTrace();
}
return null;
}
/*
*/
public static String CheckForUpdate(String colType, String parameter,
String parametervalue) {
if (CheckForType(colType))
return parameter + "=" + parametervalue;
else
return parameter + "=" + "'" + parametervalue + "'";
}
public static String BuildUpdateSql(String tableName,
HttpServletRequest request,int head,int offal) {
try {
String bsql = "";
String sql = "select * from " + tableName + " limit 1";
DBConnect conn = new DBConnect();
ResultSet rs = conn.executeQuery(sql);
bsql = "update " + tableName + " set ";
for (int i = head+1; i <= rs.getMetaData().getColumnCount()-offal; i++) {
bsql +=
CheckForUpdate(rs.getMetaData().getColumnTypeName(i),
rs.getMetaData().getColumnName(i),
request.getParameter(rs.getMetaData().getColumnName(i))) +
",";
}
bsql = bsql.substring(0, bsql.length() - 1);
bsql += " where id=" + request.getParameter("id");
//System.out.println(bsql);
conn.close();
return bsql;
}
catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
/*******************************************************************************************************************************************************************88
import java.util.*;
/**
* 用于处理画面翻页的类
* <p>Copyright: 2003</p>
* @author Filippo Guan
* @version 1.0
*/
public class ListPage {
private List totalList;
private int currentPageNum;
private int totalPageNum;
private int limit;
public ListPage(List _totalList,int _pageLimit) {
if (_totalList == null) {
totalList = new ArrayList();
}
else {
totalList = _totalList;
}
limit = _pageLimit;
currentPageNum = 1;
totalPageNum = totalList.size()%limit==0 ? totalList.size()/limit : totalList.size()/limit+1;
}
public ListPage(){
this(new ArrayList());
}
public ListPage(List _totalList){
this(_totalList,10);
}
public void clear(){
this.totalList = new Vector();
currentPageNum = 1;
totalPageNum = 0;
}
public int size(){
return totalList.size();
}
public List getTotalList(){
return totalList;
}
public int getTotalPageNum(){
if (totalList == null) return 0;
totalPageNum = totalList.size()%limit==0 ? totalList.size()/limit : totalList.size()/limit+1;
return this.totalPageNum;
}
public int getPageLimit(){
return limit;
}
public void setPageLimit(int _Limit){
limit = _Limit;
}
// -----------------------------------------------------------
public Object getLineObject(int _LineNum){
if (totalList == null) return null;
Object retObj = totalList.get((currentPageNum-1)*limit + _LineNum - 1);
return retObj;
}
// -----------------------------------------------------------
public void setCurrentPageNum(int _currentPageNum){
currentPageNum = _currentPageNum;
}
public int getCurrentPageNum(){
return currentPageNum;
}
public boolean hasPreviousPage(){
return currentPageNum > 1;
}
public boolean hasNextPage(){
return currentPageNum < totalPageNum;
}
public List getCurrentPage(){
return getPage(currentPageNum);
}
public List getFirstPage(){
return this.getPage(1);
}
public List getLastPage(){
return this.getPage(totalPageNum);
}
public List getPreviousPage(){
if (!hasPreviousPage()) throw new NullPointerException("Has not Previous page");
return this.getPage(currentPageNum - 1);
}
public List getNextPage(){
if (!hasNextPage()) throw new NullPointerException("Has not Next page");
return this.getPage(currentPageNum + 1);
}
public List turnPreviousPage(){
this.currentPageNum--;
return this.getCurrentPage();
}
public List turnNextPage(){
this.currentPageNum++;
return this.getCurrentPage();
}
public List turnFirstPage(){
this.currentPageNum = 1;
return this.getCurrentPage();
}
public List turnLastPage(){
this.currentPageNum = this.totalPageNum;
return this.getCurrentPage();
}
// -----------------------------------------------------------
public List getPage(int _pageNum){
Vector vec = new Vector();
for(int i=(_pageNum-1)*limit;i<_pageNum*limit && i<totalList.size();i++){
vec.add(totalList.get(i));
}
return vec;
}
public boolean isFirstPage(int _pageNum){
return _pageNum == 1;
}
public boolean isLastPage(int _pageNum){
return _pageNum == totalPageNum;
}
public static void main(String[] args) {
Vector tryVec = new Vector();
for (int i=0;i<49;i++){
tryVec.add("test" + Integer.toString(i));
}
ListPage page = new ListPage(tryVec,10);
System.err.println("MaxPage=" + page.getTotalPageNum());
if (page.hasNextPage()) page.turnNextPage();
Vector retVec = new Vector(page.getCurrentPage());
try{
System.in.read();
} catch (Exception e){
}
}
}
/***********************************************************************************************************************************************************************88
数据库中字段id递增问题
我的代码如下：添加数据时实现数据库中字段id递增1；
String id="1";
ResultSet rs=stmt.executeQuery("select * from product");
if (!rs.next())
id="1";
else
{
rs.last();
id=rs.getString("id");
id=String.valueOf(Integer.parseInt(id)+1);
rs.close();
}
//下面写插入语句
当数据库中没有记录时，也就是加第一条记录时会出现java.lang.NumberFormatException:这种错误，如果数据库中有记录，也就是加的不
是第一条记录时，可以正常添加，没有任何错误，请问大侠为什么 啊？
不甚感激！！！
---------------------------------------------------------------
怀疑你的条件没起作用，不管是不是有记录都走的else
if (!rs.next())
id="1";
else
{
rs.last();
id=rs.getString("id");
id=String.valueOf(Integer.parseInt(id)+1);
rs.close();
}
改成
while(rs.next()) {
rs.last();
id=rs.getString("id");
id=String.valueOf(Integer.parseInt(id)+1);
rs.close();
}
---------------------------------------------------------------
改成
while(rs.next()) {
rs.last();
id=rs.getString("id");
if(id==null | |id.equals(""))
id="1";
else
id=String.valueOf(Integer.parseInt(id)+1);
rs.close();
}
---------------------------------------------------------------
oracle中没有“自增字段”类型，不过可以用其它方法实现，下面是用sequence实现
第一步：建立sequence变量
create sequence sequence_id
说明：该语句作为sql语句在建表之时直接运行，create sequence是关键字，就像create table一样，sequence_id是你自己取的名字，最好和你表中的递增字段名相关
第二步：在插入数据时引用sequence
insert mytable(id,name) values(sequence_id.nextVal,'sandm')
说明：nextVal用于获得sequence的下一个值，即让其递增
/********************************************************************************************************************************************************************************************
package com.oa.util;
/**
* <p>Title: 电子政务系统</p>
* <p>Description: 浏览器认证</p>
* <p>Copyright: Copyright (c) 2004</p>
* <p>Company: </p>
* @author
* @version 1.0
*/
public final class Base64 {
static private final int BASELENGTH = 255;
static private final int LOOKUPLENGTH = 63;
static private final int TWENTYFOURBITGROUP = 24;
static private final int EIGHTBIT = 8;
static private final int SIXTEENBIT = 16;
static private final int SIXBIT = 6;
static private final int FOURBYTE = 4;
static private final byte PAD = (byte) '=';
static private byte[] base64Alphabet = new byte[BASELENGTH];
static private byte[] lookUpBase64Alphabet = new byte[LOOKUPLENGTH];
static {
for (int i = 0; i < BASELENGTH; i++) {
base64Alphabet[i] = -1;
}
for (int i = 'Z'; i >= 'A'; i--) {
base64Alphabet[i] = (byte) (i - 'A');
}
for (int i = 'z'; i >= 'a'; i--) {
base64Alphabet[i] = (byte) (i - 'a' + 26);
}
for (int i = '9'; i >= '0'; i--) {
base64Alphabet[i] = (byte) (i - '0' + 52);
}
base64Alphabet['+'] = 62;
base64Alphabet['/'] = 63;
for (int i = 0; i <= 25; i++) {
lookUpBase64Alphabet[i] = (byte) ('A' + i);
}
for (int i = 26, j = 0; i <= 51; i++, j++) {
lookUpBase64Alphabet[i] = (byte) ('a' + j);
}
for (int i = 52, j = 0; i <= 61; i++, j++) {
lookUpBase64Alphabet[i] = (byte) ('0' + j);
}
}
static boolean isBase64(byte octect) {
//shall we ignore white space? JEFF??
return (octect == PAD || base64Alphabet[octect] != -1);
}
static boolean isArrayByteBase64(byte[] arrayOctect) {
int length = arrayOctect.length;
if (length == 0) {
return false;
}
for (int i = 0; i < length; i++) {
if (Base64.isBase64(arrayOctect[i]) == false) {
return false;
}
}
return true;
}
/**
* Encodes hex octects into Base64
*
* @param binaryData Array containing binaryData
* @return Encoded Base64 array
*/
public static byte[] encode(byte[] binaryData) {
int lengthDataBits = binaryData.length * EIGHTBIT;
int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
byte encodedData[] = null;
if (fewerThan24bits != 0) { //data not divisible by 24 bit
encodedData = new byte[ (numberTriplets + 1) * 4];
}
else { // 16 or 8 bit
encodedData = new byte[numberTriplets * 4];
}
byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
int encodedIndex = 0;
int dataIndex = 0;
int i = 0;
for (i = 0; i < numberTriplets; i++) {
dataIndex = i * 3;
b1 = binaryData[dataIndex];
b2 = binaryData[dataIndex + 1];
b3 = binaryData[dataIndex + 2];
l = (byte) (b2 & 0x0f);
k = (byte) (b1 & 0x03);
encodedIndex = i * 4;
encodedData[encodedIndex] = lookUpBase64Alphabet[b1 >> 2];
encodedData[encodedIndex + 1] = lookUpBase64Alphabet[ (b2 >> 4) |
(k << 4)];
encodedData[encodedIndex + 2] = lookUpBase64Alphabet[ (l << 2) |
(b3 >> 6)];
encodedData[encodedIndex + 3] = lookUpBase64Alphabet[b3 & 0x3f];
}
// form integral number of 6-bit groups
dataIndex = i * 3;
encodedIndex = i * 4;
if (fewerThan24bits == EIGHTBIT) {
b1 = binaryData[dataIndex];
k = (byte) (b1 & 0x03);
encodedData[encodedIndex] = lookUpBase64Alphabet[b1 >> 2];
encodedData[encodedIndex + 1] = lookUpBase64Alphabet[k << 4];
encodedData[encodedIndex + 2] = PAD;
encodedData[encodedIndex + 3] = PAD;
}
else if (fewerThan24bits == SIXTEENBIT) {
b1 = binaryData[dataIndex];
b2 = binaryData[dataIndex + 1];
l = (byte) (b2 & 0x0f);
k = (byte) (b1 & 0x03);
encodedData[encodedIndex] = lookUpBase64Alphabet[b1 >> 2];
encodedData[encodedIndex + 1] = lookUpBase64Alphabet[ (b2 >> 4)
| (k << 4)];
encodedData[encodedIndex + 2] = lookUpBase64Alphabet[l << 2];
encodedData[encodedIndex + 3] = PAD;
}
return encodedData;
}
/**
* Decodes Base64 data into octects
* @param base64Data binaryData Byte array containing Base64 data
* @return Array containind decoded data.
*/
public byte[] decode(byte[] base64Data) {
int numberQuadruple = base64Data.length / FOURBYTE;
byte decodedData[] = null;
byte b1 = 0, b2 = 0, b3 = 0, b4 = 0, marker0 = 0, marker1 = 0;
// Throw away anything not in base64Data
// Adjust size
int encodedIndex = 0;
int dataIndex = 0;
decodedData = new byte[numberQuadruple * 3 + 1];
for (int i = 0; i < numberQuadruple; i++) {
dataIndex = i * 4;
marker0 = base64Data[dataIndex + 2];
marker1 = base64Data[dataIndex + 3];
b1 = base64Alphabet[base64Data[dataIndex]];
b2 = base64Alphabet[base64Data[dataIndex + 1]];
if (marker0 != PAD && marker1 != PAD) { //No PAD e.g 3cQl
b3 = base64Alphabet[marker0];
b4 = base64Alphabet[marker1];
decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
decodedData[encodedIndex + 1] = (byte) ( ( (b2 & 0xf) << 4) | (
(b3 >> 2) & 0xf));
decodedData[encodedIndex + 2] = (byte) (b3 << 6 | b4);
}
else if (marker0 == PAD) { //Two PAD e.g. 3c[Pad][Pad]
decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
decodedData[encodedIndex + 1] = (byte) ( (b2 & 0xf) << 4);
decodedData[encodedIndex + 2] = (byte) 0;
}
else if (marker1 == PAD) { //One PAD e.g. 3cQ[Pad]
b3 = base64Alphabet[marker0];
decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
decodedData[encodedIndex + 1] = (byte) ( ( (b2 & 0xf) << 4) | (
(b3 >> 2) & 0xf));
decodedData[encodedIndex + 2] = (byte) (b3 << 6);
}
encodedIndex += 3;
}
return decodedData;
}
static final int base64[] = {
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 64, 64, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64,
64, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 64,
64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
};
public static String base64Decode(String orig) {
char chars[] = orig.toCharArray();
StringBuffer sb = new StringBuffer();
int i = 0;
int shift = 0; // # of excess bits stored in accum
int acc = 0;
for (i = 0; i < chars.length; i++) {
int v = base64[chars[i] & 0xFF];
if (v >= 64) {
if (chars[i] != '=') {
System.out.println("Wrong char in base64: " + chars[i]);
}
}
else {
acc = (acc << 6) | v;
shift += 6;
if (shift >= 8) {
shift -= 8;
sb.append( (char) ( (acc >> shift) & 0xff));
}
}
}
return sb.toString();
}
}
/*********************************************************************************************************************************
import java.util.*;
/**
* 处理字符串相关功能的类
* <p>Copyright: 2003</p>
* @author Filippo Guan
* @version 1.0
*/
public class StringFunction {
private String str;
public StringFunction(String _Str) {
str = _Str;
}
/**
* 将字符串扩充到长度为num，如果超过长度则去除超过的部分，否则则在前补0
* @param num 指定扩充到的长度
* @return 返回的字串
*/
public String updateZero(int num) {
return updateChar(num, '0');
}
public synchronized static String updateZero(String str, int num) {
return new StringFunction(str).updateZero(num);
}
/**
* 将字符串扩充到长度为num，如果超过长度则去除超过的部分，
* 否则则在前面不上某个字符
* @param num 指定扩充到的长度
* @param c 补上的字符
* @return 返回的字串
*/
public String updateChar(int num, char c) {
if (str.length() == num) {
return str;
}
else if (str.length() < num) {
for (int i = str.length(); i < num; i++) {
str = c + str;
}
return str;
}
else {
return str.substring(str.length() - num);
}
}
/**
* 如果字符串为空，则返回一个" "符号
* @param s 传入的字串
* @return 返回的字串
*/
public synchronized static String getHtmlFormat(String s) {
if (s != null) {
if (s.trim().equals("")) {
return " ";
}
else {
return s.trim();
}
}
else {
return " ";
}
}
/**
* 保证字符串可以转化为数值型，若不能则返回"0"
* @param s 传入的字串
* @return 返回的字串
*/
public synchronized static String getNumberFormat(Object o) {
if (o == null) {
return "0";
}
String s = o.toString();
try {
double dou = Double.parseDouble(s);
}
catch (Exception e) {
return "0";
}
return s;
}
public static double getDouble(Object o) {
return Double.parseDouble(getNumberFormat(o));
}
public static long getLong(Object o) {
return (long) getDouble(o);
}
public static int getInt(Object o) {
return (int) getDouble(o);
}
public static float getFloat(Object o) {
return (float) getDouble(o);
}
/**
* 把一个字符串转换成字符串YYYYMMDDHHMISS的形式
* @param _date 传入的字串
* @return 返回的字串
*/
public static synchronized String getDateTimeFormat(String _date) {
if (_date == null) {
return "";
}
if (_date.length() == 8) {
_date += "000000";
}
if (_date.length() == 14) {
return _date;
}
if (_date.length() > 14) {
return _date.substring(0, 4)
+ _date.substring(5, 7)
+ _date.substring(8, 10)
+ _date.substring(11, 13)
+ _date.substring(14, 16)
+ _date.substring(17, 19);
}
return "";
}
/**
* 获取一个字符串的绝对长度(如果遇到汉字字符则算两个)
* @param s 传入的字串
* @return 字串的绝对长度
*/
public static int absoluteLength(String s) {
if (s == null) {
return 0;
}
try {
return new String(s.getBytes("GB2312"), "8859_1").length();
}
catch (Exception e) {
return s.length();
}
}
/**
* 对一个字符串的绝对长度进行拆解(如果遇到汉字字符会把它当作两个字符处理)
* @param s 传入的字串
* @param start 起始绝对位置
* @param end 终止绝对位置
* @return 返回的字串
*/
public static String absoluteSubstring(String s, int start, int end) {
if (s == null) {
return null;
}
try {
String s2 = new String(s.getBytes("GB2312"), "8859_1");
s2 = s2.substring(start, end);
return new String(s2.getBytes("8859_1"), "GB2312");
}
catch (Exception e) {
return s.substring(start, end);
}
}
/**
* 扩充一个字串，使其绝对长度为指定的长度，如果过长就截断，过短就补充指定的字串
* @param str 传入的字串
* @param updateStr 填充的字串
* @param num 指定的长度
* @param flag 填补字符串的位置：true的话在前面填补、false在后面填补
* @return 返回的字串
*/
public static String updateAbsoluteLength(
String str,
String updateStr,
int num,
boolean flag) {
if (updateStr == null) {
return str;
}
if (str == null) {
str = "";
for (int i = 0; i < num; i++) {
str += updateStr;
}
return str;
}
if (absoluteLength(str) == num) {
return str;
}
else if (absoluteLength(str) < num) {
for (int i = absoluteLength(str); i < num; i++) {
if (flag) {
str = updateStr + str;
}
else {
str = str + updateStr;
}
}
return str;
}
else {
return absoluteSubstring(str, 0, absoluteLength(str) - num);
}
}
public static String updateAbsoluteLength(
String str,
String updateStr,
int num) {
return updateAbsoluteLength(str, updateStr, num, true);
}
public static void main(String[] args) {
String c = new String("管振宇");
String c2 = new String("刘蓓丽");
String c3 = new String("administrator");
System.out.println(StringFunction.updateAbsoluteLength(c, "& ", 28));
System.out.println(StringFunction.updateAbsoluteLength(c2, "& ", 28));
System.out.println(StringFunction.updateAbsoluteLength(c3, "& ", 28));
}
}
/*******************************************************************************************************************************************************************8
IE缓存jsp文件
1、使用java提供的方法，在jsp或者servlet中都可以
<%
response.setHeader("Pragma","No-cache");
response.setHeader("Cache-Control","no-cache");
response.setDateHeader("Expires", 0);
%>
2|、使用HTML标记，如下面：
<HEAD>
<META HTTP-EQUIV="Pragma" CONTENT="no-cache">
<META HTTP-EQUIV="Cache-Control" CONTENT="no-cache">
<META HTTP-EQUIV="Expires" CONTENT="0">
</HEAD>
/********************************************************************************************************************************************88
Md5 算法java实现！
import java.security.*;
import java.math.*;
public class TestMd5
{
public String MD5(String sInput) throws Exception{
String algorithm="";
//输入不能为空
if(sInput.trim()==null){
return "null";
}
//指定采用MD5算法
try{
algorithm=System.getProperty("MD5.algorithm","MD5");
}catch(SecurityException se){
}
//定义MessageDigest对象
MessageDigest md=MessageDigest.getInstance(algorithm);
//按照系统缺省的字符编码方式把sInput 转换成字节，并把结果存到一新的字节数组buffer中
byte buffer[]=sInput.getBytes();
//从指定的字节数组buffer的偏移量0开始，用指定的字节数组修改由sInput生成摘要
//count为从 0 开始用的字节数长度。
for(int count=0;count<sInput.length();count++)
{
md.update(buffer,0,count);
}
//通过执行最后的诸如填充的操作完成散列码的计算。 在调用之后复位该摘要
//返回存放结果散列值的字节数组bDigest
byte bDigest[]=md.digest();
//将bDigest转换为大整数bi
BigInteger bi=new BigInteger(bDigest);
//返回bi字符串表示，即最终的编码结果
return(bi.toString(16));
}
public static void main(String [] a)
{
TestMd5 my = new TestMd5();
try
{
System.out.println(my.MD5("abc"));
//50f260602273676bfc60ab35352d8d40 //111
//-19da6a11674a7aeac2537831e54963c4 //abc
}catch (Exception e){}
}
}
/**************************************************************************************************************************************************************************************************************
解决多国语言..
1、根据系统默认的语言设置读取参数值的类Resource：
package i18n.article;
import java.io.*;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Locale;
import java.util.PropertyResourceBundle;
import java.util.ResourceBundle;
/**
* <p>Title:多国语言的后台实现类 </p>
* <p>Description: 根据属性文件及区域与语言设置,得到对应的语言</p>
* <p>Copyright: Copyright (c) 2003</p>
* <p>Company: Timer Corporation</p>
* @author:宋兆辉
* @version 1.0
*/
public class Resource {
private static final String HEAD_FILE = "ATTR"; //属性文件名的前缀
private static final String LAST_FILE=".properties"; //属性文件名的后缀
private static final String FILE_PATH="c://"; //定义属性文件存放的目录
public Resource() {
}
/*以下是根据传入的属性文件中的"键",而得到与区域与语言设置相对应的"值"*/
public synchronized String srcStr(String disStr) {
String ret = "";
try {
Locale locale = Locale.getDefault(); //获取系统的区域与语言默认设置
System.out.println("");
String baseName = new StringBuffer()
.append(HEAD_FILE).append("_").append(locale.toString())
.append(LAST_FILE).toString(); //根据local属性,前缀以及后缀生成文件名
String fileName = new StringBuffer(FILE_PATH).append(baseName)
.toString(); //获取文件的完整路径
InputStream is = new FileInputStream(fileName); //生成文件输入流
PropertyResourceBundle pr = new PropertyResourceBundle(is); //根据输入流构造PropertyResourceBundle的实例
ret = pr.getString(disStr);
if(locale.equals(Locale.CHINA)){
ret = new String(ret.getBytes("ISO-8859-1"),"GB2312");
} //如果是要显示中文,则要进行内码的转换
is.close();
return ret;
}
catch (Exception e) {
e.printStackTrace();
return disStr;
}
}
}
2、对应的properties文件：ATTR.properties和ATTR_zh_CN.properties
（1）ATTR_en_US.properties：
LoginName=login name
Password=password
Login=login
LoginTime=loginTime
LogOff=logout
ChineseVersion=English Version
MainPage=home
SoftWare=softWare
Hardware=Hardware
YourLocationMainPage=YourLocationMainPage
MyCalendar=MyCalendar
MyMails=MyMails
R&D=R&D
Forum=Forum
DeveloperProcess=DeveloperProcess
TechnologyCommunion=TechnologyCommunion
(2)ATTR_zh_CN.properties：
LoginName=用户
Password=密码
Login=登陆
LoginTime=登陆时间
LogOff=注销登陆
ChineseVersion=中文版
MainPage=首页
SoftWare=软件
Hardware=硬件
YourLocationMainPage=当前位置：首页
MyCalendar=我的日程
MyMails=我的邮件
R&D=研发区
Forum=讨论区
DeveloperProcess=开发进程
TechnologyCommunion=技术交流
3、对应的jsp文件：
本例中有3个jsp页面：
(1)login.jsp:(登陆页面)
图1-登陆页面_中文
图2—登陆页面_英文
<%@ page contentType="text/html; charset=GB2312" %>
<HTML>
<HEAD>
<TITLE></TITLE>
<link href="css/style.css" rel="stylesheet" type="text/css">
<script language = javascript>
function focusIt() {
window.document.login.loginName.focus();
}
</script>
</HEAD>
<jsp:useBean id="resource" scope="application" class="i18n.article.Resource"/>
<BODY οnlοad="javascript:focusIt();" bgcolor="#ffffff">
<form name="login" method="post" action="main.jsp">
<table border=0 cellpadding=0 cellspacing=0 align=center>
<tr>
<td height="150"></td></tr>
<tr>
<td width=262><img alt="" border=0 src="images/cover_r1_c1.jpg"></td>
<td> </td>
<td>
<table border=0 cellpadding=1 cellspacing=1>
<tr>
<td>
<p align=right><%=resource.srcStr("LoginName")%></p></td>
<td><input type=text name="loginName" ID=Text1></td></tr>
<tr>
<td>
<p align=right><%=resource.srcStr("Password")%></p></td>
<td><input type=password name="password" ID=Password1></td></tr>
<tr>
<td> </td>
<td align=center>
<input class="button" type=submit value=" <%=resource.srcStr("Login")%> " ID=Submit1></td></tr>
</table>
</td></tr>
<tr>
<td colspan=3><img alt="" border=0
src="images/cover_r2_c1.jpg"></td></tr>
<tr>
<td colspan=3><img alt="" border=0
src="images/cover_r3_c1.jpg"></td></tr>
<tr>
<td colspan=3 height=20> </td>
</tr>
<tr>
<td colspan=3 align=center><font color="#c0c0c0">Best Viewed In IE5.0 Or Up ,1024x768</font></td>
</tr>
<tr>
<td colspan=3><hr size=1 width="100%" color="#c0c0c0"></td>
</tr>
<tr>
<td colspan=3 align=center>© 2003 Corporation. All rights reserved.</td>
</tr>
</table>
</form>
</BODY>
</HTML>
图3-主页面_中文
图3主页面_英文
(2)main.jsp：（主页面左边及上边部分）
%@ page contentType="text/html; charset=GB2312" %>
<jsp:useBean id="resource" scope="application" class="i18n.article.Resource"/>
<HTML>
<HEAD>
<TITLE></TITLE>
<META NAME="GENERATOR" Content="Microsoft Visual Studio">
<META HTTP-EQUIV="Content-Type" content="text/html; charset=UTF-8">
<LINK rel="stylesheet" href="css/style.css" type="text/css">
</HEAD>
<BODY topMargin=2 leftMargin=2 bgcolor="#ffffff">
<TABLE WIDTH="100%" HEIGHT="100%" BORDER="0" CELLSPACING="0" CELLPADDING="0">
<tr>
<td height=80>
<%
String loginName = request.getParameter("loginName");
%>
<table width=100% height=100% cellpadding=0 cellspacing=0 border=0>
<tr>
<td width=163 rowspan=3><img src="images/system_logo.jpg" border=0></td>
<td width=30 rowspan=3><img src="images/logo_linked_corner.gif" border=0></td>
<td width=140><img src="images/logo_extended_bar.jpg" border=0></td>
<td height=25 bgcolor="#95ADD3" align=right class="P1">
<%=resource.srcStr("LoginTime")%><%=new java.util.Date().toLocaleString()%>
<%=resource.srcStr("LoginName")%><%=loginName%>
<img src="images/logout.gif" align="absMiddle" border=0>
<a href="login.jsp"><%=resource.srcStr("LogOff")%></a>
<img src="images/row_ender.jpg" align="absMiddle" border=0></td>
</tr>
<tr><td height=30 colspan=2><p>
<a href="#"><%=resource.srcStr("MainPage")%></a> |
<a href="#"><%=resource.srcStr("SoftWare")%></a> |
<a href="#"><%=resource.srcStr("Hardware")%></a> | </p></td></tr>
<tr><td height=25 colspan=2<%=resource.srcStr("YourLocationMainPage")%>></td></tr>
</table>
</td>
</tr>
<tr>
<td>
<table width=100% height=100% cellpadding=0 cellspacing=0 border=0>
<tr>
<td width=165 valign=top>
<table width=100% cellpadding=0 cellspacing=0 border=0>
<tr><td colspan=2><img src="images/left_menu_top.jpg" border=0></td></tr>
<tr><td width=35 align=left><img src="images/left_menu_colbar.jpg" border=0></td>
<td width=130 align=left valign=top>
<table width=100% cellpadding=0 cellspacing=0 border=0>
<tr><td style="cursor:hand;"><p><%=resource.srcStr("MyCalendar")%></p></td></tr>
<tr><td><hr size=1 width=100% color="#C6FF00"></td></tr>
<tr><td style="cursor:hand;"><p><%=resource.srcStr("MyMails")%></p></td></tr>
<tr><td><hr size=1 width=100% color="#C6FF00"></td></tr>
<tr><td style="cursor:hand;"><p><%=resource.srcStr("DeveloperProcess")%></p></td></tr>
<tr><td><hr size=1 width=100% color="#C6FF00"></td></tr>
<tr><td style="cursor:hand;"><p><%=resource.srcStr("TechnologyCommunion")%></p></td></tr>
<tr><td><hr size=1 width=100% color="#C6FF00"></td></tr>
<tr><td style="cursor:hand;"><p><%=resource.srcStr("Forum")%></p></td></tr>
<tr><td><hr size=1 width=100% color="#C6FF00"></td></tr>
<tr><td style="cursor:hand;"><p><%=resource.srcStr("R&D")%></p></td></tr>
<tr><td><hr size=1 width=100% color="#C6FF00"></td></tr>
</table>
</td>
</tr>
</table>
</td>
<td><IFRAME frameBorder=0 id=main name=main scrolling=auto src="version.jsp"
style="HEIGHT: 100%; VISIBILITY: inherit; WIDTH: 100%; Z-INDEX: 1"></IFRAME></td>
</tr>
</table>
</td>
</tr>
<tr>
<td height=50 valign=top>
<table width=100% cellpadding=0 cellspacing=0 border=0>
<tr><td align=center><hr size=1 width=80% color="#95ADD3"></td></tr>
<tr><td align=center>?2003 Corporation. All rights reserved.</td></tr>
</table>
</td>
</tr>
</TABLE>
</BODY>
</HTML>
(3)version.jsp：(主页面的中间部分)
<%@ page contentType="text/html; charset=GBK" %>
<jsp:useBean id="resource" scope="application" class="i18n.article.Resource"/>
<HTML>
<HEAD>
<TITLE></TITLE>
<META HTTP-EQUIV="Content-Type" content="text/html; charset=UTF-8">
</HEAD>
<BODY leftMargin="0" topMargin="0">
<table width="100%" height="100%" cellpadding=0 cellspacing=0 border=0>
<tr>
<td align=center valign=middle colspan=2>
<table align="center" border="0" cellspacing="3" cellpadding="5" style="filter:dropshadow(color=gray,offx=5,offy=5,positive=1);">
<tr>
<td width=400 height=100 bgcolor="#CBD3EA" align="center" style="border: 1px #0A246A solid;">
<p><font color="#5c6bac" style="font-size:30px;"><b><%=resource.srcStr("ChineseVersion")%></b></font></p>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<td width=50% valign=top align=center> </td>
<td width=50% height=155 align=center><img src="images/internationalization.jpg"></td>
</tr>
</table>
</BODY>
</HTML>
/************************************************************************************************************************************************************
支持一下，request 工具
package com.commons.util;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletContext;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.ServletConfig;
import java.io.IOException;
/**
* request工具类
*
* @author
* @version 1.0
*/
public class RequestUtil {
private RequestUtil() {
}
public static Object requsetGetObject(HttpServletRequest req, String name) {
Object result = req.getAttribute(name);
if (result == null) {
result = req.getParameter(name);
}
return result;
}
public static String requestGetString(HttpServletRequest req, String name) {
String result = (String) req.getAttribute(name);
if (result == null) {
result = req.getParameter(name);
}
return result;
}
public static String requestGetString(HttpServletRequest req, String name, String defaultValue) {
String result = (String) req.getAttribute(name);
if (result == null) {
result = req.getParameter(name);
}
if (result == null) {
result = defaultValue;
}
return result;
}
public static int requestGetInt(HttpServletRequest req, String name) {
String result = requestGetString(req, name);
if (result != null) {
Integer i = new Integer(result);
return i.intValue();
}
return 0;
}
public static double requestGetDouble(HttpServletRequest req, String name) {
String result = requestGetString(req, name);
if (result != null) {
Double d = new Double(result);
return d.doubleValue();
}
return 0;
}
public static boolean requestGetBoolean(HttpServletRequest req, String name) {
String result = requestGetString(req, name);
if (result != null) {
Boolean b = new Boolean(result);
return b.booleanValue();
}
return false;
}
public static String[] requestGetArray(HttpServletRequest req, String name) {
String[] sa = null;
if (sa == null) {
sa = req.getParameterValues(name);
}
return sa;
}
public static void forward(ServletConfig sc, HttpServletRequest req, HttpServletResponse res, String toUrl) throws
ServletException, IOException {
ServletContext ctx = sc.getServletContext();
RequestDispatcher dispatcher = ctx.getRequestDispatcher(toUrl);
dispatcher.forward(req, res);
}
public static void include(ServletConfig sc, HttpServletRequest req, HttpServletResponse res, String toUrl) throws
ServletException, IOException {
ServletContext ctx = sc.getServletContext();
RequestDispatcher dispatcher = ctx.getRequestDispatcher(toUrl);
dispatcher.include(req, res);
}
public static String requestGetUrl(HttpServletRequest request) {
String contextPath = request.getContextPath();
String servletPath = request.getServletPath();
String queryString = request.getQueryString();
if (queryString == null || queryString.equals(""))
return contextPath + servletPath;
else
return contextPath + servletPath + "?" + queryString;
}
public static String requestGetCleanUrl(HttpServletRequest request) {
String contextPath = request.getContextPath();
String servletPath = request.getServletPath();
return contextPath + servletPath;
}
}
/********************************************************************************************************************************************
右键菜单的淡入淡出效果
<HTML><HEAD><TITLE>右键菜单的淡入淡出效果</TITLE>
<META content="text/html; charset=gb2312" http-equiv=Content-Type>
<SCRIPT language=JavaScript>
<!-- // RightClickMenu
var intDelay=10; //设置菜单显示速度，越大越慢
var intInterval=5; //每次更改的透明度
function showmenuie5(){
var rightedge=document.body.clientWidth-event.clientX
var bottomedge=document.body.clientHeight-event.clientY
if (rightedge<ie5menu.offsetWidth)
ie5menu.style.left=document.body.scrollLeft+event.clientX-ie5menu.offsetWidth
else
ie5menu.style.left=document.body.scrollLeft+event.clientX
if (bottomedge<ie5menu.offsetHeight)
ie5menu.style.top=document.body.scrollTop+event.clientY-ie5menu.offsetHeight
else
ie5menu.style.top=document.body.scrollTop+event.clientY
ie5menu.style.visibility="visible"
//ie5menu.style.visibility=""
ie5menu.filters.alpha.opacity=0
GradientShow()
return false
}
function hidemenuie5(){
//ie5menu.style.visibility="hidden"
GradientClose()
}
function highlightie5(){
if (event.srcElement.className=="menuitems"){
event.srcElement.style.backgroundColor="highlight"
event.srcElement.style.color="white"
}
}
function lowlightie5(){
if (event.srcElement.className=="menuitems"){
event.srcElement.style.backgroundColor=""
event.srcElement.style.color="#000000"
}
}
function jumptoie5(){
if (event.srcElement.className=="menuitems"){
if (event.srcElement.url != ''){
if (event.srcElement.getAttribute("target")!=null)
window.open(event.srcElement.url,event.srcElement.getAttribute("target"))
else
window.location=event.srcElement.url
}
}
}
function GradientShow() //实现淡入的函数
{
ie5menu.filters.alpha.opacity+=intInterval
if (ie5menu.filters.alpha.opacity<100) setTimeout("GradientShow()",intDelay)
}
function GradientClose() //实现淡出的函数
{
ie5menu.filters.alpha.opacity-=intInterval
if (ie5menu.filters.alpha.opacity>0) {
setTimeout("GradientClose()",intDelay)
}
else {
ie5menu.style.visibility="hidden"
}
}
function ChangeBG() //改变菜单项的背景颜色，这里的两种颜色值可以改为你需要的
{
oEl=event.srcElement
if (oEl.style.background!="navy") {
oEl.style.background="navy"
}
else {
oEl.style.background="#cccccc"
}
}
// -->
</SCRIPT>
<style type=text/css>
.cMenu {
FILTER: alpha(opacity=0);BACKGROUND-COLOR: #D6D3CE;BORDER-BOTTOM: #666666 2px solid; BORDER-LEFT: #E4E4E4 2px solid; BORDER-RIGHT: #666666 2px solid; BORDER-TOP: #E4E4E4 2px solid; COLOR: #000000; CURSOR: default; FONT-SIZE: 9pt; color:#000000;FONT-WEIGHT: normal; LINE-HEIGHT: 20px; POSITION: absolute; VISIBILITY: hidden; WIDTH: 110px
}
.menuitems {
font-size:9pt;
MARGIN: 2px;
PADDING-BOTTOM: 0px;
PADDING-LEFT: 15px;
PADDING-RIGHT: 3px;
PADDING-TOP: 0px;
}
</style>
<META content="Microsoft FrontPage 4.0" name=GENERATOR>
</HEAD>
<BODY>
<OBJECT classid=CLSID:8856F961-340A-11D0-A96B-00C04FD705A2 height=0 id=WebBrowser width=0>
</OBJECT>
<RIGHTCLICK><!--[if IE]>
<DIV class=cMenu id=ie5menu οnclick=jumptoie5() οnmοuseοut=lowlightie5()
οnmοuseοver=highlightie5()>
<DIV class=menuitems url="javascript:click_obj(0)">后退</DIV>
<DIV class=menuitems url="javascript:click_obj(1)">前进</DIV>
<DIV class=menuhr><hr style="width:100%"></DIV>
<DIV class=menuitems url="javascript:click_obj(2)">刷新</DIV>
<DIV class=menuitems url="javascript:click_obj(3)">加入收藏夹</DIV>
<DIV class=menuitems url="javascript:click_obj(4)">查看源文件</DIV>
<DIV class=menuhr><hr style="width:100%"></DIV>
<DIV class=menuitems url="javascript:click_obj(5)">属性</DIV>
</DIV>
<![endif]-->
<SCRIPT language=JavaScript>
<!--
function click_obj(id){
switch(id){
case 0:
history.back()
break
case 1:
history.forward()
break
case 2:
window.location.reload()
break
case 3:
window.external.AddFavorite(location.href, document.title)
break
case 4:
window.location = "view-source:" + window.location.href
break
case 5:
document.all.WebBrowser.ExecWB(10,1)
break
}
}
if (document.all&&window.print){
ie5menu.className="cMenu"
document.οncοntextmenu=showmenuie5
document.body.οnclick=hidemenuie5
}
//-->
</SCRIPT>
</RIGHTCLICK>
</BODY></HTML>
/********************************************************************************************************************************************88
不准确的页面loging
<script>
var text="正在载入文档";i=0;
function load() {
if (i<6) {
text+=".";
Waiting.innerText=text;
i++;}
else {text="正在载入文档";i=0;}}
timer=window.setInterval("load()",300);
</script>
/*****************************************************************************************************************************************
不准确的页面loging
<script>
var text="正在载入文档";i=0;
function load() {
if (i<6) {
text+=".";
Waiting.innerText=text;
i++;}
else {text="正在载入文档";i=0;}}
timer=window.setInterval("load()",300);
</script>
/*********************************************************************************************************************88
我贴一个限制输入类型的，代码如下：
function KeyInput(flag,sTag){
var rtn=false;
if(sTag!=""){
for(var i=0;i<sTag.length;i++){
if (event.keyCode==sTag.charCodeAt(i))
rtn=true;
}
}
if (flag==0){//只输入数字
if((event.keyCode>=48)&&(event.keyCode<=57))
rtn=true;
}
else if (flag==1){//只输入字母
if(((event.keyCode>=65)&&(event.keyCode<=90)) ||
((event.keyCode>=97)&&(event.keyCode<=122)))
rtn=true;
}
else if (flag==2){//输入字母和数字
if( ( (event.keyCode>=65)&&(event.keyCode<=90 ) ) ||
( (event.keyCode>=97)&&(event.keyCode<=122) ) ||
( (event.keyCode>=48)&&(event.keyCode<=57 ) ) )
rtn=true;
}
else{//所有
rtn=true;
}
event.returnValue=rtn;
}
/***************************************************************************************************************************
获得随机数(String型)，代码如下：
import java.util.*;
import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
/**
* 一个获得随机数的类
* <p>Copyright: 2004</p>
* @author Filippo Guan
* @version 1.1
*/
public class RandomStr
{
static String randomstr;
static boolean allchars = false;
//欠缺是8位字符串
static Integer length = new Integer(8);
static HashMap hmap;
static ArrayList lower = null;
static ArrayList upper = null;
static char[] single = null;
static int singlecount = 0;
static boolean singles = false;
static String algorithm = null;
static String provider = null;
static boolean secure = false;
static Random random = null;
static SecureRandom secrandom = null;
private static float getFloat()
{
if (random == null)
{
return secrandom.nextFloat();
}
else
{
return random.nextFloat();
}
}
public static void generateRandomObject() throws Exception
{
// check to see if the object is a SecureRandom object
if (secure)
{
try
{
// get an instance of a SecureRandom object
if (provider != null)
{
random = SecureRandom.getInstance(algorithm, provider);
}
else
{
random = SecureRandom.getInstance(algorithm);
}
}
catch (NoSuchAlgorithmException ne)
{
throw new Exception(ne.getMessage());
}
catch (NoSuchProviderException pe)
{
throw new Exception(pe.getMessage());
}
}
else
{
random = new Random();
}
}
/**
* generate the random string
*/
private static void generaterandom()
{
if (allchars)
{
for (int i = 0; i < length.intValue(); i++)
{
randomstr = randomstr + new Character((char)((int) 34 +((int)(getFloat() * 93)))).toString();
}
}
else if (singles)
{
// check if there are single chars to be included
if (upper.size() == 3)
{
// check for the number of ranges max 3 uppercase lowercase digits build the random string
for (int i = 0; i < length.intValue(); i++)
{
// you have four groups to choose a random number from, to make
// the choice a little more random select a number out of 100 get a random number even or odd
if (((int) (getFloat() * 100)) % 2 == 0)
{
// the number was even get another number even or odd
if (((int) (getFloat() * 100)) % 2 == 0)
{
// choose a random char from the single char group
randomstr = randomstr + randomSingle().toString();
}
else
{
// get a random char from the first range
randomstr = randomstr + randomChar((Character)lower.get(2),(Character)upper.get(2)).toString();
}
}
else
{
// the number was odd
if (((int) (getFloat() * 100)) % 2 == 0)
{
// choose a random char from the second range
randomstr = randomstr + randomChar((Character)lower.get(1),(Character)upper.get(1)).toString();
}
else
{
// choose a random char from the third range
randomstr = randomstr + randomChar((Character)lower.get(0),(Character)upper.get(0)).toString();
}
}
}
}
else if (upper.size() == 2)
{
// single chars are to be included choose a random char from
// two different ranges build the random char from single chars and two ranges
for (int i = 0; i < length.intValue(); i++)
{
// select the single chars or a range to get each random charfrom
if (((int)(getFloat() * 100)) % 2 == 0)
{
// get random char from the single chars
randomstr = randomstr + randomSingle().toString();
}
else if (((int) (getFloat() * 100)) % 2 == 0)
{
// get the random char from the first range
randomstr = randomstr + randomChar((Character)lower.get(1),(Character)upper.get(1)).toString();
}
else
{
// get the random char from the second range
randomstr = randomstr + randomChar((Character)lower.get(0),(Character)upper.get(0)).toString();
}
}
}
else if (upper.size() == 1)
{
// build the random string from single chars and one range
for (int i = 0; i < length.intValue(); i++)
{
if (((int) getFloat() * 100) % 2 == 0)
{
// get a random single char
randomstr = randomstr + randomSingle().toString();
}
else
{
// get a random char from the range
randomstr = randomstr + randomChar((Character)lower.get(0),(Character)upper.get(0)).toString();
}
}
}
else
{
// build the rand string from single chars
for (int i = 0; i < length.intValue(); i++)
{
randomstr = randomstr + randomSingle().toString();
}
}
}
else
{
// no single chars are to be included in the random string
if (upper.size() == 3)
{
// build random strng from three ranges
for (int i = 0; i < length.intValue(); i++)
{
if (((int) (getFloat() * 100)) % 2 == 0)
{
// get random char from first range
randomstr = randomstr + randomChar((Character)lower.get(2),(Character)upper.get(2)).toString();
}
else if (((int) (getFloat() * 100)) % 2 == 0)
{
// get random char form second range
randomstr = randomstr + randomChar((Character)lower.get(1),(Character)upper.get(1)).toString();
}
else
{
// get random char from third range
randomstr = randomstr + randomChar((Character)lower.get(0),(Character)upper.get(0)).toString();
}
}
}
else if (upper.size() == 2)
{
// build random string from two ranges
for (int i = 0; i < length.intValue(); i++)
{
if (((int) (getFloat() * 100)) % 2 == 0)
{
// get random char from first range
randomstr = randomstr + randomChar((Character)lower.get(1),(Character)upper.get(1)).toString();
}
else
{
// get random char from second range
randomstr = randomstr + randomChar((Character)lower.get(0),(Character)upper.get(0)).toString();
}
}
}
else
{
// build random string
for (int i = 0; i < length.intValue(); i++)
{
// get random char from only range
randomstr = randomstr + randomChar((Character)lower.get(0),(Character)upper.get(0)).toString();
}
}
}
}
/**
* generate a random char from the single char list
*
* @returns - a randomly selscted character from the single char list
*
*/
private static Character randomSingle()
{
return (new Character(single[(int)((getFloat() * singlecount) - 1)]));
}
/**
* generate a random character
*
* @param lower lower bound from which to get a random char
* @param upper upper bound from which to get a random char
*
* @returns - a randomly generated character
*
*/
private static Character randomChar(Character lower, Character upper)
{
int tempval;
char low = lower.charValue();
char up = upper.charValue();
// get a random number in the range lowlow - lowup
tempval = (int)((int)low + (getFloat() * ((int)(up - low))));
// return the random char
return (new Character((char) tempval));
}
/**
* get the randomly created string for use with the
* <jsp:getProperty name=<i>"id"</i> property="randomstr"/>
*
* @return - randomly created string
*
*/
public static String getRandom()
{
randomstr = new String();
generaterandom(); // generate the first random string
if (hmap != null)
{
while (hmap.containsKey(randomstr))
{
// random string has already been created generate a different one
generaterandom();
}
hmap.put(randomstr, null); // add the new random string
}
return randomstr;
}
/**
* set the ranges from which to choose the characters for the random string
*
* @param low set of lower ranges
* @param up set of upper ranges
*
*/
public static void setRanges(ArrayList low, ArrayList up)
{
lower = low;
upper = up;
}
/**
* set the hashmap that is used to check the uniqueness of random strings
*
* @param map hashmap whose keys are used to insure uniqueness of random strgs
*
*/
public static void setHmap(HashMap map)
{
hmap = map;
}
/**
* set the length of the random string
*
* @param value length of the random string
*
*/
public static void setLength(String value)
{
length = new Integer(value);
}
/**
* set the algorithm name
*
* @param value name of the algorithm to use for a SecureRandom object
*
*/
public static void setAlgorithm(String value)
{
algorithm = value;
secure = true; // a SecureRandom object is to be used
}
/**
* set the provider name
*
* @param value name of the package to check for the algorithm
*
*/
public static void setProvider(String value)
{
provider = value;
}
/**
* set the allchars flag
*
* @param value boolean value of the allchars flag
*
*/
public static void setAllchars(boolean value)
{
allchars = value;
}
/**
* set the array of single chars to choose from for this random string and the
* number of chars in the array
*
* @param chars the array of single chars
* @param value the number of single chars
*
*/
public static void setSingle(char[] chars, int value)
{
single = chars; // set the array of chars
singlecount = value; // set the number of chars in array single
singles = true; // set flag that single chars are in use
}
public static void setCharset(String value)
{
// values tells the method whether or not to check for single chars
boolean more = true;
// create the arraylists to hold the upper and lower bounds for the char
// ranges
lower = new ArrayList(3);
upper = new ArrayList(3);
// user has chosen to use all possible characters in the random string
if (value.compareTo("all") == 0)
{
allchars = true; // set allchars flag
// all chars are to be used so there are no single chars to sort
// through
more = false;
}
else if ((value.charAt(1) == '-') && (value.charAt(0) != '\\'))
{
// run through the ranges at most 3
while (more && (value.charAt(1) == '-'))
{
// check to make sure that the dash is not the single char
if (value.charAt(0) == '\\')
{
break;
}
else
{
// add upper and lower ranges to there list
lower.add(new Character(value.charAt(0)));
upper.add(new Character(value.charAt(2)));
}
// check to see if there is more to the charset
if (value.length() <= 3)
{
more = false;
}
else
{
// create a new string so that the next range if there is one
// starts it
value = value.substring(3);
}
}
}
// if more = false there are no single chars in the charset
if (more)
{
single = new char[30]; // create single
// create a set of tokens from the string of single chars
StringTokenizer tokens = new StringTokenizer(value);
while (tokens.hasMoreTokens())
{
// get the next token from the string
String token = tokens.nextToken();
if (token.length() > 1)
{
// char is a - add it to the list
single[singlecount++] = '-';
}
// add the current char to the list
single[singlecount++] = token.charAt(0);
}
}
if ((lower == null) && (single == null))
setCharset("a-zA-Z0-9");
}
}
关于使用:可以获得0-9 a-z A-Z 中的随机数.
RandomStr.setCharset("0-9"); //范围
RandomStr.setLength("8"); //长度
RandomStr.generateRandomObject();
随机数(字符型) = RandomStr.getRandom();
/************************************************************************************************************************************************************************
/* 将当前日期加减n天数。
* 如传入字符型"-5" 意为将当前日期减去5天的日期
* 如传入字符型"5" 意为将当前日期加上5天后的日期
* 返回字串 例(1999-02-03)
*/
public String dateAdd(String to)
{
//日期处理模块 (将日期加上某些天或减去天数)返回字符串
int strTo;
try {
strTo = Integer.parseInt(to);
}
catch (Exception e) {
System.out.println("日期标识转换出错! : \n:::" + to + "不能转为数字型");
e.printStackTrace();
strTo = 0;
}
Calendar strDate = Calendar.getInstance(); //java.util包
strDate.add(strDate.DATE, strTo); //日期减 如果不够减会将月变动
//生成 (年-月-日) 字符串
String meStrDate = strDate.get(strDate.YEAR) + "-" +
String.valueOf(strDate.get(strDate.MONTH)+1) + "-" + strDate.get(strDate.DATE);
return meStrDate;
}
/******************************************************************************************************************************************88
JSP中文件上传
一、前言
文件上载对于任何web应用程序都是一个很有用处的功能。比如，在基于web的email中使用文件上载在消息中加入附件；在技术支持站点可以使用文件上载接收从用户处发来的错误日志和缺陷报告文档；在web应用中使用文件上载，通过友好的web界面在用户间共享文件。本文将对如何在JSP编程中上载文件进行讨论，并给出解决方法。
二、文件上载的方式
在TCP/IP中最早出现的文件上载机制是FTP，它是将文件由客户端发送到服务器的标准机制。它很可靠，能够考虑到跨平台的文本和二进制格式文件。但在JSP编程中不能使用FTP方法来上载文件，这是由JSP的运行机制所决定的。我们知道：JSP（JavaServer Pages）是由Sun MicroSystems公司倡导、许多公司参与，一起建立的一种动态网页技术标准。它在传统的网页HTML文件中加入JAVA程序片段和JSP标记就构成了JSP网页。web服务器在遇到访问JSP网页请求时，首先执行其中的程序片段，然后将执行结果以HTML形式返回客户。这种运行机制就要求客户与服务器的联系需要使用HTTP协议而不能是FTP协议。
在HTTP协议中上载文件主要有两种机制：
1）RFC1867方式：RFC1867在作为标准发布之前首先被Netscape的Navigator 2.0中采用。随后被Microsoft的IE3.0的附件和IE3.03的一部分使用。它是一种简单实用的方法。只在表单字段中定义一个file类型的input：
<input type="file">
并且在表单本身中加入了不同的编码方案，它不再使用典型的：
<form action="test.jsp" method="post">
而是使用
<form action="test.jsp" method="post" enctype="multipart/form-data">
这种编码方案在传送大量数据时比缺省的"application/x-url-encoded"表单编码方案要效率高得多。因为URL编码只有很有限的字符集。当使用任何超出字符集的字符时，必须用"%nn"代替（这里的nn表示相应的两个十进制数）。这样即使是普通的空格字符也要用"%20"代替。那么，通过URL编码方式上载的文件将会是原来的2-3倍大。而使用RFC1867编码方式则只是在传送数据的周围加上很简单的头部来标识文件内容。
2）put方式：在HTTP1.1中引入了一个新的HTTP动词：put。当web服务器收到一个HTTP的put请求和对象名字（如："/myweb/images/x.gif"）时，它会验证用户，接收HTTP流的内容，并把它直接存入web服务器。由于这种方式可能会对一个web站点造成破坏，因而并不常用。而且它也失去了web服务器端的最大优势：服务器的可编程性。在使用put方式时，服务器自己处理客户的请求，没有空间让JSP介入，因此，此方式对于JSP应用开发都是毫无用处的。
三、JSP中实现文件上载的方法
从以上分析中我们可以得出结论：RFC1867是在JSP编写的web应用程序中实现文件上载的最好方法。它是如何在实际应用的呢？
这里将介绍一种简单而实用的方法，只需要几行代码就可以在JSP程序中实现文件上载。这就是使用一个免费的JAVA组件JspSmartUpload（http://www.jspsmart.com）实现文件上载。
1） JspSmartUpload的配置要求
安装JspSmartUpload组件需要如下的配置：
a. web服务器（如IIS，apache等）
b. JDK1.1.2以上的JAVA编译器
c. 支持JSP1.1及JavaServelet API 2.2的引擎。
其中的JSP引擎有许多产品，如：
Tomcat: http://java.sun.com/products/jsp/tomcat
Allaire Jrun: http://www.allaire.com/products/jrun
JSWDK: http://java.sun.com/produces/jsp/
IBM webSphere: http://www-4.ibm.com/software/webservers/
Resin: http://www.caucho.com
注意：本文将主要讨论JspSmartUpload在Tomcat引擎中的安装及使用。
2） JspSmartUpload的安装
首先， 把下载的压缩文件JspSmartUpload.zip解压缩到/tomcat/webapps/ 目录下（/tomcat目录是你的tomcat引擎安装的根目录），这样就会形成如下的目录结构/tomcat/webapps/jspsmartupload/。所有必需的文件都在这个目录下。
其次，把如下内容粘贴到/tomcat/conf/server.xml文件中。
<Context path="/jspsmartupload" docBase="/tomcat/webapps/jspsmartupload"
defaultSessionTimeOut="30" isWARExpanded="true" isWARValidated="false" isInvokerEnabled="true" isWorkDirPersistent="false" />
最后，把如下的内容粘贴到/tomcat/conf/uniworkermap.properties文件中。
/jspsmartupload/*.jsp=ajp12
/jspsmartupload/servlet/*=ajp12
至此，jspsmartupload在tomcat引擎中的安装就完成了。
3） 上载文件的HTML表单
如前所述，在JSP中文件上载使用的是RFC1867标准。在其中也规定了上载文件所使用的HTML表单的格式。此表单的格式被Netscape 3和Microsoft IE3.02以上的浏览器所支持。上载文件的表单发布具备如下的格式：
a) 单所使用的方法必须是post
b) 在action属性中的执行程序必须能处理由客户端返回的数据
c) 表单必须使用MIME类型：multipart/form-data
d) 表单必须至少包含一个<input type=”file”>元素。与RFC1867兼容的浏览器将会在客户端界面上显示一个文本框和一个“游览”按钮，以方便客户端选择上载的文件。
下面是使用此类型表单的HTML文件例子。
upload.htm
<HTML>
<BODY BGCOLOR="white">
<H1>jspUpload : Sample </H1>
<HR>
<form METHOD="POST" ACTION="/jspsmartupload/upload.jsp" NAME="PW" ENCTYPE="multipart/form-data">
<table CELLSPACING="0" CELLPADDING="3" BORDER="1" WIDTH="474">
<!-- FILE -->
<tr>
<td><small><font face="Verdana">
Select a first file :
</font></small></td>
<td><small><font face="Verdana">
<input TYPE="file" name="FILE1"></font></small></td>
</tr>
<tr>
<td><small><font face="Verdana">Select a second file : </font></small></td>
<td><small><font face="Verdana">
<input TYPE="file" name="FILE2"></font></small></td>
</tr>
<!-- TEXT -->
<tr>
<td width="150"><div align="left"><p><small><font face="Verdana">Text : </font></small></td>
<td width="324"><small><font face="Verdana"><input TYPE="TEXT" name="myText" value=""><br></font></small></td>
</tr>
<!-- SUBMIT -->
<tr>
<td colspan="2" width="474"><div align="center"><center><p><small><font face="Verdana"><input
TYPE="Submit"> </font></small></td>
</tr>
</table>
</form>
</BODY>
</HTML>
4） 使用JspSmartUpload处理表单
当客户端submit表单以后，服务器将会调用表单action中的JSP程序处理客户端的请求。在此JSP中就要调用JspSmartUpload来完成文件上载的请求。
在JSP程序中，首先要在<%@ page import=my.class %>中声明引入JspSmartUpload类。然后使用JavaBean来实例化一个JspSmartUpload类。如：<jsp:useBean id=”mybean” class=”my.class”>。在实例化后，要使用JSP引擎隐含的对象pageContext对JspSmartUpload JavaBean进行初使化，这样就把客户端的请求传给了JspSmartUpload组件。然后使用组件的upload()方法对客户的请求进行分析，最后把这些数据通过save()方法存入一个文件。
下面是处理上一个HTML表单的JSP例程。
upload.jsp
<%@page language="java" import="com.jspsmart.upload.*"%>
<jsp:useBean id="myUpload" scope="page" class="com.jspsmart.upload.SmartUpload" />
<HTML>
<BODY BGCOLOR="white">
<H1>jspUpload : Sample</H1>
<HR>
<%
// 初使化
myUpload.initialize(pageContext);
// 分析客户数据
myUpload.upload();
//
// 处理上载文件
//
out.println("<BR><STRONG>关于文件的信息</STRONG><BR>");
out.println("上载文件的数量 = " + myUpload.getFiles().getCount() + "<BR>");
//out.println("文件大小 (bytes) = " + myUpload.getFiles().getSize() +"<BR>");
for (int i=0;i<myUpload.getFiles().getCount();i++){
out.print(myUpload.getFiles().getFile(i).getFieldName());
if (!myUpload.getFiles().getFile(i).isMissing())
out.print(" = " + myUpload.getFiles().getFile(i).getFileName() + " (" + myUpload.getFiles().getFile(i).getSize() + ")");
else
out.print(" = 空");
out.println("<BR>");
}
//
// 处理客户请求信息
//
out.println("<BR><BR><STRONG>显示客户表单数据</STRONG><BR>");
// 显示请求名
java.util.Enumeration e = myUpload.getRequest().getParameterNames();
// 得到请求的值
while (e.hasMoreElements()) {
String key = (String)e.nextElement();
String[] values = myUpload.getRequest().getParameterValues(key);
// 显示请求的值
for(int i = 0; i < values.length; i++) {
out.print(key + " = ");
out.print(values[i] + "<BR>");
}
}
%>
</BODY></HTML>
5） 运行例程
把上述的HTML表单例子及处理表单的JSP例程存到/tomcat/webapps/uspsmartupload/目录下，然后运行/tomcat/bin/startup.bat启动服务器。在IE或Netscape的地址栏中输入：
http://localhost:8080/jspsmartupload/jspupload.htm
就可以看到运行结果了。
四、结论
JspSmartUpload组件不仅可以把客户端的数据存入到文件中，也可以把它存入到数据库中。而且，它的安装及使用方法简单易学，是一个非常好的上传组件，可以给JSP编制的web应用程序提供更强大的功能。
/***********************************************************************************************************************************************************************************************************************************************88
检查日期的函数，大家常用把。
function checkDate(obj_YMD,obj_nm){
date_flg = "0";
intYMD = fgetdata(obj_YMD);
intY = intYMD.substr(0,4);
intM = intYMD.substr(4,2);
intD = intYMD.substr(6,2);
if (intYMD.length != 0){
if (intYMD.length < 8 || intYMD.length > 8){
alert(obj_nm + "的位数不正确。");
obj_YMD.focus();
date_flg="1";
}
chkstr = "0123456789";
if (date_flg == "0") {
for (var i=0; i< intY.length; i++){
if ( chkstr.indexOf(intY.charAt(i)) == -1){
alert(obj_nm + "的年不正确。");
obj_YMD.focus();
date_flg="1";
break;
}
}
}
if (date_flg == "0") {
for (var i=0; i< intM.length; i++){
if ( chkstr.indexOf(intM.charAt(i)) == -1){
alert(obj_nm + "的月不正确。");
obj_YMD.focus();
date_flg="1";
break;
}
}
}
if (date_flg == "0") {
for (var i=0; i< intD.length; i++){
if ( chkstr.indexOf(intD.charAt(i)) == -1){
alert(obj_nm + "的日不正确。");
obj_YMD.focus();
date_flg="1";
break;
}
}
}
if (date_flg=="0" && intY < 1){
alert(obj_nm + "的年不正确。");
obj_YMD.focus();
date_flg="1";
}
if (date_flg=="0" && (intM > 12 || intM < 1)){
alert(obj_nm + "的月不正确。");
obj_YMD.focus();
date_flg="1";
}
if (date_flg=="0" && (intD > 31 || intD < 1)){
alert(obj_nm + "的日不正确。");
obj_YMD.focus();
date_flg="1";
}
Yper4 = intY % 4;
Yper100 = intY % 100;
Yper400 = intY % 400;
if (date_flg=="0" && (Yper4 == 0 && Yper100 != 0 && intM == 2 && intD >= 30)){
alert(intY+"年的2月是29日。");
obj_YMD.focus();
date_flg="1";
}
if (date_flg=="0" && (Yper400 == 0 && intM == 2 && intD >= 30)){
alert(intY+"年的2月是29日。");
obj_YMD.focus();
date_flg="1";
}
if (date_flg=="0" && (Yper4 != 0 && Yper100 != 0 && Yper400 != 0 && intM == 2 && intD >= 29)){
alert(intY+"年的2月是28日。");
obj_YMD.focus();
date_flg="1";
}
if (date_flg=="0" && (((intM == 4)||(intM == 6)||(intM == 9)||(intM == 11)) && intD >= 31)){
alert(intM+"月是30日。");
obj_YMD.focus();
date_flg="1";
}
}
return date_flg;
}
/*******************************************************************************************************************************************************************
/************************************************
* <p>Copyright: 2003</p>
* @author Filippo Guan
* javascript正则表达式检验
*************************************************
*/
//校验是否全由数字组成
function isDigit(s)
{
var patrn=/^[0-9]{1,20}$/;
if (!patrn.exec(s)) return false;
return true;
}
//校验登录名：只能输入4-20个以字母开头、可带数字、“_”、“.”的字串
function isRegisterUserName(s)
{
var patrn=/^[a-zA-Z]{1}([a-zA-Z0-9]|[._]){3,19}$/;
if (!patrn.exec(s)) return false;
return true;
}
//校验用户姓名：只能输入1-30个以字母开头的字串
function isTrueName(s)
{
var patrn=/^[a-zA-Z]{1,30}$/;
if (!patrn.exec(s)) return false;
return true;
}
//校验密码：只能输入6-20个字母、数字、下划线
function isPasswd(s)
{
var patrn=/^(\w){6,20}$/;
if (!patrn.exec(s)) return false;
return true;
}
//校验普通电话、传真号码：可以“+”开头，除数字外，可含有“-”
function isTel(s)
{
//var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?(\d){1,12})+$/;
var patrn=/^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$/;
if (!patrn.exec(s)) return false;
return true;
}
//校验手机号码：必须以数字开头，除数字外，可含有“-”
function isMobile(s)
{
var patrn=/13[0,1,2,3,4,5,6,7,8,9]\d{8}/;
if (!patrn.exec(s)) return false;
return true;
}
//校验手机号码(移动)：必须以数字开头，除数字外，可含有“-”
function isCMCCMobile(s)
{
var patrn=/13[5,6,7,8,9]\d{8}/;
if (!patrn.exec(s)) return false;
return true;
}
//校验手机号码(联通)：必须以数字开头，除数字外，可含有“-”
function isUNICOMMobile(s)
{
var patrn=/13[0,1,2,3,4]\d{8}/;
if (!patrn.exec(s)) return false;
return true;
}
//校验邮政编码
function isPostalCode(s)
{
//var patrn=/^[a-zA-Z0-9]{3,12}$/;
var patrn=/^[a-zA-Z0-9 ]{3,12}$/;
if (!patrn.exec(s)) return false;
return true;
}
//校验搜索关键字
function isSearch(s)
{
var patrn=/^[^`~!@#$%^&*()+=|\\\][\]\{\}:;\'\,.<>/?]{1}[^`~!@$%^&()+=|\\\][\]\{\}:;\'\,.<>?]{0,19}$/;
if (!patrn.exec(s)) return false;
return true;
}
//校验IP
function isIP(s)
{
var patrn=/^[0-9.]{1,20}$/;
if (!patrn.exec(s)) return false;
return true;
}
/*************************************************************************************************************************8
//*******************************************************************************/
// * @(#)FileUtils.java
// * @version 1.0
// * @description 常用目录文件操作类
// * @author Filippo Guan
//*******************************************************************************//
import java.io.*;
public class FileUtils
{
public FileUtils()
{
}
public static void copy(File src, File dest, boolean cover)
throws IOException
{
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(dest);
byte buf[] = new byte[1024];
int i;
try
{
while((i = fis.read(buf)) >= 0)
{
fos.write(buf, 0, i);
}
}
finally
{
try
{
fis.close();
}
catch(Exception exception1)
{
}
try
{
fos.close();
}
catch(Exception exception2)
{
}
}
}
public static void copy(String src, String dest, boolean cover) throws IOException
{
File fsrc = new File(src);
File fdest = new File(dest);
copy(fsrc,fdest,cover);
}
public static void copytree(File src, File dest, boolean cover) throws IOException
{
if(src.isFile())
{
copy(src, dest, cover);
}
else
{
File children[] = src.listFiles();
for(int i = 0; i < children.length; i++)
{
File f = new File(dest, children[i].getName());
if(children[i].isDirectory())
{
f.mkdirs();
copytree(children[i], f, cover);
}
else
{
copy(children[i], f, cover);
}
}
}
}
public static void copytree(String src, String dest, boolean cover) throws IOException
{
File fsrc = new File(src);
File fdest = new File(dest);
copytree(fsrc,fdest,cover);
}
public static void movetree(File src, File dest, boolean cover) throws IOException
{
copytree(src, dest, cover);
deltree(src);
}
public static void deltree(File f)
{
File children[] = f.listFiles();
if(children != null && children.length != 0)
{
for(int i = 0; i < children.length; i++)
{
deltree(children[i]);
}
}
f.delete();
}
public static void deltree(String path)
{
File f = new File(path);
deltree(f);
}
public static void move(String src, String dest, boolean cover) throws IOException
{
File fsrc = new File(src);
File fdest = new File(dest);
copy(fsrc,fdest,cover);
fsrc.delete();
}
public static boolean find(File root, FileFilter filter)
{
if(filter.accept(root))
{
return true;
}
File children[] = root.listFiles();
if(children == null || children.length == 0)
{
return false;
}
for(int i = 0; i < children.length; i++)
{
if(find(children[i], filter))
{
return true;
}
}
return false;
}
public static boolean contains(File file, String suffix)
{
if(!file.exists() || !file.isDirectory())
{
return false;
}
File children[] = file.listFiles();
for(int i = 0; i < children.length; i++)
{
if(children[i].isFile() && children[i].getName().endsWith(suffix))
{
return true;
}
}
return false;
}
//读取单行文件内容
public static String getFline(String filePath)
{
String fc = null;
try
{
BufferedReader f = new BufferedReader(new FileReader(filePath));
fc = f.readLine();
f.close();
}
catch (IOException e)
{
System.out.println("readLine problem, terminating.");
}
return fc;
}
//读取单行文件内容并加一写入返回
public static String getIline(String filePath)
{
String fc = null;
try
{
BufferedReader f = new BufferedReader(new FileReader(filePath));
fc = f.readLine();
long l = Long.parseLong(fc);
l++;
fc = String.valueOf(l);
f.close();
BufferedWriter bw = new BufferedWriter(new FileWriter(filePath));
bw.write(fc + "\n");
bw.flush();
bw.close();
}
catch (IOException e)
{
System.out.println("readLine problem, terminating.");
}
return fc;
}
public static String getFileExt(String fileName)
{
String ext = "";
int dot = fileName.lastIndexOf(".");
if (dot != -1)
{
ext = fileName.substring(dot + 1);
}
return ext;
}
public static String getFullFileName(String filePath)
{
String fileName = filePath;
int i = filePath.lastIndexOf("/");
if (i != -1)
{
fileName = filePath.substring(i + 1);
}
return fileName;
}
public static String getFileName(String filePath)
{
String fileName = filePath;
int i = filePath.lastIndexOf("/");
int j = filePath.lastIndexOf(".");
if (i != -1)
{
fileName = filePath.substring(i + 1, j);
}
return fileName;
}
public static String getPath(String filePath)
{
String path = "";
int i = filePath.lastIndexOf("/");
if (i != -1)
{
path = filePath.substring(0,i);
}
return path;
}
public static boolean WriteTo(String path, String info)
{
try
{
File f = new File(path);
PrintWriter out = new PrintWriter(new FileWriter(f));
out.print(info);
out.close();
return true;
}
catch (IOException e)
{
return false;
}
}
//追加字符串
public static boolean Append(String path,String info)
{
try
{
File f = new File(path);
PrintWriter out;
FileWriter theFile;
if (f.exists())
{
theFile = new FileWriter(path,true);
out = new PrintWriter(theFile);
}
else
{
theFile = new FileWriter(f);
out = new PrintWriter(theFile);
}
out.print(info + "\n");
out.close();
theFile.close();
return true;
}
catch (IOException e)
{
return false;
}
}
public static String getFileContent(File srcfile)
{
String strReturn = "";
try
{
BufferedInputStream buff = new BufferedInputStream(new FileInputStream(srcfile));
int in = 0;
do{
in = buff.read();
if(in != -1)
{
strReturn += (char)in;
}
}while(in != -1);
return strReturn;
}
catch(Exception e)
{
return strReturn;
}
}
public static String getFileContent(String fpath)
{
File srcfile = new File(fpath);
return getFileContent(srcfile);
}
public static boolean isType(String ext,String ptype)
{
if (ext.equals("jpg")||ext.equals("jpeg")||ext.equals("gif")||ext.equals("png")||ext.equals("bmp"))
{
if(ptype.equals("pic"))
{
return true;
}
}
else if (ext.equals("mid")||ext.equals("amr")||ext.equals("wma"))
{
if(ptype.equals("ring"))
{
return true;
}
}
else if (ext.equals("htm")||ext.equals("html"))
{
if(ptype.equals("webpage"))
{
return true;
}
}
else if (ext.equals("css"))
{
if(ptype.equals("css"))
{
return true;
}
}
else if (ext.equals("htt")||ext.equals("ini")||ext.equals("inc"))
{
if(ptype.equals("htt"))
{
return true;
}
}
else if (ext.equals("js")||ext.equals("htc"))
{
if(ptype.equals("js"))
{
return true;
}
}
return false;
}
/*******************************************************************************************************************************************************************************
日期转为汉字
///把日期转换成汉字 cnDateFormat("2002/01/01","/") out 二零零二年一月一日 or cnDateFormat("2002-01-01","-") out 二零零二年一月一日
public String cnDateFormat(String sDate, String DelimeterChar) {
String restr = "";
String tmpArr[] = sDate.split(DelimeterChar);
String dArr[] = {
"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};
for (int i = 0; i < 10; i++) {
Integer x = new Integer(i);
String temp = x.toString();
tmpArr[0] = tmpArr[0].replaceAll(temp, dArr[i]);
}
tmpArr[0] = tmpArr[0] + "年";
if (tmpArr[1].length() == 1) {
tmpArr[1] = dArr[Integer.parseInt(tmpArr[1])] + "月";
}
else {
if (tmpArr[1].substring(0, 1).equals("0")) {
tmpArr[1] = dArr[Integer.parseInt(tmpArr[1].substring(tmpArr[1].length() -
1, tmpArr[1].length()))] + "月";
}
else {
tmpArr[1] = "十" +
dArr[Integer.parseInt(tmpArr[1].substring(tmpArr[1].length() - 1,
tmpArr[1].length()))] + "月";
tmpArr[1] = tmpArr[1].replaceAll("零", "");
}
}
if (tmpArr[2].length() == 1) {
tmpArr[2] = dArr[Integer.parseInt(tmpArr[2])] + "日";
}
else {
if (tmpArr[2].substring(0, 1).equals("0")) {
tmpArr[2] = dArr[Integer.parseInt(tmpArr[2].substring(tmpArr[2].length() -
1, tmpArr[2].length()))] + "日";
}
else {
tmpArr[2] = dArr[Integer.parseInt(tmpArr[2].substring(0, 1))] + "十" +
dArr[Integer.parseInt(tmpArr[2].substring(tmpArr[2].length() - 1,
tmpArr[2].length()))] + "日";
tmpArr[2] = tmpArr[2].replaceAll("零", "");
}
}
return tmpArr[0] + tmpArr[1] + tmpArr[2];
}
/**********************************************************************************************************************************************
产生zip文件的程序：
public void makeZIP(String s_zipPath,
String s_newZipFile,
String s_fileName,
String s_filePath,
String status,
String yearmonth)
throws FileNotFoundException,IOException
{
try
{
File f_compressFile=new File(s_filePath,s_fileName);
if (f_compressFile.isFile())
{
FileInputStream s_fileIn=new FileInputStream(f_compressFile);
DataInputStream in = new DataInputStream(s_fileIn);
outZip.putNextEntry(new ZipEntry(s_fileName));
int c;
while((c = in.read()) != -1)
outZip.write(c);
in.close();
s_fileIn.close();
outZip.closeEntry();
java.io.File ZipfileDir = new java.io.File(s_filePath+"\\"+s_fileName);
if (ZipfileDir.exists())
{
ZipfileDir.delete();
}
if (status=="end")
{
outZip.close();
this.addNormalMessage("Download/"+
this.getSessionParam().getString(
CMN_APP_ColConstant.MANNO)+"_"+yearmonth+".zip");
}
}
else if (f_compressFile.isDirectory())
{
File f_zip=new File(s_zipPath,s_newZipFile);
FileOutputStream f_zipFile = new FileOutputStream(f_zip);
outZip = new ZipOutputStream(new DataOutputStream(f_zipFile));
String[] s_fileList=f_compressFile.list();
String s_newDirectory=f_compressFile.getAbsolutePath();
String nowStatus=null;
for (int i=0;i<s_fileList.length ;i++ )
{
if (i==s_fileList.length-1)
{
nowStatus="end";
}
makeZIP(s_zipPath,s_newZipFile,s_fileList[i],
s_newDirectory,nowStatus,yearmonth);
}
}
//
}
catch (Exception e)
{
e.printStackTrace();
}
}
/****************************************************************************************************************************************************************
下面这些关于文件的...
1.新建目录
<%@ page contentType="text/html;charset=gb2312"%>
<%
String filePath="c:/aaa/";
filePath=filePath.toString();//中文转换
java.io.File myFilePath=new java.io.File(filePath);
if(!myFilePath.exists())
myFilePath.mkdir();
%>
2。新建文件
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*" %>
<%
String filePath="c:/哈哈.txt";
filePath=filePath.toString();
File myFilePath=new File(filePath);
if(!myFilePath.exists())
myFilePath.createNewFile();
FileWriter resultFile=new FileWriter(myFilePath);
PrintWriter myFile=new PrintWriter(resultFile);
String strContent = "中文测试".toString();
myFile.println(strContent);
resultFile.close();
%>
3。删除文件
<%@ page contentType="text/html;charset=gb2312"%>
<%
String filePath="c:/支出证明单.xls";
filePath=filePath.toString();
java.io.File myDelFile=new java.io.File(filePath);
myDelFile.delete();
%>
4。文件拷贝
<%@ page contentType="text/html; charset=gb2312" %>
<%@ page import="java.io.*" %>
<%
int bytesum=0;
int byteread=0;
file://读到流中
InputStream inStream=new FileInputStream("c:/aaa.doc");
FileOutputStream fs=new FileOutputStream( "d:/aaa.doc");byte[] buffer =new byte[1444];
int length;
while ((byteread=inStream.read(buffer))!=-1)
{
out.println("<DT><B>"+byteread+"</B></DT>");
bytesum+=byteread;
System.out.println(bytesum);
fs.write(buffer,0,byteread);
}
inStream.close();
%>
5。整个文件夹拷贝
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*" %>
<%String url1="C:/aaa";
String url2="d:/java/";
(new File(url2)).mkdirs();
File[] file=(new File(url1)).listFiles();
for(int i=0;i<file.length;i++){
if(file[i].isFile()){
file[i].toString();
FileInputStream input=new FileInputStream(file[i]);
FileOutputStream output=new FileOutputStream(url2+"/"+(file[i].getName()).toString());
byte[] b=new byte[1024*5];
int len;
while((len=input.read(b))!=-1){
output.write(b,0,len);
}
output.flush();
output.close();
input.close();
}
}
%>
6。文件下载
<%@ page contentType="text/html; charset=gb2312" %>
<%@ page import="java.io.*" %>
<%
String fileName = "zsc104.swf".toString();
//读到流中
InputStream inStream=new FileInputStream("c:/zsc104.swf");
//设置输出的格式
response.reset();
response.setContentType("bin");
response.addHeader("Content-Disposition","attachment; filename=\"" + fileName + "\"");
//循环取出流中的数据
byte[] b = new byte[100];
int len;
while((len=inStream.read(b)) >0)
response.getOutputStream().write(b,0,len);
inStream.close();
%>
7。数据库字段中的文件下载
<%@ page contentType="text/html; charset=gb2312" %>
<%@ page import="java.sql.*"%>
<%@ page import="java.lang.*" %>
<%@ page import="java.io.*" %>
<%@ page import="com.jspsmart.upload.*" %>
<%@ page import="DBstep.iDBManager2000.*"%>
<%
int bytesum=0;
int byteread=0;
//打开数据库
ResultSet result=null;
String Sql=null;
PreparedStatement prestmt=null;
DBstep.iDBManager2000 DbaObj=new DBstep.iDBManager2000();
DbaObj.OpenConnection();
//取得数据库中的数据
Sql="select * from t_local_zhongzhuan ";
result=DbaObj.ExecuteQuery(Sql);
result.next();
file://将数据库中的数据读到流中
InputStream inStream=result.getBinaryStream("content");
FileOutputStream fs=new FileOutputStream( "c:/dffdsafd.doc");
byte[] buffer =new byte[1444];
int length;
while ((byteread=inStream.read(buffer))!=-1)
{
out.println("<DT><B>"+byteread+"</B></DT>");
bytesum+=byteread;
System.out.println(bytesum);
fs.write(buffer,0,byteread);
}
%>
8。把网页保存成文件
<%@ page import="java.text.*"%>
<%@ page import="java.util.*"%>
<%@ page import="java.io.*"%>
<%@ page import="java.net.*"%>
<%
URL stdURL = null;
BufferedReader stdIn = null;
PrintWriter stdOut = null;
try {
stdURL = new URL("http://www.163.com");
}
catch (MalformedURLException e) {
throw e;
}
try {
stdIn = new BufferedReader(new InputStreamReader(stdURL.openStream()));
stdOut = new PrintWriter(new BufferedWriter(new FileWriter("c:/163.html")));
}
catch (IOException e) {
}
/***把URL指定的页面以流的形式读出，写成指定的文件***/
try {
String strHtml = "";
while((strHtml = stdIn.readLine())!=null) {
stdOut.println(strHtml);
}
}
catch (IOException e) {
throw e;
}
finally {
try {
if(stdIn != null)
stdIn.close();
if(stdOut != null)
stdOut.close();
}
catch (Exception e) {
System.out.println(e);
}
}
%>
9。直接下载网上的文件
<%@ page import="java.io.*"%>
<%@ page import="java.net.*"%>
<%
int bytesum=0;
int byteread=0;
URL url = new URL("http://pimg.163.com/sms/micheal/logo.gif");
URLConnection conn = url.openConnection();
InputStream inStream = conn.getInputStream();
FileOutputStream fs=new FileOutputStream( "c:/abc.gif");
byte[] buffer =new byte[1444];
int length;
while ((byteread=inStream.read(buffer))!=-1)
{
out.println("<DT><B>"+byteread+"</B></DT>");
bytesum+=byteread;
System.out.println(bytesum);
fs.write(buffer,0,byteread);
}
%>
/*
目录递归并删除该目录下所以的文件及文件夹
*/
public void SearchDirOk(String Dir){
File tempFolder = new File(Dir);
String fileList[] =tempFolder.list();
for (int i = 0;i < fileList.length;i++){
File tempSubFolder = new File(Dir+"/"+fileList[i]);
if (tempSubFolder.isDirectory())
this.SearchDirOk(Dir+"/"+fileList[i]);
else
tempSubFolder.delete();
}
tempFolder.delete();
}
调用方法:
CommonClass common = new CommonClass();
common.SearchDirOk((String)sessionDir.toString()) ;
sessionDir为路径
删除文件:
public static void delete(String filename) {
File f = new File(filename);
if (!f.exists()) fail("Delete: no such file or directory: " +filename);
if (!f.canWrite()) fail("Delete: write protected: " + filename);
if (f.isDirectory()) {
String[] files = f.list();
if (files.length > 0)
fail("Delete: directory not empty: " + filename);
}
boolean success = f.delete();
if (!success) fail("Delete: deletion failed");
}
protected static void fail(String msg) throws IllegalArgumentException {
throw new IllegalArgumentException(msg);
}
下面是两种删除方法：
方法1：
try {
String sql1 = "drop table DATA ";
int num1 = stmt.executeUpdate(sql1);
String sql2 = "drop table HEAD ";
int num2 = stmt.executeUpdate(sql2);
String sql3 = "drop table payinfo ";
int num3 = stmt.executeUpdate(sql3);
} catch (Exception ex) {
SystemLog.writeErrorLog("删除数据库文件出错！", ex.toString());
}
方法2：
File f = new File(path);
File[] fname = f.listFiles();
try{
for(int i=0;i<fname.length;i++){
fname[i].delete();
}
}catch (Exception e) {
SystemLog.writeErrorLog("删除BDF数据库文件出错!!"+e.getMessage(), e.toString());
}
/*************************************************************************************************************************************************************************************************************
今天想学习一下基础知识，就看了一下HTML(4.0)，发现自己对HTML掌握的太少了。很多代码都很陌生，根本就没见过，更别提用了。
就拿<a></a>元素来举个例子。它的属性就有：
name，href，target，title(这都是我们常用的，就不用多说了)
rel，rev，charset，hreflang，tabindex，accesskey，shape(default|rect|circle|poly)，coords(length-list) 这些以前基本很少见过，在这里就加以介绍。
rel=cdate
这个属性指出了从当前位置到链接位置的关系。例如 rel="next" href="A" 指出了A这个链接是下一个。
rev=cdate
这个属性刚好与rel相反，就不再多说。
charset=cdate
这个属性指定了链接的编码方式，属性值必须是在[RFC2O45]中作为“charset”指定的名称：例如：“euc-jp”。这个属性的缺省值是“iso-8859-1”。
hreflang=languagecode
这个属性用来指定链接所使用的语言。例如："en"指的是英语，"cn"指的是汉语。
tabindex＝number
这个属性是用来指定元素获得焦点顺序的。它的值可以是从0～32767中的任何一个。
tabindex属性的元素中，具有较小数字的较先获得焦点，在具有相等值得情况下，在HTML文档里最先显示的元素先处理。一个“tabindex=0”或者没有tabindex属性的元素将在最后被访问。（看了这个我突然想起能否有这个值来控制页面的下载元素，不过不知道这个想法是否正确，好像别的不支持这个属性）。
accesskey=character
这个属性分配一个热键给一个A元素。一个热键是来自于客户端浏览器当前字符集的单个字符。客户端浏览器应当把这个属性作为大小写无关来对待。
shape＝default|rect|cirle|poly
这个属性是用来建立客户端图象映像的，它指定了区域的形状，可能的值为：
default：定义这个区域
rect ：定义一个矩形区域
circle：定义一个圆形区域
poly ： 定义一个椭圆形区域
默认得shape值为rect
coords=length-list
这个属性被用来建立客户端图象映像的，它指定了一个形状在屏幕上的位置，值的数字和值取决于被定义的形状。可能的组合为：
rect：left-x，top-y，right-x，bottom-y
circle： center-x，center-y，radius
poly： x1，y1，x2，y2……xn，yn
坐标联系到特件的左上角，所有的值都是长度(可以是像素或百分比)
以上所写，均为本人参照书籍整理，并不代表我的个人水平，因为这个我基本也没用到过，也不是很理解，贴出来的意思是希望那些不知道的朋友能够熟悉一下，而对此十分了解的朋友能够根据这些给予说明，结合实际指出这些代码的作用，让大家都能加深对HTML的认识。虽然现在的软件基本可以满足大家的要求，可是毕竟网页最终还是有代码来实现的，所以我想多掌握一些，多了解和认识一些会对自己更有帮助，只有好处，没有坏处，其实在HTML中还有好多这样的代码，上面的只是一个例子，希望大家也能多多交流，共同进步，就说到这里。
/******************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************
Clip属性的应用
上一节说到了动态可视区的调整，实际上就是Clip属性的应用。
Clipping的中文解释就是剪辑的意思，这个属性决定了对象的哪个部位可以被看到。它不会改变任何对象的性质。
Clipping 的区域是一个矩形， 而这个矩形的尺寸取决于于四个边的位置。
这四个边用 top, right, botton, left 来表示。
请注意：这四个边的位置是相对于对象的而不是相对于窗口的。
Clip属性的书写格式是这样的：
Clip rect（top，right，bottom，left）
在这里，top，right，bottom，left的值都是以像素pixels为单位的。
扫一扫
2003
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
