java something

本程序可以控制3個線程按順序執行， 代碼如下：

public class Test3 {

 public static void main(String[] args) throws IOException {
  final Test obj = new Test();
  
  new Thread()
  {
   public void run()
   {
    obj.m1();
   }
  }.start();
  new Thread()
  {
   public void run()
   {
    obj.m2();
   }
  }.start();
  new Thread()
  {
   public void run()
   {
    obj.m3();
   }
  }.start();
  
 }

}

class Test
{
 static int count;
 volatile int target = 1;
 synchronized void m1()
 { 
   for (int i = 0; i < 10; i++)
   {
    while (target == 2 || target == 3)
    {
     try {
      wait();
     } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
    }
    System.out.println("m1() =" + i);
    target = 2;
    notifyAll();
   }
 }
 
 synchronized void m2()
 {
  for (int i = 0; i < 10; i++)
  {
   while (target == 1 || target == 3)
   {
    try {
     wait();
    } catch (InterruptedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }
   }
   System.out.println("m2() =" + i);
   target = 3;
   notifyAll();
  }
 }
 
 synchronized void m3()
 {
  for (int i = 0; i < 10; i++)
  {
   while (target == 1 || target == 2)
   {
    try {
     wait();
    } catch (InterruptedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }
   }
   System.out.println("m3() =" + i);
   target = 1;
   notifyAll();
  }
 }
}

  1,線程的生命周期

        線程從創建、運行到結束總是處于下面五個狀態之一：新建狀態、就緒狀態、運行狀態、阻塞狀態及死亡狀態。

    1.新建狀態(New)： 
        當用new操作符創建一個線程時， 例如new Thread(r)，線程還沒有開始運行，此時線程處在新建狀態。 當一個線程處于新生狀態時，程序還沒有開始運行線程中的代碼

     2.就緒狀態(Runnable)

        一個新創建的線程并不自動開始運行，要執行線程，必須調用線程的start()方法。當線程對象調用start()方法即啟動了線程，start()方法創建線程運行的系統資源，并調度線程運行run()方法。當start()方法返回后，線程就處于就緒狀態。

        處于就緒狀態的線程并不一定立即運行run()方法，線程還必須同其他線程競爭CPU時間，只有獲得CPU時間才可以運行線程。因為在單CPU的計算機系統中，不可能同時運行多個線程，一個時刻僅有一個線程處于運行狀態。因此此時可能有多個線程處于就緒狀態。對多個處于就緒狀態的線程是由Java運行時系統的線程調度程序(thread scheduler)來調度的。

    3.運行狀態(Running)

        當線程獲得CPU時間后，它才進入運行狀態，真正開始執行run()方法.

    4. 阻塞狀態(Blocked)

        線程運行過程中，可能由于各種原因進入阻塞狀態:
        1>線程通過調用sleep方法進入睡眠狀態；
        2>線程調用一個在I/O上被阻塞的操作，即該操作在輸入輸出操作完成之前不會返回到它的調用者；
        3>線程試圖得到一個鎖，而該鎖正被其他線程持有；
        4>線程在等待某個觸發條件；
        ......           

        所謂阻塞狀態是正在運行的線程沒有運行結束，暫時讓出CPU，這時其他處于就緒狀態的線程就可以獲得CPU時間，進入運行狀態。

    5. 死亡狀態(Dead)

        有兩個原因會導致線程死亡：
        1) run方法正常退出而自然死亡，
        2) 一個未捕獲的異常終止了run方法而使線程猝死。
        為了確定線程在當前是否存活著（就是要么是可運行的，要么是被阻塞了），需要使用isAlive方法。如果是可運行或被阻塞，這個方法返回true； 如果線程仍舊是new狀態且不是可運行的， 或者線程死亡了，則返回false.

2,  線程的優先級和調度

Java的每個線程都有一個優先級，當有多個線程處于就緒狀態時，線程調度程序根據線程的優先級調度線程運行。

可以用下面方法設置和返回線程的優先級。

    · public final void setPriority(int newPriority) 設置線程的優先級。

    · public final int getPriority() 返回線程的優先級。

