analysis

对与java中的final变量，java编译器是进行了优化的。每个使用了final类型变量的地方都不会通过连接而进行访问。比如说Test类中使用了Data类中一个final的int数字fNumber=77，这时候，java编译器会将77这个常数编译到Test类的指令码或者常量池中。这样，每次Test类用到fNumber的时候，不会通过引用连接到Data类中进行读取，而是直接使用自己保存在类文件中的副本。
用程序说话：
Test.java:
public class Test{
public static void main(String[] args){
System.out.println(Data.fNumber);
}
}

Data.java:
public class Data{
public static final int fNumber=77;
}
执行命令和结果：
Microsoft Windows XP [版本 5.1.2600]
(C) 版权所有 1985-2001 Microsoft Corp.
C:/Documents and Settings/zangmeng>cd ..
C:/Documents and Settings>cd ..
C:/>javac Test.java
C:/>java Test
77
C:/>

这时候，我们更改Data.java的内容：
public class Data{
public static final int fNumber=777;
}
然后执行如下命令：
C:/>javac Data.java
C:/>java Test
77
C:/>
这里我们看到，虽然Data.java中的fNumber已经更改为777，而且已经重新编译了，但是因为编译器把fNumber的副本保存Test类中，所以在重新编译Test类的前，Test类一直把fNumber认为是77而不是777。下面我们变异Test.java，再执行，看看结果。
C:/>javac Test.java
C:/>java Test
777
C:/>
这时候，我们看到，重新编译的Test类将新的777数值封装到了自己类中。

堆内存被分成了 new 和 old 两部分，

new 部分包括新创建对象区和两个 survivor 区（SS#1和SS#2），新创建的对象分配内存在 new 中，长时间存活的对象被移动到了 old 部分。Perm 是一个永久区域，分配给JVM本省，可以通过 命令行参数 -XX:MaxPermSize=64m 来设置。

当 new 被填满后，会触发"辅助" GC，把存在足够长时间的对象移动到 old 中。当 old 中也被填满了，会触发"主" GC ，将遍历堆内存中的所有对象。可以看出，"主" GC 会消耗更多的时间。足够大的 new 会适合需要大量创建存在时间很短的对象，而 old 如果不够大会频繁的触发"主" GC ，大大降低了性能。所以，我们的任务就是如何设置堆内存的大小以及如何规划 new 和 old 区域的比例来适合我们应用。

SOCKET UPD 通讯
客户端->步骤:
1 s = new DatagramSocket ();
客户端创建自寻址套接字与服务器端进行通信连接，并发送和接受自寻址套接字

2 buffer = new String ("Send me a datagram").getBytes ();
DatagramPacket dgp = new
DatagramPacket (字节数组,字节长度,主机名,端口号);
创建自寻址数据包

3: s.send (dgp);//发送自寻址数据包

4: receive()得到响应的自寻址数据包，然后自寻址数据包的getData()
(字节数组)方法返回该自寻址数据包的一个引用，最后关闭DatagramSocket

服务端->步骤:
3 s = new DatagramSocket (端口号);
客户端创建自寻址套接字与服务器端进行通信连接，并发送和接受自寻址套接字

4 buffer = new String ("Send me a datagram").getBytes ();
DatagramPacket dgp = new
DatagramPacket (字节数组,字节长度);
创建自寻址数据包

3: s.send (dgp);//发送自寻址数据包

4: receive()得到响应的自寻址数据包，然后自寻址数据包的getData()
(字节数组)方法返回该自寻址数据包的一个引用，最后关闭DatagramSocket

自寻址套接字工作包括下面三个类：DatagramPacket, DatagramSocket,和 MulticastSocket。
DatagramPacket对象描绘了自寻址包的地址信息，
DatagramSocket表示客户程序和服务程序自寻址套接字，
MulticastSocket描绘了能进行多点传送的自寻址套接字，这三个类均位于java.net包内。

SOCKET TCP 通讯
服务端:
1: 创建ServerSocket对象,作为服务端,四个构造函数绑定端口,IP
ServerSocket s = new ServerSocket(3366);
2: 连接请求被接受,服务器开始提供服务
Socket incoming = s.accept();
3: 从客户端到服务器的请求数据流
BufferedReader in = new
BufferedReader(new InputStreamReader(incoming.getInputStream()));

4: 需要发送到客户端的数据流
PrintWriter out = new PrintWriter(incoming.getOutputStream(), true /* autoFlush */);

5:

//加以利用到读取网络下载文本文件,(ServletInputStream不知道是否可以用)
BufferedReader reader = new BufferedReader(new InputStreamReader(inStream));
问题四：final关键字到底修饰了什么？
应用的对象不能变,应用对象的值不管
final使得被修饰的变量"不变"，但是由于对象型变量的本质是“引用”，使得“不变”也有了两种含义：引用本身的不变，和引用指向的对象不变。

引用本身的不变：
final StringBuffer a=new StringBuffer("immutable");
final StringBuffer b=new StringBuffer("not immutable");
a=b;//编译期错误

引用指向的对象不变：
final StringBuffer a=new StringBuffer("immutable");
a.append(" broken!"); //编译通过

