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()方法的返回值相等。