newPriority為線程的優先級，其取值為1到10之間的整數，也可以使用Thread類定義的常量來設置線程的優先級，這些常量分別為：Thread.MIN_PRIORITY、Thread.NORM_PRIORITY、Thread.MAX_PRIORITY，它們分別對應于線程優先級的1、5和10，數值越大優先級越高。當創建Java線程時，如果沒有指定它的優先級，則它從創建該線程那里繼承優先級。

一般來說，只有在當前線程停止或由于某種原因被阻塞，較低優先級的線程才有機會運行。

前面說過多個線程可并發運行，然而實際上并不總是這樣。由于很多計算機都是單CPU的，所以一個時刻只能有一個線程運行，多個線程的并發運行只是幻覺。在單CPU機器上多個線程的執行是按照某種順序執行的，這稱為線程的調度(scheduling)。

大多數計算機僅有一個CPU，所以線程必須與其他線程共享CPU。多個線程在單個CPU是按照某種順序執行的。實際的調度策略隨系統的不同而不同，通常線程調度可以采用兩種策略調度處于就緒狀態的線程。

(1) 搶占式調度策略

     Java運行時系統的線程調度算法是搶占式的 (preemptive)。Java運行時系統支持一種簡單的固定優先級的調度算法。如果一個優先級比其他任何處于可運行狀態的線程都高的線程進入就緒狀態，那么運行時系統就會選擇該線程運行。新的優先級較高的線程搶占(preempt)了其他線程。但是Java運行時系統并不搶占同優先級的線程。換句話說，Java運行時系統不是分時的(time-slice)。然而，基于Java Thread類的實現系統可能是支持分時的，因此編寫代碼時不要依賴分時。當系統中的處于就緒狀態的線程都具有相同優先級時，線程調度程序采用一種簡單的、非搶占式的輪轉的調度順序。

(2) 時間片輪轉調度策略

    有些系統的線程調度采用時間片輪轉(round-robin)調度策略。這種調度策略是從所有處于就緒狀態的線程中選擇優先級最高的線程分配一定的CPU時間運行。該時間過后再選擇其他線程運行。只有當線程運行結束、放棄(yield)CPU或由于某種原因進入阻塞狀態，低優先級的線程才有機會執行。如果有兩個優先級相同的線程都在等待CPU，則調度程序以輪轉的方式選擇運行的線程。

 3.  線程狀態的改變

一個線程在其生命周期中可以從一種狀態改變到另一種狀態，線程狀態的變遷如圖所示：

    
    
1>  控制線程的啟動和結束

當一個新建的線程調用它的start()方法后即進入就緒狀態，處于就緒狀態的線程被線程調度程序選中就可以獲得CPU時間，進入運行狀態，該線程就開始運行run()方法。

控制線程的結束稍微復雜一點。如果線程的run()方法是一個確定次數的循環，則循環結束后，線程運行就結束了，線程對象即進入死亡狀態。如果run()方法是一個不確定循環，早期的方法是調用線程對象的stop()方法，然而由于該方法可能導致線程死鎖，因此從1.1版開始，不推薦使用該方法結束線程。一般是通過設置一個標志變量，在程序中改變標志變量的值實現結束線程。請看下面的例子：

程序 ThreadStop.java

import java.util.*;

class Timer implements Runnable{

    boolean flag=true;
    public void run(){
      while(flag){
        System.out.print("\r\t"+new Date()+"");
        try{
              Thread.sleep(1000);
        }catch(InterruptedException e){} 
      }
      System.out.println("\n"+Thread.currentThread().getName()+" Stop");
    }

    public void stopRun(){
           flag = false;
    }
}

public class ThreadStop{
    public static void main(String args[]){
       Timer timer = new Timer();
       Thread thread = new Thread(timer);       
       thread.setName("Timer");
       thread.start();

       for(int i=0;i<100;i++){
         System.out.print("\r"+i);
        try{
              Thread.sleep(100);
        }catch(InterruptedException e){} 
       }     
       timer.stopRun();
    }
}