可见，final只对引用的“值”(也即它所指向的那个对象的内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。这很类似==操作符：==操作符只负责引用的“值”相等，至于这个地址所指向的对象内容是否相等，==操作符是不管的。
==对象引用相等
Equals对象引用值所对应的内容空间的内容相等

对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创建实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化(类属性初始化非构造函数内)，对于后来的实例的创建，不再次进行初始化。这个问题会在以后的系列中进行详细讨论。

对于第二种变量(局部变量)，必须明确地进行初始化。如果再没有初始化之前就试图使用它，编译器会抗议。如果初始化的语句在try块中或if块中(前)，也必须要让它在第一次使用前一定能够得到赋值。也就是说，把初始化语句放在只有if块的条件判断语句中编译器也会抗议，因为执行的时候可能不符合if后面的判断条件，如此一来初始化语句就不会被执行了，这就违反了局部变量使用前必须初始化的规定。但如果在else块中也有初始化语句，就可以通过编译，因为无论如何，总有至少一条初始化语句会被执行，不会发生使用前未被初始化的事情。对于try-catch也是一样，如果只有在try块里才有初始化语句，编译部通过。如果在catch或finally里也有，则可以通过编译。总之，要保证局部变量在使用之前一定被初始化了。所以，一个好的做法是在声明他们的时候就初始化他们，如果不知道要出事化成什么值好，就用上面的默认值吧！

其实第三种变量和第二种本质上是一样的，都是方法中的局部变量。只不过作为参数，肯定是被初始化过的，传入的值就是初始值，所以不需要初始化。

理解final问题有很重要的含义。许多程序漏洞都基于此----final只能保证引用永远指向固定对象，不能保证那个对象的状态不变。在多线程的操作中,一个对象会被多个线程共享或修改，一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final，意图使得它“永远不变”。其实那是徒劳的。
线程与进程相似,是一段完成某个特定功能的代码,是程序中单个顺序的流控制;但与进程不同的是,同类的多个线程是共享一块内存空间和一组系统资源,而线程本身的数据通常只有微处理器的寄存器数据,以及一个供程序执行时使用的堆栈.所以系统在产生一个线程,或者在各个线程之间切换时,负担要比进程小的多,正因如此,线程也被称为轻负荷进程(light-weight process).一个进程中可以包含多个线程.
GC是什么? 为什么要有GC?
GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。
7、垃圾回收机制,如何优化程序?
当一个对象失去引用或者离开了作用域后，就成为垃圾而被Java运行环境自动清除，清除垃圾就是清除这些对象。
Java垃圾回收机制的特点是：
1、垃圾回收机制自动运行。系统提供一个低优先级的线程来跟踪内存的分配情况。如果发现某个内存单元不再使用，就清除它。
2、何时清除垃圾是不可预期的。
3、垃圾回收机制随JVM的不同而不同。
Java的垃圾搜索器为内存管理器提供一种自动解决方案。缺点是不能完全控制它什么时候执行以及什么时候不执行。
当垃圾搜集器运行时，其目的是查找和删除不能被访问的对象。
垃圾搜集器受JVM控制，JVM决定什么时候运行垃圾搜集器。从Java程序内可以请求JVM运行垃圾搜集器，但是，在任何情况下都无法保证JVM会答应你的请求。JVM通常会在它感到内存减少时运行垃圾搜集器。
垃圾收集器运行时，当它发现一个对象不能被任何活线程访问时，它将认为该对象符合删除条件，它可能在某时删除该对象。
垃圾收集器不能保证有足够的内存，它只能保证可以使用的内存将尽可能被有效的管理。
使对象符合垃圾搜集器搜索条件的情况有：出现空引用、重新为引用变量赋值、隔离引用。
强制执行垃圾搜集：
Runtime对象为直接与虚拟机通信提供一种机制。System类可以调用与其相同的方法。
请求垃圾收集器的最简单的方法是：System.gc();

调用时web容器自动编译(resin2.*会自动编译，tomcat不行)
一个线程一个对象(非同步),或者一个对象对应多个线程(同步)
同步也可能出现时间相同但是他们的随机数字一般是不同的
一个线程能多次获得对象的锁。也就是说，一个synchronized方法(同步方法的嵌套)调用了另一个synchronized方法，而后者又调用了另一synchronized方法，诸如此类。JVM会跟踪对象被上锁的次数。如果对象没有被锁住，那么它的计数器应该为零。当线程第一次获得对象的锁时，计数器为一。线程每获一次对象的锁，计数器就加一。当然，只有第一次获得对象锁的线程才能多次获得锁。线程每退出一个synchronized方法，计数器就减一。等减到零了，对象也就解锁了，这时其它线程就可以使用这个对象了。

通常共享资源就是一段内存，其表现形式就是对象，不过也可以是文件，I/O端口或打印机之类的。要想控制对共享资源的访问，先把它放进对象里面。然后把所有要访问这个资源的方法都作成synchronized的。也就是说，只要有一个线程还在调用synchronized方法，其它线程就不允许访问所有的synchronized方法。

我发现在我的机器上加了yield( )之后，错误提前了很多，不过这与操作系统和JVM有关。你可以试试把yield( )去掉；可能要花很长时间才会产生错误，这也证明了多线程程序的排错有多难。

前面已经讲过了，我们可以用yield( )和setPriority( )来给线程调度机制提一些建议，但究竟能起多大作用，还要看平台和JVM。

在当前的Java内存模型下，线程可以把变量保存在本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。要解决这个问题，只需要像在本程序中的这样，把该变量声明为volatile（不稳定的）即可，这就指示JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。一般说来，多任务环境下各任务间共享的标志都应该加volatile修饰。
Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。
这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。
而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。
使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。
由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。

this(invariant);使用本身类的单参数的构造函数

一般对数据库的操作必须用表单否则如果权限没有控制好的话,或者session没有空值好的话容易出现系统伪操作

<input type="button" name="deleteChecked" value="批量删除"onClick="delChecked(this);"></td>
这里input的name不能和javascript函数的名称同名否则报错,没有对象

非终止：线程状态

此外，必须注意，只有同一实例的synchronized方法同一时间只能被一个线程执行，不同实例的synchronized方法是可以并发的。例如，class A定义了synchronized方法sync()，则不同实例a1.sync()和a2.sync()可以同时由两个线程来执行。

重新取得最近的包和更新操作,sysconfig.xml 必须改IP和数据库密码
Java-resin-tomcat 配置

CATALINA_BASE=D:/Program Files/Tomcat 5.0
CATALINA_HOME=D:/Program Files/Tomcat 5.0
TOMCAT_HOME=D:/Program Files/Tomcat 5.0
Classpath=.;%java_home%/jdk/lib/dt.jar;
%java_home%/jdk/lib/tools.jar;
%java_home%/jdk/jre/lib/rt.jar;
%CATALINA_HOME%/common/lib/servlet.jar;
Path=%SystemRoot%;%SystemRoot%/system32;%SystemRoot%/system32/Wbem;%java_home%/jdk/bin;

关闭空文件流不报错.
Count(distinct keyword)
readLine() FileReader一段一段读
<pengxue_ename>(.*)</pengxue_ename>这种正则不能用
StringReader
BufferReader.readLine()

String str = "";
String str = null;
两种不同的效果
if(!str.equals(""))
{
System.out.println("非空鸡巴");
}
else
{
System.out.println("空鸡巴");
}

HTML中td元素的nowrap属性表示禁止单元格中的文字自动换行。
但使用时要注意的是，td元素中nowrap属性的行为与td元素的width属性有关。如果未设置td宽度，则nowrap属性起作用的，如果设置了td宽度，则nowrap属性不起作用。

＜form action="checkbox.jsp"＞
＜input type="checkbox" name="fruits" value="Apple"＞Apple＜br＞
＜input type="checkbox" name="fruits" value="Banana"＞Banana＜br＞
＜input type="checkbox" name="fruits" value="Orange"＞Orange＜br＞
＜input type="submit" value="Enter"＞
＜/form＞
方法1.给所有的checkbox取同一个名字,而value值不同,用request的getParameterValues();方法把所有被选中的checkbox的值传到一个数组中,从而确定哪些checkbox被选中了.

普通表单POST或者GET用getParameter(“字段名”)
上传文件用request.getInputStream();类型ServletInputStream

JspFactory _jspxFactory = null;
PageContext pageContext = null;//本页的
HttpSession session = null;//session
ServletContext application = null;//服务器开机都在
ServletConfig config = null;//服务器配置参数
JspWriter out = null;//输出流
Object page = this;
String _value = null;

StringBuffer value = new StringBuffer();能编译和运行append()不报错
StringBuffer value = null;可以编译过去但是运行的时候报错

如果异常处理好了就可以使程序继续进行,否这如果不亲自处理异常的话,让机器捕获异常的话,虚拟机会停止运行.

String.Indexof(String str)

Str的第一个字符从父字符串String中的哪里开始算起.开始的起点是
下标值0

改业务层和JSP页面不用重新启动.
改动的java文件和改动的jsp文件一样都会重新编译成.class文件,然后执行.

5.0.18-nt
mysql-connector-java-3.1.12

createStatement()效果无论是查询或者插入效果比prepareStatement()好一倍以上Statement()是PreparedStatement()的父类

executeQuery()
executeUpdate()
execute()
做完事务就关闭游标了
不允许出现的结构
Rss = executeQuery();
Rs = executeQuery();
While(rs.next())
{
Code可以用的
}
While(rss.next())
{
Code不可用的报错
}

ResultSet.TYPE_FORWARD_ONLY好像不管用

executeQuery()
getGeneratedKeys 插入产生的KEY是个ResultSet
int executeUpdate 插入或者更新或者删除的影响数据都出来了
相关的内容语句是

executeQuery()
getGeneratedKeys 插入产生的KEY是个ResultSet
int executeUpdate 插入或者更新或者删除的影响数据都出来了
int findColumn(String columnName)
将给定的 ResultSet 列名称映射到其 ResultSet 列索引。
给定的字段名映射出他在结果集合中的列索引
select id,cateid,w_name from temptable where cateid>527
那么 cateid在集合中是二个, 但是在数据库中却是第四个

标准上下文的根目录是 java:comp/env

JDNI通过绑定的概念将对象和名称联系起来。来组织和定位实体,用于上下文的引用.
在一个文件系统中，文件名被绑定给文件。在DNS中，一个IP地址绑定一个URL。在目录服务中，一个对象名被绑定给一个对象实体。

JNDI中的一组绑定作为上下文来引用。

每个上下文暴露的一组操作是一致的。

目录服务是命名服务的自然扩展
命名服务将名称和对象联系起来，使得我们可以用名称访问对象。
目录服务是一种命名服务，在这种服务里，对象不但有名称，还有属性。

换句话说，JNDI独立于目录服务的具体实现，只要你有目录的服务提供接口（或驱动），你就可以使用目录。

JNDI是一组API，它用命名/目录服务增强了网络应用。

JNDI架构
JNDI架构提供了一组标准的独立于命名系统的API,这些API构建在与命名系统有关的驱动之上这一层有助于将应用与实际数据源分离，因此不管应用访问的是LDAP、RMI、DNS、还是其他的目录服务。换句话说，JNDI独立于目录服务的具体实现，只要你有目录的服务提供接口（或驱动），你就可以使用目录。

Tomcat 5.0连接池我在conf->Catalina->www.fj.cn->ename.xml做了配置
在WEB-INF->web.xml中没有配置什么东西.(可以使用数据库连接池)

getParameter()是获取POST/GET传递的参数值；返回的一定是String
request.getAttribute()是获取对象容器中的数据值,forward或者include中可以用到否则不同页面一般用session.getAttribute()或者application.getAttribute()

默认的情况下IE浏览器发送的请求采用“ISO-8859-1”字符编码，如果WEB应用程序要正确地读取用户发送的中文数据，则需要编码转换。

动态的ActionForm
Public Object get(String name)这里就是为什么要最大话的包容很多对象，然后自己去根据需要封装
Public void set(String name ,Object value)

用表单到jsp页面或者<jsp:forward page=”2.jsp”><jsp:param name=”peng”,value=”xue” /></jsp:forward>
都用request.getParameter(“键名name”);

pageContext.setAttribute("str", attr,pageContext.REQUEST_SCOPE);

request.setAttribute(“键”,”值”)

4-4-1 page 指令
page指令是最复杂的JSP指令，它的主要功能为设定整个 JSP网页的属性和相关功能。page指
令的基本语法如下：
<%@ page attribute1="value1" attribute2= "value2" attribute3=…%>
page 指令是以<%@ page 起始，以%>结束。像所有 JSP 标签元素一样，page 指令也支持以 XML
为基础的语法，如下所示：
<jsp:directive.page attribute1="value1" attribute2= "value2" />
page指令有11个属性，如表4-1所示：
表 4-1
属 性 定 义
language = 主要指定 JSP Container要用什么语言来编译 JSP网页。
"scriptingLanguage" JSP 2.0规范中指出，目前只可以使用 Java语言，不过未
来不排除增加其他语言，如 C、C++、Perl 等等。默认值
为Java
extends = "className" 主要定义此 JSP 网页产生的 Servlet 是继承哪个父类
import = "importList" 主要定义此 JSP 网页可以使用哪些 Java API
session = "true | false" 决定此 JSP 网页是否可以使用 session 对象。
默认值为true
buffer = "none | size in 决定输出流 (output stream)是否有缓冲区。
默认值为kb" 8KB的缓冲区
autoFlush = "true | 决定输出流的缓冲区是否要自动清除，缓冲区满了会产生
false" 异常 (Exception)。
默认值为 true
isThreadSafe = "true | 主要是告诉 JSP Container，此 JSP 网页能处理超过一个
false" 以上的请求。
默认值为 true，如果此值设为 false，
SingleThreadModel 将会被使用。SingleThreadModel 在Servlet 2.4 中已经声明不赞成使用(deprecate)
info = "text" 主要表示此 JSP 网页的相关信息
errorPage = "error_url" 表示如果发生异常错误时，网页会被重新指向那一个 URL
isErrorPage = "true | false"表示此 JSP Page 是否为处理异常错误的网页
contentType = "ctinfo" 表示MIME 类型和 JSP 网页的编码方式
pageEncoding = "ctinfo" 表示JSP网页的编码方式
isELIgnored = "true | 表示是否在此 JSP 网页中执行或忽略 EL 表达式。如果为
false" true时，JSP Container将忽略 EL表达式；反之为 false
时，EL 表达式将会被执行

PageContext就是JSP中的page，ServletContext就是JSP中的application。两者的scope不一样。
---------------------------------------------------------------

是啊，在jsp里用pageContext，servlet里用servletContext。要用对地方，否则会运行不了的。
---------------------------------------------------------------

pageContext的认识
[ 作者： | 来源：| 点击数： 451]
pageContext隱含物件對應於javax.servlet.jsp.PageContext型態之物件，隱含物件都自動的被加入至pageContext中，您可以藉由它來取得與JSP相關的隱含物件
對應之Servlet物件，像是getRequest()可以取得ServletRequest，
getServletConfig()可以取得ServletConfig，
getSession()可以取得HttpSession等等。
提供取得隱含物件對應之Servlet物件並不是pageContext的主要作用，它的主要功能在提供一個單一個介面，以管理各種的公開物件（像是HttpSession、ServletContext、ServletConfig、ServletRequest、ServletResponse等等），提供一個單一的API來管理屬性作用範圍等等。

我們之前曾經使用過session的setAttribute()等方法設定一個進程可以共用的屬性物件，使用session設定的屬性在同一個進程中可以共用，除了session之外，還有pageContext、request、application也都可以使用setAttribute()之類的方法（詳請查閱API文件）來設定可以共用的屬性物件，只不過這四個物件所設定的屬性其共用範圍各不相同。

使用pageContext所設定的屬性物件，其共用範圍限於同一個JSP頁面，使用request所設定的屬性物件，其在同一個request處理期間可以共用（包括forward給其它JSP頁面，include），
session物件所設定的屬性物件則限於同一個進程作用期間可以共用，
而application物件所設定的屬性，則在整個Web應用程式中的JSP頁面都可以共用。

以下舉application為例，您可以將一些物件當作屬性設定給application，則另一個JSP頁面就可以在適當的時候取得這個屬性物件，例如：
<%
String attr = "字串物件";
out.println("設定屬性給application：" + attr);
application.setAttribute("str", attr);
%>

我們先連上這個JSP網頁以執行屬性設定，然後我們再連上這個JSP網頁：
<%
String attr = (String) application.getAttribute("str");
out.println("取得application屬性：" + attr);
%>

由於我們之前已經將字串物件設定在application中作為屬性，所以我們可以在上面這個頁面中取得之前設定的物件，同樣的道理，您也可以用相同的方式設定屬性給pageContext、request、session等物件，只要在允許的作用範圍中，就可以取得所設定的屬性物件。

您可以使用pageContext物件來設定屬性，並指定屬性的作用範圍，而不用使用個別的pageContext、request、session、application來進行設定，這就是之前所提的，以pageContext提供一個單一的API來管理屬性作用範圍，您可以使用以下的方法來進行設定：
getAttribute(String name, int scope)
setAttribute(String name, Object value, int scope)
removeAttribute(String name, int scope)

其中的scope可以使用以下的常數來進行指定：pageContext.PAGE_SCOPE、pageContext.REQUEST_SCOPE、pageContext.SESSION_SCOPE、pageContext.APPLICATION_SCOPE，常數的名稱已經直接指明屬性範圍，我們可以將上面的兩個JSP頁面改為以下的形式：
<%
String attr = "字串物件";
out.println("設定屬性給application：" + attr);
pageContext.setAttribute("str", attr, pageContext.APPLICATION_SCOPE);
%>

<%
String attr = (String) pageContext.getAttribute("str", pageContext.APPLICATION_SCOPE);
out.println("取得application屬性：" + attr);
%>

所有的数据源都必须实现的接口 javax.sql.DataSource

Struts就是尽量地那资源和程序分开,一些变量,资源常量,或者配置常量尽量用用配置文件来完成,不放在程序中,程序中局部或者临时变量。
每次根改.java都必须重新启动服务器，重新编译所以提取变量。。。。

native2ascii -encoding gb2312 application.properties ApplicationResources_CN.properties

必须用ApplicationResources否则不幸

每个Session 0.5M,1000个session占内存500M,tomcat又管理session 的功能,对SESSION进行持久化管理.

Forward 请求转发(只能请求转发到同一web应用中的组建,而不能转发到卡WEB的组件),request数据共享

sendRedirect(URL) 请求重定向,到任意的URL,不能共享request数据.

用include包含,俗称,模板处理器.不同的URL组成一个页面共享
Request数据.

调用processActionForm( )方法检查是否存在为ActionMapping配置的ActionForm 。如果存在，则在有效区域内查找是否存在该ActionForm 的实例，存在，则复用，不存在，则创建一个实例。然后将实例保存与再配置文件中配置好的有效区域(request,session,application)内，并用Action元素的name属性作为该实例的关键字。

Request的范围是,本JSP页面和<%@ include 指令以及<forward标记包含的JSP文件范围,都能共享数据

这是判断设计好坏的标准，主要是面向OO的设计，主要是看类的内聚性是否高，偶合度是否低。高内聚:类与类之间的关系而定，高，意思是他们之间的关系要简单，明了，不要有很强的关系，不然，运行起来就会出问题。一个类的运行影响到其他的类。

低偶合：类内部的方法而言。把程序的功能尽量分散，别在一个类里只写一个或很好的方法，因为那样会给你的调试等带来很多问题。出了错你都不知道在什么地方。

高内聚->专用类,低耦合->专用类方法,通用类方法是最好的
"^//d+$"　　//非负整数（正整数 + 0）
"^[0-9]*[1-9][0-9]*$"　　//正整数
"^((-//d+)|(0+))$"　　//非正整数（负整数 + 0）
"^-[0-9]*[1-9][0-9]*$"　　//负整数
"^-?//d+$"　　　　//整数
"^//d+(//.//d+)?$"　　//非负浮点数（正浮点数 + 0）
"^(([0-9]+//.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*//.[0-9]+)|([0-9]*[1-9][0-9]*))$"　　//正浮点数
"^((-//d+(//.//d+)?)|(0+(//.0+)?))$"　　//非正浮点数（负浮点数 + 0）
"^(-(([0-9]+//.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*//.[0-9]+)|([0-9]*[1-9][0-9]*)))$"　　//负浮点数
"^(-?//d+)(//.//d+)?$"　　//浮点数
"^[A-Za-z]+$"　　//由26个英文字母组成的字符串
"^[A-Z]+$"　　//由26个英文字母的大写组成的字符串
"^[a-z]+$"　　//由26个英文字母的小写组成的字符串
"^[A-Za-z0-9]+$"　　//由数字和26个英文字母组成的字符串
"^//w+$"　　//由数字、26个英文字母或者下划线组成的字符串
"^[//w-]+(//.[//w-]+)*@[//w-]+(//.[//w-]+)+$"　　　　//email地址
"^[a-zA-z]+://(//w+(-//w+)*)(//.(//w+(-//w+)*))*(//?//S*)?$"　　//url
matches( )的前提是Pattern匹配整个字符串，
而lookingAt( )的意思(前提)是Pattern匹配字符串的开头。

(public,private)
因为一般来说，公共函数必须对无效的参数进行检查和处理。而私有函数往往是直接使用的。

表达式expression必须为byte，short，int或char类型。( 不能是Long,或者boolean,或者表达式 或者 String )每个case语句后的值value必须是与表达式类型兼容的特定的一个常量（它必须为一个常量，而不是变量）。重复的case值
是不允许的。

switch(count) {//count表达式
case 1:
switch(target) { // nested switch
case 0:
System.out.println("target is zero");
break;
case 1: // no conflicts with outer switch
System.out.println("target is one");
break;
}
break;
case 2: // ..

概括起来说，switch语句有3个重要的特性需注意：
• switch语句不同于if语句的是switch语句仅能测试相等的情况，而if语句可计算任何
类型的布尔表达式。也就是switch语句只能寻找case常量间某个值与表达式的值相
匹配。
• 在同一个switch语句中没有两个相同的case常量。当然，外部switch语句中的case常
量可以和内部switch语句中的case常量相同。(嵌套的switch)
• switch语句通常比一系列嵌套if语句更有效。
最后一点尤其有趣，因为它使我们知道Java编译器如何工作。当编译一个switch语句时，
Java编译器将检查每个case常量并且创造一个“跳转表”，这个表将用来在表达式值的基础
上选择执行路径。因此，如果你需要在一组值中做出选择，switch语句将比与之等效的if-else
语句快得多。编译器可以这样做是因为它知道case常量都是同类型的，所要做的只是将它与switch表达式相比较看是否相等。对于一系列的if表达式，编译器就无此功能。

如果是多处理器的系统，线程还会被分到多个处理器上，这样就能大大提高(指令的)吞吐率了。
但是多线程最值得称道的还是它的底层抽象，即代码无需知道它是运行在单CPU还是多CPU的系统上。
线程永远也不会启动。（直接调用RUN那么避开了Start）
Thread的start( )方法会先对线程做一些初始化，再调用run( )。
Start()注册了一个线程，在内存的某个地方会保留了线程的reference,虽然没有去取用他的reference但是他和普通的对象不同他们除非推出run否则不会被垃圾收集器回收资源）
如果你知道run( )已经告一段落了，你就可以给线程调度机制作一个暗示，告诉它你干完了，可以让别的线程来使用CPU了。这个暗示(注意，只是暗示——无法保证你用的这个JVM会不会对此作出反映)是用yield( )形式给出的。
Yield()
直接从运行状态转移到等待状态，有时候系统可能分配5秒让你的Thread对象运行可是你只用了3秒工作就完成了，就可以调用该方法，把程序转移到等待运行状态

Java的线程调度机制是抢占式的(preemptive)，也就是说，只要它认为有必要，它会随时中断当前线程，并且切换到其它线程(线程的调度机制来执行)。因此，如果I/O(通过main( )线程执行)占用的时间太长了，线程调度机制就会在run( )运行到yield( )之前把它给停下来(线程被线程的调度机制强行命令停止)。

sleep( )一定要放在try域里，这是因为有可能会出现时间没到sleep( )就被中断的情况。

如果你准备用interrupt( )唤醒线程，那最好是用wait( )而不是sleep( )，

sleep()和yield()的区别
1) sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行；yield()只是使当前线程重新回到可执行状态(排队等待CPU资源)，
所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
2) sleep()可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会；yield()只能使同优先级的线程有执行的机会。
资源访问的冲突
对EvenGenerator来说，最糟糕的事情就是客户线程观察到它正处于不稳定的中间状态。但是这个对象的内部数据的一致性还是有保证的，最终还是会回到其正常的状态。但是如果真有两个线程在同时修改一个对象，那么这种资源冲突的后果就严重了，对象的状态很可能会被改错。
先简单地介绍一下semaphore的概念。Semaphore是一种用于线程间通信的标志对象。如果semaphore的值是零，则线程可以获得它所监视的资源，如果不是零，那么线程就无法获取这个资源，于是线程必须等。如果申请到了资源，线程会先对semaphore作递增，再使用这个资源。递增和递减是原子操作(atomic operation，也就是说不会被打断的操作)，由此semaphore就防止两个线程同时使用同一项资源。
如果semaphore能妥善的看护它所监视的资源，那么对象就永远也不会陷入不稳定状态。下面我们先简单地实践一下semaphore的思想:
注意
semaphore字段是volatile的，这样就能确保编译器不对读做优化了。

