亚洲自偷自偷精品,亚洲国产精品狼友中文久久久,亚洲午夜爱爱香蕉片

JSP内徏对象- -

�z�d��JAVA岛的日子 — Sun, 12 Feb 2006 03:35:00 GMT

JSP内徏对象- -

�?out - javax.servlet.jsp.jspWriter
out对象用于把结果输出到�|�页上�?/FONT>

�Ҏ(gu��)��Q?BR>1. void clear() ;
清除输出�~�冲区的内容�Q�但是不输出到客��L(f��ng)��?/FONT>

2. void clearBuffer() ;
清除输出�~�冲区的内容�Q��ƈ输出到客��L(f��ng)��?/FONT>

3. void close() ;
关闭输出��，清除所有内宏V�?/FONT>

4. void flush() ;
输出�~�冲区里面的数据�?/FONT>

5. int getBufferSize() ;
获取以kb为单位的目前�~�冲区大��?/FONT>

6. int getRemaining() ;
获取以kb为单位的�~�冲��Z��未被占用的空间大��?/FONT>

7. boolean isAutoFlush() ;
是否自动��h��~�冲区�?/FONT>

8. void newLine() ;
输出一个换行字�W��?/FONT>

9. void print( boolean b ) ;
   void print( char c ) ;
   void print( char[] s ) ;
   void print( double d ) ;
   void print( float f ) ;
   void print( int i ) ;
   void print( long l ) ;
   void print( Object obj ) ;
   void print( String s ) ;
   ��指定类型的数据输出到Http��，不换行�?/FONT>

10. void println( boolean b ) ;
    void println( char c ) ;
    void println( char[] s ) ;
    void println( double d ) ;
    void println( float f ) ;
    void println( int i ) ;
    void println( long l ) ;
    void println( Object obj ) ;
    void println( String s ) ;
    ��指定类型的数据输出到Http��，�q�输��Z��个换行符�?BR>
11. Appendable append( char c ) ;
    Appendable append( CharSequence cxq, int start, int end ) ;
    Appendable append( CharSequence cxq ) ;
    ��一个字�W�或者实��C��CharSequence接口的对象添加到输出��的后面�?/FONT>

成员�Q?BR>int DEFAULT_BUFFER = 0 - �~�省�~�冲区大��?BR>int NO_BUFFER = -1 - writer是否处于�~�冲输出状�?BR>int UNBOUNDED_BUFFER = -2 - 是否限制�~�冲区大��?/FONT>

�?request - javax.servlet.http.HttpServletRequest
request对象包含所有请求的信息�Q�如��h��的来源、标头、cookies和请求相关的参数值等�?/FONT>

�Ҏ(gu��)��Q?BR>1. Object getAttribute( String name ) ;
�q�回由name指定的属性��|��该属性不存在时返回null�?/FONT>

2. Enumeration getAttributeNames() ;
�q�回request对象的所有属性名�U�的集合�?/FONT>

3. String getAuthType() ;
�q�回用来保护servlet的认证方法的名称�Q�未受保护时�q�回null�?/FONT>

4. String getCharacterEncoding() ;
�q�回��h��中的字符�~�码�Ҏ(gu��)��Q�可以在response对象中设�|��?/FONT>

5. int getContentLength() ;
�q�回��h��的BODY的长度，不能��定长度时返�?1。可以在response中设�|��?/FONT>

6. String getContentType() ;
�q�回在response中定义的内容�c�d��?/FONT>

7. String getContentPath() ;
�q�回��h��的�\径�?/FONT>

8. Cookie[] getCookies() ;
�q�回客户端所有的Cookie的数�l��?/FONT>

9. Enumeration getHeaderNames() ;
�q�回所有HTTP头的名称的集合�?/FONT>

10. Enumeration getHeaders( String name ) ;
�q�回指定HTTP头的所有值的集合�?/FONT>

11. String getHeader( String name ) ;
�q�回指定名称的HTTP头的信息�?/FONT>

12. long getDateHeader( String name ) ;
�q�回指定名称的Data�c�d��的HTTP头的信息�?/FONT>

13. int getIntHeader( String name ) ;
�q�回指定名称的Int�c�d��的HTTP头的信息�?/FONT>

14. ServletInputStream getInputStream() ;
�q�回��h��的输入流�?/FONT>

15. Locale getLocale() ;
�q�回当前��늚�Locale对象�Q�可以在response中设定�?/FONT>

16. Enumeration getLocales() ;
�q�回��h��中所有的Locale对象的集合�?/FONT>

17. String getLocalName() ;
获取响应��h��的服务器端主机名�?/FONT>

18. String getLocalAddr() ;
获取响应��h��的服务器端地址�?/FONT>

19. int getLocalPort() ;
获取响应��h��的服务器端端�?/FONT>

20. String getMethod() ;
获取客户端向服务器端发送请求的�Ҏ(gu��)��(GET、POST)�?/FONT>

21. String getParameter( String name ) ;
获取客户端发送给服务器端的参数倹{�?/FONT>

22. Map getParameterMap() ;
该方法返回包含请求中所有参数的一个Map对象�?/FONT>

23. Enumeration getParameterNames() ;
�q�回��h��中所有参数的集合�?/FONT>

24. String[] getParameterValues( String name ) ;
获得��h��中指定参数的所有倹{�?/FONT>

25. String getQueryString() ;
�q�回get�Ҏ(gu��)��传递的参数字符�Ԍ��该方法不分解出单独的参数�?/FONT>

26. String getPathInfo() ;
取出��h��中处于ServletPath和QueryString之间的额外信息�?/FONT>

27. String getPathTranslated() ;
�q�回用getPathInfo()�Ҏ(gu��)��取得的�\径信息的实际路径�?/FONT>

28. String getProtocol() ;
�q�回��h��使用的协议。可以是HTTP1.1或者HTTP1.0�?/FONT>

29. BufferedReader getReader() ;
�q�回��h��的输入流对应的Reader对象�Q�该�Ҏ(gu��)��和getInputStream()�Ҏ(gu��)��在一个页面中只能调用一个�?/FONT>

30. String getRemoteAddr() ;
获取发出��h��的客��L(f��ng)��IP地址�?/FONT>

31. String getRemoteHost() ;
获取发出��h��的客��L(f��ng)��L��?/FONT>

32. String getRemoteUser() ;
�q�回�l�过客户端验证的用户名，未经验证�q�回null�?/FONT>

33. int getRemotePort() ;
�q�回发出��h��的客��L(f��ng)��L��端口�?/FONT>

34. String getRealPath( String path ) ;
�q�回�l�定虚拟路径的物理�\径�?/FONT>

35. RequestDispatcher getRequestDispatcher( String path ) ;
按给定的路径生成资源转向处理适配器对象�?/FONT>

36. String getRequestedSessionId() ;
�q�回��h��的session的标识�?/FONT>

37. String RequestURI() ;
�q�回发出��h��的客��L(f��ng)��地址�Q�但是不包括��h��的参数字�W�串�?/FONT>

38. StringBuffer getRequestURI() ;
�q�回响应��h��的服务器端地址

39. String getScheme() ;
获取协议名称�Q�缺省��gؓ(f��)HTTP协议�?/FONT>

40. String getServerName() ;
�q�回响应��h��的服务器名称�?/FONT>

41. String getServletPath() ;
获取客户端所��h��的脚本文件的文�g路径�?/FONT>

42. int getServerPort() ;
获取响应��h��的服务器端主机端口号�?/FONT>

43. void removeAttribute( String name ) ;
在属性列表中删除指定名称的属性�?/FONT>

44. void setAttribute( String name, Object value ) ;
在属性列表中��d��/删除指定的属性�?/FONT>

45. void setCharacterEncoding( String name ) ;
讄��h��的字�W�编码格式�?/FONT>

46. HttpSession getSession() ;
    HttpSession getSession( boolean create ) ;
    获取session�Q�如果create为true�Q�在无session的情况下创徏一个�?BR>
47. boolean isRequestedSessionIdFromCookie() ;
    ��(g��)查请求的�?x��)话ID是否为通过Cookie传入�?/FONT>

48. boolean isRequestedSessionIdFromURL() ;
��(g��)查请求的�?x��)话ID是否为通过URL传入�?/FONT>

49. boolean isRequestedSessionIdValid() ;
��(g��)查请求的�?x��)话ID是否仍然有效�?/FONT>