該程序在Timer類中定義了一個布爾變量flag，同時定義了一個stopRun()方法，在其中將該變量設置為false。在主程序中通過調用該方法，從而改變該變量的值，使得run()方法的while循環條件不滿足，從而實現結束線程的運行。

說明  在Thread類中除了stop()方法被標注為不推薦(deprecated) 使用外，suspend()方法和resume()方法也被標明不推薦使用，這兩個方法原來用作線程的掛起和恢復.

2>  線程阻塞條件

處于運行狀態的線程除了可以進入死亡狀態外，還可能進入就緒狀態和阻塞狀態。下面分別討論這兩種情況：

(1) 運行狀態到就緒狀態

處于運行狀態的線程如果調用了yield()方法，那么它將放棄CPU時間，使當前正在運行的線程進入就緒狀態。這時有幾種可能的情況：如果沒有其他的線程處于就緒狀態等待運行，該線程會立即繼續運行；如果有等待的線程，此時線程回到就緒狀態狀態與其他線程競爭CPU時間，當有比該線程優先級高的線程時，高優先級的線程進入運行狀態，當沒有比該線程優先級高的線程時，但有同優先級的線程，則由線程調度程序來決定哪個線程進入運行狀態，因此線程調用yield()方法只能將CPU時間讓給具有同優先級的或高優先級的線程而不能讓給低優先級的線程。

一般來說，在調用線程的yield()方法可以使耗時的線程暫停執行一段時間，使其他線程有執行的機會。

(2) 運行狀態到阻塞狀態

有多種原因可使當前運行的線程進入阻塞狀態，進入阻塞狀態的線程當相應的事件結束或條件滿足時進入就緒狀態。使線程進入阻塞狀態可能有多種原因：

① 線程調用了sleep()方法，線程進入睡眠狀態，此時該線程停止執行一段時間。當時間到時該線程回到就緒狀態，與其他線程競爭CPU時間。

Thread類中定義了一個interrupt()方法。一個處于睡眠中的線程若調用了interrupt()方法，該線程立即結束睡眠進入就緒狀態。

② 如果一個線程的運行需要進行I/O操作，比如從鍵盤接收數據，這時程序可能需要等待用戶的輸入，這時如果該線程一直占用CPU，其他線程就得不到運行。這種情況稱為I/O阻塞。這時該線程就會離開運行狀態而進入阻塞狀態。Java語言的所有I/O方法都具有這種行為。

③ 有時要求當前線程的執行在另一個線程執行結束后再繼續執行，這時可以調用join()方法實現，join()方法有下面三種格式：

·         public void join() throws InterruptedException 使當前線程暫停執行，等待調用該方法的線程結束后再執行當前線程。

·         public void join(long millis) throws InterruptedException 最多等待millis毫秒后，當前線程繼續執行。

·         public void join(long millis, int nanos) throws InterruptedException 可以指定多少毫秒、多少納秒后繼續執行當前線程。

上述方法使當前線程暫停執行，進入阻塞狀態，當調用線程結束或指定的時間過后，當前線程線程進入就緒狀態，例如執行下面代碼：

t.join();

將使當前線程進入阻塞狀態，當線程t執行結束后，當前線程才能繼續執行。

④ 線程調用了wait()方法，等待某個條件變量，此時該線程進入阻塞狀態。直到被通知(調用了notify()或notifyAll()方法)結束等待后，線程回到就緒狀態。

⑤ 另外如果線程不能獲得對象鎖，也進入就緒狀態。

后兩種情況在下一節討論。

錯誤可能是由XML有中文格式的字符引起的。

樹遍歷這個概念先提一下：遍歷即逐個訪問，對于樹而言主要有三種：前序，后序，中序遍歷樹的每個節點。遍歷一般是用遞歸算法來實現的，三種遍歷法區別于先訪問樹的那個部分。樹遍歷也是比較難的一個技術，不好掌握，我在大學時用匯編實現過這三種算法，到現在還記憶猶新（完全自己找到的規律），一下來和朋友們分享一下。
對于一個有兩個子節點的樹（或多個子節點），請你沿著樹的外圍畫一個輪廓線：