while (avalink.hasNext())
{
link = avalink.next().toString();
String title = this.getTitleContent(link);
String content = new String0028this.getMatContent(link));
this.DoText(title, content);
}

错误
while (avalink.hasNext())
{

String title = this.getTitleContent(avalink.next().toString()
);

String content = new String(this.getMatContent(avalink.next().
toString()
));
this.DoText(title, content);
}
每个循环用了两个next就是步数2而不是1

现在文件的可读长度必须大于byte[] b的长度，否则回出现EOFException的异常错误。
这里小心Seek(长度)，这个函数可能影响到readFully（）的执行。
我们可以先getFilePointer()知道现在的Seek的长度然后用file.length()-getFilePointer
void /(byte[] b)
将 b.length 个字节从此文件读入字节数组，并从当前文件指针开始。
void readFully(byte[] b, int off, int len)
将正好 len 个字节从此文件读入字节数组，并从当前文件指针开始。

java.io.ByteArrayOutputStream.writeTo(java.io.OutputStream)
java.io.CharArrayWriter.writeTo(java.io.Writer)

只有CharArrayWriter和ByteArrayOutputStream
又直接输出到文件
WriteTo(文件的Output)

1.13.2 flush和close
有些输出流在输出时先放在缓冲中，可以使用flush将这些数据真正写入指定的输出流中。Close用于关闭指定的输出流。
管道流
这一章只会大致地提一下PipedInputStream，PipedOutputStream，PipedReader和PipedWriter。这并不是说它们不重要，只是因为管道流是用于线程间的通信的，所以除非你已经理解了多线程，否则是不会理解它的价值的。我们会在第13章用一个例子来讲解这个问题。

