function addDev()
{
var sFeatures="dialogWidth:700px;dialogHeight:500px;scroll:no;";
var customerId = document.all['cusId'].value;
var result= window.showModalDialog('<%=appURL %>/businesspermit/DeviceSelectAction.do?formAction=toAddPage&customerId='+customerId,"",sFeatures);
if(result!=null )
{
<logic:present name="edit" scope="request">
document.CustomerSetForm.action="<%=appURL %>/businesspermit/CustomerSetAction.do?formAction=toEditBusi&showType=1";
</logic:present>
<logic:notPresent name="edit" scope="request">
document.CustomerSetForm.action="<%=appURL %>/businesspermit/CustomerSetAction.do?formAction=getBusinessSet";
</logic:notPresent>
// window.location.reload();
CustomerSetForm.submit();
}
}
这个函数表示：添加新的设备JS函数，window.showModalDialog（）会返回一个值result,如果result!=null，则刷新这个页面。
原来是用window.location.reload();刷新页面的，但是这样就不能保留之前页面上输入的数据，为了保留原来输入的数据，换成了
document.CustomerSetForm.action=“”；
CustomerSetForm.submit();
上面的语句表示：让这个页面重新指向另一个action地址，然后提交。这样，用了Struts标签后，以前四输入的数据仍然会保留到返回后的页面了。
注意：在js代码中，可能使用譬如说<logic:present>等标签。
// 新建链表并加入元素
List<Member> members=new ArrayList<Member>();
members.add(new Member("Andy",20));
members.add(new Member("Dell",23));
members.add(new Member("Felex",24));
members.add(new Member("Bill",21));
members.add(new Member("Cindy",22));
// 创建一个比较器匿名类
Comparator comparator=new Comparator(){
public int compare(Object op1,Object op2){
Member memberOp1=(Member)op1;
Member memberOp2=(Member)op2;
// 按姓名排序
return memberOp1.getName().compareTo(memberOp2.getName());
}
};
// 排序
Collections.sort(members,comparator);
// 输出排序后的链表
for(Member member:members){
System.out.println(member.getName() + ":" + member.getAge());
}
}
输出结果:
Andy:20
Bill:21
Cindy:22
Dell:23
Felex:24
当你做网页时，是不是有的时候想让你的网页自动不停刷新，或者过一段时间自动跳转到另外一个你自己设定的页面？其实实现这个效果非常地简单，而且这个效果甚至不能称之为特效。你只要把如下代码加入你的网页中就可以了。
1，页面自动刷新：把如下代码加入<head>区域中<meta http-equiv="refresh" content="20">,其中20指每隔20秒刷新一次页面.
window.opener 返回的是创建当前窗口的那个窗口的引用，比如点击了a.htm上的一个链接而打开了b.htm，然后我们打算在b.htm上输入一个值然后赋予a.htm上的一个id为“name”的textbox中，就可以写为：
window.opener.document.getElementById("name").value = "输入的数据";
以前的好像是用Timer类来实现的,后来的JDK有改善了:
ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(10);
class RunnablTest implements Runnable
{
public void run()
{
System.out.println("ok");
}
}
// 5秒后执行任务，每隔2秒执行一次任务：打印"ok"字符串
executor.scheduleAtFixedRate(new RunnablTest(), 5, 2, TimeUnit.SECONDS);
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<set name="addresses" table="PersonAddress">
<key column="personId"/>
<many-to-many column="addressId"
class="Address"/>
</set>
</class>
<class name="Address">
<id name="id" column="addressId">
<generator class="native"/>
</id>
</class>
create table Person ( personId bigint not null primary key )
create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId, addressId) )
create table Address ( addressId bigint not null primary key )
在java中内存分为“栈”和“堆”这两种（Stack and Heap).基本数据类型存储在“栈”中，对象引用类型实际存储在“堆”中，在栈中只是保留了引用内存的地址值。
顺便说说“==”与“equals（）方法”，以帮助理解两者（Stack and Heap)的概念。
在Java中利用"=="比较变量时候，系统使用变量在stack(栈)中所存的值来作为对比的依据，基本数据类型在stack中所存的值就是其內容值，而引用类型在stack中所存放的值是本身所指向Heap中对象的地址值。 Java.lang包中的Object类有public boolean equals (Object obj)方法。它比较两个对象是否相等。仅当被比较的两个引用指向同一对象时，对象的equals()方法返回true。（至于String类的equals（）方法，是因为它重写（override）equals()方法）
java.util.Map m = new java.util.HashMap();
m.put("aaa", "aaa ");
m.put("bbb", " bbb");
m.put("ccc", "ccc ");
Iterator iterator = m.keySet().iterator();
while (iterator.hasNext())
{
String sessionId = (String) iterator.next();
if ("aaa".equals(sessionId))
{
// 这行代码是关键
iterator.remove();
}
}
在一个类里，初始化的顺序是由变量在类内的定义顺序决定的。即使变量定义大量遍布于方法定义的中间，那些变量仍会在调用任何方法之前得到初始化——甚至在构建器调用之前。例如：
class Tag {
Tag(
int marker) {
System.out.println(
"Tag(" + marker +
")");
}
}
class Card {
Tag t1 =
new Tag(1);
// 先初始化t1
Card() {
// Indicate we're in the constructor:
System.out.println(
"Card()");
t3 =
new Tag(33);
// Re-initialize t3
}
Tag t2 =
new Tag(2);
// 然后初始化t2
void f() {
System.out.println(
"f()");
}
Tag t3 =
new Tag(3);
// 接着初始化t3
}
public class OrderOfInitialization {
public static void main(String[] args) {
Card t =
new Card();
t.f();
// Shows that construction is done
}
}
它的输入结果如下：
"Tag(1)",
"Tag(2)",
"Tag(3)",
"Card()",
"Tag(33)",
"f()"
// 以下是人综合例子：
//总的原则:先静态后动态,先定义初始化,后构造函数初始化
/**
* 实例化Child对象时
* 先父类静态成员初始化,后子类静态成员初始化
* 然后是父类成员,父类构造函数,最后是子类
* 成员,子类构造函数
*/
class Parent {
private static int s = getS("父类静态成员");
private int num = getNum();
public Parent() {
System.out.println("父类构造函数");
}
private static int getS(String string) {
System.out.println(string);
return 47;
}
public int getNum() {
System.out.println("父类私有成员");
return num;
}
public static void setS(int s) {
Parent.s = s;
}
}
class Child extends Parent {
private int num = prt("子类私有成员");
private static int s = getS("子类静态成员");
public static void setS(int s) {
Child.s = s;
}
public Child() {
System.out.println("子类构造函数");
}
public void setNum(int num) {
this.num = num;
}
private int prt(String string) {
System.out.println(string);
return 5;
}
public static int getS(String string) {
System.out.println(string);
return s;
}
}
public class Tee {
/**
* @param args
*/
public static void main(String[] args) {
Child c = new Child();
c.setNum(100);
// 为什么输出的是0
System.out.print(c.getNum());
// Child cStatic = new Child();
// cStatic.setS(100);
// System.out.println(cStatic.getS("s"));
}
}
最后输出结果：
父类静态成员
子类静态成员
父类私有成员
父类构造函数
子类私有成员
子类构造函数
父类私有成员
0
l HashSet：如果集合中对象所属的类重新定义了equals()方法，那么这个类也必须重新定义hashCode()方法，并且保证当两个对象用equals()方法比较的结果为true时，这两个对象的hashCode()方法的返回值相等。
l TreeSet：如果对集合中的对象进行自然排序，要求对象所属的类实现Comparable接口，并且保证这个类的compareTo()和equals()方法采用相同的比较规则来比较两个对象是否相等。
l HashMap：如果集合中键对象所属的类重新定义了equals()方法，那么这个类也必须重新定义hashCode()方法，并且保证当两个键对象用equals()方法比较的结果为true时，这两个键对象的hashCode()方法的返回值相等。
l TreeMap：如果对集合中的键对象进行自然排序，要求键对象所属的类实现Comparable接口，并且保证这个类的compareTo()和equals()方法采用相同的比较规则来比较两个对象是否相等。
由此可见，为了使应用程序更加健壮，在编写JAVA类时不妨养这样的编程习惯：
l 如果JAVA类重新定义了equals()方法，那么这个类也必须重新定义hashCode()方法，并且保证当两个对象用equals()方法比较的结果为true时，这两个对象的hashCode()方法的返回值相等。
l 如果JAVA类实现了Comparable接口，那么应该重新定义compareTo()，equals()和hashCode()方法，保证compareTo()和equals()方法采用相同的比较规则来比较两个对象是否相等，并且保证当两个对象用equals()方法比较的结果为true时，这两个对象的hashCode()方法的返回值相等。