———>         >——————
        /             \
      /                 \
     /_____>____\     

       這是大致繞樹行走的輪廓線，大家都知道（或許你還不知道）函數的調用時控制流的傳遞就是這個樣子的。（控制流是線程執行方法時的形象表述）比如一下函數： main(){

     f1();
     f2();
}//該函數的控制流向是：先傳給main，再由main（）傳給f1,之后退回到mian（），在傳給f2()在由f2退回給main之后結束程序。異步方法調用時才會從這個封閉的輪廓中分出一個分支來。現在來談你如何設計一個樹遍歷方法：
我們來看一個函數的幾個關鍵部位，
       func（）{
        entry入口處
          
            中間部位           

        return出口處   
      }也許你很迷惑這與樹遍歷算法有和關系，告訴你吧這三個特殊部位就是你在設計遞歸時，遞歸函數應該出現的位置，他們出現在不同的位置就是不同的“序”,偽碼如：
先序遍歷
traversTree(Node root){
   if(root !=null){
     if(root.isLeaf()){//當是葉子時，
         visit（root）;//前序遍歷是先遍歷頁節點
     }   
         Node[] children=root.getChildren();//獲取所有子樹
         for(Node n:children){
           traversTree(n);//遞歸遍歷所有子樹，注意子樹可能為空。
          }
   }

}

中序遍歷（亦稱廣度優先遍歷，總是先遍歷樹的根）

traversTree(Node root){
   if(root !=null){
     //樹非空
     visit(root); //這是中序遍歷 visit出現與遞歸函數之前。
    
     Node[] children=root.getChildren();//獲取所有子樹
         for(Node n:children){
           traversTree(n);//遞歸遍歷所有子樹，注意子樹可能為空。
          }
   }

}

后序遍歷（亦稱深度優先搜索）：
traversTree(Node root){
   if(root !=null){
        
     Node[] children=root.getChildren();//獲取所有子樹
         for(Node n:children){
           traversTree(n);//遞歸遍歷所有子樹，注意子樹可能為空。
          }
    
     
     visit(root); //這是后序遍歷 visit出現在遞歸函數之后。
   }

}

以上三個算法，可能有點不正確，我沒測試過，時間太久了有點忘了，總之為大家做個參考吧！
因為樹結構典型的是應用了組合設計模式，所以只要涉及到樹肯定涉及遍歷，和遞歸。所以這里羅嗦一下。   所有的樹都是節點                   
**
***
swing中Jtree處理樹結構是通過樹模型接口，它實現了TreeNode接口（在api文檔中竟看不到此信息！），DefaultMutableTreeNode類實現了TreeNode接口，并提供了前,中,后序的樹遍歷能力。
JTree圖形化的顯示了樹結構的每一個節點，所有的UI控件都有兩個目的，顯示和輸入（輸入包括數據的輸入如JTextField和命令輸入如菜單，按鈕等），JTree既可以用于樹結構的顯示，也可以用于命令的輸入，或使得我們編輯樹節點。
樹節點可以被選中，它由TreeSelectionModel來控制，選擇涉及到維護作為TreeNode實例的樹節點間的路徑軌跡。樹控件典型的可以激發兩類事件：TreeModelEvent和TreeExpansionEvent，當然其他Awt和Swing事件也可由樹控件激發（看其繼承層次結構即可知）比如MouseListener可用來截取鼠標事件。JTree擴展了Scrollable接口，可被放在一個滾動面板中。