输出一个换行符（/n/r）
也就是说，这类对象的任务就是提供一个accept( )的方法。之所以要创建这个类，就是要给list( )提供一个accept( )方法，这样当list( )判断该返回哪些文件名的时候，能够"回过头来调用"accept( )方法。
因此，这种结构通常被称为回调(callback)。
更准确地说，由于list( )实现了基本功能，而FilenameFilter提供了"对外服务所需的算法"，因此这是一种"策略模式(Strategy Pattern)"。由于list( )拿FilenameFilter对象当参数，因此你可以将任何实现FilenameFilter接口的对象传给它，并以此(甚至是在运行时)控制list( )的工作方式。回调能提高程序的灵活性。
DirFilter还告诉我们，interface只是包含了一些方法，它没说你只能写这些方法。(但是，你至少要定义接口里有的方法。) 这里我们还定义了DirFilter的构造函数。
accept( )方法需要两个参数，一个是File对象，表示这个文件是在哪个目录里面的；另一个是String，表示文件名。虽然你可以忽略它们中的一个，甚至两个都不管，但是你大概总得用一下文件名吧。
记住，list( )会对目录里的每个文件调用accept( )，
并以此判断是不是把它包括到返回值里；这个判断依据就是accept( )的返回值。
切记，文件名里不能有路径信息。为此你只要用一个String对象来创建File对象，然后再调用这个File对象的getName( )就可以了。它会帮你剥离路径信息（以一种平台无关的方式）。然后再在accept( )里面用正则表达式(regular expression)的matcher对象判断，regex是否与文件名相匹配。兜完这个圈子，list( )方法返回了一个数组。