50. boolean isSecure() ;
��(g��)查请求是否��用安全链接，如果HTTPS�{��?/FONT>

51. boolean isUserInRole( String role ) ;
��(g��)查已�l�通过验证的用��h��否在是role所指定的角艌Ӏ?/FONT>

52. Principal getUserPrincipal() ;
�q�回包含用户登陆名的一个java.security.Principal对象�?/FONT>

成员�Q?BR>String BASIC_AUTH = "BASIC"             -
String CLIENT_CERT_AUTH = "CLIENT_CERT" -
String DIGEST_AUTH = "DIGEST"           -
String FORM_AUTH = "FORM"               -

�?response - javax.servlet.http.HttpServletResponse
response对象主要��JSP容器处理后的�l�果传回到客��L(f��ng)��?/FONT>

�Ҏ(gu��)��Q?BR>1. void addCookie( Cookie cookie ) ;
��d��一个Cookie对象�Q�保存客��L(f��ng)��信息�?/FONT>

2. void addDateHeader( String name, long value ) ;
��d��一个日期类型的HTTP头信息，覆盖同名的HTTP头信息�?/FONT>

3. void addHeader( String name, String value ) ;
��d��一个HTTP��_(d��)��覆盖同名的旧HTTP头�?/FONT>

4. void addIntHeader( String name, int value ) ;
��d��一个整型的HTTP��_(d��)��覆盖同名的旧HTTP头�?/FONT>

5. boolean containsHeader( String name ) ;
判断指定的HTTP头是否存在�?/FONT>

6. String encodeRedirectURL( String url ) ;
对sendRedirect()�Ҏ(gu��)��使用的URL�q�行�~�码�?/FONT>

7. String encodeURL( String url ) ;
��URL予以�~�码�Q�回传包含session ID的URL�?BR>
8. void flushBuffer() ;
强制把当前缓冲区的内容发送到客户端�?/FONT>

9. int getBufferSize() ;
取得以kb为单位的�~�冲区大��?/FONT>

10. String getCharacterEncoding() ;
获取响应的字�W�编码格式�?/FONT>

11. String getContentType() ;
获取响应的类型�?/FONT>

12. Locale getLocale() ;
获取响应的Locale对象�?/FONT>

13. ServletOutputStream getOutputStream() ;
�q�回客户端的输出��对象�?/FONT>

14. PrintWriter getWriter() ;
获取输出��对应的writer对象�?/FONT>

15. boolean isCommitted() ;
判断服务器端是否已经��数据输出到客户端�?/FONT>

16. void reset() ;
清空buffer中的所有内宏V�?/FONT>

17. void resetBuffer() ;
情况buffer中所有的内容�Q�但是保留HTTP头和状态信息�?/FONT>

18. void sendError( int xc, String msg ) ;
void sendError( int xc ) ;
发送错误，包括状态码和错误信息�?/FONT>

19. void sendRedirect( String locationg ) ;
把响应发送到另外一个位�|�进行处理�?/FONT>

20. void setBufferSize( int size ) ;
讄��以kb为单位的�~�冲区大��?/FONT>

21. void setCharacterEncoding( String charset ) ;
讄��响应使用的字�W�编码格式�?/FONT>

22. void setContentLength( int length ) ;
讄��响应的BODY长度�?/FONT>

23. void setContentType( String type ) ;
讄��响应的类型�?/FONT>

24. void setDateHeader( String name, long value ) ;
讄��指定名称的Data�c�d��的HTTP头的倹{�?/FONT>

25. void setHeader( String name, String value ) ;
讄��指定名称的HTTP头的倹{�?/FONT>

26. void setIntHeader( String name, int value ) ;
讄��指定名称的int�c�d��的HTTP头的倹{�?/FONT>

27. void setStatus( int xc ) ;
讄��响应状态码�Q�新��g��(x��)覆盖当前倹{�?/FONT>

成员(HTTP状态码)�Q?BR>int SC_CONTINUE = 100                      int SC_SWITCHING_PROTOCOLS = 101
int SC_OK = 200                            int SC_NON_AUTHORITATIVE_INFORMATION = 203
int SC_ACCEPTED = 202                      int SC_CREATED = 201
int SC_NO_CONTENT = 204                    int SC_RESET_CONTENT = 205
int SC_PARTIAL_CONTENT = 206               int SC_MULTIPLE_CHOICES = 300
int SC_MOVED_PERMANENTLY = 301             int SC_MOVED_TEMPORARILY = 302
int SC_FOUND = 302                         int SC_SEE_OTHER = 303
int SC_NOT_MODIFIED = 304                  int SC_USE_PROXY = 305
int SC_TEMPORARY_REDIRECT = 307            int SC_BAD_REQUEST = 400
int SC_UNAUTHORIZED = 401                  int SC_PAYMENT_REQUIRED = 402
int SC_FORBIDDEN = 403                     int SC_NOT_FOUND = 404
int SC_METHOD_NOT_ALLOWED = 405            int SC_NOT_ACCEPTABLE = 406
int SC_PROXY_AUTHENTICATION_REQUIRED = 407 int SC_REQUEST_TIMEOUT = 408
int SC_CONFLICT = 409                      int SC_GONE = 410
int SC_LENGTH_REQUIRED = 411               int SC_PRECONDITION_FAILED = 412
int SC_REQUEST_ENTITY_TOO_LARGE = 413      int SC_REQUEST_URI_TOO_LONG = 414
int SC_UNSUPPORTED_MEDIA_TYPE = 415        int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416
int SC_EXPECTATION_FAILED = 417            int SC_INTERNAL_SERVER_ERROR = 500
int SC_NOT_IMPLEMENTED = 501               int SC_BAD_GATEWAY = 502
int SC_SERVICE_UNAVAILABLE = 503           int SC_GATEWAY_TIMEOUT = 504
int SC_HTTP_VERSION_NOT_SUPPORTED = 505

�?session - javax.servlet.http.HttpSession
session对象表示目前个别用户的会(x��)话状态，用来识别每个用户�?/FONT>

�Ҏ(gu��)��Q?BR>1. Object getAttribute( String name ) ;
获取与指定名字相兌��的session属性倹{�?/FONT>

2. Enumeration getAttributeNames() ;
取得session内所有属性的集合�?/FONT>

3. long getCreationTime() ;
�q�回session的创建时��_(d��)��最��单位千分之一�U��?/FONT>

4. String getId() ;
取得session标识�?/FONT>

5. long getLastAccessedTime() ;
�q�回与当前session相关的客��L(f��ng)��最后一�ơ访问的旉��Q�由1970-01-01��v�Q�单位毫�U��?/FONT>

6. int getMaxInactiveInterval( int interval ) ;
�q�回��L��_(d��)��以秒为单位，表示session的有效时�?session不活动时�?�?1为永不过期�?/FONT>

7. ServletContext getServletContext() ;
�q�回一个该JSP��面对应的ServletContext对象实例�?/FONT>

8. HttpSessionContext getSessionContext() ;

9. Object getValue( String name ) ;
取得指定名称的session变量��|��不推荐��用�?/FONT>

10. String[] getValueNames() ;
取得所有session变量的名�U�的集合�Q�不推荐使用�?/FONT>

11. void invalidate() ;
销毁这个session对象�?/FONT>

12. boolean isNew() ;
判断一个session是否由服务器产生�Q�但是客��L(f��ng)��q�没有��用�?/FONT>

13. void pubValue( String name, Object value ) ;
��d��一个session变量�Q�不推荐使用�?/FONT>

14. void removeValue( String name ) ;
�U�除一个session变量的��|��不推荐��用�?/FONT>

15. void setAttribute( String name, String value ) ;
讄��指定名称的session属性倹{�?/FONT>

16. void setMaxInactiveInterval( int interval ) ;
讄��session的有效期�?/FONT>

17. void removeAttribute( String name ) ;
�U�除指定名称的session属性�?/FONT>

�?pageContext - javax.servlet.jsp.PageContext
pageContext对象存储本JSP��面相关信息�Q�如属性、内建对象等�?/FONT>

�Ҏ(gu��)��Q?BR>1. void setAttribute( String name, Object value, int scope ) ;
void setAttribute( String name, Object value ) ;
在指定的�׃�n范围内设�|�属性�?/FONT>

2. Object getAttribute( String name, int scope ) ;
Object getAttribute( String name ) ;
取得指定�׃�n范围内以name为名字的属性倹{�?/FONT>

3. Object findAttribute( String name ) ;
按页面、请求、会(x��)话和应用�E�序�׃�n范围搜烦(ch��)已命名的属性�?/FONT>

4. void removeAttribute( String name, int scope ) ;
void removeAttribute( String name ) ;
�U�除指定名称和共享范围的属性�?/FONT>

5. void forward( String url ) ;
��页面导航到指定的URL�?/FONT>

6. Enumeration getAttributeNamesScope( int scope ) ;
取得指定�׃�n范围内的所有属性名�U�的集合�?/FONT>

7. int getAttributeScope( String name ) ;
取得指定属性的�׃�n范围�?/FONT>

8. ErrorData getErrorDate() ;
取得��面的errorData对象�?/FONT>

9. Exception getException() ;
取得��面的exception对象�?/FONT>

10. ExpressionEvaluator getExpressionEvaluator() ;
取得��面的expressionEvaluator对象�?/FONT>

11. JspWriter getOut() ;
取得��面的out对象�?/FONT>

12. Object getPage() ;
取得��面的page对象�?/FONT>

13. ServletRequest getRequest() ;
取得��面的request对象�?/FONT>

14. ServletResponse getResponse() ;
取得��面的response对象�?/FONT>

15. ServletConfig getConfig() ;
取得��面的config对象�?/FONT>

16. ServletContext getServletContext() ;
取得��面的servletContext对象�?/FONT>

17. HttpSession getSession() ;
取得��面的session对象�?/FONT>

18. VariableResolver getVariableResolver() ;
取得��面的variableResolver对象�?/FONT>

19. void include( String url, boolean flush ) ;
void include( String url ) ;
包含其他的资源，�q�指定是否自动刷新�?/FONT>

20. void release() ;
重置pageContext内部状态，释放所有内部引用�?/FONT>

21. void initialize( Servlet servlet, ServletRequest request, ServletResponse response,
String errorPageURL, boolean needSession, int bufferSize, boolean autoFlush ) ;
初始化未�l�初始化的pageContext对象�?/FONT>

22. BodyContext pushBody() ;
BodyContext pushBody( Writer writer ) ;
保存当前的out对象�Q��ƈ更新pageContext中page范围内的out对象�?/FONT>

23. JspWrite popBody() ;
取出由pushBody()�Ҏ(gu��)��保存的out对象�?/FONT>

24. void handlePageException( Exception e ) ;
void handlePageException( Thrwoable t ) ;

成员�Q?BR>int PAGE_SCOPE = 1        - ��面�׃�n范围
int REQUEST_SCOPE = 2     - ��h��׃�n范围
int SESSION_SCOPE = 3     - �?x��)话�׃�n范围
int APPLICATION_SCOPE = 4 - 应用�E�序�׃�n范围
String PAGE = "javax.servlet.jsp.jspPage"
String PAGECONTEXT = "javax.servlet.jsp.jspPageContext"
String REQUEST = "javax.servlet.jsp.jspRequest"
String RESPONSE = "javax.servlet.jsp.jspResponse"
String CONFIG = "javax.servlet.jsp.jspConfig"
String SESSION = "javax.servlet.jsp.jspSession"
String OUT = "javax.servlet.jsp.jspOut"
String APPLICATION = "javax.servlet.jsp.jspApplication"
String EXCEPTION = "javax.servlet.jsp.jspException"

�?application - javax.servlet.ServletContext
application主要功用在于取得或更改Servlet的设定�?/FONT>

�Ҏ(gu��)��Q?BR>1. Object getAttribute( String name ) ;
�q�回由name指定的application属性�?/FONT>

2. Enumeration getAttributes() ;
�q�回所有的application属性�?/FONT>

3. ServletContext getContext( String uripath ) ;
取得当前应用的ServletContext对象�?/FONT>

4. String getInitParameter( String name ) ;
�q�回由name指定的application属性的初始倹{�?/FONT>

5. Enumeration getInitParameters() ;
�q�回所有的application属性的初始值的集合�?/FONT>

6. int getMajorVersion() ;
�q�回servlet容器支持的Servlet API的版本号�?/FONT>

7. String getMimeType( String file ) ;
�q�回指定文�g的类型，未知�c�d��q�回null。一般�ؓ(f��)"text/html"�?image/gif"�?/FONT>

8. int getMinorVersion() ;
�q�回servlet容器支持的Servlet API的副版本受��?/FONT>

9. String getRealPath( String path ) ;
�q�回�l�定虚拟路径所对应物理路径�?/FONT>

10. RequestDispatcher getNamedDispatcher( String name ) ;
为指定名字的Servlet对象�q�回一个RequestDispatcher对象的实例�?/FONT>

11. RequestDispatcher getRequestDispatcher( String path ) ;
�q�回一个RequestDispatcher对象的实例�?/FONT>

12. URL getResource( String path ) ;
�q�回指定的资源�\径对应的一个URL对象实例�Q�参数要�?/"开头�?/FONT>

13. InputStream getResourceAsStream( String path ) ;
�q�回一个由path指定位置的资源的InputStream对象实例�?/FONT>

14. Set getResourcePaths( String path ) ;
�q�回存储在web-app中所有资源�\径的集合�?/FONT>

15. String getServerInfo() ;
取得应用服务器版本信息�?/FONT>

16. Servlet getServlet( String name ) ;
在ServletContext中检索指定名�U�的servlet�?/FONT>

17. Enumeration getServlets() ;
�q�回ServletContext中所有servlet的集合�?/FONT>

18. String getServletContextName() ;
�q�回本web应用的名�U��?/FONT>

19. Enumeration getServletContextNames() ;
�q�回ServletContext中所有servlet的名�U�集合�?/FONT>

20. void log( Exception ex, String msg ) ;
    void log( String msg, Throwable t ) ;
    void log( String msg ) ;
    把指定的信息写入servlet log文�g�?/FONT>

21. void removeAttribute( String name ) ;
�U�除指定名称的application属性�?/FONT>

22. void setAttribute( String name, Object value ) ;
讑֮�指定的application属性的倹{�?/FONT>

�?config - javax.servlet.ServletConfig
config对象用来存放Servlet初始的数据结构�?/FONT>

�Ҏ(gu��)��Q?BR>1. String getInitParameter( String name ) ;
�q�回名称为name的促使参数的倹{�?/FONT>

2. Enumeration getInitParameters() ;
�q�回�q�个JSP所有的促��参数的名�U�集合�?/FONT>

3. ServletContext getContext() ;
�q�回执行者的servlet上下文�?/FONT>

4. String getServletName() ;
�q�回servlet的名�U��?/FONT>

�?exception - java.lang.Throwable
错误对象�Q�只有在JSP��面的page指��o(h��)中指定isErrorPage="true"后，才可以在本页面��用exception对象�?/FONT>

�Ҏ(gu��)��Q?BR>1. Throwable fillInStackTrace() ;
��当前stack信息记录到exception对象中�?/FONT>

2. String getLocalizedMessage() ;
取得本地语系的错误提�C�Z��息�?/FONT>

3. String getMessage()
取得错误提示信息�?/FONT>

4. StackTrackElement[] getStackTrace() ;
�q�回对象中记录的call stack track信息�?/FONT>

5. Throwable initCause( Throwable cause ) ;
��另外一个异常对象嵌套进当前异常对象中�?BR>
6. Throwable getCause() ;
取出嵌套在当前异常对象中的异常�?/FONT>

7. void printStackTrace() ;
   void printStackTrace( printStream s ) ;
   void printStackTrace( printWriter s ) ;
   打印出Throwable�?qi��ng)其call stack trace信息�?/FONT>

8. void setStackTrace( StackTraceElement[] stackTrace )
讄��对象的call stack trace信息�?/FONT>

�?page - javax.servlet.jsp.HttpJspPage
page对象代表JSP对象本��n�Q�或者说代表�~�译后的servlet对象�Q?BR> 可以�? (javax.servlet.jsp.HttpJspPage)page )来取用它的方法和属性�?/FONT>

�z�d��JAVA岛的日子 2006-02-12 11:35 发表评论

Servlets/JSP开发技术问�{?转脓(chu��ng))

�z�d��JAVA岛的日子 — Sun, 12 Feb 2006 03:29:00 GMT

��Z��么GenericServlet在init(ServletConfig config)基础上增加了一个init()�Ҏ(gu��)��Q?

init()�Ҏ(gu��)��被GenericServlet.init(ServletConfig config)�Ҏ(gu��)��调用�?BR>init()�Ҏ(gu��)��方便了开发�h员定制Servlet的初始化�Q�而无��d��l�护ServletConfig对象的存储工作�?BR>重写GenericServlet.init(ServletConfig config)必须要显�C�的调用super.init(config)�Ҏ(gu��)��?

ServletContext.getContect(java.lang.String uripath)的作用是什么？

�q�回同一Server中指定的path对应的ServletContext对象,通过该对象可以实��C��Server中的其他Context打交道�?BR>uripath必须是以"/"开始（该�\径的含义是相对于整个Servlet文档的根路径�Q�而不是当前ServletContext的根路径�Q��?

Servlet生命周期是什么？

一般的Servlet(GenericServlet,即与协议无关的Servlet)的生命周期：(x��)init() --> GenericServlet.service(ServletRequest req, ServletResponse res) --> destroy.
HttpServlet的生命周�? init() --> GenericServlet.service(ServletRequest req, ServletResponse res)---> service(HttpServletRequest req, HttpServletResponse resp) --> doXXXX()-->destroy.

有没有必要重写GenericServlet.service()�Ҏ(gu��)��Q?

对于HttpServlet来说没有必要。只需要重写它的doXXXX()�Ҏ(gu��)��可以了。HttpServlet中service()�Ҏ(gu��)��?x��)自动的��?gu��)��用户��h��c�d��把请求�{发给相应的doXXXX()�Ҏ(gu��)��Q�例如doGet()�Ҏ(gu��)��Q��?

ServletRequest.getReader()和ServletRequest.getInputStream()如何使用�Q?

注意两个�Ҏ(gu��)��不能同时使用�?

ServletRequest.getRealPath(String path)�Ҏ(gu��)��已经不推荐��用�?

请��用ServletContext.getRealPath(String path)�Ҏ(gu��)��?

ServletResponse�~�省的字�W�集(charset)是什�?

ServletResponse�~�省的字�W�集(charset)是ISO-8859-1,可以通过setContentType(java.lang.String)�Ҏ(gu��)��改变新的字符集�?BR>例如�Q�setContentType("text/html; charset=Shift_JIS").
关于字符集信息，可以��览RFC 2045

HttpServletRequest.getRequestURI()和HttpServletRequest.getRequestURL()区别是什�?

request.getRequestURI() �q�回值类��|��(x��)/xuejava/requestdemo.jsp
request.getRequestURL() �q�回值类��|��(x��)http://localhost:8080/xuejava/requestdemo.jsp

HttpServletRequest.encodeURL()和HttpServletRequest.encodeRedirectURL(()区别是什�?��Z��么要有两个不同的�Ҏ(gu��)��呢？

当用URL-rewriting方式来管理Session的时候，需要用��C��上的两个�Ҏ(gu��)��?BR>两个�Ҏ(gu��)��的不同点是：(x��)两个�Ҏ(gu��)��定是否需要包含session ID的逻辑不同�?BR>在调用HttpServletResponse.sendRedirect前，应该先调用encodeRedirectURL()�Ҏ(gu��)��Q�否则可能会(x��)丢失Sesssion信息�?...

如何使你的Servlet或者JSP实现Single Thread Model?

对于Servlet实现javax.single.SingleThreadModel接口�?BR>对于JSP,在Page Directive中写如下的语�?!--page isThreadSafe="false"-->

JSP Tag �?JSP XML-based Tag

...

如何把某一个JSP Page定义成�ؓ(f��)Error Page?��Z��么要�q�样做？

实现�Ҏ(gu��)��Q?
��Z��么？因�ؓ(f��)需要获取Exception 对象�Q�缺省情况下�Q�在JSP Page中是不能直接使用“隐含对象�?exception的）(j��)�?

JSP Page的执行顺序是如何的？

JSP Page的执行顺序如下：(x��)

JSP Page Translation. JSP Page --> Servlet source code.
JSP Page Compilation. Servlet source code --> Servlet class.
Load Class(First time or the server restarted)
Create instance(可能�?x��)很多次�Q�如果JSP Page中声明了)
Call jspInit method�Q�一般的JSP Page都没有重写这个方法，重写需要在声明语句�D�中�Q��?
Call _jspService method�Q�类��g��一般HttpServlet的doGet和doPost�Ҏ(gu��)��Q�但是可以同时用来处理Post和Getq��h��Q��?
Call jspDestroy method�Q�Server在卸载Servet的时候，例如当Servlet很久没有使用的情况）(j��)�?

JSP Page中有哪些隐含对象(Implicity Object)?各自的类型和作用是什么？

request --
reponse --
session --
application --
out --
page --
pagecontext --
exception -- 只有在当前JSP Page为Error Page的时候才有效�?
config --

�?<@ include file="/foo/foo.jsp" %>的区别是什么？

<@ include ... -- Page translation time.

Servlets/JSP Container(Engine)有几�U�运行方式？

Standalone
Tomcat standalone mode

In-process
Tomcat running inside Apache Web Server.

Out-of-process
Apache + mod_jk + Tomcat

Servlet,Servlet开发�h员，Servlet API, Servlet Container的关�p�L��什么？

Servlet,Servlet开发�h�?--->Servlet API --> Servlet Container

The parts of an HTTP message

 
    Message part Description
    The initial line�Q?Specifies the purpose of the request or response message
                       例子�Q�GET /reports/sales/index.html HTTP/1.0 
    The header section:Specifies the meta-information, such as size, type, and encoding, 
                       about the content of the message
    A blank line: 
    An optional message body: The main content of the request or response message

下面是一个Response的例子：(x��)

 
    
    HTTP/1.0 200 OK
    Date: Tue, 01 Dec 2001 23:59:59 GMT
    Content-Type: text/html
    Content-Length: 52
    
    
    
    Hello, John!

HTTP规范中定义了哪些�Ҏ(gu��)��Q�各自有什么用途？

GET
HEAD
POST
�?Http 1.1规范开始，增加了以下的�Ҏ(gu��)��:

PUT
OPTIONS
TRACE
DELETE
CONNECT

ServetRequest中�ؓ(f��)什么要定义:getContentType(),getContentLength()�Ҏ(gu��)��?/STRONG>
�Ҏ(gu��)��HTTP协议规范�Q�Request �?Response一样也有这些必不可��的内容�Q?BR>所以需要首先了�?HTTP Message的概念和其内容的格式�Q�这些东西对于Request和Reponse是一��L(f��ng)��?BR>对于GET方式发送的��h��Q�其内容�c�d��为：(x��)null
对于POST方式发送的��h��Q�其内容�c�d��为：(x��)application/x-www-form-urlencoded

POST方式发送请求的内容�c�M��于：(x��)username=xuejava.

RequestDispatcher.forward()和HttpServletResponse.sendRedirect()的区别是什么？
RequestDispatcher.forward()是在服务器端�q�行�Q�HttpServletResponse.sendRedirect()是通过向客��h��览器发送命令来完成�?BR>所以RequestDispatcher.forward()对于��览器来说是“透明的”；而HttpServletResponse.sendRedirect()则不是�?BR>另外�Q�还要注意RequestDispatcher.forward()在调用的时候Response不能已经Commit了（Response.isCommitted()�Q��?

ServletContext.getRequestDispatcher(String url)和ServletRequest.getRequestDispatcher(String url)的区别是什么？��Z��么？
ServletContext.getRequestDispatcher(String url)中的url只能使用�l�对路径�Q�而ServletRequest.getRequestDispatcher(String url)中的url可以使用相对路径�?BR>因�ؓ(f��)ServletRequest��h��相对路径的概念；而ServletContext对象无次概念�?BR>

如何把请求�{�U�d��另外一个Web App中的某个地址�Q?/STRONG>
ServletContext.getRequestDispatcher(String url)和ServletRequest.getRequestDispatcher(String url)只能把请求�{�U�d��同一个Web App中的地址�?BR>如果需要把��h��转移到另外一个Web App中的某个地址�Q�可以按下面的做法：(x��)
1. 获得另外一个Web App的ServletConext对象(currentServletContext.getContext(uripath)).
2. 调用ServletContext.getRequestDispatcher(String url)�Ҏ(gu��)��?

�z�d��JAVA岛的日子 2006-02-12 11:29 发表评论

全面理解String 转脓(chu��ng)

�z�d��JAVA岛的日子 — Tue, 06 Dec 2005 14:28:00 GMT

全面理解String(JAVA复习(f��n))- -


1.      首先不属�?/SPAN>�U�基本数据类型，是一个对象�?/SPAN>因�ؓ(f��)对象的默认值是�Q�所�?/SPAN>的默认��g��?/SPAN>�Q?/SPAN>但它又是一�U�特�D�的对象�Q�有其它对象没有的一些特性�?/SPAN>2.      �?/SPAN>都是��x��一个新的空字符�Ԍ��是空串不�?/SPAN>�Q?/SPAN>3.      �Q?/SPAN>的区别：(x��)在这里，我们不谈堆，也不谈栈�Q�只先简单引入常量池�q�个��单的概念�?/SPAN>帔R��?/SPAN>指的是在�~�译期被��定�Q��ƈ被保存在已编译的文�g中的一些数据。它包括了关于类、方法、接口等中的帔R��Q�也包括字符串常量�?/SPAN>看例�Q?/SPAN>        String s0=”kvill�?

        String s1=”kvill�?

        String s2=”kv�?+ “ill�?

        System.out.println( s0==s1 );

        �l�果为：(x��)       首先�Q�我们要知道�?x��)确保一个字�W�串帔R��只有一个拷贝�?/SPAN>因�ؓ(f��)例子中的�?/SPAN>中的都是字符串常量，它们在编译期��p��定了，所�?/SPAN>�?/SPAN>�Q��?/SPAN>�?/SPAN>也都是字�W�串帔R��Q�当一个字�W�串由多个字�W�串帔R��q�接而成�Ӟ��它自��p��定也是字�W�串帔R��Q�所�?/SPAN>也同样在�~�译期就被解析�ؓ(f��)一个字�W�串帔R��Q�所�?/SPAN>也是帔R��池中的一个引用�?/SPAN>所以我们得�?/SPAN>�?/SPAN>创徏的字�W�串不是帔R��Q�不能在�~�译期就��定�Q�所�?/SPAN>创徏的字�W�串不放入常量池中，它们有自��q��地址�I�间�?/SPAN>看例�Q?/SPAN>        String s0=”kvill�?

        String s1=new String(”kvill�?;

        String s2=”kv�?+ new String(“ill�?;

        System.out.println( s0==s1 );

        �l�果为：(x��)       �?/SPAN>�?/SPAN>�q�是帔R��池中的应用，因�ؓ(f��)无法在编译期��定�Q�所以是�q�行时创建的新对�?/SPAN>的引用，因�ؓ(f��)有后半部�?/SPAN>所以也无法在编译期��定�Q�所以也是一个新创徏对象的应�?/SPAN>明白了这些也��q��道�ؓ(f��)何得出此�l�果了�?/SPAN>4.      �Q?/SPAN>再补充介�l�一点：(x��)存在�?/SPAN>文�g中的帔R��池，在运行期�?/SPAN>装蝲�Q��ƈ且可以扩充�?/SPAN>�?/SPAN>�Ҏ(gu��)��是扩充帔R��池的一个方法；当一�?/SPAN>实例调用�Ҏ(gu��)��Ӟ��查找帔R��池中是否有相�?/SPAN>的字�W�串帔R��Q�如果有�Q�则�q�回其的引用�Q�如果没有，则在帔R��池中增加一�?/SPAN>�{�于的字�W�串�q�返回它的引用；看例��清楚了�?/SPAN>�Q?/SPAN>        String s0= “kvill�?

        String s1=new String(”kvill�?;

        String s2=new String(“kvill�?;

        System.out.println( s0==s1 );

        System.out.println( �?*********�?);

       s1.intern();

        s2=s2.intern();             //把常量池中�?/SPAN>”的引用赋给        System.out.println( s0==s1);

        �l�果为：(x��)

       //虽然执行�?/SPAN>但它的返回值没有赋�l?/SPAN>    //说明�q�回的是帔R��池中的引�?/SPAN>



       最后我再破除一个错误的理解�Q?/SPAN>有�h��_(d��)��“��?/SPAN>�Ҏ(gu��)��则可以将一�?/SPAN>�cȝ��保存��C��个全局表中如果��h��相同值的字符串已�l�在�q�个表中�Q�那么该�Ҏ(gu��)��q�回表中已有字符串的地址如果在表中没有相同值的字符�Ԍ��则将自己的地址注册到表中�?/SPAN>如果我把他说的这个全局�?/SPAN>表理解�ؓ(f��)帔R��池的话，他的最后一句话�Q�“如果在表中没有相同值的字符�Ԍ��则将自己的地址注册到表中”是错的�Q?/SPAN>看例�Q?/SPAN>        String s1=new String("kvill");

        String s2=s1.intern();

"+s2 );

�l�果�Q?/SPAN> kvill

在这个类中我们没有声名一�?/SPAN>帔R��Q�所以常量池中一开始是没有�?/SPAN>当我们调�?/SPAN>后就在常量池中新��d��了一�?/SPAN>帔R��Q�原来的不在帔R��池中�?/SPAN>仍然存在�Q�也��׃��是“将自己的地址注册到常量池中”了�?/SPAN>       s1==s1.intern()�?/SPAN>说明原来的�?/SPAN>”仍然存在；       s2现在为常量池中�?/SPAN>的地址�Q�所以有�?/SPAN>�?/SPAN>5.      关于�?/SPAN>�q�个对于��单来说就是比较两字符串的序列是否相当�Q�如果相�{�返�?/SPAN>�?/SPAN>是比较两字符串的地址是否相同�Q�也��是是否是同一个字�W�串的引用�?/SPAN>6.      关于是不可变的�?/SPAN>�q�一说又要说很多�Q�大家只要知�?/SPAN>的实例一旦生成就不会(x��)再改变了�Q?/SPAN>比如��_(d��)��(x��) �?”ans�?

��是�?/SPAN>个字�W�串帔R��Q�首�?/SPAN>�?/SPAN>生成�?/SPAN>存在内存中，然后又和 �?生成 �?/SPAN>存在内存中，最后又和生成了 ans�?�q�把�q�个字符串的地址赋给�?/SPAN>��是因�ؓ(f��)的“不可变”��生了很多临时变量�Q�这也就是�ؓ(f��)什么徏议用的原因了�Q�因�?/SPAN>是可改变�?/SPAN>

�z�d��JAVA岛的日子 2005-12-06 22:28 发表评论

Vetor Arraylist list

�z�d��JAVA岛的日子 — Thu, 24 Nov 2005 17:05:00 GMT

Vector、ArrayList和List的异同[zz]

�U�性表�Q�链表，哈希表是常用的数据结构，在进行Java开发时�Q�JDK已经为我们提供了一�p�d��相应的类来实现基本的数据�l�构。这些类均在java.util包中。本文试��N��过��单的描述�Q�向读者阐�q�各个类的作用以�?qi��ng)如何正��用这些类�?

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap

Collection接口
　　Collection是最基本的集合接口，一个Collection代表一�l�Object�Q�即Collection的元素（Elements�Q�。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接��承自Collection的类�Q�Java SDK提供的类都是�l�承自Collection的“子接口”如List和Set�?BR>　　所有实现Collection接口的类都必��L��供两个标准的构造函敎ͼ�(x��)无参数的构造函数用于创��Z��个空的Collection�Q�有一个Collection参数的构造函数用于创��Z��个新的Collection�Q�这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection�?BR>　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个�P代子�Q��用该�q�代子即可逐一讉K��Collection中每一个元素。典型的用法如下�Q?BR>　　　　Iterator it = collection.iterator(); // 获得一个�P代子
　　　　while(it.hasNext()) {
　　　　　　Object obj = it.next(); // 得到下一个元�?BR>　　　　}
　　由Collection接口�z��的两个接口是List和Set�?/FONT>

List接口
　　List是有序的Collection�Q��用此接口能够�_��的控制每个元素插入的位置。用戯��够��用烦(ch��)引（元素在List中的位置�Q�类��g��数组下标�Q�来讉K��List中的元素�Q�这�c�M��于Java的数�l��?BR>和下面要提到的Set不同�Q�List允许有相同的元素�?BR>　　除了��h��Collection接口必备的iterator()�Ҏ(gu��)��外，List�q�提供一个listIterator()�Ҏ(gu��)��Q�返回一个ListIterator接口�Q�和标准的Iterator接口相比�Q�ListIterator多了一些add()之类的方法，允许��d��Q�删除，讑֮�元素�Q�还能向前或向后遍历�?BR>　　实现List接口的常用类有LinkedList�Q�ArrayList�Q�Vector和Stack�?/FONT>

LinkedList�c?BR>　　LinkedList实现了List接口�Q�允许null元素。此外LinkedList提供额外的get�Q�remove�Q�insert�Ҏ(gu��)��在LinkedList的首部或��N��。这些操作��LinkedList可被用作堆栈�Q�stack�Q�，队列�Q�queue�Q�或双向队列�Q�deque�Q��?BR>　　注意LinkedList没有同步�Ҏ(gu��)��。如果多个线�E�同时访问一个List�Q�则必须自己实现讉K��同步。一�U�解��x��法是在创建List时构造一个同步的List�Q?BR>　　　　List list = Collections.synchronizedList(new LinkedList(...));

ArrayList�c?BR>　　ArrayList实现了可变大��的数组。它允许所有元素，包括null。ArrayList没有同步�?BR>size�Q�isEmpty�Q�get�Q�set�Ҏ(gu��)��q�行旉��为常数。但是add�Ҏ(gu��)��开销为分摊的常数�Q�添加n个元素需要O(n)的时间。其他的�Ҏ(gu��)��q�行旉��为线性�?BR>　　每个ArrayList实例都有一个容量（Capacity�Q�，即用于存储元素的数组的大��。这个容量可随着不断��d��新元素而自动增加，但是增长��法�q�没有定义。当需要插入大量元素时�Q�在插入前可以调用ensureCapacity�Ҏ(gu��)��来增加ArrayList的容量以提高插入效率�?BR>　　和LinkedList一��P��ArrayList也是非同步的�Q�unsynchronized�Q��?/FONT>

Vector�c?BR>　　Vector非常�c�M��ArrayList�Q�但是Vector是同步的。由Vector创徏的Iterator�Q�虽然和ArrayList创徏的Iterator是同一接口�Q�但是，因�ؓ(f��)Vector是同步的�Q�当一个Iterator被创��且正在被��用，另一个线�E�改变了Vector的状态（例如�Q�添加或删除了一些元素）(j��)�Q�这时调用Iterator的方法时��抛出ConcurrentModificationException�Q�因此必��L��莯��异常�?/FONT>

Stack �c?BR>　　Stack�l�承自Vector�Q�实��C��个后�q�先出的堆栈。Stack提供5个额外的�Ҏ(gu��)��使得Vector得以被当作堆栈��用。基本的push和pop�Ҏ(gu��)��Q�还有peek�Ҏ(gu��)��得到栈顶的元素，empty�Ҏ(gu��)��试堆栈是否为空�Q�search�Ҏ(gu��)��(g��)��一个元素在堆栈中的位置。Stack刚创建后是空栈�?/FONT>

Set接口
　　Set是一�U�不包含重复的元素的Collection�Q�即��L��的两个元素e1和e2都有e1.equals(e2)=false�Q�Set最多有一个null元素�?BR>　　很明显，Set的构造函数有一个约束条�Ӟ��传入的Collection参数不能包含重复的元素�?BR>　　��h��意：(x��)必须��心操作可变对象�Q�Mutable Object�Q�。如果一个Set中的可变元素改变了自�w�状态导致Object.equals(Object)=true��导致一些问题�?/FONT>

Map接口
　　��h��意，Map没有�l�承Collection接口�Q�Map提供key到value的映��。一个Map中不能包含相同的key�Q�每个key只能映射一个value。Map接口提供3�U�集合的视图�Q�Map的内容可以被当作一�l�key集合�Q�一�l�value集合�Q�或者一�l�key-value映射�?/FONT>

Hashtable�c?BR>　　Hashtable�l�承Map接口�Q�实��C��个key-value映射的哈希表。�Q何非�I�（non-null�Q�的对象都可作�ؓ(f��)key或者value�?BR>　　��d��数据使用put(key, value)�Q�取出数据��用get(key)�Q�这两个基本操作的时间开销为常数�?BR>Hashtable通过initial capacity和load factor两个参数调整性能。通常�~�省的load factor 0.75较好地实��C��旉��和空间的均衡。增大load factor可以节省�I�间但相应的查找旉��增大，�q�会(x��)影响像get和put�q�样的操作�?BR>使用Hashtable的简单示例如下，��?�Q?�Q?攑ֈ�Hashtable中，他们的key分别是”one”，”two”，”three”：(x��)
　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one�? new Integer(1));
　　　　numbers.put(“two�? new Integer(2));
　　　　numbers.put(“three�? new Integer(3));
　　要取��Z��个数�Q�比�?�Q�用相应的key�Q?BR>　　　　Integer n = (Integer)numbers.get(“two�?;
　　　　System.out.println(“two = �?+ n);
　　�׃��作�ؓ(f��)key的对象将通过计算其散列函数来��定与之对应的value的位�|�，因此��M��作�ؓ(f��)key的对象都必须实现hashCode和equals�Ҏ(gu��)��。hashCode和equals�Ҏ(gu��)��l�承自根�c�Object�Q�如果你用自定义的类当作key的话�Q�要相当��心�Q�按照散列函数的定义�Q�如果两个对象相同，即obj1.equals(obj2)=true�Q�则它们的hashCode必须相同�Q�但如果两个对象不同�Q�则它们的hashCode不一定不同，如果两个不同对象的hashCode相同�Q�这�U�现象称为冲�H�，冲突�?x��)导致操作哈希表的时间开销增大�Q�所以尽量定义好的hashCode()�Ҏ(gu��)��Q�能加快哈希表的操作�?BR>　　如果相同的对象有不同的hashCode�Q�对哈希表的操作�?x��)出现意想不到的�l�果�Q�期待的get�Ҏ(gu��)��q�回null�Q�，要避免这�U�问题，只需要牢��C��条：(x��)要同时复写equals�Ҏ(gu��)��和hashCode�Ҏ(gu��)��Q�而不要只写其中一个�?BR>　　Hashtable是同步的�?/FONT>

HashMap�c?BR>　　HashMap和Hashtable�c�M��Q�不同之处在于HashMap是非同步的，�q�且允许null�Q�即null value和null key。，但是��HashMap视�ؓ(f��)Collection�Ӟ��values()�Ҏ(gu��)��可返回Collection�Q�，其�P代子操作旉��开销和HashMap的容量成比例。因此，如果�q�代操作的性能相当重要的话�Q�不要将HashMap的初始化定w��讑־��q�高�Q�或者load factor�q�低�?/FONT>

WeakHashMap�c?BR>　　WeakHashMap是一�U�改�q�的HashMap�Q�它对key实行“弱引用”，如果一个key不再被外部所引用�Q�那么该key可以被GC回收�?/FONT>

�ȝ��
　　如果涉及(qi��ng)到堆栈，队列�{�操作，应该考虑用List�Q�对于需要快速插入，删除元素�Q�应该��用LinkedList�Q�如果需要快速随��问元素，应该使用ArrayList�?BR>　　如果�E�序在单�U�程环境中，或者访问仅仅在一个线�E�中�q�行�Q�考虑非同步的�c�，其效率较高，如果多个�U�程可能同时操作一个类�Q�应该��用同步的�c�R�?BR>　　要特别注意对哈希表的操作�Q�作为key的对象要正确复写equals和hashCode�Ҏ(gu��)��?BR>　　��量�q�回接口而非实际的类型，如返回List而非ArrayList�Q�这样如果以后需要将ArrayList换成LinkedList�Ӟ��客户端代码不用改变。这��是针对抽象�~�程�?BR>
[b]同步�?BR>Vector是同步的。这个类中的一些方法保证了Vector中的对象是线�E�安全的。而ArrayList则是异步的，因此ArrayList中的对象�q�不是线�E�安全的。因为同步的要求�?x��)�?ji��ng)响执行的效率�Q�所以如果你不需要线�E�安全的集合那么使用ArrayList是一个很好的选择�Q�这样可以避免由于同步带来的不必要的性能开销�?BR>数据增长
从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控刉��合中的对象。当你向�q�两�U�类型中增加元素的时候，如果元素的数目超��Z��内部数组目前的长度它们都需要扩展内部数�l�的长度�Q�Vector�~�省情况下自动增长原来一倍的数组长度�Q�ArrayList是原来的50%,所以最后你获得的这个集合所占的�I�间��L��比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一些优势，因�ؓ(f��)你可以通过讄��集合的初始化大小来避免不必要的资源开销�?BR>使用模式
在ArrayList和Vector中，从一个指定的位置�Q�通过索引�Q�查找数据或是在集合的末��֢�加、移除一个元素所��p��的时间是一��L(f��ng)��Q�这个时间我们用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的旉��?x��)呈�U��Ş增长�Q�O(n-i)�Q�其中n代表集合中元素的个数�Q�i代表元素增加或移除元素的索引位置。�ؓ(f��)什么会(x��)�q�样呢？以�ؓ(f��)在进行上�q�操作的时候集合中�W�i和第i个元素之后的所有元素都要执行位�Uȝ��操作。这一切意味着什么呢�Q?BR>�q�意味着�Q�你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作�Q�你最好选择其他的集合操作类。比如，LinkList集合�c�d��增加或移除集合中��M��位置的元素所��p��的时间都是一��L(f��ng)��—O(1)�Q�但它在索引一个元素的使用�~�比较慢�Q�O(i),其中i是烦(ch��)引的位置.使用ArrayList也很�Ҏ(gu��)��Q�因��Z��可以��单的使用索引来代替创建iterator对象的操作。LinkList也会(x��)为每个插入的元素创徏对象�Q�所有你要明白它也会(x��)带来额外的开销�?BR>最后，在《Practical Java》一书中Peter Haggar��使用一个简单的数组�Q�Array�Q�来代替Vector或ArrayList。尤其是对于执行效率要求高的�E�序更应如此。因��Z��用数�l?Array)避免了同步、额外的�Ҏ(gu��)��调用和不必要的重新分配空间的操作�?/FONT>

�z�d��JAVA岛的日子 2005-11-25 01:05 发表评论

java.util�?转脓(chu��ng))

�z�d��JAVA岛的日子 — Thu, 24 Nov 2005 09:55:00 GMT
ArrayList是List接口的一个可变长数组实现。实��C��所有List接口的操作，�q�允许存储null倹{��除了没有进行同步，ArrayList基本�{�同于Vector。在Vector中几乎对所有的�Ҏ(gu��)��都进行了同步�Q�但ArrayList仅对writeObject和readObject�q�行了同步，其它比如add(Object)、remove(int)�{�都没有同步�?BR>
1.存储
ArrayList使用一个Object的数�l�存储元素�?BR>private transient Object elementData[];
ArrayList实现了java.io.Serializable接口�Q�这儿的transient标示�q�个属性不需要自动序列化。下面会(x��)在writeObject()�Ҏ(gu��)��中详�l�讲解�ؓ(f��)什么要�q�样作�?BR>
2.add和remove

    public boolean add(Object o) {
    ensureCapacity(size + 1);  // Increments modCount!!
    elementData[size++] = o;
    return true;
    }

注意�q�儿的ensureCapacity()�Ҏ(gu��)��Q�它的作用是保证elementData数组的长度可以容�U�一个新元素。在“自动变长机制”中��详�l�讲解�?BR>
    public Object remove(int index) {
    RangeCheck(index);
    modCount++;
    Object oldValue = elementData[index];
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                 numMoved);
    elementData[--size] = null; // Let gc do its work
    return oldValue;
    }

RangeCheck()的作用是�q�行边界��(g��)查。由于ArrayList采用一个对象数�l�存储元素，所以在删除一个元素时需要把后面的元素前�U�R��删除一个元素时只是把该元素在elementData数组中的引用�|��ؓ(f��)null�Q�具体的对象的销毁由垃圾攉��器负责�?BR>modCount的作用将在下面的“iterator()中的同步”中说明�?BR>注：(x��)在前�U�L��使用了System提供的一个实用方法：(x��)arraycopy()�Q�在本例中可以看出System.arraycopy()�Ҏ(gu��)��可以对同一个数�l�进行操作，�q�个�Ҏ(gu��)��是一个native�Ҏ(gu��)��Q�如果对同一个数�l�进行操作时�Q�会(x��)首先把从源部分拷贝到一个��(f��)时数�l�，在把临时数组的元素拷贝到目标位置�?BR>
3.自动变长机制
在实例化一个ArrayList�Ӟ��你可以指定一个初始容量。这个容量就是elementData数组的初始长度。如果你使用�Q?BR>
    ArrayList list = new ArrayList();

则��用缺省的定w��Q?0�?BR>
    public ArrayList() {
    this(10);
    }

ArrayList提供了四�U�add()�Ҏ(gu��)��Q?BR>
public boolean add(Object o)

public void add(int index, Object element)

public boolean addAll(Collection c)

public boolean addAll(int index, Collection c)

在每一�U�add()�Ҏ(gu��)��中，都首先调用了一个ensureCapacity(int miniCapacity)�Ҏ(gu��)��Q�这个方法保证elementData数组的长度不��于miniCapacity。ArrayList的自动变长机制就是在�q�个�Ҏ(gu��)��中实现的�?BR>
    public void ensureCapacity(int minCapacity) {
    modCount++;
    int oldCapacity = elementData.length;
    if (minCapacity > oldCapacity) {
        Object oldData[] = elementData;
        int newCapacity = (oldCapacity * 3)/2 + 1;
            if (newCapacity < minCapacity)
        newCapacity = minCapacity;
        elementData = new Object[newCapacity];
        System.arraycopy(oldData, 0, elementData, 0, size);
    }
    }

从这个方法实��C��可以看出ArrayList每次扩容�Q�都扩大到原来大��的1.5倍�?BR>每种add()�Ҏ(gu��)��的实现都大同��异�Q�下面给出add(Object)�Ҏ(gu��)��的实玎ͼ�(x��)

    public boolean add(Object o) {
    ensureCapacity(size + 1);  // Increments modCount!!
    elementData[size++] = o;
    return true;
    }

4.iterator()中的同步
在父�c�AbstractList中定义了一个int型的属性：(x��)modCount�Q�记录了ArrayList�l�构性变化的�ơ数�?BR>
    protected transient int modCount = 0;

在ArrayList的所有涉�?qi��ng)结构变化的��?gu��)��中都增加modCount的��|��包括�Q�add()、remove()、addAll()、removeRange()�?qi��ng)clear()�Ҏ(gu��)��。这些方法每调用一�ơ，modCount的值就�?�?BR>注：(x��)add()�?qi��ng)addAll()�Ҏ(gu��)��的modCount的值是在其中调用的ensureCapacity()�Ҏ(gu��)��中增加的�?BR>
AbstractList中的iterator()�Ҏ(gu��)��Q�ArrayList直接�l�承了这个方法）(j��)使用了一个私有内部成员类Itr�Q�生成一个Itr对象�Q�Iterator接口�Q�返回：(x��)

    public Iterator iterator() {
    return new Itr();
    }

Itr实现了Iterator()接口�Q�其中也定义了一个int型的属性：(x��)expectedModCount�Q�这个属性在Itr�c�d��始化时被赋予ArrayList对象的modCount属性的倹{�?BR>
    int expectedModCount = modCount;

注：(x��)内部成员�c�Itr也是ArrayList�cȝ��一个成员，它可以访问所有的AbstractList的属性和�Ҏ(gu��)��。理解了�q�一点，Itr�cȝ��实现��容易理解了�?BR>
在Itr.hasNext()�Ҏ(gu��)��中：(x��)

    public boolean hasNext() {
        return cursor != size();
    }

调用了AbstractList的size()�Ҏ(gu��)��Q�比较当前光标位�|�是否越界�?BR>
在Itr.next()�Ҏ(gu��)��中，Itr也调用了定义在AbstractList中的get(int)�Ҏ(gu��)��Q�返回当前光标处的元素：(x��)

    public Object next() {
        try {
        Object next = get(cursor);
        checkForComodification();
        lastRet = cursor++;
        return next;
        } catch(IndexOutOfBoundsException e) {
        checkForComodification();
        throw new NoSuchElementException();
        }
    }

注意�Q�在next()�Ҏ(gu��)��中调用了checkForComodification()�Ҏ(gu��)��Q�进行对修改的同步检查：(x��)

    final void checkForComodification() {
        if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
    }

现在对modCount和expectedModCount的作用应该非常清楚了。在对一个集合对象进行跌代操作的同时�Q��ƈ不限制对集合对象的元素进行操作，�q�些操作包括一些可能引赯��代错误的add()或remove()�{�危险操作。在AbstractList中，使用了一个简单的机制来规避这些风险。这��是modCount和expectedModCount的作用所在�?BR>
5.序列化支�?BR>ArrayList实现了java.io.Serializable接口�Q�所以ArrayList对象可以序列化到持久存储介质中。ArrayList的主要属性定义如下：(x��)

private static final long serialVersionUID = 8683452581122892189L;

private transient Object elementData[];

private int size;

可以看出serialVersionUID和size都将自动序列化到介质中，但elementData数组对象却定义�ؓ(f��)transient了。也��是说ArrayList中的所有这些元素都不会(x��)自动�p�d��化到介质中。�ؓ(f��)什么要�q�样实现�Q�因为elementData数组中存储的“元素”其实仅是对�q�些元素的一个引用，�q�不是真正的对象�Q�序列化一个对象的引用是毫无意义的�Q�因为序列化是�ؓ(f��)了反序列化，当你反序列化�Ӟ��q�些对象的引用已�l�不可能指向原来的对象了。所以在�q�儿需要手工的对ArrayList的元素进行序列化操作。这��是writeObject()的作用�?BR>
    private synchronized void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
    // Write out element count, and any hidden stuff
    s.defaultWriteObject();
   // Write out array length
    s.writeInt(elementData.length);
    // Write out all elements in the proper order.
    for (int i=0; i            s.writeObject(elementData[i]);
    }

�q�样元素数组elementData中的所以元素对象就可以正确地序列化到存储介质了�?BR>对应的readObject()也按照writeObject()�Ҏ(gu��)��的顺序从输入��中��d��Q?BR>
    private synchronized void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
    // Read in size, and any hidden stuff
    s.defaultReadObject();
    // Read in array length and allocate array
    int arrayLength = s.readInt();
    elementData = new Object[arrayLength];
    // Read in all elements in the proper order.
    for (int i=0; i            elementData[i] = s.readObject();
    }

本章介绍Java的实用工��L(f��ng)��库java.util包。在�q�个包中�Q�Java提供了一些实用的�Ҏ(gu��)��和数据结构。例如，Java提供日期(Data)�c�R��日�?Calendar)�c�L��产生和获取日期及(qi��ng)旉��Q�提供随机数(Random)�c�M�生各�U�类型的随机敎ͼ��q�提供了堆栈(Stack)、向�?Vector) 、位集合(Bitset)以及(qi��ng)哈希�?Hashtable)�{�类来表�C�相应的数据�l�构�?BR>　　�?.1�l�出了java.util包的基本层次�l�构图。下面我们将具体介绍其中几个重要的类�?BR>　　　　　　　　　　　┌java.util.BitSet
　　　　　　　　　　　│java.util.Calendar
　　　　　　　　　　　│　　　　　　└java.util.GregorianCalendar
　　　　　　　　　　　│java.util.Date
　　　　　　　　　　　│java.util.Dictionary
　　　　　　　　　　　│　　　　　　└java.util.Hashtable
　　　　　　　　　　　│　　　　　　　　　　　　　└java.util.Properties
　　　　　　　　　　　│java.util.EventObject
　　　　　　　　　　　│java.util.ResourceBundle
　　　　　　　┌普通类┤　　　　　　├java.util.ListResourceBundle
　　　　　　　│　　　│　　　　　　└java.util.PropertyResourceBundle
　　　　　　　│　　　│java.util.Local
　　　　　　　│　　　│java.util.Observable
　　　　　　　│　　　│java.util.Random
　　　　　　　│　　　│java.util.StringTokenizer
　　　　　　　│　　　│java.util.Vector
　　　　　　　│　　　│　　　　　　└java.util.Stack
　　Java.util┤　　　└java.util.TimeZone
　　　　　　　│　　　　　　　　　　└java.util.SimpleTimeZone
　　　　　　　│　　　┌java.util.Enumeration
　　　　　　　├接　口┤java.util.EventListener
　　　　　　　│　　　└java.util.Observer
　　　　　　　│　　　┌java.util.EmptyStackException
　　　　　　　└异常类┤java.util.MissingResourceException
　　　　　　　　　　　│java.util.NoSuchElementException
　　　　　　　　　　　└java.util.TooManyListenersException
　　　　　　　�?.1 java.util包的基本层次�l�构

1.2 日期�c�Date

　　Java在日期类中封装了有关日期和时间的信息�Q�用户可以通过调用相应的方法来获取�pȝ��旉��或设�|�日期和旉��。Date�c�M��有很多方法在JDK1.0公布后已�l�过时了�Q�在8.3中我们将介绍JDK1.0中新加的用于替代Date的功能的其它�c�R�?BR>　　在日期类中共定义了六�U�构造函数�?BR>　　(1)public Date()
　　创徏的日期类对象的日期时间被讄��成创建时�ȝ��对应的日期时间�?BR>　　�?nbsp;Date today=new Date()�Q?/today被设�|�成创徏时刻相对应的日期旉��?BR>　　(2)public Date (long date)
　　long 型的参数date可以通过调用Date�c�M��的static�Ҏ(gu��)��parse(String s)来获得�?BR>　　�?nbsp;long l=Date.parse("Mon 6 Jan 1997 13:3:00");
　　　　Date day=new Date(l);
　　//day中时间�ؓ(f��)1997�q?nbsp;1�?��h��期一�Q?3:3:00�?BR>　　(3)public Date(String s)
　　按字�W�串s产生一日期对象。s的格式与�Ҏ(gu��)��parse中字�W�串参数的模式相同�?BR>　　�?nbsp;Date day=new Date("Mon 6 Jan 1997 13:3:00");
　　//day 中时间�ؓ(f��)1997�q?�?��h��期一�Q?3:3:00.
　　(4)public Date(int year,int month,int date)
　　(5)public Date(int year,int month,int date,int hrs,int min)
　　(6)public Date(int year,int month,int date,int hrs,int min,int sec)
　　按给定的参数创徏一日期对象�?BR>　　参数说明�Q?BR>　　year的��gؓ(f��)�Q�需讑֮�的年�?1900。例如需讑֮�的年份是1997则year的值应�?7�Q�即1997-1900的结果。所以Date中可讑֮�的年份最��ؓ(f��)1900�Q?BR>　　month的值域�?�?1�Q?代表1月，11表代�?2月；
　　date的值域�?�?1之间�Q?BR>　　hrs的值域�?�?3之间。从午夜到次日凌�?炚w��hrs=0�Q�从中午��C��?炚w��hrs=12�Q?BR>　　min和sec的值域�?�?9之间�?BR>　　�?nbsp;Date day=new Date(11,3,4);
　　//day中的旉��为：(x��)04-Apr-11 12:00:00 AM
另外�Q�还可以�l�出不正��的参数�?BR>　　例　讑֮�旉��?910�q?�?0日，它将被解释成3�?日�?BR>　　Date day=new Date(10,1,30,10,12,34);
　　System.out.println("Day's date is:"+day);
　　//打印�l�果为：(x��)Day's date is:Web Mar 02 10:13:34 GMT+08:00 1910
　　下面我们�l�出一些Date�c�M��常用�Ҏ(gu��)��?BR>　　(1)public static long UTC(int year,int month,int date,int hrs. int min,int sec)
　　该方法将利用�l�定参数计算UTC倹{��UTC是一�U�计时体�Ӟ��与GMT(格林威治旉��)的计时体�pȝ��有差别。UTC计时体系是基于原子时钟的�Q�而GTMT计时体系是基于天文学观测的。计��中使用的一般�ؓ(f��)GMT计时体系�?BR>　　(2)public static long parse(String s)
　　该方法将字符串s转换成一个long型的日期。在介绍构造方法Date(long date)时曾使用�q�这个方法�?BR>　　字符串s有一定的格式�Q�一般�ؓ(f��)�Q?BR>　　(星期 �?nbsp;�q?nbsp;旉��GMT+时区)
　　若不注明时区�Q�则为本地时区�?BR>　　(3)public void setMonth(int month)
　　(4)public int getMonth()
　　�q�两个方法分别�ؓ(f��)讑֮�和获取月份倹{�?BR>　　获取的月份的值域�?�?1�Q?代表1月，11代表12月�?BR>　　(5)public String toString()
　　(6)public String toLocalString()
　　(7)public String toGMTString()
　　��给定日期对象�{换成不同格式的字�W�串。它们对应的具体的格式可参看例子8.1�?BR>　　(8)public int getTimezoneOffset()
　　该方法用于获取日期对象的时区偏移量�?BR>　　�?.1中对上面介绍的Date�c�M��的基本方法进行了具体的应用，�q�打��C��相应的结果。由于��用了一些过时的�Ҏ(gu��)��Q�所以编译时�?x��)有警告信息。另外，�׃��本例中的旉��表示与��^台有养I��不同的JDK版本�Ҏ(gu��)��处理不完全相同，因此不同版本的JDK执行本例的结果可能有�l�微差异�?BR>　　�?.1 DateApp.java
　　import java.lang.System;
　　import java.util.Date;
　　public class DateApp{
　　　public static void main(String args[]){
　　　　Date today=new Date();
　　　　//today中的日期被设成创建时�ȝ��日期和时��_(d��)��假设创徏时刻�?997�q?�?BR>　　　　//23�?7�?1�?4�U��?BR>　　　　System.out.println("Today's date is "+today);
　　　　//�q�回一般的旉��表示法，本例中结果�ؓ(f��)
　　　　//Today's date is Fri May 23 17:51:54 1997
　　　　System.out.println("Today's date(Internet GMT)is:"
　　　　　+today.toGMTString());
　　　　//�q�回�l�果为GMT旉��表示法，本例中结果�ؓ(f��)
　　　　//Today's date(Internet GMT)is: 23 May 1997 09:51:54:GMT
　　　　System.out.println("Today's date(Locale) is:"
　　　　　+today.toLocaleString());
　　　　//�q�回�l�果为本��C��(f��n)惯的旉��表示法，�l�果�?BR>　　　　//Today's date(Locale)is:05/23/97 17:51:54
　　　　System.out.println("Today's year is: "+today.getYear());
　　　　System.out.println("Today's month is: "+(today.getMonth()+1));
　　　　System.out.println("Today's date is: "+today.getDate());
　　　　//调用Date�c�M��Ҏ(gu��)��Q�获取年月日的倹{�?BR>　　　　//下面调用了不同的构造方法来创徏Date�cȝ��对象�?BR>　　　　Date day1=new Date(100,1,23,10,12,34);
　　　　System.out.println("Day1's date is: "+day1);
　　　　Date day2=new Date("Sat 12 Aug 1996 13:3:00");
　　　　System.out.println("Day2's date is: "+day2);
　　　　long l= Date.parse("Sat 5 Aug 1996 13:3:00 GMT+0800");
　　　　Date day3= new Date(l);
　　　　System.out.println("Day3's date(GMT)is: "+day3.toGMTString());
　　　　System.out.println("Day3's date(Locale)is: "
　　　　　+day3.toLocaleString());
　　　　System.out.println("Day3's time zone offset is:"
　　　　　+day3.getTimezoneOffset());
　　　}
　　}

　　�q�行�l�果(JDK1.3版，与原文不同，原文是JDK1.0�?�Q?BR>　　E:\java\tutorial\java01>java DateApp
　　Today's date is Thu Dec 27 17:58:16 CST 2001
　　Today's date(Internet GMT)is:27 Dec 2001 09:58:16 GMT
　　Today's date(Locale) is:2001-12-27 17:58:16
　　Today's year is: 101
　　Today's month is: 12
　　Today's date is: 27
　　Day1's date is: Wed Feb 23 10:12:34 CST 2000
　　Day2's date is: Fri Aug 12 13:03:00 CST 1996
　　Day3's date(GMT)is: 5 Aug 1996 05:03:00 GMT
　　Day3's date(Locale)is: 1996-8-5 13:03:00
　　Day3's time zone offset is:-480

　　E:\java\tutorial\java01>

1.3 日历�c�Calendar

　　在早期的JDK版本中，日期(Date)�c�附有两大功能：(x��)(1)允许用年、月、日、时、分、秒来解释日期：(x��)(2)允许对表�C�日期的字符串进行格式化和句法分析。在JDK1.1中提供了�c�Calendar来完成第一�U�功能，�c�DateFormat来完成第二项功能。dateFormat是java.text包中的一个类。与Date�c�L��所不同的是�Q�DateFormat�c�L��受用各种语言和不同习(f��n)惯表�C�的日期字符丌Ӏ�本节将介绍java.util包中的类Calendar�?qi��ng)其它新增加的相关的�c�R�?BR>　　�c�Calendar是一个抽象类�Q�它完成日期(Date)�c�d��普通日期表�C�法(即用一�l�整型域如YEAR�Q�MONTH�Q�DAY�Q�HOUR表示日期)之间的�{换�?BR>　　�׃��所使用的规则不同，不同的日历系�l�对同一个日期的解释有所不同。在JDK1.1中提供了Calendar�c�M��个子�c�GregorianCalendar??它实��C��世界上普遍��用的公历�pȝ��。当然用户也可以通过�l�承Calendar�c�，�q�增加所需规则�Q�以实现不同的日历系�l��?BR>　　�W�GregorianCalendar�l�承了Calendar�c�R��本节将在介�l�类GregorianCalendar的同旉��带介�l�Calendar�c�M��的相��x��法�?BR>　　�c�GregorianCalendar提供了七�U�构造函敎ͼ�(x��)
　　(1)public GregorianCalendar()
　　创徏的对象中的相兛_��D��讄��成指定时区，�~�省地点的当前时��_(d��)��即程序运行时所处的时区、地点的当前旉��?BR>　　(2)public GregorianCalendar(TimeZone zone)
　　创徏的对象中的相兛_��D��讄��成指定时区zone�Q�缺省地点的当前旉��?BR>　　(3)public GregorianCalendar(Locale aLocale)
　　创徏的对象中的相兛_��D��讄��成缺省时区，指定地点aLocale的当前时间�?BR>　　(4)public GregorianCalendar(TimeZone zone,Local aLocale)
　　创徏的对象中的相兛_��D��讄��成指定时区，指定地点的当前时间�?BR>　　上面使用到的�c�TimeZone的性质如下�Q?BR>　　TimeZone是java.util包中的一个类�Q�其中封装了有关时区的信息。每一个时区对应一�l�ID。类TimeZone提供了一些方法完成时��Z��对应ID两者之间的转换�?BR>　　(�?已知某个特定的ID�Q�可以调用方�?BR>　　public static synchronized TimeZone getTimeZone(String ID)
来获取对应的时区对象�?BR>　　�?nbsp;太��^�z�时区的ID为PST�Q�用下面的方法可获取对应于太�q�x��时区的时区对象：(x��)
　　TimeZone tz=TimeZone.getTimeZone("PST");
　　调用�Ҏ(gu��)��getDefault()可以获取��L��所处时区的对象�?BR>　　TimeZone tz=TimeZone.getDefault();
　　(�?调用以下�Ҏ(gu��)��可以获取时区的ID
　　■public static synchronized String[] getavailableIDs(int rawOffset)
　　�Ҏ(gu��)��l�定时区偏移��D��取ID数组。同一时区的不同地区的ID可能不同�Q�这是由于不同地区对是否实施夏时制意见不�l�一而造成的�?BR>　　例String s[]=TimeZone.getAvailableIDs(-7*60*60*1000);
　　打印s�Q�结果�ؓ(f��)s[0]=PNT�Q�s[1]=MST
　　■public static synchronized String[] getAvailableIDs()
　　获取提供的所有支持的ID�?BR>　　■public String getID()
　　获取特定时区对象的ID�?BR>　　�?nbsp;TimeZone tz=TimeZone.getDefault();
　　String s=tz.getID();
　　打印s�Q�结果�ؓ(f��)s=CTT�?BR>　　上面使用�cȝ��对象代表了一个特定的地理、政��L��文化区域。Locale只是一�U�机�Ӟ��它用来标识一�c�d��象，Local本��n�q�不包含此类对象�?BR>　　要获取一个Locale的对象有两种�Ҏ(gu��)��Q?BR>　　(�?调用Locale�cȝ��构造方�?BR>　　Locale(String language,String country)
　　Locale(String language,String country,String variant)
　　参数说明�Q�language??在ISO-639中定义的代码�Q�由两个��写字母�l�成�?BR>　　　　　　　country??在ISO-3166中定义的代码�Q�由两个大写字母�l�成�?BR>　　　　　　　variant??售货商以�?qi��ng)特定浏览器的代码，例如使用WIN代表Windows�?BR>　　(�?调用Locale�c�M��定义的常�?BR>　　Local�c�L��供了大量的常量供用户创徏Locale对象�?BR>　　�?nbsp;Locale.CHINA
　　　　��Z��国创��Z��个Locale的对象�?BR>　　�c�TimeZone和类Locale中的其它�Ҏ(gu��)��Q�读者可查阅API�?BR>　　(5)public GregorianCalendar(int year,int month,int date)
　　(6)public GregorianCalendar(int year,int month,int date,int hour,int minute)
　　(7)public GregorianCalendar(int year,int month,int date,int hour,int minute,int second)
　　用给定的日期和时间创��Z��个GregorianCalendar的对象�?BR>　　参数说明�Q?BR>　　year-讑֮�日历对象的变量YEAR�Q�month-讑֮�日历对象的变量MONTH�Q?BR>　　date-讑֮�日历对象的变量DATE�Q�hour-讑֮�日历对象的变量HOUR_OF_DAY�Q?BR>　　minute-讑֮�日历对象的变量MINUTE�Q�second-讑֮�日历对象的变量SECOND�?BR>　　与Date�c�M��不同的是year的值没�?900�q�个下限�Q�而且year的��g��表实际的�q�䆾。month的含义与Date�cȝ��同，0代表1月，11代表12月�?BR>　　�?nbsp;GregorianCalendar cal=new GregorianCalendar(1991,2,4)
　　cal的日期�ؓ(f��)1991�q?�?受��?BR>　　除了与Date中类似的�Ҏ(gu��)��外，Calendar�c�还提供了有��x��法对日历�q�行滚动计算和数学计��。计��规则由�l�定的日历系�l�决定。进行日期计��时�Q�有时会(x��)遇到信息不��或信息不实等�Ҏ(gu��)��情况。Calendar采取了相应的�Ҏ(gu��)��解决�q�些问题。当信息不��时将采用�~�省讄��Q�在GregorianCalendar�c�M��~�省讄��一般�ؓ(f��)YEAR=1970,MONTH=JANUARY,DATE=1�?BR>　　当信息不实时�Q�Calendar��按下面的次序优先选择相应的Calendar的变量组合，�q�将其它有冲�H�的信息丢弃�?BR>　　MONTH+DAY_OF_MONTH
　　MONTH+WEEK_OF_MONTH+DAY_OF_WEEK
　　MONTH+DAY_OF_WEEK_OF_MONTH+DAY_OF_WEEK
　　DAY_OF+YEAR
　　DAY_OF_WEEK_WEEK_OF_YEAR
　　HOUR_OF_DAY

1.4 随机数类Random

　　Java实用工具�c�d��中的�c�java.util.Random提供了��生各�U�类型随机数的方法。它可以产生int、long、float、double以及(qi��ng)Goussian�{�类型的随机数。这也是它与java.lang.Math中的�Ҏ(gu��)��Random()最大的不同之处�Q�后者只产生double型的随机数�?BR>　　�c�Random中的�Ҏ(gu��)��十分��单，它只有两个构造方法和六个普通方法�?BR>　　构造方法：(x��)
　　(1)public Random()
　　(2)public Random(long seed)
　　Java产生随机数需要有一个基值seed�Q�在�W�一�U�方法中基值缺省，则将�pȝ��旉��作�ؓ(f��)seed�?BR>　　普通方法：(x��)
　　(1)public synonronized void setSeed(long seed)
　　该方法是讑֮�基值seed�?BR>　　(2)public int nextInt()
　　该方法是产生一个整型随机数�?BR>　　(3)public long nextLong()
　　该方法是产生一个long型随机数�?BR>　　(4)public float nextFloat()
　　该方法是产生一个Float型随机数�?BR>　　(5)public double nextDouble()
　　该方法是产生一个Double型随机数�?BR>　　(6)public synchronized double nextGoussian()
　　该方法是产生一个double型的Goussian随机数�?BR>　　�?.2 RandomApp.java�?BR>　　//import java.lang.*;
　　import java.util.Random;

　　public class RandomApp{
　　　public static void main(String args[]){
　　　　Random ran1=new Random();
　　　　Random ran2=new Random(12345);
　　　　//创徏了两个类Random的对象�?BR>　　　　System.out.println("The 1st set of random numbers:");
　　　　System.out.println("\t Integer:"+ran1.nextInt());
　　　　System.out.println("\t Long:"+ran1.nextLong());
　　　　System.out.println("\t Float:"+ran1.nextFloat());
　　　　System.out.println("\t Double:"+ran1.nextDouble());
　　　　System.out.println("\t Gaussian:"+ran1.nextGaussian());
　　　　//产生各种�c�d��的随机数
　　　　System.out.print("The 2nd set of random numbers:");
　　　　for(int i=0;i<5;i++){
　　　　　System.out.println(ran2.nextInt()+" ");
　　　　　if(i==2) System.out.println();
　　　　　//产生同种�c�d��的不同的随机数�?BR>　　　　　System.out.println();//原文如此
　　　　}
　　　}
　　}

　　�q�行�l�果�Q?BR>　　E:\java01>java RandomApp
　　The 1st set of random numbers:
　　　　Integer:-173899656
　　　　Long:8056223819738127077
　　　　Float:0.6293638
　　　　Double:0.7888394520265607
　　　　Gaussian:0.5015701094568733
　　The 2nd set of random numbers:1553932502
　　-2090749135
　　-287790814
　　-355989640
　　-716867186
　　E:\java01>

1.5 向量�c�Vector

　　Java.util.Vector提供了向�?Vector)�c�M��实现�c�M��动态数�l�的功能。在Java语言中。正如在一开始就提到�q�，是没有指针概�늚��Q�但如果能正��灵�z�d��使用指针又确实可以大大提高程序的质量�Q�比如在C、C++中所谓“动态数�l�”一般都由指针来实现。�ؓ(f��)了��I补这点缺��P��Java提供了丰富的�c�d��来方便编�E�者��用，Vector�c�M��是其中之一。事实上�Q�灵�z�M��用数�l�也可完成向量类的功能，但向量类中提供的大量�Ҏ(gu��)��大大方便了用��L(f��ng)��使用�?BR>　　创徏了一个向量类的对象后�Q�可以往其中随意地插入不同的�cȝ��对象�Q�既不需��֏�(qi��ng)�c�d��也不需预先选定向量的容量，�q�可方便地进行查找。对于预先不知或不愿预先定义数组大小�Q��ƈ需频繁�q�行查找、插入和删除工作的情况，可以考虑使用向量�c�R�?BR>　　向量�c�L��供了三种构造方法：(x��)
　　public vector()
　　public vector(int initialcapacity,int capacityIncrement)
　　public vector(int initialcapacity)
　　使用�W�一�U�方法，�pȝ��?x��)自动对向量对象�q�行��理。若使用后两�U�方法，则系�l�将�Ҏ(gu��)��参数initialcapacity讑֮�向量对象的容�?卛_��量对象可存储数据的大��?�Q�当真正存放的数据个数超�q�容量时�Q�系�l�会(x��)扩充向量对象的存储容量。参数capacityIncrement�l�定了每�ơ扩充的扩充倹{��当capacityIncrement�?�Ӟ��则每�ơ扩充一倍。利用这个功能可以优化存储�?BR>　　在Vector�c�M��提供了各�U�方法方便用户��用：(x��)
　　■插入功�?BR>　　(1)public final synchronized void addElement(Object obj)
　　��obj插入向量的尾部。obj可以是�Q何类的对象。对同一个向量对象，可在其中插入不同�cȝ��对象。但插入的应是对象而不是数��|��所以插入数值时要注意将数��D�{换成相应的对象�?BR>　　�?nbsp;要插入一个整�?�Ӟ��不要直接调用v1.addElement(1)�Q�正��的�Ҏ(gu��)��为：(x��)
　　Vector v1=new Vector();
　　Integer integer1=new Integer(1);
　　v1.addElement(integer1);
　　(2)public final synchronized void setElementAt(object obj,int index)
　　��index处的对象设成obj�Q�原来的对象��被覆盖�?BR>　　(3)public final synchronized void insertElementAt(Object obj,int index)
　　在index指定的位�|�插入obj�Q�原来对象以�?qi��ng)此后的对象依次往后顺延�?BR>　　■删除功�?BR>　　(1)public final synchronized void removeElement(Object obj)
　　从向量中删除obj。若有多个存在，则从向量头开始试�Q�删除找到的�W�一个与obj相同的向量成员�?BR>　　(2)public final synchronized void removeAllElement()
　　删除向量中所有的对象�?BR>　　(3)public final synchronized void removeElementlAt(int index)
　　删除index所指的地方的对象�?BR>　　■查询搜索功�?BR>　　(1)public final int indexOf(Object obj)
　　从向量头开始搜索obj ,�q�回所遇到的第一个obj对应的下标，若不存在此obj�Q�返�?1�?BR>　　(2)public final synchronized int indexOf(Object obj,int index)
　　从index所表示的下标处开始搜索obj�?BR>　　(3)public final int lastIndexOf(Object obj)
　　从向量尾部开始逆向搜烦(ch��)obj�?BR>　　(4)public final synchronized int lastIndexOf(Object obj,int index)
　　从index所表示的下标处由尾臛_��逆向搜烦(ch��)obj�?BR>　　(5)public final synchronized Object firstElement()
　　获取向量对象中的首个obj�?BR>　　(6)public final synchronized Object lastelement()
　　获取向量对象中的最后一个obj�?BR>　　了解了向量的最基本的方法后�Q�我们来看一下例8.3VectorApp.java�?BR>　　�?.3 VectorApp.java�?BR>　　import java.util.Vector;
　　import java.lang.*;//�q�一句不应该要，但原文如�?BR>　　import java.util.Enumeration;
　　public class VectorApp{
　　　public static void main(String[] args){
　　　　Vector v1=new Vector();
　　　　Integer integer1=new Integer(1);
　　　　v1.addElement("one");
　　　　//加入的�ؓ(f��)字符串对�?BR>　　　　v1.addElement(integer1);
　　　　v1.addElement(integer1);
　　　　//加入的�ؓ(f��)Integer的对�?BR>　　　　v1.addElement("two");
　　　　v1.addElement(new Integer(2));
　　　　v1.addElement(integer1);
　　　　v1.addElement(integer1);
　　　　System.out.println("The vector v1 is:\n\t"+v1);
　　　　//��v1转换成字�W�串�q�打�?BR>　　　　v1.insertElementAt("three",2);
　　　　v1.insertElementAt(new Float(3.9),3);
　　　　System.out.println("The vector v1(used method insertElementAt()) is:\n\t "+v1);
　　　　//往指定位置插入新的对象�Q�指定位�|�后的对象依�ơ往后顺�?BR>　　　　v1.setElementAt("four",2);
　　　　System.out.println("The vector v1(used method setElementAt()) is:\n\t "+v1);
　　　　//��指定位�|�的对象讄��为新的对�?BR>　　　　v1.removeElement(integer1);
　　　　//从向量对象v1中删除对象integer1�׃��存在多个integer1所以从头开�?BR>　　　　//找，删除扑ֈ�的第一个integer1
　　　　Enumeration enum=v1.elements();
　　　　System.out.print("The vector v1(used method removeElement())is:");
　　　　while(enum.hasMoreElements())
　　　　System.out.print(enum.nextElement()+" ");
　　　　System.out.println();
　　　　//使用枚�D�c?Enumeration)的方法来获取向量对象的每个元�?BR>　　　　System.out.println("The position of object 1(top-to-bottom):"
　　　　　+ v1.indexOf(integer1));
　　　　System.out.println("The position of object 1(tottom-to-top):"
　　　　　+v1.lastIndexOf(integer1));
　　　　//按不同的方向查找对象integer1所处的位置
　　　　v1.setSize(4);
　　　　System.out.println("The new vector(resized the vector)is:"+v1);
　　　　//重新讄��v1的大��，多余的元素被行弃
　　　}
　　}
　　�q�行�l�果�Q?BR>　　E:\java01>java VectorApp
　　The vector v1 is:
　　　　　[one, 1, 1, two, 2, 1, 1]
　　The vector v1(used method insertElementAt()) is:
　　　　　[one, 1, three, 3.9, 1, two, 2, 1, 1]
　　The vector v1(used method setElementAt()) is:
　　　　　[one, 1, four, 3.9, 1, two, 2, 1, 1]
　　The vector v1(used method removeElement())is:one four 3.9 1 two 2 1 1
　　The position of object 1(top-to-bottom):3
　　The position of object 1(tottom-to-top):7
　　The new vector(resized the vector)is:[one, four, 3.9, 1]
　　E:\java01>
　　从例1.3�q�行的结果中可以清楚��C��解上面各�U�方法的作用�Q�另外还有几炚w��解释�?BR>　　(1)�c�Vector定义了方�?BR>　　public final int size()
　　此方法用于获取向量元素的个数。它的返回值是向是中实际存在的元素个数�Q�而非向量定w��。可以调用方法capactly()来获取容量倹{�?BR>　　�Ҏ(gu��)��Q?BR>　　public final synchronized void setsize(int newsize)
　　此方法用来定义向量大��。若向量对象现有成员个数已超�q�了newsize的��|��则超�q�部分的多余元素�?x��)丢失�?BR>　　(2)�E�序中定义了Enumeration�cȝ��一个对�?BR>　　Enumeration是java.util中的一个接口类�Q�在Enumeration中封装了有关枚�D数据集合的方法�?BR>　　在Enumeration中提供了�Ҏ(gu��)��hawMoreElement()来判断集合中是束�q�有其它元素和方法nextElement()来获取下一个元素。利用这两个�Ҏ(gu��)��可以依次获得集合中元素�?BR>　　Vector中提供方法：(x��)
　　public final synchronized Enumeration elements()
　　此方法将向量对象对应��C��个枚丄��型。java.util包中的其它类中也大都有这�c�L��法，以便于用戯��取对应的枚�D�c�d��?BR>
1.6 栈类Stack

　　Stack�c�L��Vector�cȝ��子类。它向用��h��供了堆栈�q�种高��的数据结构。栈的基本特性就是先�q�后出。即先放入栈中的元素��后被推出。Stack�c�M��提供了相应方法完成栈的有��x��作�?BR>　　基本�Ҏ(gu��)��Q?BR>　　public Object push(Object Hem)
　　��Hem压入栈中�Q�Hem可以是�Q何类的对象�?BR>　　public Object pop()
　　弹出一个对象�?BR>　　public Object peek()
　　�q�回栈顶元素�Q�但不弹出此元素�?BR>　　public int search(Object obj)
　　搜烦(ch��)对象obj,�q�回它所处的位置�?BR>　　public boolean empty()
　　判别栈是否�ؓ(f��)�I��?BR>　　�?.4 StackApp.java使用了上面的各种�Ҏ(gu��)��?BR>　　�?.4 StackApp.java�?BR>　　import java.lang.*;
　　import java.util.*;
　　public class StackApp{
　　　public static void main(String args[]){
　　　　Stack sta=new Stack();
　　　　sta.push("Apple");
　　　　sta.push("banana");
　　　　sta.push("Cherry");
　　　　//压入的�ؓ(f��)字符串对�?BR>　　　　sta.push(new Integer(2));
　　　　//压入的�ؓ(f��)Integer的对象，��gؓ(f��)2
　　　　sta.push(new Float(3.5));
　　　　//压入的�ؓ(f��)Float的对象，��gؓ(f��)3.5
　　　　System.out.println("The stack is,"+sta);
　　　　//对应栈sta
　　　　System.out.println("The top of stack is:"+sta.peek());
　　　　//对应栈顶元素�Q�但不将此元素弹�?BR>　　　　System.out.println("The position of object Cherry is:"
　　　　+sta.search("cherry"));
　　　　//打印对象Cherry所处的位置
　　　　System.out.print("Pop the element of the stack:");
　　　　while(!sta.empty())
　　　　System.out.print(sta.pop()+" ");
　　　　System.out.println();
　　　　//��栈中的元素依次弹出�q�打印。与�W�一�ơ打印的sta的结果比较，可看出栈
　　　　//先进后出的特�?BR>　　　}
　　}
　　�q�行�l�果(�?

1.7 哈希表类Hashtable

　　哈希表是一�U�重要的存储方式�Q�也是一�U�常见的��(g��)索方法。其基本思想是将关系码的��g��变量�Q�通过一定的函数关系计算出对应的函数��|��把这个数��D��释�ؓ(f��)�l�点的存储地址�Q�将�l�点存入计算得到存储地址所对应的存储单元。检索时采用��(g��)索关键码的方法。现在哈希表有一套完整的��法来进行插入、删除和解决冲突。在Java中哈希表用于存储对象�Q�实现快速检索�?BR>　　Java.util.Hashtable提供了种�Ҏ(gu��)��让用户��用哈希表�Q�而不需要考虑其哈希表真正如何工作�?BR>　　哈希表类中提供了三种构造方法，分别是：(x��)
　　public Hashtable()
　　public Hashtable(int initialcapacity)
　　public Hashtable(int initialCapacity,float loadFactor)
　　参数initialCapacity是Hashtable的初始容量，它的值应大于0。loadFactor又称装蝲因子�Q�是一�?.0�?.1之间的float型的��点数。它是一个百分比�Q�表明了哈希表何旉��要扩充，例如�Q�有一哈希表，定w��?00�Q�而装载因子�ؓ(f��)0.9�Q�那么当哈希�?0%的容量已被��用时�Q�此哈希表会(x��)自动扩充成一个更大的哈希表。如果用户不赋这些参敎ͼ��pȝ��?x��)自动进行处理，而不需要用��h��心�?BR>　　Hashtable提供了基本的插入、检索等�Ҏ(gu��)��?BR>　　■插�?BR>　　public synchronized void put(Object key,Object value)
�l�对象value讑֮�一关键字key,�q�将其加到Hashtable中。若此关键字已经存在�Q�则��此关键字对应的旧对象更��Cؓ(f��)新的对象Value。这表明在哈希表中相同的关键字不可能对应不同的对�?从哈希表的基本思想来看�Q�这也是显而易见的)�?BR>　　■检�?BR>　　public synchronized Object get(Object key)
　　�Ҏ(gu��)��l�定关键字key获取相对应的对象�?BR>　　public synchronized boolean containsKey(Object key)
　　判断哈希表中是否包含关键字key�?BR>　　public synchronized boolean contains(Object value)
　　判断value是否是哈希表中的一个元素�?BR>　　■删�?BR>　　public synchronized object remove(object key)
　　从哈希表中删除关键字key所对应的对象�?BR>　　public synchronized void clear()
　　清除哈希�?BR>　　另外�Q�Hashtalbe�q�提供方法获取相对应的枚��N��合：(x��)
　　public synchronized Enumeration keys()
　　�q�回关键字对应的枚�D对象�?BR>　　public synchronized Enumeration elements()
　　�q�回元素对应的枚丑֯�象�?BR>　　�?.5 Hashtable.java�l�出了��用Hashtable的例子�?BR>　　�?.5 Hashtalbe.java�?BR>　　//import java.lang.*;
　　import java.util.Hashtable;
　　import java.util.Enumeration;
　　public class HashApp{
　　　public static void main(String args[]){
　　　　Hashtable hash=new Hashtable(2,(float)0.8);
　　　　//创徏了一个哈希表的对象hash�Q�初始容量�ؓ(f��)2�Q�装载因子�ؓ(f��)0.8

　　　　hash.put("Jiangsu","Nanjing");
　　　　//��字�W�串对象“Jiangsu”给定一关键字“Nanjing�?�q�将它加入hash
　　　　hash.put("Beijing","Beijing");
　　　　hash.put("Zhejiang","Hangzhou");

　　　　System.out.println("The hashtable hash1 is: "+hash);
　　　　System.out.println("The size of this hash table is "+hash.size());
　　　　//打印hash的内容和大小

　　　　Enumeration enum1=hash.elements();
　　　　System.out.print("The element of hash is: ");
　　　　while(enum1.hasMoreElements())
　　　　　System.out.print(enum1.nextElement()+" ");
　　　　System.out.println();
　　　　//依次打印hash中的内容
　　　　if(hash.containsKey("Jiangsu"))
　　　　　System.out.println("The capatial of Jiangsu is "+hash.get("Jiangsu"));
　　　　hash.remove("Beijing");
　　　　//删除关键字Beijing对应对象
　　　　System.out.println("The hashtable hash2 is: "+hash);
　　　　System.out.println("The size of this hash table is "+hash.size());
　　　}
　　}

　　�q�行�l�果�Q?BR>　　The hashtable hash1 is: {Beijing=Beijing, Zhejiang=Hangzhou, Jiangsu=Nanjing}
　　The size of this hash table is 3
　　The element of hash is: Beijing Hangzhou Nanjing
　　The capatial of Jiangsu is Nanjing
　　The hashtable hash2 is: {Zhejiang=Hangzhou, Jiangsu=Nanjing}
　　The size of this hash table is 2

　　Hashtable是Dictionary(字典)�cȝ��子类。在字典�c�M��把关键字对应到数据倹{��字典类是一个抽象类。在java.util中还有一个类Properties�Q�它是Hashtable的子�c�R��用它可以进行与对象属性相关的操作�?BR>
1.8 位集合类BitSet

　　位集合类中封装了有关一�l�二�q�制数据的操作�?BR>　　我们先来看一下例8.6 BitSetApp.java�?BR>　　�?.6 BitSetApp.java
　　//import java.lang.*;
　　import java.util.BitSet;
　　public class BitSetApp{
　　　private static int n=5;
　　　public static void main(String[] args){
　　　　BitSet set1=new BitSet(n);
　　　　for(int i=0;i　　　　//��set1的各位赋1�Q�即各位均�ؓ(f��)true
　　　　BitSet set2= new BitSet();
　　　　set2=(BitSet)set1.clone();
　　　　//set2为set1的拷�?BR>　　　　set1.clear(0);
　　　　set2.clear(2);
　　　　//��set1的第0位set2的第2位清�?BR>　　　　System.out.println("The set1 is: "+set1);
　　　　//直接��set1转换成字�W�串输出�Q�输出的内容是set1中值true所处的位置
　　　　//打印�l�果为The set1 is:{1,2,3,4}
　　　　System.out.println("The hash code of set2 is: "+set2.hashCode());
　　　　//打印set2的hashCode
　　　　printbit("set1",set1);
　　　　printbit("set2",set2);
　　　　//调用打印�E�序printbit(),打印对象中的每一个元�?BR>　　　　//打印set1的结果�ؓ(f��)The bit set1 is: false true true true true
　　　　set1.and(set2);
　　　　printbit("set1 and set2",set1);
　　　　//完成set1 and set2,�q�打印结�?BR>　　　　set1.or(set2);
　　　　printbit("set1 or set2",set1);
　　　　//完成set1 or set2,�q�打印结�?BR>　　　　set1.xor(set2);
　　　　printbit("set1 xor set2",set1);
　　　　//完成set1 xor set2,�q�打印结�?BR>　　　}
　　　//打印BitSet对象中的内容
　　　public static void printbit(String name,BitSet set){
　　　　System.out.print("The bit "+name+" is: ");
　　　　for(int i=0;i　　　　　System.out.print(set.get(i)+" ");
　　　　System.out.println();
　　　}
　　}

　　�q�行�l�果�Q?BR>　　The set1 is: {1, 2, 3, 4}
　　The hash code of set2 is: 1225
　　The bit set1 is: false true true true true
　　The bit set2 is: true true false true true
　　The bit set1 and set2 is: false true false true true
　　The bit set1 or set2 is: true true false true true
　　The bit set1 xor set2 is: false false false false false

　　�E�序中��用了BitSet�c�L��供的两种构造方法：(x��)
　　　　public BitSet();
　　　　public BitSet(int n);
　　参数n代表所创徏的BitSet�cȝ��对象的大��。BitSet�cȝ��对象的大��在必要时会(x��)��q��l�自动扩充�?BR>　　其它�Ҏ(gu��)��Q?BR>　　public void set(int n)
　　��BitSet对象的第n位设�|�成1�?BR>　　public void clear(int n)
　　��BitSet对象的第n位清零�?BR>　　public boolean get(int n)
　　��d��位集合对象的�W�n位的��|��它获取的是一个布?y��u)��(d��ng)倹{��当�W�n位�ؓ(f��)1�Ӟ��q�回true�Q�第n位�ؓ(f��)0�Ӟ��q�回false�?BR>　　另外�Q�如在程序中所�C�，当把一BitSet�cȝ��对象转换成字�W�串输出�Ӟ��输出的内�Ҏ(gu��)��此对象中true所处的位置�?BR>　　在BitSet中提供了一�l�位操作�Q�分别是�Q?BR>　　public void and(BitSet set)
　　public void or(BitSet set)
　　public void xor(BitSet set)
利用它们可以完成两个位集合之间的与、或、异或操作�?BR>　　BitSet�c�M��有一�Ҏ(gu��)��public int size()来取得位集合的大��，它的�q�回��g��初始化时讑֮�的位集合大小n不一��P��一般�ؓ(f��)64�?BR>
��结

　　本章我们介绍了Java的实用工��L(f��ng)��库java.util中一些常用的�c�R��java.util包中�q�有其它一些类。它们的具体用法用户可以自行查阅API�?nbsp;

�z�d��JAVA岛的日子 2005-11-24 17:55 发表评论

ARRAYS

�z�d��JAVA岛的日子 — Wed, 23 Nov 2005 09:22:00 GMT

     package untitled4;
import java.util.*;
class compare implements Comparator
{
    public int compare(Object o1,Object o2)
    {
        int i=((Person)o1).getFirstName().compareTo(((Person)o2).getFirstName());
        return (i!=0?i:((Person)o1).getLastName().compareTo(((Person)o2).getLastName()));
    }
}
class Person implements Comparable
{   private String firstName;
    private String lastName;
    public String getFirstName()
    {
      return firstName;
    }
    public String getLastName()
    {      return lastName;
    }
    public Person(String f,String l)
    {
       firstName=f;
       lastName=l;
    }
    public int compareTo(Object o)
    { Person p=(Person)o;
        int l=firstName.compareTo(p.firstName);
       return (l!=0?l:(lastName.compareTo(p.lastName)));
    }
    public String toString()
    {
        return firstName+" "+lastName;
    }

}
public class ArrayTest {
    public ArrayTest() {
    }
public static void main(String args[])
    {
        int a[];
        a = new int[5];
        Arrays.fill(a, 5); //�?填充数组
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        int b[] = {10, 3, 5, 6, 8, 9};
        Arrays.sort(b);
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]);
        }

        Person p[] = {
                     new Person("John", "Lennon"),
                     new Person("Karl", "Marx"),
                     new Person("Groucho", "Marx"),
                     new Person("Oscar", "Grouch")
        };
        for (int i = 0; i < p.length; i++) {
            System.out.println(p[i]);
        }

        //Arrays.sort(p);
        Arrays.sort(p, new compare());
        for (int i = 0; i < p.length; i++) {
           System.out.println(p[i]);
       }

        int s = Arrays.binarySearch(p, new Person("Groucho", "Marx"), new compare());
        System.out.println(s);
        Person person[];
        person = new Person[4];
        System.arraycopy(p, 0, person, 0, p.length);
        for (int c= 0; c < person.length; c++)
        {
            System.out.println(person[c]);

        }
    }
}
当用Arrays的sort�Ҏ(gu��)��?需要排序的数组必须实现Comparable借口.或者实现Comparator接口
Arrays的fill�Ҏ(gu��)��是用一个基本类型或者一个对象填充数�l?
当调用binarySearch()时如果是调用sort(Objiec a[],Comparator a)�?,应调用相应的binarySearch(Object a[],Object value,Comparator)�Ҏ(gu��)��.
equals()�Ҏ(gu��)��用于比较非基本类型数�l�时,调用他们的equals�Ҏ(gu��)��..比如
int a[]={5,4,3,2,1};
int c[]={5,4,3,2,1}; 基本�c�d��比较他们的�?
System.out.println(Arrays.equals(a,c)); TRUE
Integer a[]={new Integer(1),new Integer(2),new Integer(3)};
Integer b[]={new Integer(1),new Integer(2),new Integer(3)};
System.out.println(Arrays.equals(a,b));   调用Integer.equals()�Ҏ(gu��)��
对于没有覆盖Object equals�Ҏ(gu��)��的对象数�l?他们之间比较的是对象的引�?
System.arraycopy()�Ҏ(gu��)��对与基本�c�d��来说只是复制他们的�?而对于非基本�c�d��时他们复制引�?BR> person person[]={new person("guo",20),new person("cher",21)};
         person per[]={new person("guo",20),new person("cher",21)};
       person []p=new person[2];
       System.arraycopy(person,0,p,0,person.length);
       System.out.println(person==p);    //输出 false
       person[1].setName("hao");
       System.out.println(person[1].equals(p[1])); 输出 true
       System.out.println(Arrays.equals(person,p));   输出 true
        System.out.println(Arrays.equals(person,per)); 输出 false

�z�d��JAVA岛的日子 2005-11-23 17:22 发表评论

对多态的理解

�z�d��JAVA岛的日子 — Tue, 15 Nov 2005 18:59:00 GMT
如果子类�l�承了父�cȝ��Ҏ(gu��)��Q�未重写�Q�，则运行时�pȝ��调用父类的方法�?/SPAN>
在例3-6中，父类对象a引用的是子类的实�?/SPAN>�Q�所以，java�q�行时调用子�c�B的callme�Ҏ(gu��)��?BR>importjava.io.*;
　　classA{
　　　　　voidcallme(){
　　　　　　System.out.println("InsideA'scallme()method");
　　　　　}
　　}
　　classBextendsA{
　　　　　voidcallme(){
　　　　　　System.out.println("InsideB'scallme()Method");
　　　　　}
　　}
　　publicclassDispatch{
　　　　　publicstaticvoidmain(Stringargs[]){
　　　　　　Aa=newB();
　　　　　　a.callme();
　　　　　}
　　}

◇方法重写时应遵循的原则�Q?/SPAN>
　　1�Q�改写后的方法不能比被重写的�Ҏ(gu��)��有更严格的访问权限（可以相同�Q��?/FONT>
　　2�Q�改写后的方法不能比重写的方法��生更多的例外�?/SPANSTYLE="COLOR:RED">

�z�d��JAVA岛的日子 2005-11-16 02:59 发表评论

�z�d��JAVA岛的日子 — Tue, 15 Nov 2005 18:44:00 GMT

品味Java子类型多态的��力

减小字体增大字体

　　“polymorphism(多态）(j��)”一词来自希腊语�Q�意为“多�U��Ş式”。多数Java�E�序员把多态看作对象的一�U�能力，使其能调用正��的�Ҏ(gu��)��版本。尽��如此，�q�种面向实现的观点导致了多态的��奇功能�Q�胜于仅仅把多态看成纯�_�的概念�?BR>
　　Java中的多态��L��子类型的多态。几乎是机械式��生了一些多态的行�ؓ(f��)�Q��我们不去考虑其中涉及(qi��ng)的类型问题。本文研�I�了一�U�面向类型的对象观点�Q�分析了如何��对象能够表现的行�ؓ(f��)和对象即��表现的行�ؓ(f��)分离开来。抛开Java中的多态都是来自��承的概念�Q�我们仍然可以感刎ͼ�Java中的接口是一�l�没有公�׃��码的对象�׃�n实现�?BR>
　　多态的分类

　　多态在面向对象语言中是个很普遍的概�?虽然我们�l�常把多态�؜��Z��谈，但实际上有四�U�不同类型的多态。在开始正式的子类型多态的�l�节讨论前，然我们先来看看普通面向对象中的多态�?BR>
　　Luca Cardelli和Peter Wegner�Q?On Understanding Types, Data Abstraction, and Polymorphism"一文的作者，文章参考资源链接）(j��)把多态分��Z��大类----特定的和通用�?---四小�c�：(x��)强制的，重蝲的，参数的和包含的。他们的�l�构如下�Q?BR>
screen.width-600)this.style.width=screen.width-600;">

　　在这样一个体�p�M��Q�多态表现出多种形式的能力。通用多态引用有相同�l�构�c�d��的大量对象，他们有着共同的特征。特定的多态涉�?qi��ng)的是小部分没有相同特征的对象。四�U�多态可做以下描�q�ͼ�(x��)

　　强制的：(x��)一�U�隐式做�c�d��转换的方法�?BR>
　　重蝲的：(x��)��一个标志符用作多个意义�?BR>
　　参数的：(x��)��Z��同类型的参数提供相同的操作�?BR>
　　包含的：(x��)�c�d��含关�pȝ��抽象操作�?BR>
　　我将在讲�q�子�c�d��多态前��单介�l�一下这几种多态�?BR>
　　强制的多�?/B>

　　强制多态隐式的��参数按某种�Ҏ(gu��)��Q��{换成�~�译器认为正��的�c�d��以避免错误。在以下的表辑ּ�中，�~�译器必��d��定二元运��符�?’所应做的工作：(x��)

　　2.0 + 2.0

　　2.0 + 2

　　2.0 + "2"

　　�W�一个表辑ּ��两个double的操作数相加�Q�Java中特别声明了�q�种用法�?BR>
　　�W�二个表辑ּ��double型和int相加。Java中没有明��定义这�U�运��。不�q�，�~�译器隐式的��第二个操作数�{换�ؓ(f��)double型，�q�作double型的加法。做对程序员来说十分方便�Q�否则将�?x��)抛��Z��个编译错误，或者强制程序员昑ּ�的将int转换为double�?BR>
　　�W�三个表辑ּ��double与一个String相加。Java中同��h��有定义这��L(f��ng)��操作。所以，�~�译器将double转换成String�c�d��Q��ƈ��他们做串联�?BR>
　　强制多态也�?x��)发生在��?gu��)��调用中。假讄��Derived�l�承了类Base�Q�类C有一个方法，原型为m(Base)�Q�在下面的代码中�Q�编译器隐式的将Derived�cȝ��对象derived转化为Base�cȝ��对象。这�U�隐式的转换使m(Base)�Ҏ(gu��)��使用所有能转换成Base�cȝ��所有参数�?BR>
C c = new C();

Derived derived = new Derived();

c.m( derived );

　　�q�且�Q�隐式的强制转换�Q�可以避免类型�{换的�ȝ��(ch��)�Q�减��编译错误。当�?d��ng)��~�译器仍然会(x��)优先验证�W�合定义的对象类型�?BR>
　　重蝲的多�?/B>

　　重蝲允许用相同的�q�算�W�或�Ҏ(gu��)��Q�去表示截然不同的意义。�?’在上面的程序中有两个意思：(x��)两个double型的数相加；两个串相�q�。另外还有整型相加，长整型，�{�等。这些运��符的重载，依赖于编译器�Ҏ(gu��)��上下文做出的选择。以往的编译器�?x��)把操作数隐式�{换�ؓ(f��)完全�W�合操作�W�的�c�d��。虽然Java明确支持重蝲�Q�但不支持用户定义的操作�W�重载�?BR>
　　Java支持用户定义的函数重载。一个类中可以有相同名字的方法，�q�些�Ҏ(gu��)��可以有不同的意义。这些重载的�Ҏ(gu��)��中，必须满��参数数目不同�Q�相同位�|�上的参数类型不同。这些不同可以帮助编译器区分不同版本的方法�?BR>
　　�~�译器以�q�种唯一表示的特征来表示不同的方法，比用名字表示更�ؓ(f��)有效。据此，所有的多态行为都能编译通过�?BR>
　　强制和重载的多态都被分�c�Mؓ(f��)特定的多态，因�ؓ(f��)�q�些多态都是在特定的意义上的。这些被划入多态的�Ҏ(gu��)��给�E�序员带来了很大的方�ѝ��强制多态排除了�ȝ��(ch��)的类型和�~�译错误。重载多态像一块糖�Q�允许程序员用相同的名字表示不同的方法，很方�ѝ�?BR>
　　参数的多�?/B>

　　参数多态允许把许多�c�d��抽象成单一的表�C�。例如，List抽象�c�M��Q�描�q�C��一�l�具有同��L(f��ng)��征的对象�Q�提供了一个通用的模�ѝ��你可以通过指定一�U�类型以重用�q�个抽象�c�R��这些参数可以是��M��用户定义的类型，大量的用户可以��用这个抽象类�Q�因此参数多态毫无疑问的成�ؓ(f��)最强大的多态�?BR>
　　乍一看，上面抽象�c�d��像是java.util.List的功能。然而，Java实际上�ƈ不支持真正的安全�c�d��风格的参数多态，�q�也是java.util.List和java.util的其他集合类是用原始的java.lang.Object写的原因�Q�参考我的文�?A Primordial Interface?" 以获得更多细节）(j��)。Java的单根��承方式解决了部分问题�Q�但没有发挥出参数多态的全部功能。Eric Allen有一��精彩的文章“Behold the Power of Parametric Polymorphism”，描述了Java通用�c�d��的需求，�q�徏议给Sun的Java规格需�?000014��h��?Add Generic Types to the Java Programming Language."�Q�参考资源链接）(j��)

　　包含的多�?/B>

　　包含多态通过值的�c�d��和集合的包含关系实现了多态的行�ؓ(f��).在包括Java在内的众多面向对象语�a�中，包含关系是子�c�d��的。所以，Java的包含多态是子类型的多态�?BR>
　　在早期，Java开发者们所提及(qi��ng)的多态就�Ҏ(gu��)��子类型的多态。通过一�U�面向类型的观点�Q�我们可以看到子�c�d��多态的强大功能。以下的文章中我们将仔细探讨�q�个问题。�ؓ(f��)��明�v见，下文中的多态均指包含多态�?BR>
　　面向�c�d��观点

　　�?的UML�c�d��l�出了类和类型的��单��承关�p�，以便于解释多态机制。模型中包含5�U�类型，4个类和一个接口。虽然UML中称为类图，我把它看成类型图。如"Thanks Type and Gentle Class," 一文中所�q�ͼ�每个�c�d��接口都是一�U�用户定义的�c�d��。按独立实现的观点（如面向类型的观点�Q�，下图中的每个矩�Ş代表一�U�类型。从实现�Ҏ(gu��)��看，四种�c�d��q�用了类的结构，一�U�运用了接口的结构�?BR>
screen.width-600)this.style.width=screen.width-600;">
�?�Q�示范代码的UML�c�d��

　　以下的代码实��C��每个用户定义的数据类型，我把实现写得很简单�?BR>

/* Base.java */

public class Base
{
　public String m1()
　{
　　return "Base.m1()";
　}

　public String m2( String s )
　{
　　return "Base.m2( " + s + " )";
　}
}

/* IType.java */

interface IType
{
　String m2( String s );
　String m3();
}

/* Derived.java */

public class Derived
extends Base
implements IType
{
　public String m1()
　{
　　return "Derived.m1()";
　}

　public String m3()
　{
　　return "Derived.m3()";
　}
}

/* Derived2.java */

public class Derived2
extends Derived
{
　public String m2( String s )
　{
　　return "Derived2.m2( " + s + " )";
　}
　public String m4()
　{
　　return "Derived2.m4()";
　}
}

/* Separate.java */

public class Separate
implements IType
{
　public String m1()
　{
　　return "Separate.m1()";
　}
　public String m2( String s )
　{
　　return "Separate.m2( " + s + " )";
　}

　public String m3()
　{
　　return "Separate.m3()";
　}
}

　　用这��L(f��ng)��c�d��声明和类的定义，�?从概�늚�观点描述了Java指��o(h��)�?BR>
Derived2 derived2 = new Derived2();

screen.width-600)this.style.width=screen.width-600;">
�? �Q�Derived2 对象上的引用

　　上文中声明了derived2�q�个对象�Q�它是Derived2�cȝ��。图2�U�的最��层把Derived2引用描述成一个集合的�H�口�Q�虽然其下的Derived2对象是可见的。这里�ؓ(f��)每个Derived2�c�d��的操作留了一个孔。Derived2对象的每个操作都��L��适当的代码，按照上面的代码所描述的那栗��例如，Derived2对象映射了在Derived中定义的m1()�Ҏ(gu��)��。而且�q�重载了Base�cȝ��m1()�Ҏ(gu��)��。一个Derived2的引用变量无权访问Base�c�M��被重载的m1()�Ҏ(gu��)��。但�q��ƈ不意味着不可以用super.m1()的方法调用去使用�q�个�Ҏ(gu��)��。关�p�d��derived2�q�个引用的变量，�q�个代码是不合适的。Derived2的其他的操作映射同样表明了每�U�类型操作的代码执行�?BR>
　　既然你有一个Derived2对象�Q�可以用��M��一个Derived2�c�d��的变量去引用它。如�?所�C�，Derived, Base和IType都是Derived2的基�c�R��所以，Base�cȝ��引用是很有用的。图3描述了以下语句的概念观点�?BR>
Base base = derived2;

screen.width-600)this.style.width=screen.width-600;">
�?�Q�Base�c�d��用附于Derived2对象之上
　
　　虽然Base�cȝ��引用不用再访问m3()和m4()�Q�但是却不会(x��)改变它Derived2对象的�Q何特征及(qi��ng)操作映射。无论是变量derived2�q�是base�Q�其调用m1()或m2(String)所执行的代码都是一��L(f��ng)��?BR>

String tmp;
// Derived2 reference (Figure 2)
tmp = derived2.m1(); // tmp is "Derived.m1()"
tmp = derived2.m2( "Hello" ); // tmp is "Derived2.m2( Hello )"

// Base reference (Figure 3)

tmp = base.m1(); // tmp is "Derived.m1()"
tmp = base.m2( "Hello" ); // tmp is "Derived2.m2( Hello )"

　　两个引用之所以调用同一个行为，是因为Derived2对象�q�不知道去调用哪个方法。对象只知道什么时候调用，它随着�l�承实现的顺序去执行。这��L(f��ng)��序军_��了Derived2对象调用Derived里的m1()�Ҏ(gu��)��Q��ƈ调用Derived2里的m2(String)�Ҏ(gu��)��。这�U�结果取决于对象本��n的类型，而不是引用的�c�d��?BR>
　　��管如此�Q�但不意味着你用derived2和base引用的效果是完全一��L(f��ng)��。如�?所�C�，Base的引用只能看到Base�c�d��拥有的操作。所以，虽然Derived2有对�Ҏ(gu��)��m3()和m4()的映��，但是变量base不能讉K��q�些�Ҏ(gu��)��?BR>

String tmp;
// Derived2 reference (Figure 2)
tmp = derived2.m3(); // tmp is "Derived.m3()"
tmp = derived2.m4(); // tmp is "Derived2.m4()"

// Base reference (Figure 3)

tmp = base.m3(); // Compile-time error
tmp = base.m4(); // Compile-time error

　　�q�行期的Derived2对象保持了接受m3()和m4()�Ҏ(gu��)��的能力。类型的限制使Base的引用不能在�~�译期调用这些方法。编译期的类型检查像一套铠�Ԍ��保证了运行期对象只能和正��的操作�q�行�怺�作用。换句话��_(d��)��c�d��定义了对象间�怺�作用的边界�?BR>
　　多态的依附�?/B>

　　�c�d��的一致性是多态的核心。对象上的每一个引用，静态的�c�d��(g��)查器都要��认�q�样的依附和其对象的层次是一致的。当一个引用成功的依附于另一个不同的对象�Ӟ��有趣的多态现象就产生了。（严格的说�Q�对象类型是指类的定义。）(j��)你也可以把几个不同的引用依附于同一个对象。在开始更有趣的场景前�Q�我们先来看一下下面的情况��Z��么不�?x��)��生多态�?BR>
　　多个引用依附于一个对�?/B>

　　�?和图3描述的例子是把两个及(qi��ng)两个以上的引用依附于一个对象。虽然Derived2对象在被依附之后仍保持了变量的类型，但是�Q�图3中的Base�c�d��的引用依附之后，其功能减��了。结论很明显�Q�把一个基�cȝ��引用依附于派生类的对象之上会(x��)减少其能力�?BR>
　　一个开发这怎么�?x��)选择减少对象能力的方案呢�Q�这�U�选择是间接的。假设有一个名为ref的引用依附于一个包含如下方法的�cȝ��对象�Q?BR>

public String poly1( Base base )
{
　return base.m1();
}

　　用一个Derived2的参数调用poly(Base)是符合参数类型检查的�Q?BR>

ref.poly1( derived2 );

　　�Ҏ(gu��)��调用把一个本地Base�c�d��的变量依附在一个引入的对象上。所以，虽然�q�个�Ҏ(gu��)��只接受Base�c�d��的参敎ͼ�但Derived2对象仍是允许的。开发这��׃��必选择丢失功能的方案。从人眼在通过Derived2对象时所看到的情况，Base�c�d��引用的依附导致了功能的��失。但从执行的观点看，每一个传入poly1(Base)的参数都认�ؓ(f��)是Base的对象。执行机�q�不在乎有多个引用指向同一个对象，它只注重把指向另一个对象的引用传给�Ҏ(gu��)��。这些对象的�c�d��不一致�ƈ不是主要问题。执行器只关心给�q�行时的对象扑ֈ�适当的实现。面向类型的观点展示了多态的巨大能力�?BR>
　　附于多个对象的引�?/B>

　　让我们来看一下发生在poly1(Base)中的多态行为。下面的代码创徏了三个对象，�q��过引用传给poly1(Base):

Derived2 derived2 = new Derived2();
Derived derived = new Derived();
Base base = new Base();

String tmp;

tmp = ref.poly1( derived2 ); // tmp is "Derived.m1()"
tmp = ref.poly1( derived ); // tmp is "Derived.m1()"
tmp = ref.poly1( base ); // tmp is "Base.m1()"

　　poly1(Base)的实��C��码是调用传进来的参数的m1()�Ҏ(gu��)��。图3和图4展示了把三个�cȝ��对象传给�Ҏ(gu��)��Ӟ��面向�c�d��的所使用的体�pȝ��构�?BR>
screen.width-600)this.style.width=screen.width-600;">
�?�Q�将Base引用指向Derived�c�，以及(qi��ng)Base对象

　　��h��意每个图中方法m1()的映��。图3中，m1()调用了Derived�cȝ��代码�Q�上面代码中的注释标明了ploy1(Base)调用Derived.m1()。图4中Derived对象调用的仍然是Derived�cȝ��m1()�Ҏ(gu��)��。最后，�?中，Base对象调用的m1()是Base�c�M��定义的代码�?BR>
　　多态的��力何在�Q�再来看一下poly1(Base)的代码，它可以接受�Q何属于Base�c�范畴的参数。然而，当他收到一个Derived2的对象时�Q�它实际上却调用了Derived版本的方法。当你根据Base�c�L��生出其他�c�L��Q�如Derived�Q�Derived2�Q�poly1(Base)都可以接受这些参敎ͼ��q�作出选择调用合适的�Ҏ(gu��)��。多态允�怽�在完成poly1(Base)后扩展它的用途�?BR>
　　�q�看��h��当然很神奇。基本的理解展示了多态的内部工作原理。在面向�c�d��的观点中�Q�底层的对象所实现的代码是非实质性的。重要的是，�c�d��(g��)查器�?x��)在�~�译期间为每个引用选择合适的代码以实现其�Ҏ(gu��)��。多态��开发者运用面向类型的观点�Q�不考虑实现的细节。这��h��助于把类型和实现分离�Q�实际用处是把接口和实现分离�Q��?BR>
　　对象接口

　　多态依赖于�c�d��和实现的分离�Q�多用来把接口和实现分离。但下面的观点好像把Java的关键字interface搞得很糊涂�?BR>
　　更�ؓ(f��)重要的��开发者们怎样理解短语“the interface to an object"�Q�典型地�Q�根据上下文�Q�这个短语的意思是指一切对象类中所定义的方法，至一切对象公开的方法。这�U�們֐�于以实现��Z��心的观点较之于面向类型的观点来说�Q��我们更加注重于对象在�q�行期的能力。图3中，引用面板的对象表面被标志�?Derived2 Object"。这个面板上列出了Derived2对象的所有可用的�Ҏ(gu��)��。但是要理解多态，我们必须从实现这一层次上解攑և�来，�q�注意面向类型的透视图中被标�?Base Reference"的面�ѝ��在�q�一层意思上�Q�引用变量的�c�d��指明了一个对象的表面。这只是一个表面，不是接口。在�c�d��一致的原则下，我们可以用面向类型的观点�Q��ؓ(f��)一个对象依附多个引用。对interface to an object�q�个短语的理解没有确定的理解�?BR>
　　在类型概念中�Q�the interface to an object refers 引用了面向类型观点的最大可�?---如图2的情形。把一个基�cȝ��引用指向相同的对象羃?y��u)��了�q�样的观�?---如图3所�C�。类型概念能使�h获得把对象间的相互作用同实现�l�节分离的要领。相对于一个对象的接口�Q�面向类型的观点更鼓�׃�h们去使用一个对象的引用。引用类型规定了对象间的�怺�作用。当你考虑一个对象能做什么的时候，只需搞明白他的类型，而不需要去考虑他的实现�l�节�?BR>
　　Java接口

　　以上所谈到的多态行为用��C��cȝ��l�承关系所建立��h��的子�c�d��关系。Java接口同样支持用户定义的类型，相对圎ͼ�Java的接口机制启动了建立在类型层�ơ结构上的多态行为。假设一个名为ref的引用变量，�q��其指向一个包含一下方法的�c�d��象：(x��)

public String poly2( IType iType )
{
　return iType.m3();
}

　　��Z��弄明白poly2(IType)中的多态，以下的代码从不同的类创徏两个对象�Q��ƈ分别把他们传�l�poly2(IType)�Q?BR>

Derived2 derived2 = new Derived2();
Separate separate = new Separate();

String tmp;

tmp = ref.poly2( derived2 ); // tmp is "Derived.m3()"
tmp = ref.poly2( separate ); // tmp is "Separate.m3()"

　　上面的代码类��g��关于poly1(Base)中的多态的讨论。poly2(IType)的实��C��码是调用每个对象的本地版本的m3()�Ҏ(gu��)��。如同以前，代码的注释表明了每次调用所�q�回的CString�c�d��的结果。图5表明了两�ơ调用poly2(IType)的概�늻�构：(x��)

screen.width-600)this.style.width=screen.width-600;">
�?�Q�指向Derived2和Separate对象的IType引用

　　�Ҏ(gu��)��poly1(Base)和poly2(IType)中所表现的多态行为的�怼�之处可以从透视图中直接看出来。把我们在实现在一层上的理解再提高一层，��可以看到这两段代码的技巧。基�cȝ��引用指向了作为参��C��q�的�c�，�q�且按照�c�d��的限制调用对象的�Ҏ(gu��)��。引用既不知道也不关心执行哪一�D�代码。编译期间的子类型关�p�L��查保证了通过的对象有能力在被调用的时候选择合适的实现代码�?BR>
　　然而，他们在实现层上有一个重要的差别。在poly1(Base)的例子中�Q�图3和图4�Q�，Base-Derived-Derived2的类�l�承�l�构为子�c�d��关系的徏立提供了条�g�Q��ƈ军_��了方法去调用哪段代码。在poly2(IType)的例子中�Q�如�?�Q�，则是完全不同的动态发生的。Derived2和Separate不共享�Q何实现的层次�Q�但是他们还是通过IType的引用展�C�Z��多态的行�ؓ(f��)�?BR>
　　�q�样的多态行��Z��Java的接口的功能的重大意义显得很明显。图1中的UML�c�d��说明了Derived是Base和IType的子�c�d��。通过完全��q��实现�l�节的类型的定义�Ҏ(gu��)��Q�Java实现了多�c�d��l�承�Q��ƈ且不存在Java所��止的多�l�承所带来的烦(ch��)人的问题。完全脱��d��现层�ơ的�c�d��以按照Java接口实现分组。在�?中，接口IType和Derived,Separate以及(qi��ng)�q�类型的其他子类型应该划��Z��l��?BR>
　　按照�q�种完全不同于实现层�ơ的分类�Ҏ(gu��)��Q�Java的接口机制是多态变得很方便�Q�哪怕不存在��M��׃�n的实现或者复写的�Ҏ(gu��)��。如�?所�C�，一个IType的引用，用多态的�Ҏ(gu��)��讉K��C��Derived2和Separate对象的m3()�Ҏ(gu��)��?BR>
　　再次探讨对象的接�?/B>

　　注意�?中的Derived2和Separate对象的对m1()的映��方法。如前所�q�ͼ�每一个对象的接口都包含方法m1()。但却没有办法用�q�两个对象��Ҏ(gu��)��m1()表现出多态的行�ؓ(f��)。每一个对象占有一个m1()�Ҏ(gu��)��是不够的。必��d��在一个可以操作m1()�Ҏ(gu��)��的类型，通过�q�个�c�d��可以看到对象。这些对象似乎是�׃�n了m1()�Ҏ(gu��)��Q�但在没有共同基�cȝ��条�g下，多态是不可能的。通过对象的接口来看多态，�?x��)把�q�个概念搞�؜�?BR>
　　�l�论