JTree的構造：可使用默認的構造方法，提供一個TreeNode作為其根節點，提供一個TreeModel包含所有其它的節點，或提供一個一維數組，向量，或對象的哈希表，對于這些集合中的單個元素，如果它又是一個集合，那么他們會被解釋顯示為子樹，該功能由JTree的內部類DynamicUtilTreeNode完成。
***
****
TreeModel接口：
該接口的實現者為JTree提供顯示的數據，如果你熟悉MVC模式，你應該明白所有的swing或awt控件中模型的作用就是為相應的控件提供數據。當模型的數據結構有所變化時它會通知視圖（這里就是JTree）來更新顯示。當然模型也可以添加其他的監聽器如Jtree的addTreeModelListener，你可以實現該監聽器，來使你自己的類接收模型變化給你的通知。如果你不熟悉MVC模式，請參考POSA卷一或其他資料，順便提一下在我們學校GUI時都知道有MVC模式的應用，往往不知道那個Controller是什么類，其實就是視圖的監聽器，比如ActionListener，注意別被眾多的監聽器弄昏了，一類是模型需要添加的，一類是視圖（比如JComponent的子類）需要添加的。控制的流向或數據的流向是相反的，視圖需要添加的監聽器（我們常常實現他們）才是控制器。

因為模型和視圖都能夠觸發事件，比如視圖（JTree等控件）是觸發用戶輸入導致的事件，而模型觸發的事件是因為模型中維護的數據有所變動才觸發的（比如，樹模型中樹節點的增刪，改，或樹路徑的變動）。而他們都使用了觀察者模式，算了不多說了，到時全弄成模式了，會搞昏大家的。繼續....