int count = f.available();
byte b[] = new byte[100];
f.read(b);把流读到b这个字节数组中，然后通过string来转成string
比 new String(byte[],charset)少了一步字符集转换的问题
System.out.println(new String(b, 0, 51));
System.out.println("/nStill Available: " + (size = f.available()));

f.available()就是说可以取到的字节数。有时URL只是先取一点，所以并不能代表整个HTML文件的大小。
我们可以先取一点，f.available()他仍然可以得出剩下的字节数。

定理：一个字节8位
但是java的字符集是unicode所以一个字符16位就是，那么A 与 鹏的所占的位数（16位）或者说字节数（两个）是相同的。

if(){}
else{}
单个表达式的简化
f1.canWrite() ? "is writeable" : "is not writeable"

如果被println的对象，那么如果在他实例化的类中重新定义了toString的话，那么println的形式依照被重新定义的toString方法的表达形式。
Static
class Tstatic
{
int i = 2; //不影响内容的共享数据

public static void main(String args[])
{
TStatic t = new TStatic(); //第一次实例化，系统自动初始化
t.i = 3;
TStatic tt = new TStatic(); //第二次实例化对象，但是静态变量只能初始化一次，
静态变量是内存共享的。

System.out.println(t.i);
System.out.println(tt.i);
}
}
最后结果为3，2，在这里实例化了两次对象，而全局变量就初始化了两次，而如果全局变量i声明为static的话，那么虽然实例化两次，实际上变量i只初始化了一次，在第二次实例化的时候不会对全局变量进行初始化了，此时输出的结果是3，3，对象tt的成员i也是3，而不是想象中被int i=2初始化为2了，因为它不会再进行第二次初始化。
最后再讲一下使用static需要主要的地方，主要就是在static方法中，只能访问static方法和static变量，而反过来在非static方法中就什么都可以访问了，关于static的一些讲解就到这里了，由于本人所学有限，还有很多遗漏的或者是不足的地方，希望大家能够提出来，随时欢迎和我一起讨论相关的知识，谢谢支持
1:
主要就是在static方法中，只能访问static方法和static变量，(两个限制)
而反过来在非static方法中就什么都可以访问了(无限制)
它们不能以任何方式引用this 或super