　　从全文所�q�的面向对象多态所建立��h��的子�c�d��多态，你可以清楚地认识到这�U�面向类型的观点。如果你想理解子�c�d��多态的思想�Q�就应该把注意力从实现的�l�节转移到类型的上。类型把对象分成�l�，�q�且��理着�q�些对象的接口。类型的�l�承层次�l�构军_��了实现多态所需的类型关�p�R�?BR>
　　有趣的是�Q�实现的�l�节�q�不影响子类型多态的层次�l�构。类型决定了对象调用什么方法，而实现则军_��了对象怎么执行�q�个�Ҏ(gu��)��。也��是��_(d��)��c�d��表明了责任，而负责实施的则是具体的实现。将实现和类型分��d��Q�我们好像看��C��q�两个部分在一赯��舞，�c�d��军_��了他的舞伴和舞蹈的名字，而实现则是舞�y�动作的设计师�?BR>

�z�d��JAVA岛的日子 2005-11-16 02:44 发表评论

初学者如何开发出高质量的J2EE�pȝ�� (转蝲)

�z�d��JAVA岛的日子 — Tue, 15 Nov 2005 08:13:00 GMT
J2EE学习(f��n)者越来越多，J2EE本��n技术不断在发展�Q�涌现出各种概念�Q�本文章试图从一�U�容易理解的角度对这些概念向初学者进行解释，以便掌握学习(f��n)J2EE学习(f��n)方向。首先我们需要知道Java和J2EE是两个不同概念，Java不只是指一�U�语�a��Q�已�l�代表与微��Y不同的另外一个巨大阵营，所以Java有时是指一�U��Y件系�l�的��派�Q�当然目前主要是.NET和Java两大��L��体系�?BR>
　　J2EE可以说指Java在数据库信息�pȝ��上实玎ͼ�数据库信息系�l�从早期的dBase、到Delphi/VB�{�C/S�l�构�Q�发展到B/S�Q�Browser��览�?Server服务器）(j��)�l�构�Q�而J2EE主要是指B/S�l�构的实现�?BR>
　　J2EE又是一�U�框架和标准�Q�框架类似API、库的概念，但是要超出它们。如果需要详�l�了解框�Ӟ��可先从设计模式开始学�?f��n)�?BR>
　　J2EE是一个虚的大的概念，J2EE标准主要有三�U�子技术标准：(x��)WEB技术、EJB技术和JMS�Q�谈到J2EE应该说最�l�要落实到这三个子概念上�?BR>
　　�q�三�U�技术的每个技术在应用旉��涉及(qi��ng)两个部分�Q�容器部分和应用部分�Q�W(xu��)eb容器也是指Jsp/Servlet容器�Q�你如果要开发一个Web应用�Q�无论是�~�译或运行，都必��要有Jsp/Servlet库或API支持�Q�除了JDK/J2SE以外�Q��?BR>
　　Web技术中除了Jsp/Servlet技术外�Q�还需要JavaBeans或Java Class实现一些功能或者包装携带数据，所以Web技术最初裸体简�U�Cؓ(f��)Jsp/Servlet+JavaBeans�pȝ��?BR>谈到JavaBeans技术，��涉�?qi��ng)到�l��g构�g技术（component�Q�，�q�是Java的核心基��部分�Q�很多��Y件设计概念（设计模式�Q�都是通过JavaBeans实现的�?BR>
　　JavaBeans不属于J2EE概念范畴中，如果一个JavaBeans对象被Web技术（也就是Jsp/Servlet�Q�调用，那么JavaBeans��p��行在J2EE的Web容器中；如果它被EJB调用�Q�它?y��u)��p��行在EJB容器中�?BR>
　　EJB�Q�企业JavaBeans�Q�是普通JavaBeans的一�U�提升和规范�Q�因��Z��业信息系�l�开发中需要一个可伸羃的性能和事务、安全机�Ӟ��q�样能保证企业系�l��^滑发展，而不是发展到一�U�规模重新更换一套��Y件系�l��?BR>
　　��x��Q�JavaBeans�l��g发展到EJB后，�q�不是说以前的那�U�JavaBeans形式��消�׃��Q�这��p��然�Ş成了两种JavaBeans技术：(x��)EJB和POJO�Q�POJO完全不同于EJB概念�Q�指的是普通JavaBeans�Q�而且�q�个JavaBeans不依附某�U�框�Ӟ��或者干脆可以说�Q�这个JavaBeans是你��个应用程序单独开发创建的�?BR>
　　J2EE应用�pȝ��开发工��h��很多�Q�如JBuilder、Eclipse�{�，�q�些IDE首先是Java开发工��P��也就是说�Q�它们首要基本功能是可以开发出JavaBeans或Java class�Q�但是如果要开发出J2EE�pȝ��Q�就要落实到要么是Web技术或EJB技术，那么��有可能要一些专门模块功�?如eclipse需要lomboz插�g)�Q�最重要的是�Q�因为J2EE�pȝ��区分为容器和应用两个部分�Q�所以，在�Q何开发工具中开发J2EE都需要指定J2EE容器�?BR>
　　J2EE容器分�ؓ(f��)WEB容器和EJB容器�Q�Tomcat/Resin是Web容器�Q�JBoss是EJB容器+Web容器�{�，其中Web容器直接使用Tomcat实现的。所以你开发的Web应用�E�序可以在上面两�U�容器运行，而你开发的Web+EJB应用则只可以在JBoss服务器上�q�行�Q�商业��品Websphere/Weblogic�{�和JBoss属于同一�U�性质�?BR>
　　J2EE容器也称为J2EE服务器，大部分时它们概念是一致的�?BR>如果你的J2EE应用�pȝ��的数据库�q�接是通过JNDI获得�Q�也��是说是从容器中获得�Q�那么你的J2EE应用�pȝ��基本与数据库无关�Q�如果你在你的J2EE应用�pȝ��耦合了数据库JDBC驱动的配�|�，那么你的J2EE应用�pȝ��有数据库概念色彩，作�ؓ(f��)一个成熟需要推�q�的J2EE应用�pȝ��Q�不推荐和具体数据库耦合�Q�当然这其中如何保证J2EE应用�pȝ��q�行性能又是体现你的设计水��^了�?BR>
　　衡量J2EE应用�pȝ��设计开发水�q�高低的标准��是�Q�解耦性；你的应用�pȝ��各个功能是否能够��d��q��Q�是否不�怺�依赖�Q�也只有�q�样�Q�才能体现可�l�护性、可拓展性的软�g设计目标�?BR>
　　��Z��辑ֈ��q�个目的�Q�诞生各�U�框架概念，J2EE框架标准��一个系�l�划分�ؓ(f��)WEB和EJB主要部分�Q�当然我们有时不是以�q�个具体技术区分，而是从设计上抽象��现层、服务层和持久层�Q�这三个层次从一个高度将J2EE分离开来，实现解耦目的�?BR>
　　因此�Q�我们实际编�E�中�Q�也要将自己的功能向�q�三个层�ơ上靠，做到大方向清楚，泾渭分明�Q�但是没有技术上�U�束限制要做到这�Ҏ(gu��)��很不�Ҏ(gu��)��的，因此我们�q�是必须借助J2EE具体技术来实现�Q�这�Ӟ��你可以��用EJB规范实现服务层和持久层，W(xu��)eb技术实现表现层�Q?BR>
　　EJB��Z��么能��服务层从Jsp/Servlet手中分离出来�Q�因为它对JavaBeans�~�码有强制的�U�束�Q�现在有一�U�对JavaBeans��q��束，使用Ioc模式实现的（当然EJB 3.0也采取这�U�方式）(j��)�Q�在Ioc模式诞生前，一般都是通过工厂模式来对JavaBeans�U�束�Q��Ş成一个服务层�Q�这也是是Jive�q�样开源论坛设计原理之一�?BR>
　　由此�Q�将服务层从表现层中分离出来目前有两�U�可选架构选择�Q�管理普通JavaBeans�Q�POJO�Q�框�?如Spring、JdonFramework)以及(qi��ng)��理EJB的EJB框架�Q�因为EJB不只是框�Ӟ��q�是标准�Q�而标准可以扩展发展，所以，�q�两�U�区别将来是可能模糊�Q�被�U�_��同一个标准了。　但是�Q�个��为：(x��)标准制定是�ؓ(f��)某个目的服务的，总要牺牲一些换取另外一些，所以，�q�两�U�架构会(x��)长时间�ƈ存�?BR>
　　�q�两�U�架构分歧也曄��诞生一个新名词�Q�完全POJO的系�l�也�U�Cؓ(f��)轻量�U�系�l?lightweight)�Q�其实这个名词本�w�就没有一个严格定义，更多是一个吸引�h的招牌，轻量是指�Ҏ(gu��)��学习(f��n)�Ҏ(gu��)��使用吗？按照�q�个定义�Q�其实轻量Spring�{�系�l��ƈ不容易学�?f��n)；而且EJB 3.0�Q�依然叫EJB�Q�以后的�pȝ��是否可称��量��了呢�Q?BR>前面谈了服务层框�Ӟ��使用服务层框架可以将JavaBeans从Jsp/Servlet中分��d��来，而��用表现层框架则可以将Jsp中剩余的JavaBeans完全分离�Q�这部分JavaBeans主要负责昄��相关�Q�一般是通过标签库（taglib�Q�实玎ͼ�不同框架有不同自��q��标签库，Struts是应用比较广泛的一�U�表现层框架�?BR>
　　�q�样�Q�表现层和服务层的分��L��通过两种框架辑ֈ�目的�Q�剩余的��是持久层框架了�Q�通过持久层的框架��数据库存储从服务层中分��d��来是其目的，持久层框架有两种方向�Q�直接自��q��写JDBC�{�SQL语句�Q�如iBatis�Q�；使用O/R Mapping技术实现的Hibernate和JDO技术；当然�q�有EJB中的实体Bean技术�?BR>
　　持久层框架目前呈现百花齐放，各有优缺点的现状�Q�所以正如表现层框架一��P��目前没有一个框架被指定为标准框�Ӟ��当然�Q�表现层框架现在又出来了一个JSF�Q�它代表的页面组件概忉|��一个新的发展方向，但是复杂的实现让人有些忘而却步�?BR>
　　在所有这些J2EE技术中�Q�虽然SUN公司发挥了很大的作用�Q�不�q��M��来说�Q�网�l�上有这样一个评��P��(x��)SUN的理论天下无敌；SUN的��品用��h��撞墙�Q�对于初学者，特别是那些试��N��过或已�l�通过SUN认证的初学者，赶快摆脱SUN的阴影，立即开溜，使用开源领域的产品来实现自��q��应用�pȝ��?BR>
　　最后，你的J2EE应用�pȝ��如果采取上面提到的表现层、服务层和持久层的框架实玎ͼ�基本你也可以在无需深刻掌握设计模式的情况下开发出一个高质量的应用系�l�了�?BR>
　　�q�要注意的是: 开发出一个高质量的J2EE�pȝ��q�需要正��的业务需求理解，那么域徏模提供了一�U�比较切实可行的正确理解业务需求的�Ҏ(gu��)��Q�相兌��l�知识可从UML角度�l�合理解�?BR>
　　当然�Q�如果你惌��计自��q��行业框架�Q�那么第一步从设计模式开始吧�Q�因��计模式提供你一个实现JavaBeans或类之间解耦参考实现方法，当你学会(x��)了系�l�基本单元JavaBean或类之间解耦时�Q�那么系�l�模块之间的解耦你��可能掌握，�q�而你��可以实现行业框架的提炼了，�q�又是另外一个发展方向了�?BR>

�z�d��JAVA岛的日子 2005-11-15 16:13 发表评论

�z�d��JAVA岛的日子 — Sat, 12 Nov 2005 13:53:00 GMT

public class statictest {
    public statictest()
    {
    }
    public static void prin(String s)
    {
    System.out.println(s);
    }
    public static int i=printy("hehe");
    public static int printy(String s)
      {
          System.out.println(s);
          return 4;
       }
    public static void main(String[] args) {
        statictest.prin("fdsafa");
    }
}
输出�l�果 hehe fdsafa
当生成一个类的对象时,或者首�ơ访问属于哪个类的静态数据成员时,,�q�行初始�?
package untitled4;
class teststatic
{
   static int i=prin("test");
   static int prin(String s)
   {
       System.out.println(s);
       return 2;
   }
   static void play()
   {
   System.out.println("play");
   }

}
public class statictest2 {
    public statictest2() {
    }

    public static void main(String[] args) {
      teststatic.play();
    }
}
输出�l�果   TEST PLAY
对于�c�CLASS A的执行相当于调用A.main(),,他首先对A的元素初始化(遵��@,从A的基�c�d��?STATIC)
非STATIC在对象生成时候才初始�?/P>

�z�d��JAVA岛的日子 2005-11-12 21:53 发表评论