skyful

  BlogJava :: 首页 :: 联系 :: 聚合  :: 管理
  16 Posts :: 0 Stories :: 45 Comments :: 0 Trackbacks

2007年4月6日 #

<body onLoad="page_onload();">

function page_onload(){
 if(typeof(initPage)=='function'){
  initPage();
 }
}


function initPage(){
 for(var i=0;i<document.forms[0].elements.length;i++)
{
 if (document.forms[0].elements[i].type=="checkbox" && document.forms[0].elements[i].name.substring(0,22)=="hotelRoom.cardTypeItem"){
 document.forms[0].elements[i].checked=true;
}
}
}
posted @ 2007-04-06 10:13 氓氓 阅读(1435) | 评论 (0)编辑 收藏

2007年3月17日 #

Struts作为MVC 2的Web框架,自推出以来不断受到开发者的追捧,得到用广泛的应用。作为最成功的Web框架,Struts自然拥有众多的优点:
  • MVC 2模型的使用
  • 功能齐全的标志库(Tag Library)
  • 开放源代码

但是,所谓“金无赤金,人无完人”,Struts自身也有不少的缺点:

  • 需要编写的代码过多,容易引起“类爆炸”
  • 单元测试困难

这些缺点随着Web的发展越来越明显。这就促生了Struts 2.0,它的诞生能很好的解决上述问题。 好啦,废话就不多说了,现在就让我们感受一下的Struts 2.0的魅力吧。

  1. 搭建开发和运行环境
    1. 到Apache下载Struts 2.0包

    2. 打开Eclipse 3.2新建Web工程

      点击菜单File\New\Project,出现如图1所示对话框
      图1 新建工程对话框
      图1 新建工程对话框
      选择Web\Dynamic Web Project,点击“Next”,出现图2对话框

      图2 新建动态Web工程对话框
      图2 新建动态Web工程对话框
      在“Project Name”中键入Struts2_HelloWorld,点击“New”,出现以下对话框

      图3 新建服务器运行时对话框
      图3 新建服务器运行时对话框
      选择“Apache\Apache Tomat v5.5”,点击“Next”,出现以下对话框

      图4新建服务器运行时对话框
      图4新建服务器运行时对话框
      点击“Finish”,关闭对话框。

    3. 将Struts 2.0 lib下的jar文件加到工程的构建路径(build path)

      图5 Struts 2.0的lib目录
      图5 Struts 2.0的lib目录
      按ctr+a全选,复制,再转到Eclipse窗口,在“Project Explorer”子窗口中选中Struts2_HelloWorld\WebContent\WEB-INF\lib,然后粘贴。经过Eclipse自动刷新“Project Explorer”子窗口,刚才所粘贴的jar文件应该会出现在Struts2_HelloWorld\Java Resources: src\Libraries\Web App Libraries下,如图6所示:

      图6 Project Explorer子窗口
      图6 Project Explorer子窗口

    4. 打开web.xml文件,将其修改为以下代码:
      <?xml version="1.0" encoding="ISO-8859-1"?>
      <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
      <web-app>
          
      <display-name>Struts 2.0 Hello World</display-name>
          
      <filter>
              
      <filter-name>struts2</filter-name>        <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
          
      </filter>
          
      <filter-mapping>
              
      <filter-name>struts2</filter-name>
              
      <url-pattern>/*</url-pattern>
          
      </filter-mapping>
          
      <welcome-file-list>
              
      <welcome-file>index.html</welcome-file>
          
      </welcome-file-list>
      </web-app>

    5. 新建struts.xml文件

      右键点击,Struts2_HelloWorld\Java Resources: src,出现如图7所示菜单
      图7 新建Other菜单
      图7 新建Other菜单
      点击“Other”,出现新建对话框,如图8所示

      图8 新建对话框
      图8 新建对话框
      点击“Next”,出现新建文件对话框,如图9所示

      图9 新建文件对话框
      图9 新建文件对话框
      在“File name”中键入sturts.xml,点击“Finish”,然后将struts.xml的内容修改为:

      <!DOCTYPE struts PUBLIC
              "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
              "http://struts.apache.org/dtds/struts-2.0.dtd"
      >
      <struts>
          
      <include file="struts-default.xml"/>
      </struts>

    6. 新建index.html文件

      右键点击Struts2_HelloWorld\WebContent,出现如图10所示的菜单
      图10 新建Other菜单
      图10 新建Other菜单
      点击“Other”,出现新建对话框,如图11所示

      图11 新建对话框
      图11 新建对话框
      选择Web\HTML,点击“Next”出现如图12所示的对话框

      图12 新建HTML页面对话框
      图12 新建HTML页面对话框
      在“File Name”中键入index.html,点击“Next”,出现如图13所示的对话框

      图13 模板选择对话框
      图13 模板选择对话框
      点击“Finish”,将index.html的内容修改为以下内容:

      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
      <html>
      <head>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      <title>Hello World</title>
      </head>
      <body>
      <h3>Hello World!</h3>
      </body>
      </html>

    7. 将应用程序打包到tomcat上

      右键点击Struts_HelloWorld,出现如图14所示的菜单
      图14 工程菜单
      图14 工程菜单
      点击“Export\WAR file”,出现如图15所示的对话框

      图15 输出对话框
      图15 输出对话框
      选择“Web\WAR file”,点击“Next”,出现如图16所示的对话框

      图16 输出路径对话框
      图16 输出路径对话框
      输入war文件的路径(如%tomcat%\webapps\Struts2_HelloWorld.war),点击“Finish”关闭对话框。

    8. 启动tomcat,运行应用程序

      打开你的Internet Explorer,键入http://localhost:8080/Struts2_HelloWorld/,窗口输出如图17所示
      图17 Hello World窗口
      图17 Hello World窗口

  2. 第一个Struts 2.0应用程序——Hello World
    1. 新建类包(package)

      右键点击Struts2_HelloWorld\Java Resources: src,出现如图18所示菜单
      图18 新建菜单
      图18 新建菜单"
      点击“New\Package”,出现如图19所示对话框

      图19新建Java类包对话框
      图19新建Java类包对话框
      在“Name”键入tutorial,点击“Finish”关闭对话框。

    2. 新建HelloWorld.java文件

      右键点击Struts2_HelloWorld\Java Resources: src\tutorial,出现如图20所示菜单
      图20 新建菜单
      图20 新建菜单
      点击“New\Class”,出现如图21所示对话框

      图21 新建Java类对话框
      图21 新建Java类对话框
      在“Name”中键入HelloWorld,在“Superclass”中键入com.opensymphony.xwork2.ActionSupport,点击“Finish”关闭对话框。将HelloWorld.java的内容修改为:

      package tutorial;

      import com.opensymphony.xwork2.ActionSupport;

      public class HelloWorld extends ActionSupport {
          
      private String name;
          
          
      public String getName() {
              
      return name;
          }

          
          
      public void setName(String name) {
              
      this.name = name;
          }

          
          
      public String execute() {
              name 
      = "Hello, " + name + "!"
              
      return SUCCESS;
          }

      }

    3. 在struts.xml中添加action映射(mapping)
      <!DOCTYPE struts PUBLIC
              "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
              "http://struts.apache.org/dtds/struts-2.0.dtd"
      >
      <struts>
          
      <include file="struts-default.xml"/>
          
      <package name="tutorial" extends="struts-default">
              
      <action name="HelloWorld" class="tutorial.HelloWorld">
                  
      <result>HelloWorld.jsp</result>
              
      </action>
          
      </package>
      </struts>

    4. 新建SayHello.jsp

      参考“新建index.html文件”步骤,弹出如图22所示对话框
      图22 新建对话框
      图22 新建对话框
      点击“Next”, 进入下一步,如图23所示

      图23 新建JSP对话框
      图23 新建JSP对话框
      在“File name”键入SayHello.jsp,点击“Next”进入下一步,如图24所示

      图24 模板选择对话框
      图24 模板选择对话框
      点击“Finish”关闭对话框,并将SayHello.jsp的内容修改为:

      <%@ page contentType="text/html; charset=UTF-8" %>
      <%@ taglib prefix="s" uri="/struts-tags" %>
      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
      <html>
          
      <head>
              
      <title>Say Hello</title>
          
      </head>
          
      <body>
              
      <h3>Say "Hello" to: </h3>
              
      <s:form action="HelloWorld">
                  Name: 
      <s:textfield name="name" />
                  
      <s:submit />
              
      </s:form>
          
      </body>
      </html>

    5. 新建HelloWorld.jsp(请参考上一步),HelloWorld.jsp的内容为:
      <%@ page contentType="text/html; charset=UTF-8" %>
      <%@ taglib prefix="s" uri="/struts-tags" %>
      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
      <html>
          
      <head>
              
      <title>Hello</title>
          
      </head>
          
      <body>
              
      <h3><s:property value="name" /></h3>
          
      </body>
      </html>

    6. 重新打包发布应用程序

      先停止tomcat, 再将tomcat里webapps下的Struts2_HelloWorld.war和Struts2_HelloWorld文件夹删除,参照“将应用程序打包到tomcat上”重新发布应用程序。

    7. 启动tomcat,运行测试

      打开Internet Explorer,键入http://localhost:8080/Struts2_HelloWorld/SayHello.jsp,窗口输出如图25所示
      图25 SayHello.jsp
      图25 SayHello.jsp
      在“Name”键入字符串(如World),点击Submit,转到HelloWorld.jsp页面,如图26所示

      图26 HelloWorld.jsp
      图26 HelloWorld.jsp

  3. 单元测试Hello World

    在文章开始的时候提及,单元测试困难是Struts一大缺点。现在让我们在体验一下,在Struts 2.0中是如何进行测试的。

    1. 新建JUnit单元测试

      右键点击Struts2_HelloWorld\Java Resources: src\tutorial,弹出如图27所示对话框
      图27 新建菜单
      图27 新建菜单
      点击“Next\Other”

      图28 新建对话框
      图28 新建对话框
      选择“Java\JUnit\JUnit Test Case”,点击“Next”

      图29 新建JUnit 测试用例对话框
      图29 新建JUnit 测试用例对话框
      选择“New JUnit 4 test”,在“Name”中键入HelloWorldTest,在“Class under test”键入tutorial.HelloWorld,点击“Next”

      图30 选择方法对话框
      图30 选择方法对话框
      选中HelloWorld\execute方法,点击Finish。如果生成的HelloWorldTest.java文件的图标(Icon)出现红色交叉标志,请进行以下步骤添加JUnit 4的jar包。

      右键点击Struts2_HelloWorld,出现如图所示菜单。 图31 新建菜单
      图31 新建菜单
      点击“Build Path\Add Libararis”,弹出图32对话框

      图32 添加库对话框
      图32 添加库对话框
      选中“JUnit”,点击“Next”

      图33 选择版本对话框
      图33 选择版本对话框
      选择“JUnit 4”,点击“Finish”关闭对话框,并将HelloWorldTest.java的内容修改为:

      package tutorial;

      import static org.junit.Assert.assertTrue;

      import org.junit.Test;

      import com.opensymphony.xwork2.ActionSupport;

      public class HelloWorldTest {

          @Test
          
      public void testExecute() {
              HelloWorld hello 
      = new HelloWorld();
              hello.setName(
      "World");
              String result 
      = hello.execute();
              
              assertTrue(
      "Expected a success result!", ActionSupport.SUCCESS.equals(result));
              
              
      final String msg = "Hello, World!";
              assertTrue(
      "Expected the default message!", msg.equals(hello.getName()));
          }


      }

    2. 运行单元测试

      右键点击Struts2_HelloWorld\Java Resources: src\tutorial\HelloWorldTest.java,弹出如图34所示菜单
      图34 运行为菜单
      图34 运行为菜单
      点击“Run As\JUnit Test”,出现JUnit子窗口如图35所示

      图35 JUnit子窗口
      图35 JUnit子窗口
      图35的绿色矩形表示,所有单元测试通过。

  4. 总结

    上面的例子简单地演示了,Web 应用程序的基本操作,也即是,页面输入->Action处理->再输出到另外页面。Struts 2.0的简单易用、方便测试相信也会给大家留下不错的印象吧。我相信,Struts 2.0作为一个全新的Web架构,将会再次掀起Web开发的热潮。 不过,Struts 2.0还在测试中,正式版的发布还需些时日,所以文档方面可能有所欠缺。请大家继续留意我的博客,我会尽我所能为大家写更多关于Struts 2.0的文章。

posted @ 2007-03-17 15:58 氓氓 阅读(461) | 评论 (0)编辑 收藏

2007年3月13日 #

今天在eclipse+myeclipse+tomcat5 下,写个中文乱码转码filter,就报
2007-3-13 17:43:46 org.apache.catalina.core.StandardContext start
严重: Error filterStart
2007-3-13 17:43:46 org.apache.catalina.core.StandardContext start
严重: Context startup failed due to previous errors
 错误,所属项目也就启动不了,web。xml配置为 :
<filter>
   <filter-name>CharsetEncodingFilter</filter-name>
   <filter-class>com.changyou.filter.CharsetEncodingFilter</filter-class>
   <init-param>
    <param-name>encoding</param-name>
    <param-value>UTF-8</param-value>
   </init-param>
  </filter>
  <filter-mapping>
   <filter-name>CharsetEncodingFilter</filter-name>
   <url-pattern>/*</url-pattern>
  </filter-mapping>
百思不得其解,问题出在哪里。
在google搜索,有人提出这么几个解决方案:
1、试着把tomat/server/lib目录下的commons-digester.jar,commons-beanutils.jar拷贝到common/lib/目录  --经测试不行
2、里有个文章说tomcat里的bug,没有实现javax.servlet.Filter的Filter会报这样的错误,看来tomcat在启动就初始化Filter实例,但是在filter中又没有看到那段代码没有实现Filter,或者有代码在启动时没有实例化。--没发现问题。

这个问题网上也得不到解决方案,真是郁闷得紧
****************************************
终于解决了,原来是在web.xml初始化参数过程少初始化了一个,导致filter启动失败。大汗~~~~

如果以后出现tomcat 严重: Error filterStart 错误,一般原因为:1、xml配置失误(如我) 2、filter中某段代码为实例化(这个情况是出现最多的,要仔细检查) 3、试着把tomat/server/lib目录下的commons-digester.jar,commons-beanutils.jar拷贝到common/lib/目录,有些包在部署是没有被包含
 

posted @ 2007-03-13 17:53 氓氓 阅读(26571) | 评论 (40)编辑 收藏

2006年8月2日 #

这里以Eclipse 3.1.2为例给介绍!

一、下载 Eclipse 3.1.2 和语言包:
  
   Eclipse 3.1.2:点此处下载eclipse-SDK-3.1.2-win32.zip
 
   语言包:点击下载NLpack1-eclipse-SDK-3.1.1a-win32.zip

二、解压缩 eclipse-SDK-3.1.2-win32.zip 到 D:\eclipse(我放的路径,阁下可以自己选择)

  在 eclipse 目录中新建一个名为 language 和 links 的目录,并将下载下来的语言包 NLpack1-eclipse-SDK-3.1.1a-win32.zip 解压缩到 language 目录中,然后在 links 目录里新建一个文本文件,命名为 language.link ,在文件里写入下列信息:path=D:\\eclipse\\language 其中 D 为阁下所使用的盘符,设置 path 指向 language 目录,保存即可。

三,OK了,启动 Eclipse 3.1.2,已经是中文的了!

其他版本同理,下载对应语言包即可,网址:http://download.eclipse.org/eclipse/downloads/
posted @ 2006-08-02 14:17 氓氓 阅读(495) | 评论 (0)编辑 收藏

2006年6月2日 #

学习在java中计算基本的时间段
概述
如果你知道怎样在java中使用日期,那么使用时间和它才不多一样简单。这篇文章告诉你怎样把他们的差别联系起来。Robert Nielsen还告诉你怎样使用java来计算抵达航班和制造过程的时间。
作者:Robert Nielsen
翻译:Cocia Lin

 

这篇文章是在我发表过的<计算Java时间>(译者:已经翻译完成)的基础上的。在这里,我列出那篇文章几个你应该熟悉得关键点。如果这几点你不太清楚,我建议你读一下<计算Java时间>,了解一下。
1. Java计算时间依靠1970年1月1日开始的毫秒数.                                                                                                                                                              
2. Date类的构造函数Date()返回代表当前创建的时刻的对象。Date的方法getTime()返回一个long值在数值上等于1970年1月1日之前或之后的时刻。
3. DateFormat类用来转换Date到String,反之亦然。静态方法getDateInstance()返回DateFormat的缺省格式;getDateInstance(DateFormat.FIELD)返回指定的DateFormat对象格式。Format(Date d)方法返回String表示日期,例如"January 1,2002."反过来,parse(String s)方法返回以参数字符串表示的Date对象。
4. format()方法返回的字符串格式根据不同地区的时间设置而有所不同。
5. GregorianCalendear类有两个重要的构造函数:GregorianCalerdar(),返回代表当前创建时间的对象;GregorianCalendar(int year,int month,int date)返回代表任意日期的对象。GregorianCalendar类的getTime()方法返回日期对象。Add(int field,int amount)方法通过加或减时间单位,象天数,月数或年数来计算日期。
GregorianCalendar和 时间
 两个GregorianCalendar的构造函数可以用来处理时间。前者创建一个表示日期,小时和分钟的对象:

GregorianCalendar(int year, int month, int date, int hour, int minute)

第二个创建一个表示一个日期,小时,分钟和秒:

GregorianCalendar(int year, int month, int date, int hour, int minute, int second)

首先,我应该提醒一下,每一个构造函数需要时间信息中的日期信息(年,月,日)。如果你想说2:30 p.m.,你必须指出日期。
同样,每一个GregorianCalendar构造函数创建一个在时间上使用毫秒计算的对象。所以,如果你的构造函数只提供年,月,日参数,那小时,分钟,秒和毫秒的值将被置0.
DateFormat和时间
你可以使用静态方法getDateTimeInstance(int dateStyle,int timeStyle)来建立DateFormat对象来显示时间和日期。这个方法表明你想要的日期和时间格式。如果你喜欢使用缺省格式,可以使用getDateTimeInstance()来代替它。
你可以使用静态方法getTimeInstance(int timeStyle)创建DateFormat对象来显示正确的时间。
下面的程序示范了getDateTimeInstance()和getTimeInstance()怎样工作:

import java.util.*;
import java.text.*;

public class Apollo {
   public static void main(String[] args) {
      GregorianCalendar liftOffApollo11 = new GregorianCalendar(1969, Calendar.JULY, 16, 9, 32);
      Date d = liftOffApollo11.getTime();
      DateFormat df1 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
      DateFormat df2 = DateFormat.getTimeInstance(DateFormat.SHORT);
      String s1 = df1.format(d);
      String s2 = df2.format(d);
      System.out.println(s1);
      System.out.println(s2);
   }
}  
       
在我的电脑上,上面的程序显示如下:

Jul 16, 1969 9:32:00 AM
9:32 AM
(输出根据你所在得地区有所不同)

计算时间间隔
     你可能有时需要计算过去的时间;例如,给你开始和结束时间,你想知道制造流程的持续时间。一个出租公司按小时或天数出租东西,计算时间对他们也很有用。同样的,在金融界,经常需要计算重要的支付时间。
将问题复杂化,人类至少是用两种方法计算时间。你可以说一天已经结束当24小时过去了,或者日历从今天翻到明天。我们将讨论我们想到的这两种情况。
时间段,情况 1:严格时间单位
在这种情况中,只有24小时过去,这天才过去,60分钟过去,这个小时才过去,60秒过去,这个分钟才过去,以此类推。在这个方法中,23小时的时间将被认为是0天。
使用这种方法计算时间段,你从计算过去的毫秒开始。为了做到这一点,首先转换每个日期为从1970年1月1日起得毫秒数。你可以从第二个毫秒值中减去第一个毫秒值。这里有一个简单的计算:

import java.util.*;

public class ElapsedMillis {
   public static void main(String[] args) {
      GregorianCalendar gc1 = new GregorianCalendar(1995, 11, 1, 3, 2, 1);
      GregorianCalendar gc2 = new GregorianCalendar(1995, 11, 1, 3, 2, 2);
      // the above two dates are one second apart
      Date d1 = gc1.getTime();
      Date d2 = gc2.getTime();
      long l1 = d1.getTime();
      long l2 = d2.getTime();
      long difference = l2 - l1;
      System.out.println("Elapsed milliseconds: " + difference);
   }
}    

上面的程序打印如下:

Elapsed milliseconds: 1000

这个程序也带来一点混淆。GregorianCalendar类的getTime()返回一个Date对象,Date类的getTime()方法返回从1970年1月1日到这个时间的long类型的毫秒数值。虽然他们的方法名字相同,返回值却不一样!
下面的程序片断用简单的整数除法转换毫秒到秒:

long milliseconds = 1999;
long seconds = 1999 / 1000;

这种方法舍去小数部分转换毫秒到秒,所以1,999毫秒等于1秒,2,000毫秒等于2秒。
计算更大的单位-例如天数,小时和分钟-给定一个时间数值,可以使用下面的过程:
1. 计算最大的单位,减去这个数值的秒数
2. 计算第二大单位,减去这个数值的秒数
3. 重复操作直到只剩下秒
例如,如果你的时间的10,000秒,你想知道这个数值相应的是多少小时,多少分钟,多少秒,你从最大的单位开始:小时。10,000除以3600(一个小时的秒数)得到小时数。使用整数除法,答案是2小时(整数除法中小数舍去)计算剩下的秒数,10,000-(3,600 x 2) = 2,800秒。所以你有2小时和2,800秒。
将2,800秒转换成分钟,2,800除以60。使用整数除法,答案是46。2,800 - (60 x 46) = 40秒。最后答案是2小时,46分,40秒。
下面的Java程序使用上面的计算方法:

import java.util.*;

public class Elapsed1 {
   public void calcHMS(int timeInSeconds) {
      int hours, minutes, seconds;
      hours = timeInSeconds / 3600;
      timeInSeconds = timeInSeconds - (hours * 3600);
      minutes = timeInSeconds / 60;
      timeInSeconds = timeInSeconds - (minutes * 60);
      seconds = timeInSeconds;
      System.out.println(hours + " hour(s) " + minutes + " minute(s) " + seconds + " second(s)");
   }

   public static void main(String[] args) {
      Elapsed1 elap = new Elapsed1();
      elap.calcHMS(10000);
   }


输出结果如下:

2 hour(s) 46 minute(s) 40 second(s)

上面的程序甚至在时间少于一个小时也可以正确的计算小时数。例如,你用上面的程序计算1,000秒,输出入下:
0 hour(s) 16 minute(s) 40 second(s)
举一个现实世界的例子,下面的程序计算阿波罗11飞到月球使用得时间:

import java.util.*;

public class LunarLanding {

   public long getElapsedSeconds(GregorianCalendar gc1, GregorianCalendar gc2) {
      Date d1 = gc1.getTime();
      Date d2 = gc2.getTime();
      long l1 = d1.getTime();
      long l2 = d2.getTime();
      long difference = Math.abs(l2 - l1);
      return difference / 1000;
   }

   public void calcHM(long timeInSeconds) {
      long hours, minutes, seconds;
      hours = timeInSeconds / 3600;
      timeInSeconds = timeInSeconds - (hours * 3600);
      minutes = timeInSeconds / 60;
      System.out.println(hours + " hour(s) " + minutes + " minute(s)" );
   }

   public static void main(String[] args) {
      GregorianCalendar lunarLanding = new GregorianCalendar(1969, Calendar.JULY, 20, 16, 17);
      GregorianCalendar lunarDeparture = new GregorianCalendar(1969, Calendar.JULY, 21, 13, 54);
      GregorianCalendar startEVA = new GregorianCalendar(1969, Calendar.JULY, 20, 22, 56);
      GregorianCalendar endEVA = new GregorianCalendar(1969, Calendar.JULY, 21, 1, 9);

      LunarLanding apollo = new LunarLanding();

      long eva = apollo.getElapsedSeconds(startEVA, endEVA);
      System.out.print("EVA duration = ");
      apollo.calcHM(eva);

      long lunarStay = apollo.getElapsedSeconds(lunarLanding, lunarDeparture);
      System.out.print("Lunar stay = ");
      apollo.calcHM(lunarStay);
   }
}         

上面程序输出如下:

EVA duration = 2 hour(s) 13 minute(s)
Lunar stay = 21 hour(s) 37 minute(s)

目前为止,我们计算的基础公式是这样的:1分钟=60秒,1小时=60分,1天=24小时。
"1个月=?天,1年=?天"怎么办?
月份的天数有28,29,30,31;一年可以是365或366天。因此,当你试图计算严格单位的月份和年时,问题就产生了。例如,如果你使用月份的平均天数(近似30.4375),并且计算下面的时间间隔:

* July 1, 2:00 a.m. to July 31, 10:00 p.m.
* February 1, 2:00 a.m. to February 29, 10:00 p.m.

第一个计算结果是1个月;第二个结果是0个月!
所以,在计算严格单位时间的月份和年份是要想好。
时间段,情况 2:时间单位变化
时间单位的变化相当的简单:如果你要统计天数,你可以简单的统计日期变化次数。例如,如果某事15日开始,17日结束,经过2天。(日期先是便到16,再到17)同样的,一个步骤下午3:25开始,4:10 p.m结束,历时1个小时,因为小时数值变了一次(从3到4)。
图书馆经常使用这种习惯计算时间。例如,如果你从图书馆接一本书,我不能占有这本书最少24小时,会认为图书馆这样才给你算一天。而是,我的账号上记录我借书的日期。日期以变成下一天,我就已经结这本书一天了,即使总计不足24小时。
当使用单位的变化来计算时间段,通常感觉计算的时间没有多于一个时间单位。例如,如果9:00 p.m.我借了一本图书馆的书,第二天中午还回去,我能算出我借了这本书一天了。可是,有一种感觉在问:"1天和几个小时呢?"这本说总计借出15个小时,答案是一天还差9个小时呢?因此,这篇文章里,我将以一个时间单位变化计算时间。
单位变化的时间算法
 这是你怎样计算两个日期的时间变化:
1. 制作两个日期的拷贝。Close()方法能制作拷贝。
2. 使用日期拷贝,将所有的小于时间单位变化的部分设置成它的最小单位。例如,如果计算天数,那么将小时,分钟,秒和毫秒设置成0。这种情况中,使用clear()方法将时间值设置称他们各自的最小值。
3. 取出较早的日期,将你要计算的单位加1,重复直到两个日期相等。你加1的次数就是答案。可以使用before()和after()方法,他们返回boolean值,来判断是否一个日期在另一个日期之前或之后。
下面的类的方法用来计算天数和月数。

import java.util.*;

public class ElapsedTime {

   public int getDays(GregorianCalendar g1, GregorianCalendar g2) {
      int elapsed = 0;
      GregorianCalendar gc1, gc2;

      if (g2.after(g1)) {
         gc2 = (GregorianCalendar) g2.clone();
         gc1 = (GregorianCalendar) g1.clone();
      }
      else   {
         gc2 = (GregorianCalendar) g1.clone();
         gc1 = (GregorianCalendar) g2.clone();
      }

      gc1.clear(Calendar.MILLISECOND);
      gc1.clear(Calendar.SECOND);
      gc1.clear(Calendar.MINUTE);
      gc1.clear(Calendar.HOUR_OF_DAY);

      gc2.clear(Calendar.MILLISECOND);
      gc2.clear(Calendar.SECOND);
      gc2.clear(Calendar.MINUTE);
      gc2.clear(Calendar.HOUR_OF_DAY);

      while ( gc1.before(gc2) ) {
         gc1.add(Calendar.DATE, 1);
         elapsed++;
      }
      return elapsed;
   }

   public int getMonths(GregorianCalendar g1, GregorianCalendar g2) {
      int elapsed = 0;
      GregorianCalendar gc1, gc2;

      if (g2.after(g1)) {
         gc2 = (GregorianCalendar) g2.clone();
         gc1 = (GregorianCalendar) g1.clone();
      }
      else   {
         gc2 = (GregorianCalendar) g1.clone();
         gc1 = (GregorianCalendar) g2.clone();
      }

      gc1.clear(Calendar.MILLISECOND);
      gc1.clear(Calendar.SECOND);
      gc1.clear(Calendar.MINUTE);
      gc1.clear(Calendar.HOUR_OF_DAY);
      gc1.clear(Calendar.DATE);

      gc2.clear(Calendar.MILLISECOND);
      gc2.clear(Calendar.SECOND);
      gc2.clear(Calendar.MINUTE);
      gc2.clear(Calendar.HOUR_OF_DAY);
      gc2.clear(Calendar.DATE);

      while ( gc1.before(gc2) ) {
         gc1.add(Calendar.MONTH, 1);
         elapsed++;
      }
      return elapsed;
   }
}

你可以在上面的类中补充另外的方法来处理小时和分钟。同样,计算时间段的算法能更高效一些,尤其是时间相隔很长。可是,作为介绍目的,这个算法有短小和简单的优势。
下面的例子使用ElapsedTime类来计算两个日期之间的天使,而后是月数:

import java.util.*;

public class Example {
   public static void main(String[] args) {
      GregorianCalendar gc1 = new GregorianCalendar(2001, Calendar.DECEMBER, 30);
      GregorianCalendar gc2 = new GregorianCalendar(2002, Calendar.FEBRUARY, 1);

      ElapsedTime et = new ElapsedTime();
      int days = et.getDays(gc1, gc2);
      int months = et.getMonths(gc1, gc2);

      System.out.println("Days = " + days);
      System.out.println("Months = " + months);
   }
}

当计算时,上面的程序可能有用,例如,最近的航班。它显示下面的输出:

Days = 33
Months = 2

(OK,关于航班的计算有些夸张;这个天数算法很适合像图书馆借书这样的应用,你看到了她怎样工作)
告诫
在进行时间工作时要谨慎:你看到的时间段的例子,你精确仔细的考虑非常重要。本文介绍了两种通常计算时间段的想法,但是人们能想到的时间段的计算方法仅仅受到人类想象力的限制。
所以,当写一个Java程序的时候,确信你的精确度能让使用和以来这些程序的人满意。同样,彻底的测试程序对处理时间的程序非重重要。
总结
本文是在我的前一篇文章 Java时间计算介绍怎样使用GregorianCalendar 和 DateFormat类处理时间问题的基础上的。你已经看到了两种方法来思考时间段问题和两种相应的途径使用Java来处理时间问题。这里提供的信息,很基础,提供给你一个在Java中处理时间问题的有力工具。

关于作者
 Robert Nielsen是SCJP。他拥有硕士学位,专攻计算机教育,并且在计算机领域执教多年。他也在各样的杂志上发表过很多计算机相关的文章。
关于译者
Cocia Lin(cocia@163.com)是程序员。它拥有学士学位,现在专攻Java相关技术,刚刚开始在计算机领域折腾。

 


posted @ 2006-06-02 16:18 氓氓 阅读(712) | 评论 (0)编辑 收藏

2006年5月19日 #

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<script language="javascript">
 function roundFun(numberRound,roundDigit) //四舍五入,保留位数为roundDigit ,供计算时用

  {
   if (numberRound>=0)
   {
   var tempNumber = parseInt((numberRound * Math.pow(10,roundDigit)+0.5))/Math.pow(10,roundDigit);
   return tempNumber;
  }
  else
   {
   numberRound1=-numberRound
   var tempNumber = parseInt((numberRound1 * Math.pow(10,roundDigit)+0.5))/Math.pow(10,roundDigit);
   return -tempNumber;
  }

     }

</script>
<title>Test</title>
</head>

<form name="form1">
<input name="num1" type="text" id="num1" maxlength="10">
<input type="button" name="Submit" value="Click Me" onclick="javascript:this.form.num1.value=roundFun(this.form.num1.value,2)">
</form>

</body>
</html>

 

posted @ 2006-05-19 16:44 氓氓 阅读(2022) | 评论 (0)编辑 收藏

2006年4月29日 #

经常看见jsp版里有人问时间操作的问题,这些问题一般包括:取当前时间,把一个指定的字符串时间转化成时间类型,求两个时间之间的天数,求一段时间以前的时间,求一段时间以后的时间,在这里就把这些问题汇总一下。
<%@  page  contentType="text/html;charset=gb2312"%>
<%@ page import="java.text.*"%>
<%@ page import="java.util.*"%>
<%
//字符串转化成时间类型(字符串可以是任意类型,只要和SimpleDateFormat中的格式一致即可)
java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("M/dd/yyyy hh:mm:ss a",java.util.Locale.US);
java.util.Date d = sdf.parse("5/13/2003 10:31:37 AM"); 
out.println(d);
out.println("<br>");
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String mDateTime1=formatter.format(d);
out.println(mDateTime1);
out.println("<br>");
out.println(d.getTime());
out.println("<br>");
//当前时间
Calendar cal  = Calendar.getInstance();
//  SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss");
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss G E D F w W a E F");
String mDateTime=formatter.format(cal.getTime());
out.println(mDateTime);
out.println("<br>");
//1年前日期
java.util.Date myDate=new java.util.Date(); 
long myTime=(myDate.getTime()/1000)-60*60*24*365;
myDate.setTime(myTime*1000);
String mDate=formatter.format(myDate);
out.println(mDate);
out.println("<br>");
//明天日期
myDate=new java.util.Date();
myTime=(myDate.getTime()/1000)+60*60*24;
myDate.setTime(myTime*1000);
mDate=formatter.format(myDate);
out.println(mDate);
out.println("<br>");
//两个时间之间的天数
SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
java.util.Date date= myFormatter.parse("2003-05-1");
java.util.Date mydate= myFormatter.parse("1899-12-30");
long  day=(date.getTime()-mydate.getTime())/(24*60*60*1000);
out.println(day);
out.println("<br>");
//加半小时
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
java.util.Date date1 = format.parse("2002-02-28 23:16:00");
long Time=(date1.getTime()/1000)+60*30;
date1.setTime(Time*1000);
String mydate1=formatter.format(date1);
out.println(mydate1);
out.println("<br>");
//年月周求日期
SimpleDateFormat formatter2 = new SimpleDateFormat("yyyy-MM F E");
java.util.Date date2= formatter2.parse("2003-05 5 星期五");
SimpleDateFormat formatter3 = new SimpleDateFormat("yyyy-MM-dd");
String mydate2=formatter3.format(date2);
out.println(mydate2);
out.println("<br>");
//求是星期几
mydate= myFormatter.parse("2001-1-1");
SimpleDateFormat formatter4 = new SimpleDateFormat("E");
String mydate3=formatter4.format(mydate);
out.println(mydate3);
out.println("<br>");
%>
posted @ 2006-04-29 11:05 氓氓 阅读(307) | 评论 (0)编辑 收藏

一、在使用Oracle的to_date函数来做日期转换时,很多Java程序员也许会和我一样,直觉的采用“yyyy-MM-dd HH:mm:ss”的格式作为格式进行转换,但是在Oracle中会引起错误:“ORA 01810 格式代码出现两次”。
如:select to_date('2005-01-01 13:14:20','yyyy-MM-dd HH24:mm:ss') from dual;
原因是SQL中不区分大小写,MM和mm被认为是相同的格式代码,所以Oracle的SQL采用了mi代替分钟。
select to_date('2005-01-01 13:14:20','yyyy-MM-dd HH24:mi:ss') from dual;

二、另要以24小时的形式显示出来要用HH24
select to_char(sysdate,'yyyy-MM-dd HH24:mi:ss') from dual;//mi是分钟
select to_char(sysdate,'yyyy-MM-dd HH24:mm:ss') from dual;//mm会显示月份
posted @ 2006-04-29 10:31 氓氓 阅读(6117) | 评论 (0)编辑 收藏

2006年4月27日 #

<%@page import="java.sql.*,java.io.*,java.util.*,java.text.*" contentType="text/html;charset=Big5" %>
<%
   SimpleDateFormat setDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
   /* 時:分:秒  HH:mm:ss  HH : 23小時制 (0-23)
                            kk : 24小時制 (1-24)
                            hh : 12小時制 (1-12)
                            KK : 11小時制 (0-11)*/

   String temp = setDateFormat.format(Calendar.getInstance().getTime());
%>
posted @ 2006-04-27 15:04 氓氓 阅读(1831) | 评论 (2)编辑 收藏

public class MyChinese {
  public static String Decode(String s) {
    try {
      return new String(s.getBytes("ISO8859_1"), "gb2312");
    }
    catch (Exception e) {
      return s;
    }
  }

  public static String Encode(String s) {
    try {
      return new String(s.getBytes("gb2312"), "ISO8859_1");
    }
    catch (Exception e) {
      return s;
    }
  }

}

posted @ 2006-04-27 11:35 氓氓 阅读(1040) | 评论 (1)编辑 收藏