2: 那就是说该类的所有对象都共享该内存
3: 大家知道，在类函数的外部声明的变量是全局变量(相对于该类才是全局变量)，这些全局变量如果是原始数据类型的话，那么不论是否有在声明的时候显示初始化，在每次对象实例化的时候系统都会给其自动初始化的，

4: 而对于一个声明为static的原始数据类型的全局变量来说，这样的初始化只会进行一次 (发生时间是在该类被装载的时候)

5:关键字super 与继承有关，在下一章中描述。如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。

5: 注意：在一个static 方法中引用任何实例变量都是非法的。

答案:
10
4
4
4

package net;
class TStatic
{
static int i = 100; //这里无论取什么值都不会改变静态变量的值//如果后期或者构造函数的时候没有给它赋值的话它只能用默认的这里的值 100

public TStatic()
{
int p;
i = 4; //影响到了前一个对象的i值,因为这里可以改变内容共享的静态变量的值,现在所有的Tstatic的实例对象的i值都变成了4,记得用完必须清空,i=0,否则程序运行期间都存在的.
}

public TStatic(int j)

{
i = j;
}

public static void main(String args[]){
TStatic t = new TStatic(5); //声明对象引用，并实例化
TStatic.i = TStatic.i+5;
System.out.println(t.i);
TStatic tt = new TStatic(); //同上
System.out.println(t.i);
System.out.println(tt.i);
System.out.println(t.i);
} I是共享的内存
}