JTree的setModel和getModel方法是用來更換/設置和獲取模型的方法。你可替換現有JTree的模型，或者你想這樣用，兩個模型，一個用，一個備。如果構造模型復雜耗時的話，先在后臺構造好一個在換掉原先的。就如同雙緩沖技術的思路那樣。
****
*****
雜項：
DefultTreeModel是對TreeModel接口的默認實現類，
TreeNode接口可告訴你改實現者是否為一個葉子，一個父節點等。MutalbeTreeNode接口擴展了TreeNode接口，我們可在該實現者中存放一個我們自己的類實例（setUserObject（）/getUserObject）;
defaultMutableTreeNode 實現了MutableTreeNode接口，children()方法返回以一維向量形式存放的直接子節點的枚舉，也可以使用getChildAt()返回特定索引位置的子節點（注意子節點完全可以是一顆子樹）該類提供了前中后序訪問樹的能力：preorderEnumeration()，,breadthFirstEnumeration()，depthFirstEnumeration(）postorderEnumeration()最后兩個方法同行為，只不過是不同的稱號而已。

TreePath：該類用一系列節點表示一個從樹根到一個節點的路徑，它是只讀的，提供與其他路徑比較的能力。
TreeCellRenderrer接口：渲染tree的一個單元的組件，我們自己實現該接口并用jtree的setCellRenderer（）方法替換原先的渲染器，可以是樹節點在選中，獲取焦點，不同的樹狀態（葉子或父節點，展開，或收縮）等不同的狀態下的外觀。
DefaultTreeCellRenderer類是TreeCellRenderrer接口的默認實現，它擴展了JLabel，并基于以上描述的樹狀態來渲染樹節點，其提供的屬性包括圖標，背景色，前景色等，其get和set方法是我們可以訪問的，通過這些方法你當然可以換掉樹節點的圖標了。

CellEditor接口：定義了控制何時編輯將開始，結束，提取一個新的結果，是否編輯請求改變當前組件的選擇，請參考API文檔看該接口的方法。該接口在JTree和JTable中都有用到。，該接口也可以添加監聽器，當編輯停止或取消時會激發ChangeEvents到其所有的注冊處理器哪里。
TreeCellEditor接口擴展了CellEditor接口，jtree的setCellEditor()使得我們可以用任何一個可充當編輯器的組件替換掉原來的那個。DefaultCellEditor實現了該接口，這個編輯器允許使用JTextField，JComboBox或是JCheckBox組件來編輯數據，其保護的內部類EditorDelegate會響應getCellEditorValue（）方法把當前值返回。DefaultCellEditor僅基于以上三個J控件作為編輯器，其clickCountToStart方法決定鼠標單擊幾次會觸發編輯。默認對于JTextField是兩次，JComboBox和JCheckBox是一次，changeEvents會在stopCellEditing（）和cancelCellEditing（）時激發。
DefaultTreeCellEditor擴展了DefaultCellEditor類并且是TreeCellEditor的默認實現類，他使用JTextField來編輯節點數據，在鍵入ENTER鍵后stopCellEditing（）會被調用。對于樹節點的編輯我們可添加自己的時間監聽器來處理他們。默認時編輯開始于節點被單擊三次或兩次（時間間隔在內部會用一個定時器來決定），也可以改變他們的數目setClickCountToStart()；
JTree的選擇是基于行和樹路徑的，我們可以選擇使用那個。

TreeSelectionModel接口用于樹選擇模型，支持三種選擇，SINGLE_TREE_SELECTION，
DISCONTIGUOUS_TREE_SELECTION，CONTIGUOUS_TREE_SELECTION，set/getSelectionMode()可以訪選擇模型。getSelectionPath『s』()會返回一個當前選中的樹路徑。DefaultTreeSelectionModel默認實現了該接口，該類提供TreeSelectionlistener通知，當樹路徑選擇發生變化時。

TreeModelListener實現者可以偵聽模型變化，TreeSelectionListener用來偵聽視圖JTree的selection（僅有一個方法valueChanged(TreeSlectcionEvent tsEvt)）;
TreeExpansionListener用來對樹展開收縮進行處理。
TreeW illExpandListener在樹“將要”展開和收縮時得到通知，你可截獲處理，ExpandVetoException異常如果拋出，那么樹不會展開和收縮。

TreeModelEvent，用來通知模型的監聽器，JTree的數據部分或全部發生了變化。該事件對象封裝了源組件的引用，封裝了一個TreePath或一個用來表示路徑的數組。
TreeselectionEvent，視圖會用其通知所有視圖監聽器TreeSelectionListeners，選擇發生了變化。
TreeExpansionEvent，用來封裝相應最近或可能展開或收縮的TreePath，使用getPath()方法訪問樹路徑。
ExpandVetoException異常可由TreeWillExpandListener拋出，來否決樹路徑的展開和收縮。

JTree提供的現成方便的UI屬性：
myJTree.putClientProperty("JTree.lineStyle", "Angled");//更改線型。
如同其他Swing組件，我們也可以改變默認的用于JTree的ＵＩ資源（全局性的）：
UIManager.put("Tree.hash",
new ColorUIResource(Color.lightGray));／／改變渲染節點間edges邊的顏色。
UIManager.put("Tree.openIcon", new IconUIResource(
new ImageIcon("myOpenIcon.gif")));//改變一個打開的樹節點的圖標。同理可用于其它情況：Tree.leafIcon, Tree.expandedIcon，和Tree.closedIcon， Tree.collapsedIcon。

其他控制TreeＵＩ顯示的方法：
myTree.setRowHeight()／／控制樹節點的行高，
JTree的UI委托也提供了更改樹外觀的方法（相比于ＵＩＭａｎａｇｅｒ的方法，這里是局部的）。
BasicTreeUI basicTreeUI = (BasicTreeUI) myJTree.getUI();
basicTreeUI.setRightChildIndent(10);
basicTreeUI.setLeftChildIndent(8);

以上簡要提及了ＪＴｒｅｅ的方方面面,許多的事件，將聽器模型，請仔細分析，一定要分清哪些是針對模型的那些是針對視圖的。

*****
******
簡單的示例，我這里僅用到了最簡單的樹構造方法，和一個監聽器，在
以后我的自學過程中，我會繼續試用其他的JTree知識，我的JTree學習
最終都是想實現那個ＧＵＩ上的授權控制系統，請參考其他篇章，
至于這里用到的LAndFSysMenu類，在我的其他篇章中有該類的實現。
package jTreeDemo;

import java.awt.Container;
import javax.swing.*;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import lookAndFeelSys.*;
import userInterfaces.UIUtil;
import java.awt.*;
import java.util.Hashtable;
import java.util.Vector;
import javax.swing.tree.*;

public class JTreeTest extends JFrame{

public static void main(String[] args){
new JTreeTest("測試");
}

public JTreeTest(String title){
   super(title);
   biuldFrame();
}

   private void biuldFrame(){
    JMenuBar jmb=new JMenuBar();
   
    JMenu jm=new LAndFSysMenu();
    //JMenu jm=new JMenu("hello");
   
    jmb.add(jm);
    this.setJMenuBar(jmb);
   
    buildFrmContent();   
   
    UIUtil.SetComponentDimension(this,0.5,0.6);
    UIUtil.SetComponentToCenterOfScreen(this);
    this.setVisible(true);
    this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
   }
  
   private void buildFrmContent(){
    Container root_c=this.getContentPane();
    JTabbedPane jtp=new JTabbedPane();
    Container c = new JPanel();
    jtp.addTab("靜態樹組件練習",c );
    jtp.addTab("事件監聽",this.treeDemo2());
     

   root_c.add(jtp);

c.setLayout(new GridLayout(2,4));
JScrollPane jsp_1=new JScrollPane();
JScrollPane jsp_2=new JScrollPane();
JScrollPane jsp_3=new JScrollPane();
JScrollPane jsp_4=new JScrollPane();


/*為JTree準備顯示的模型*/
Object[] m1=new String[]{"節點1","節點2","節點3"};
Object[] m2=new String[][]{
    {"1.1","1.2","1.3"},
    {"2.1","2.2","2.3"},
    {"3.1","3.2","3.3"}
};
Vector<Object> m3=new Vector<Object>();
m3.add("1");
m3.add("2");
m3.add(m1);
m3.add(m2);
Hashtable<String,Object> m4=new Hashtable<String,Object>();
m4.put("子一","葉子");
m4.put("子二", m1);
m4.put("子三",m3);


JTree jtr_1=new JTree(m1);
jsp_1.getViewport().add(jtr_1);
JTree jtr_2=new JTree(m2);
jsp_2.getViewport().add(jtr_2);
JTree jtr_3=new JTree(m3);
jsp_3.getViewport().add(jtr_3);
JTree jtr_4=new JTree(m4);
jsp_4.getViewport().add(jtr_4);


c.add(jsp_1);
c.add(jsp_2);
c.add(jsp_3);
c.add(jsp_4);

/*jsp_1.getViewport().add(jtr_1);
c.add(jsp_1);*/
   }

   /*<<     另一組JTree實例：*/
   private JPanel treeDemo2(){
    JPanel rsltPanel=new JPanel();
    rsltPanel.setLayout(new BorderLayout());
   
    JLabel jl_msg=new JLabel("此標簽用來顯示樹選擇情況");
    JScrollPane jsp_1=new JScrollPane();
    Object[] m=new String[]{"節點1","節點2","節點3"};
    JTree jtr=new JTree(m);
    jtr.getSelectionModel()
    .addTreeSelectionListener(new MySelectionLstnr(
      jl_msg));
   
    jsp_1.getViewport().add(jtr);
   
    rsltPanel.add(jsp_1,BorderLayout.CENTER);
    rsltPanel.add(jl_msg,BorderLayout.SOUTH);
    return rsltPanel;
   }
   class MySelectionLstnr implements TreeSelectionListener{
    //該內部類實現樹監聽器，在樹被選中后將選中的節點
    //信息打印到一個Label上
    private JLabel jl_msg=null;
   
    public MySelectionLstnr(JLabel msgLabel){
    this.jl_msg=msgLabel;
    }
@Override
public void valueChanged(TreeSelectionEvent e) {
   // 凡是樹選擇的處理都涉及到樹路徑的處理：
   TreePath path = e.getPath();
   Object[] nodes = path.getPath();
  
   //當前選中的節點是樹路徑上最后一個節點
     Object selectedNode=nodes[nodes.length-1 ];
     if(this.jl_msg!=null){
     this.jl_msg.setText("選中的節點上的文本是："+
         selectedNode.toString());
     }
}


   }
   /*另一組JTree實例：>>*/
}

******
參考Java Swing （Manning出版社）swing hack （orelly出版社）。