Abstract 抽象类
任何含有一个或多个抽象方法的类都必须声明成抽象类。声明一个抽象类，只需在类声明开始时在关键字class前使用关键字abstract。抽象类没有对象。也就是说，一个抽象类不能通过new操作符直接实例化。这样的对象是无用的，因为抽象类是不完全定义的。而且，你不能定义抽象构造函数或抽象静态方法。所有抽象类的子类都必须执行超类中的所有抽象方法或者是它自己也声明成abstract。
因为Java的运行时多态是通过使用超类引用实现的，所以尽管抽象类不能用来实例化，它们可以用来创建对象引用。这样，创建一个抽象类的引用是可行的，这样它(超类的引用)可以用来指向一个子类对象。(实例变量)在下面的程序中你将会看到这种特性的运用。 运用抽象类，你可以改善前面所显示的Figure类。因为对于一个未定义的二维图形，面积的概念是没有意义的，下面的程序在Figure内将area( )定义成抽象方法。这样当然意味着从Figure派生的所有类都必须重载area( )方法。
class Abstract Areas {
public static void main(String args[]) {
// Figure f = new Figure(10, 10); // illegal now
Rectangle r = new Rectangle(9, 5);
Triangle t = new Triangle(10,;
Figure figref; // this is OK, no object is created

figref = r;
System.out.println("Area is " + figref.area());

figref = t;
System.out.println("Area is " + figref.area());
}
}
Main（）内的注释暗示，定义Figure类型的对象不再是可能的了，因为现在它是抽象类。而且，所有Figure的子类都必须重载area( )方法。为证明这点，试着创建不重载area( )的子类。你会收到一个编译时错误。 尽管不可能创建一个Figure类型的对象，你可以创建一个Figure类型的引用变量。变量figref声明成Figure的一个引用，意思是说它可以用来引用任何从Figure派生的对象。刚才解
释过的，通过超类引用变量重载方法在运行时解决。

那么JSP实现时SESSION如何做?第一次响应用程序先发送一个ID,和一个特殊状态标记位,要求浏览器再次发送请求时必须传回这个ID以便识别.那么,也就是说SESSION要工作,它就有一个ID保存在标准输入中.
但是response的sendRedirect()方法并不发送任何请求参数,只是把页面直接定向到要去的地方,相当于你第一次打开浏览器,直接输入一个地址.
对于如何重定向,至少有十种以上方法,表面上看都能重定向,可是内在的环境各不
相同,要根据不同的用途各不同的方法.

注意：
java.lang.*
javax.servlet.*
javax.servlet.jsp.*
javax.servlet.http.*
说已经缺省地被J S P引擎引入了
session = “true|false” 说session 变量的缺省值是true，表示当前页面中将有一个缺省的名为“session”的对象来表示当前会话。“session”对象的类型是：javax.servlet.http.HttpSession

?
一般 == 对比内存值，equals对比内容值是否相等(对象)
用法：
String a = "A";
String b = "A";
a==b 返回 false
a.equals(b) 返回 true
其它对象也一样（就是说大写开头的 类型，例如 Double,Integer,Float等等）

而小写的类型（例如，int,double,float,boolean等等）就不能用equals比较了,只能用 == 号比较(简单类型)
int a = 1;
int b = 1;
a==b 返回 true
a.equals(b)出错

必须是绝对的URL否则出现非法异常(好像已经过时了)

Session.getMaxInactiveInterval()
会话创建后,用户连续多长时间不向服务器发送请求,Session可以保持的有效时间。

 

Session.invalidate() IllegalStateException

accept */*
referer http://localhost/include.jsp
accept-language zh-cn
content-type application/x-www-form-urlencoded
accept-encoding gzip, deflate
user-agent Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; Maxthon)
host localhost
content-length 42
connection Keep-Alive
cache-control no-cache
cookie JSESSIONID=EC2E058AA929539257DBE3266382FC5B
Name

HttpRequest对象有两种形式的getSession方法调用，一个是getSession()，另一个是getSession(boolean isNew)这样的，前者会检测当前时候有session存在，如果不存在则创建一个，如果存在就返回当前的。getSession()相当于getSession(false)，getSession(true)则不管当前是否存在Session都创建一个。
Enumeration peng=request.getHeaderNames();
头信息是个集

String[] peng=request.getParameterValues("Number");
getParameter(“Number”)
FORM是个字符串数组

maxIdle，最大空闲数，数据库连接的最大空闲时间。超过空闲时间，数据库连接将被标记为不可用，然后被释放。设为0表示无限制。
MaxActive，连接池的最大数据库连接数。设为0表示无限制。
maxWait ，最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。

Pattern.MULTILINE?m(^,$用在行的开头和结尾，也继续可以用再字符串，功能的扩展),
Pattern.DOTALL?s任意包括了行结束符号

Pattern.COMMENTS(?x) 在这种模式下，匹配时会忽略(正则表达式里的)空格字符(译者注：不是指表达式里的"//s"，而是指表达式里的空格，tab，回车之类)。注释从#开始，一直到这行结束。可以通过嵌入式的标志来启用Unix行模式。
str.ReplaceAll(“ {2,},”””)效果和这个不一样
str.ReplaceAll(“//s{2,},”””)

你表达式有问题
[] 只表示一个字母, 而不是一个字串
使用
^(?i:[ab]+)$
或者
(?i)^[ab]+$
(?i) 代表后面的表达式一律是大小写无关的
(?i:string) 只是冒号后面的表达式大小写无关的
Top
5楼 registered (已注册) 回复于 2004-08-27 13:29:54 得分 0

当然也可以关闭
(?-i)
(?-i:string)

实例化一个对象时可以直接用同一个包里面的类，或者用import导入一个包的类

commons-collections,commons-dbcp-1.1,commons-pool-1.1三个包拷贝到tomcat的comman的lib中，试试吧 一般都再tomcat的common/lib里面

　file://选择数据库
　　connection.setCatalog( "MyDatabase");
ResultSet rs = st.executeQuery("SELECT * FROM mytable");
R
rs.getMetaData().getColumnCount();

long l = System.currentTimeMillis();

<%
guestbook.Init init=new guestbook.Init(getServletContext().getRealPath("/"));

import guestbook.Init
Init init=new Init(getServletContext().getRealPath("/"));

guestbook.ReadGuestbook readNote=new guestbook.ReadGuestbook(getServletContext().getRealPath("/"));
%>
注意了
（必须关闭的资源，finally）
finally
{
try
{
stmt.close();
conn.close();
LinkDB.shutdownDataSource(dataSource);
}
catch(SQLException e)
{
out.println(e);
}
}

2、ArrayList和Vector的区别,HashMap和Hashtable的区别
答：就ArrayList与Vector主要从二方面来说.
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半

就HashMap与HashTable主要从三方面来说。
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现

二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value
键值必须唯一,但是对应的值(value)可以不唯一页可以是null

3、char型变量中能不能存贮一个中文汉字?为什么?
答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的

5、继承时候类的执行顺序问题,一般都是选择题,问你将会打印出什么?
答:父类：
package test;
public class FatherClass
{
public FatherClass()
{
System.out.println("FatherClass Create");
}
}
子类:
package test;
import test.FatherClass;
public class ChildClass extends FatherClass
{
public ChildClass()
{
System.out.println("ChildClass Create");
}
public static void main(String[] args)
{
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass();
}
}
输出结果：
C:>java test.ChildClass
FatherClass Create
FatherClass Create
ChildClass Create

9、介绍JAVA中的Collection FrameWork(包括如何写自己的数据结构)?
答：Collection FrameWork如下：
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）
Map提供key到value的映射

12、抽象类与接口？
答：抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。

用<% Request.setCharacterEncoding(“gb2312”); %>FORM解决乱码问题(动态乱码)
(页面)静态的用<%@ page contentType=”text/html;charset=gb2312”%>
1:在被包含的文件里面不能放在<% %>中${param.字段名} Tomcat会乱码(解决)
2:表单上传乱码问题解决

GET 方法传输数据要用到过滤器
(Tomcat5.0够用了,服务器配置一下)
<Connector URIEncoding=”GBK”
port="80" maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
debug="0" connectionTimeout="20000"
disableUploadTimeout="true"
/>
WEB.XML有servlet但是现实的目录中没有此文档,那么这个虚拟机是不能用的.其他的可以,增加相应的servlet后必须重新启动.

转载Tomcat中文问题- -

在tomcat5中发现了以前处理tomcat4的方法不能适用于处理直接通过url提交的请求，上网找资料终于发现了最完美的解决办法，不用每个地方都转换了，而且无论get,和post都正常。写了个文档，贴出来希望跟我有同样问题的人不再像我一样痛苦一次:-)
-------------------
Tomcat 5中文问题
author:[e-mail]
-------------------
问题描述：
1 表单提交的数据，用request.getParameter(“xxx”)返回的字符串为乱码或者？？
2 直接通过url如http://localhost/a.jsp?name=中国，这样的get请求在服务端用request. getParameter(“name”)时返回的是乱码；按tomcat4的做法设置Filter也没有用或者用request.setCharacterEncoding("GBK");也不管用

原因：
1 tomcat的j2ee实现对表单提交即post方式提示时处理参数采用缺省的iso-8859-1来处理
2 tomcat对get方式提交的请求对query-string 处理时采用了和post方法不一样的处理方式。(与tomcat4不一样,所以设置setCharacterEncoding(“gbk”))不起作用。

解决办法：

首先所有的jsp文件都加上:

1 实现一个Filter.设置处理字符集为GBK。(在tomcat的webapps/servlet-examples目录有一个完整的例子。请参考web.xml和SetCharacterEncodingFilter的配置。)

1)只要把%TOMCAT安装目录%/ webapps/servlets-examples/WEB-INF/classes/filters/SetCharacterEncodingFilter.class文件拷到你的webapp目录/filters下，如果没有filters目录，就创建一个。
2)在你的web.xml里加入如下几行： <filter>
<filter-name>Set Character Encoding</filter-name>
<filter-class>filters.SetCharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>GBK</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>Set Character Encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

3)完成.
2 get方式的解决办法
1) 打开tomcat的server.xml文件，找到区块，加入如下一行：
URIEncoding=”GBK”
完整的应如下：
<Connector
port="80" maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
debug="0" connectionTimeout="20000"
disableUploadTimeout="true"
URIEncoding="GBK"
/>

2)重启tomcat,一切OK。
执行如下jsp页页测试是否成功
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.util.*"%>

<%
String q=request.getParameter("q");
q = q == null? "没有值" : q;
%>

<HTML>
<HEAD><TITLE>新闻列表显示</TITLE>
<META http-equiv=Content-Type content="text/html; charset=gb2312">
<META http-equiv=pragma content=no-cache>
<body>
你提交了：
<%=q%>

<br>
<form action="tcnchar.jsp" method="post">
输入中文:<input type="text" name="q"><input type="submit" value="确定">
<br>
<a href="tcnchar.jsp?q=中国">通过get方式提交</a>
</form>
</BODY></HTML>
测试结果如果你输入文本框或者点超链都会显示:你提交了”中国”,说明成功!!!!!

错误实例：

Collection bl = new ArrayList(al);
bl.remove(5);

错误提示如下：
类型Collection中的remove(Object ob) 的方法对于自变量（int）也就（是说remove(int 数字值)）不适用。

正确实例如下:
List/ArrayList bl = new ArrayList(al);对象赋值，指向的不是同一个元素 ArrayList bl = al;不用的引用变量，但是指向的是同一个内存，即（同一个对象实例 ）
bl.remove(5);

// Demonstrate ArrayList.
import java.util.*;

class chufa {
public static void main(String args[])
{
// create an array list
ArrayList al = new ArrayList();

System.out.println("Initial size of al: " + al.size());

// add elements to the array list
al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");
al.add(1, "A2");

List bl = new ArrayList(al);

System.out.println("Size of al after additions: " + al.size());
System.out.println("Content of bl"+bl);

// display the array list
System.out.println("Contents of al: " + al) ;

// Remove elements from the array list

al.remove("F");
al.remove(2);
bl.remove(5);

System.out.println("Size of al after deletions: " + al.size());
System.out.println("Contents of al: " + al);

//al.addAll(1,bl);
System.out.println("Contents of bl: " + bl);
}
}

错误实例：
Pattern regex =
Pattern.compile("<a[//s]*href=/"(http://www.fj.cn/culture/[^><//s]+)[//s]*/"");
只有在[]中那些特殊自如需要转义（两个反斜杆来转义他们），在圆括号的不需要的请看上面指示。

正确实例：
Pattern regex =
Pattern.compile("<a[//s]*href=/"(http://www.fj.cn/culture/[^><//s]+)[//s]*/"");

File path = new File("/java/copyright/");
//路径也可以这样//java//copyrigth// 和这样的效果一样/java/copyringht

第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
是值传递。Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

FileOutputStream(File file, boolean append)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
Boolean append 是否清空然后再重新写内容（false）类似这样
FileOutputStream(File file)
FileOutputStream(File file, false)
如果要继续添加内容的话FileOutputStream(File file, true)

File ->readonly()设置只读
->randomaccessfile可设置成读写,或者只读

Eclipse 6more
配路虚拟主机ename,指向服务器下的目标目录,myeclipse会则webapps生成一个你指定的名称的工程的名字lib和class和web.xml和原是的配置一样的拷贝一份就是

我以前用的是j2sdk1.4.2,tomcat 5.030,现在换成j2sdk1.5,tomcat没有换，总是提示我说Unable to find a javac compiler,找了好长时间，才把这个问题解决，现在把这个问题告诉大家，网上的有好多人说的是错的。
首先，你必需检查一下自己的环境变量是不是正确;这个我想大家都会，只是有时候会忘了定一些，不过检查一下看看就行了。
其次：在JDK的lib目录下有一个tools.jar文件,你把它拷到Tomcat安装目录下的common/lib目录下，应该就可以了，你试试吧
把jdk的中的lib全部拷贝倒jdk里面的jre和外面的jre,好像一般指向的都是外面的的jre
最后：如果不可以，在打开tomcat的configue tomcatg ,找到java,在java optioons里填上:-Djava.home=C:/Program Files/Java/jdk1.5.0_04;就好