javadfa演算法工具包

Ⅰ < DFA M狀態最少化的程序實現>編譯課程設計啊！！！還要求MFC的界面！！！ 求大神啊！搞定給財富值~

DFA狀態數的最小化
package chapter3;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 演算法 3.39 最小化一個DFA的狀態數
* @author Administrator
*
*/
publicclass Arithmetic_3_39
{
/**
* 輸入一個DFA D
* @param d DFA狀態轉換表
* @param S 狀態集合
* @param E 輸入字元表
* @param s 開始狀態
* @param F 接受狀態集
* @return 一個DFA D', 它和D接受相同的語言, 且輸入狀態數最少
*/
publicint[][] convert(int[][] d, Set<Integer> S, char[] E, int s, Set<Integer> F)
{
// 首先用接受狀態組和非接受狀態組劃分 PI
Set<Set<Integer>> PI = new HashSet<Set<Integer>>();
// 計算 S - F
S.removeAll(F);
PI.add(F);
PI.add(S);
// 最初, 令PInew = PI
Set<Set<Integer>> PInew = new HashSet<Set<Integer>>();
// TODO 解決淺復制帶來的問題
PInew.addAll(PI);
while (true)
{
// 對PI中的每個組G
for (Iterator<Set<Integer>> it = PI.iterator(); it.hasNext(); )
{
List<Object> groupList = new ArrayList<Object>();
Set<Integer> G = it.next();
// 使用字元表測試G的元素
// 對於字元表的每個輸入a
for (int i = 0; i < E.length; i++)
{
Map<Integer, Set<Integer>> groupMap = new HashMap<Integer, Set<Integer>>();
char a = E[i];
for (Iterator<Integer> sIt = G.iterator(); sIt.hasNext(); )
{
int stat = sIt.next();
// 從狀態S出發 沿著a能夠到達的狀態
int tar = d[stat][a];
// 獲取目標狀態在PI中的位置
int idx = getElelementIdx(PI, tar);
Set<Integer> group = groupMap.get(idx);
if (group == null)
{
group = new HashSet<Integer>();
groupMap.put(idx, group);
}
group.add(stat);
}
groupList.add(groupMap);
}
// 在PInew中將G替換為對G進行分組得到的那些小組
PInew.remove(G);
PInew.addAll(setListPoly(groupList));
}
// 判斷2個集合組是否相等
if (!isTwoSetGrpEqual(PI, PInew))
{
PI.clear();
PI.addAll(PInew);
} else
{
break;
}
}
// TODO 步驟4
for (Iterator<Set<Integer>> it = PI.iterator(); it.hasNext(); )
{
Set<Integer> set = it.next();
// 令S1是PI組中某個G的代表
for (Iterator<Integer> sIt = set.iterator(); sIt.hasNext(); )
{
int s1 = sIt.next();
while (sIt.hasNext())
{
// 用S1替換SWP
int swp = sIt.next();
for (int i = 0; i < d.length; i++)
{
for (int j = 0; j < d[i].length; j++)
{
if (d[i][j] == swp)
{
d[i][j] = s1;
}
}
}
// 刪除SWP的轉換函數
d[swp] = newint[]{};
}
}
}
return d;
}
/**
* 獲取某個元素在集合組中的索引
* @param set
* @param element
* @return
*/
privateint getElelementIdx(Set<Set<Integer>> set, int element)
{
int idx = 0;
for (Iterator<Set<Integer>> it = set.iterator(); it.hasNext(); )
{
Set<Integer> g = it.next();
if (g.contains(element))
{
// TODO 檢查HASHCODE 是否代表了集合的位置
return idx;
}
idx++;
}
return -1;
}
// 計算集合組聚合的結果
@SuppressWarnings("unchecked")
private Set<Set<Integer>> setListPoly(List<Object> oriSetList)
{
Set<Set<Integer>> result = new HashSet<Set<Integer>>();
if (oriSetList.size() > 0)
{
// 讀取第一個集合組
Map<Integer, Set<Integer>> groupMap = (Map<Integer, Set<Integer>>)oriSetList.get(0);
for (Iterator<Integer> it = groupMap.keySet().iterator(); it.hasNext(); )
{
result.add(groupMap.get(it.next()));
}
for (int i = 1; i < oriSetList.size(); i++)
{
// 獲取中間集合
Map<Integer, Set<Integer>> midMap = (Map<Integer, Set<Integer>>)oriSetList.get(i);
List<Set<Integer>> midSetList = new ArrayList<Set<Integer>>();
for (Iterator<Integer> it = midMap.keySet().iterator(); it.hasNext(); )
{
midSetList.add(midMap.get(it.next()));
}
// 開始計算
// 運算結果
List<Set<Integer>> calcResult = new ArrayList<Set<Integer>>();
for (Iterator<Set<Integer>> it = result.iterator(); it.hasNext(); )
{
Set<Integer> srcSet = it.next();
for (int k = 0; k < midSetList.size(); k++)
{
// 計算2個集合的交集
Set<Integer> mixed = getSetMixed(srcSet, midSetList.get(k));
// 如果結果不為空
if (!mixed.isEmpty())
{
// 保存運算結果
calcResult.add(mixed);
}
}
}
// 將計算結果替換result
result.clear();
result.addAll(calcResult);
}
}
return result;
}
// 計算二個集合的交集
private Set<Integer> getSetMixed(Set<Integer> set1, Set<Integer> set2)
{
Set<Integer> mixed = new HashSet<Integer>();
for (Iterator<Integer> it = set1.iterator(); it.hasNext(); )
{
int emu = it.next();
if (set2.contains(emu))
{
mixed.add(emu);
}
}
return mixed;
}
/**
* 判斷2個集合組是否相等
* @param setGrp1
* @param setGrp2
* @return
*/
privateboolean isTwoSetGrpEqual(Set<Set<Integer>> setGrp1, Set<Set<Integer>> setGrp2)
{
boolean same = false;
int matchCounts = 0;
if (setGrp1.size() == setGrp2.size())
{
for (Iterator<Set<Integer>> it = setGrp1.iterator(); it.hasNext(); )
{
Set<Integer> set1 = it.next();
for (Iterator<Set<Integer>> it2 = setGrp2.iterator(); it2.hasNext(); )
{
Set<Integer> set2 = it2.next();
if (set2.equals(set1))
{
matchCounts++;
}
}
}
if (matchCounts == setGrp1.size())
{
same = true;
}
}
return same;
}
}
// 測試:
package test;
import java.util.HashSet;
import java.util.Set;
import chapter3.Arithmetic_3_39;
publicclass TestCase
{
publicstaticvoid main(String[] args)
{
new TestCase().test_339();
}
publicvoid test_339()
{
// DFA的轉換表
int[][] d = {{}, {2, 3}, {2, 4}, {2, 3}, {2, 5}, {2, 3}};
// 輸入狀態集合
Set<Integer> S = new HashSet<Integer>();
S.add(1);
S.add(2);
S.add(3);
S.add(4);
S.add(5);
// 輸入字元
char[] E = {0, 1};
int s = 1;
Set<Integer> F = new HashSet<Integer>();
F.add(5);
Arithmetic_3_39 a339 = new Arithmetic_3_39();
a339.convert(d, S, E, s, F);
}
}

對於一個NFA，當把它確定化之後，得到的DFA所具有的狀態數可能並不是最小的。其原因之一，就在於上面所給出的確定化演算法沒有考慮到DFA中具有某種「同一性」的一些狀態可加以合並的問題。所謂一個DFA M狀態數的最小化，是指構造一個等價的DFA M′，而後者有最小的狀態數。為了說明狀態數最小化演算法的思想，我們先引入可區分狀態的概念。設M=(K,Σ,f,S0,Z)為一DFA，並設s和t是M的兩個不同狀態，我們說狀態s,t為某一輸入串w所區分，是指從s,t中之一出發，當掃視完w之後到達M的終態，但從其中的另一個狀態出發，當掃視完同一個w後而進入非終態。如果兩個狀態s和t不可區分 (即對任何輸入串w，當且僅當f(s,w)∈Z,f(t,w)∈Z)，則稱s和t等價。顯然，在一個DFA中，就識別符號串的作用而言，相互等價的狀態處於同等的地位，故可設法將它們合並，以減少DFA的狀態個數。下面給出一個將DFA M狀態數最小化的演算法。此演算法的基本思想，就是將M的狀態集K逐步進行劃分，以期最後按上述狀態的等價關系將K分裂為r個 (r≤|K|)互不相交的子集，使得屬於同一子集中的任何兩個狀態都是等價的，而屬於不同子集的任意兩個狀態都是可區分的。此演算法的執行步驟如下：(1) 首先，將M的狀態集K按終態與非終態劃分為兩個子集Z及K-Z，以構成初始分劃，記為π={Z,K-Z}。(2) 設當前的分劃π中已含有m個子集，即π={I1, I2, …, Im}其中，屬於不同子集的狀態是可區分的，而屬於同一子集中的諸狀態則是待區分的。即需對每一子集Ii={Si1,Si2,…,Sin}中各狀態Sir (Sir∈K,1≤r≤n)進行考察，看是否還能對它們再進行區分。例如，Sip和Siq是Ii中的兩個狀態，若有某個a∈Σ，使f(Sip,a)=Sju及f(Siq,a)=Skv，而狀態Sju及Skv分別屬於π中兩個不同的子集Ij和Ik，故Sju與Skv為某一w所區分，從而Sip和Siq必為w所區分，故應將子集Ii進一步細分，使Sip和Siq分別屬於Ii的不同的子集。也就是說，對於每一子集Ii及每一a∈Σ，我們需考察Iai=f(Ii,a)=∪n[]r=1f(Sir,a)若Iai中的狀態分別落於π中的p個不同的子集，則將Ii分為p個更小的狀態子集I(1)i,I(2)i,…，I(p)i，使得對於每一個I(j)i,f(I(j)i,a)中的全部狀態都落於π的同一子集之中。注意，若對某狀態Sir,f(Sir,a)無意義，則Sir與任何Sit(f(Sit,a)有定義)都是可區分的。這樣，每細分一次，就得一個新的分劃πnew，且分劃中的子集數也由原來的m個變為m+p-1個。(3) 若πnew≠π，則將πnew作為π再重復第2步中的過程，如此等等，直到最後得到一個分劃π，使πnew=π，即π中的各個子集不能再細分為止。(4) 對於所得的最後分劃π，我們從它的每一子集Ij={Sj1,Sj2,…,Sjr}中任選一個狀態，如Sj1，作為Ij中所含各狀態的代表，這些所選出的狀態便組成了M′的狀態集K′。而且，若Ij中含有M的初態，則Sj1為M′的初態；若Ij中含有M的終態，則Sj1為M′的一個終態。此外，為構成DFA M′，還應將各子集中落選的狀態從原DFA M中刪去，並將原來進入這些狀態的所有矢線都改為進入它們的代表狀態。例36設已給DFAM=({S0,S1,…,S4}, {a,b},f,S0,{S4})相應的狀態轉換圖和狀態轉移矩陣如圖314(a)及(b)所示。現用上述演算法將M最小化。(1) 初始分劃由兩個子集組成，即π:{S0,S1,S2,S3}, {S4}(2) 為得到下一分劃，考察子集{S0,S1,S2,S3}。為敘述方便起見，下面我們用記號{}a表示：當M分別處於該子集各狀態之下，對輸入符號a轉移到的下一狀態所組成的集合。因為{S0,S1,S2,S3}a={S1}{S0,S1,S2,S3}但{S0,S1,S2}b={S2,S3}{S3}b={S4}即{S0,S1,S2,S3}b不包含在π的同一子集之中，故應將{S0,S1,S2,S3}分為兩個子集{S0,S1,S2}及{S3}，於是便得到下一分劃πnew:{S0,S1,S2}, {S3}, {S4}又因πnew≠π，現以πnew作為π，即π:{S0,S1,S2}, {S3}, {S4}再考慮{S0,S1,S2}，因為{S0,S1,S2}a={S1}{S0,S1,S2}而{S0,S2}b={S2}{S1}b={S3}故應將{S0,S1,S2}再分為{S0,S2}及{S1}，從而又得到πnew:{S0,S2}, {S1}, {S3}, {S4}由於此時仍有πnew≠π，故再以πnew作為π，即π:{S0,S2}, {S1}, {S3}, {S4}現考察{S0,S2}，由於{S0,S2}a={S1}而{S0,S2}b={S2}{S0,S2}即{S0,S2}a與{S0,S2}b已分別包含在π的同一子集{S1}及{S0,S2}之中，故子集{S0,S2}已不能再分裂。此時πnew=π，子集分裂的過程宣告結束。(3) 現選擇狀態S0作為{S0,S2}的代表，將狀態S2從狀態轉換圖中刪去，並將原來引向S2的矢線都引至S0，這樣，我們就得到了化簡後的DFA M′，如圖315(a)及(b)所示。最後，再考察圖314(a)及圖315(b)所示的FA。容易看出，它們所接受的語言均是以abb為後綴的任意a,b符號串所組成的集合，也就說，這兩個FA是相互等價的。實際上，我們還可以進一步證明如下的定理。定理32對於有同一接受集的FA，與之等價且具有最小狀態數的DFA在同構意義下 (即不顧狀態的命名)是惟一的。

Ⅱ java的API中有哪些常用的包

Application Programming Interface 應用程序編程介面，Java的api就多的數不清了，平時編程用的都是API。

Ⅲ 正則表達式的引擎

正則引擎主要可以分為兩大類：一種是DFA，一種是NFA。這兩種引擎都有了很久的歷史(至今二十多年)，當中也由這兩種引擎產生了很多變體！於是POSIX的出台規避了不必要變體的繼續產生。這樣一來，主流的正則引擎又分為3類：一、DFA，二、傳統型NFA，三、POSIX NFA。
DFA 引擎在線性時狀態下執行，因為它們不要求回溯（並因此它們永遠不測試相同的字元兩次）。DFA 引擎還可以確保匹配最長的可能的字元串。但是，因為 DFA 引擎只包含有限的狀態，所以它不能匹配具有反向引用的模式；並且因為它不構造顯示擴展，所以它不可以捕獲子表達式。
傳統的 NFA 引擎運行所謂的「貪婪的」匹配回溯演算法，以指定順序測試正則表達式的所有可能的擴展並接受第一個匹配項。因為傳統的 NFA 構造正則表達式的特定擴展以獲得成功的匹配，所以它可以捕獲子表達式匹配和匹配的反向引用。但是，因為傳統的 NFA 回溯，所以它可以訪問完全相同的狀態多次（如果通過不同的路徑到達該狀態）。因此，在最壞情況下，它的執行速度可能非常慢。因為傳統的 NFA 接受它找到的第一個匹配，所以它還可能會導致其他（可能更長）匹配未被發現。
POSIX NFA 引擎與傳統的 NFA 引擎類似，不同的一點在於：在它們可以確保已找到了可能的最長的匹配之前，它們將繼續回溯。因此，POSIX NFA 引擎的速度慢於傳統的 NFA 引擎；並且在使用 POSIX NFA 時，您恐怕不會願意在更改回溯搜索的順序的情況下來支持較短的匹配搜索，而非較長的匹配搜索。
使用DFA引擎的程序主要有：awk,egrep,flex,lex,MySQL,Procmail等；
使用傳統型NFA引擎的程序主要有：GNU Emacs,Java,ergp,less,more,.NET語言,PCRE library,Perl,PHP,Python,Ruby,sed,vi；
使用POSIX NFA引擎的程序主要有：mawk,Mortice Kern Systems』 utilities,GNU Emacs(使用時可以明確指定)；
也有使用DFA/NFA混合的引擎：GNU awk,GNU grep/egrep,Tcl。
舉例簡單說明NFA與DFA工作的區別：
比如有字元串this is yansen』s blog，正則表達式為 /ya(msen|nsen|nsem)/ (不要在乎表達式怎麼樣，這里只是為了說明引擎間的工作區別)。 NFA工作方式如下，先在字元串中查找 y 然後匹配其後是否為 a ，如果是 a 則繼續，查找其後是否為 m 如果不是則匹配其後是否為 n (此時淘汰msen選擇支)。然後繼續看其後是否依次為 s,e，接著測試是否為 n ，是 n 則匹配成功，不是則測試是否為 m 。為什麼是 m ？因為 NFA 工作方式是以正則表達式為標准，反復測試字元串，這樣同樣一個字元串有可能被反復測試了很多次！
而DFA則不是如此，DFA會從 this 中 t 開始依次查找 y，定位到 y ，已知其後為 a ，則查看錶達式是否有 a ，此處正好有 a 。然後字元串 a 後為 n ，DFA依次測試表達式，此時 msen 不符合要求淘汰。nsen 和 nsem 符合要求，然後DFA依次檢查字元串，檢測到sen 中的 n 時只有nsen 分支符合，則匹配成功！
由此可以看出來，兩種引擎的工作方式完全不同，一個(NFA)以表達式為主導，一個(DFA)以文本為主導！一般而論，DFA引擎則搜索更快一些！但是NFA以表達式為主導，反而更容易操縱，因此一般程序員更偏愛NFA引擎！ 兩種引擎各有所長，而真正的引用則取決與你的需要以及所使用的語言！

Ⅳ 學java 那api中的哪幾個包要學會啊

java.applet 提供創建 applet 所必需的類和 applet 用來與其 applet 上下文通信的類。
java.awt 包含用於創建用戶界面和繪制圖形圖像的所有類。
java.awt.color 提供用於顏色空間的類。
java.awt.datatransfer 提供在應用程序之間和在應用程序內部傳輸數據的介面和類。
java.awt.dnd Drag 和 Drop 是一種直接操作動作，在許多圖形用戶界面系統中都會遇到它，它提供了一種機制，能夠在兩個與 GUI 中顯示元素邏輯相關的實體之間傳輸信息。
java.awt.event 提供處理由 AWT 組件所激發的各類事件的介面和類。
java.awt.font 提供與字體相關的類和介面。
java.awt.geom 提供用於在與二維幾何形狀相關的對象上定義和執行操作的 Java 2D 類。
java.awt.im 提供輸入方法框架所需的類和介面。
java.awt.im.spi 提供啟用可以與 Java 運行時環境一起使用的輸入方法開發的介面。
java.awt.image 提供創建和修改圖像的各種類。
java.awt.image.renderable 提供用於生成與呈現無關的圖像的類和介面。
java.awt.print 為通用的列印 API 提供類和介面。
java.beans 包含與開發 beans 有關的類，即基於 JavaBeansTM 架構的組件。
java.beans.beancontext 提供與 bean 上下文有關的類和介面。
java.io 通過數據流、序列化和文件系統提供系統輸入和輸出。
java.lang 提供利用 Java 編程語言進行程序設計的基礎類。
java.lang.annotation 為 Java 編程語言注釋設施提供庫支持。
java.lang.instrument 提供允許 Java 編程語言代理檢測運行在 JVM 上的程序的服務。
java.lang.management 提供管理介面，用於監視和管理 Java 虛擬機以及 Java 虛擬機在其上運行的操作系統。
java.lang.ref 提供了引用對象類，支持在某種程度上與垃圾回收器之間的交互。
java.lang.reflect 提供類和介面，以獲得關於類和對象的反射信息。
java.math 提供用於執行任意精度整數演算法 (BigInteger) 和任意精度小數演算法 (BigDecimal) 的類。
java.net 為實現網路應用程序提供類。
java.nio 定義作為數據容器的緩沖區，並提供其他 NIO 包的概述。
java.nio.channels 定義了各種通道，這些通道表示到能夠執行 I/O 操作的實體（如文件和套接字）的連接；定義了用於多路復用的、非阻塞 I/O 操作的選擇器。
java.nio.channels.spi 用於 java.nio.channels 包的服務提供者類。
java.nio.charset 定義用來在位元組和 Unicode 字元之間轉換的 charset、解碼器和編碼器。
java.nio.charset.spi java.nio.charset 包的服務提供者類。
java.rmi 提供 RMI 包。
java.rmi.activation 為 RMI 對象激活提供支持。
java.rmi.dgc 為 RMI 分布式垃圾回收提供了類和介面。
java.rmi.registry 提供 RMI 注冊表的一個類和兩個介面。
java.rmi.server 提供支持伺服器端 RMI 的類和介面。
java.security 為安全框架提供類和介面。
java.security.acl 此包中的類和介面已經被 java.security 包中的類取代。
java.security.cert 提供用於解析和管理證書、證書撤消列表 (CRL) 和證書路徑的類和介面。
java.security.interfaces 提供的介面用於生成 RSA Laboratory Technical Note PKCS#1 中定義的 RSA（Rivest、Shamir 和 Adleman AsymmetricCipher 演算法）密鑰，以及 NIST 的 FIPS-186 中定義的 DSA（數字簽名演算法）密鑰。
java.security.spec 提供密鑰規范和演算法參數規范的類和介面。
java.sql 提供使用 JavaTM 編程語言訪問並處理存儲在數據源（通常是一個關系資料庫）中的數據的 API。
java.text 提供以與自然語言無關的方式來處理文本、日期、數字和消息的類和介面。
java.text.spi java.text 包中類的服務提供者類。
java.util 包含 collection 框架、遺留的 collection 類、事件模型、日期和時間設施、國際化和各種實用工具類（字元串標記生成器、隨機數生成器和位數組）。
java.util.concurrent 在並發編程中很常用的實用工具類。
java.util.concurrent.atomic 類的小工具包，支持在單個變數上解除鎖的線程安全編程。
java.util.concurrent.locks 為鎖和等待條件提供一個框架的介面和類，它不同於內置同步和監視器。
java.util.jar 提供讀寫 JAR (Java ARchive) 文件格式的類，該格式基於具有可選清單文件的標准 ZIP 文件格式。
java.util.logging 提供 JavaTM 2 平台核心日誌工具的類和介面。
java.util.prefs 此包允許應用程序存儲並獲取用戶和系統首選項和配置數據。
java.util.regex 用於匹配字元序列與正則表達式指定模式的類。
java.util.spi java.util 包中類的服務提供者類。
java.util.zip 提供用於讀寫標准 ZIP 和 GZIP 文件格式的類。
javax.accessibility 定義了用戶界面組件與提供對這些組件進行訪問的輔助技術之間的協定。
javax.crypto 為加密操作提供類和介面。
javax.crypto.interfaces 根據 RSA Laboratories' PKCS #3 的定義，提供 Diffie-Hellman 密鑰介面。
javax.crypto.spec 為密鑰規范和演算法參數規范提供類和介面。
javax.imageio Java Image I/O API 的主要包。
javax.imageio.event Java Image I/O API 的一個包，用於在讀取和寫入圖像期間處理事件的同步通知。
javax.imageio.metadata 用於處理讀寫元數據的 Java Image I/O API 的包。
javax.imageio.plugins.bmp 包含供內置 BMP 插件使用的公共類的包。
javax.imageio.plugins.jpeg 支持內置 JPEG 插件的類。
javax.imageio.spi 包含用於 reader、writer、transcoder 和流的插件介面以及一個運行時注冊表的 Java Image I/O API 包。
javax.imageio.stream Java Image I/O API 的一個包，用來處理從文件和流中產生的低級別 I/O。
javax.management 提供 Java Management Extensions 的核心類。
javax.management.loading 提供實現高級動態載入的類。
javax.management.modelmbean 提供了 ModelMBean 類的定義。
javax.management.monitor 提供 monitor 類的定義。
javax.management.openmbean 提供開放數據類型和 Open MBean 描述符類。
javax.management.relation 提供 Relation Service 的定義。
javax.management.remote 對 JMX MBean 伺服器進行遠程訪問使用的介面。
javax.management.remote.rmi RMI 連接器是供 JMX Remote API 使用的一種連接器，後者使用 RMI 將客戶端請求傳輸到遠程 MBean 伺服器。
javax.management.timer 提供對 Timer MBean（計時器 MBean）的定義。
javax.naming 為訪問命名服務提供類和介面。
javax.naming.directory 擴展 javax.naming 包以提供訪問目錄服務的功能。
javax.naming.event 在訪問命名和目錄服務時提供對事件通知的支持。
javax.naming.ldap 提供對 LDAPv3 擴展操作和控制項的支持。
javax.naming.spi 提供一些方法來動態地插入對通過 javax.naming 和相關包訪問命名和目錄服務的支持。
javax.net 提供用於網路應用程序的類。
javax.net.ssl 提供用於安全套接字包的類。
javax.print 為 JavaTM Print Service API 提供了主要類和介面。
javax.print.attribute 提供了描述 JavaTM Print Service 屬性的類型以及如何分類這些屬性的類和介面。
javax.print.attribute.standard 包 javax.print.attribute.standard 包括特定列印屬性的類。
javax.print.event 包 javax.print.event 包含事件類和偵聽器介面。
javax.rmi 包含 RMI-IIOP 的用戶 API。
javax.rmi.CORBA 包含用於 RMI-IIOP 的可移植性 API。
javax.rmi.ssl 通過安全套接字層 (SSL) 或傳輸層安全 (TLS) 協議提供 RMIClientSocketFactory 和 RMIServerSocketFactory 的實現。
javax.security.auth 此包提供用於進行驗證和授權的框架。
javax.security.auth.callback 此包提供與應用程序進行交互所必需的類，以便檢索信息（例如，包括用戶名和密碼的驗證數據）或顯示信息（例如，錯誤和警告消息）。
javax.security.auth.kerberos 此包包含與 Kerberos 網路驗證協議相關的實用工具類。
javax.security.auth.login 此包提供可插入的驗證框架。
javax.security.auth.spi 此包提供用於實現可插入驗證模塊的介面。
javax.security.auth.x500 此包包含應該用來在 Subject 中存儲 X500 Principal 和 X500 Private Crendentials 的類。
javax.security.cert 為公鑰證書提供類。
javax.security.sasl 包含用於支持 SASL 的類和介面。
javax.sound.midi 提供用於 MIDI（音樂樂器數字介面）數據的 I/O、序列化和合成的介面和類。
javax.sound.midi.spi 在提供新的 MIDI 設備、MIDI 文件 reader 和 writer、或音庫 reader 時提供服務提供者要實現的介面。
javax.sound.sampled 提供用於捕獲、處理和回放取樣的音頻數據的介面和類。
javax.sound.sampled.spi 在提供新音頻設備、聲音文件 reader 和 writer，或音頻格式轉換器時，提供將為其創建子類的服務提供者的抽象類。
javax.sql 為通過 JavaTM 編程語言進行伺服器端數據源訪問和處理提供 API。
javax.sql.rowset JDBC RowSet 實現的標准介面和基類。
javax.sql.rowset.serial 提供實用工具類，允許 SQL 類型與 Java 編程語言數據類型之間的可序列化映射關系。
javax.sql.rowset.spi 第三方供應商在其同步提供者的實現中必須使用的標准類和介面。
javax.swing 提供一組「輕量級」（全部是 Java 語言）組件，盡量讓這些組件在所有平台上的工作方式都相同。
javax.swing.border 提供圍繞 Swing 組件繪制特殊邊框的類和介面。
javax.swing.colorchooser 包含供 JColorChooser 組件使用的類和介面。
javax.swing.event 供 Swing 組件觸發的事件使用。
javax.swing.filechooser 包含 JFileChooser 組件使用的類和介面。
javax.swing.plaf 提供一個介面和許多抽象類，Swing 用它們來提供自己的可插入外觀功能。
javax.swing.plaf.basic 提供了根據基本外觀構建的用戶界面對象。
javax.swing.plaf.metal 提供根據 Java 外觀（曾經代稱為 Metal）構建的用戶界面對象，Java 外觀是默認外觀。
javax.swing.plaf.multi 提供了組合兩個或多個外觀的用戶界面對象。
javax.swing.plaf.synth Synth 是一個可更換皮膚 (skinnable) 的外觀，在其中可委託所有繪制。
javax.swing.table 提供用於處理 javax.swing.JTable 的類和介面。
javax.swing.text 提供類 HTMLEditorKit 和創建 HTML 文本編輯器的支持類。
javax.swing.text.html 提供類 HTMLEditorKit 和創建 HTML 文本編輯器的支持類。
javax.swing.text.html.parser 提供默認的 HTML 解析器以及支持類。
javax.swing.text.rtf 提供一個類 (RTFEditorKit)，用於創建富文本格式（Rich-Text-Format）的文本編輯器。
javax.swing.tree 提供處理 javax.swing.JTree 的類和介面。
javax.swing.undo 允許開發人員為應用程序（例如文本編輯器）中的撤消/恢復提供支持。
javax.transaction 包含解組期間通過 ORB 機制拋出的三個異常。
javax.transaction.xa 提供定義事務管理器和資源管理器之間的協定的 API，它允許事務管理器添加或刪除 JTA 事務中的資源對象（由資源管理器驅動程序提供）。
javax.xml 根據 XML 規范定義核心 XML 常量和功能。
javax.xml.bind 為包含解組、編組和驗證功能的客戶端應用程序提供運行時綁定框架。
javax.xml.bind.annotation 定義將 Java 程序元素定製成 XML 模式映射的注釋。
javax.xml.bind.annotation.adapters XmlAdapter 及其規范定義的子類允許任意 Java 類與 JAXB 一起使用。
javax.xml.bind.attachment 此包由基於 MIME 的包處理器實現，該處理器能夠解釋並創建基於 MIME 的包格式的已優化的二進制數據。
javax.xml.bind.helpers 僅由 JAXB 提供者用於： 提供某些 javax.xml.bind 介面的部分默認實現。
javax.xml.bind.util 有用的客戶端實用工具類。
javax.xml.crypto 用於 XML 加密的通用類。
javax.xml.crypto.dom javax.xml.crypto 包的特定於 DOM 的類。
javax.xml.crypto.dsig 用於生成和驗證 XML 數字簽名的類。
javax.xml.crypto.dsig.dom javax.xml.crypto.dsig 包特定於 DOM 的類。
javax.xml.crypto.dsig.keyinfo 用來解析和處理 KeyInfo 元素和結構的類。
javax.xml.crypto.dsig.spec XML 數字簽名的參數類。
javax.xml.datatype XML/Java 類型映射關系。
javax.xml.namespace XML 名稱空間處理。
javax.xml.parsers 提供允許處理 XML 文檔的類。
javax.xml.soap 提供用於創建和構建 SOAP 消息的 API。
javax.xml.stream
javax.xml.stream.events
javax.xml.stream.util
javax.xml.transform 此包定義了用於處理轉換指令，以及執行從源到結果的轉換的一般 API。
javax.xml.transform.dom 此包實現特定於 DOM 的轉換 API。
javax.xml.transform.sax 此包實現特定於 SAX2 的轉換 API。
javax.xml.transform.stax 提供特定於 StAX 的轉換 API。
javax.xml.transform.stream 此包實現特定於流和 URI 的轉換 API。
javax.xml.validation 此包提供了用於 XML 文檔驗證的 API。
javax.xml.ws 此包包含核心 JAX-WS API。
javax.xml.ws.handler 該包定義用於消息處理程序的 API。
javax.xml.ws.handler.soap 該包定義用於 SOAP 消息處理程序的 API。
javax.xml.ws.http 該包定義特定於 HTTP 綁定的 API。
javax.xml.ws.soap 該包定義特定於 SOAP 綁定的 API。
javax.xml.ws.spi 該包定義用於 JAX-WS 2.0 的 SPI。
javax.xml.xpath 此包提供了用於 XPath 表達式的計算和訪問計算環境的 object-model neutral API。
org.ietf.jgss 此包提供一個框架，該框架允許應用程序開發人員通過利用統一的 API 使用一些來自各種基礎安全機制（如 Kerberos）的安全服務，如驗證、數據完整性和和數據機密性。
org.omg.CORBA 提供 OMG CORBA API 到 JavaTM 編程語言的映射，包括 ORB 類，如果已實現該類，則程序員可以使用此類作為全功能對象請求代理（Object Request Broker，ORB）。
org.omg.CORBA_2_3 CORBA_2_3 包定義對 Java[tm] Standard Edition 6 中現有 CORBA 介面所進行的添加。
org.omg.CORBA_2_3.portable 提供輸入和輸出值類型的各種方法，並包含 org/omg/CORBA/portable 包的其他更新。
org.omg.CORBA.DynAnyPackage 提供與 DynAny 介面一起使用的異常（InvalidValue、Invalid、InvalidSeq 和 TypeMismatch）。
org.omg.CORBA.ORBPackage 提供由 ORB.resolve_initial_references 方法拋出的異常 InvalidName，以及由 ORB 類中的動態 Any 創建方法拋出的異常 InconsistentTypeCode。
org.omg.CORBA.portable 提供可移植性層，即可以使一個供應商生成的代碼運行在另一個供應商 ORB 上的 ORB API 集合。
org.omg.CORBA.TypeCodePackage 提供用戶定義的異常 BadKind 和 Bounds，它們將由 TypeCode 類中的方法拋出。
org.omg.CosNaming 為 Java IDL 提供命名服務。
org.omg.CosNaming.NamingContextExtPackage 此包包含以下在 org.omg.CosNaming.NamingContextExt 中使用的類： AddressHelper StringNameHelper URLStringHelper InvalidAddress 包規范 有關 Java[tm] Platform, Standard Edition 6 ORB 遵守的官方規范的受支持部分的明確列表，請參閱 Official Specifications for CORBA support in Java[tm] SE 6。
org.omg.CosNaming.NamingContextPackage 此包包含 org.omg.CosNaming 包的 Exception 類。
org.omg.Dynamic 此包包含 OMG Portable Interceptor 規范 http://cgi.omg.org/cgi-bin/doc?ptc/2000-08-06 的第 21.9 小節中指定的 Dynamic 模塊。
org.omg.DynamicAny 提供一些類和介面使得在運行時能夠遍歷與 any 有關聯的數據值，並提取數據值的基本成分。
org.omg.DynamicAny.DynAnyFactoryPackage 此包包含 DynamicAny 模塊的 DynAnyFactory 介面中的類和異常，該模塊在 OMG The Common Object Request Broker: Architecture and Specification http://cgi.omg.org/cgi-bin/doc?formal/99-10-07 的第 9.2.2 小節中指定。
org.omg.DynamicAny.DynAnyPackage 此包包含 DynAny 模塊的 DynAnyFactory 介面中的類和異常，該模塊在 OMG The Common Object Request Broker: Architecture and Specification http://cgi.omg.org/cgi-bin/doc?formal/99-10-07 的第 9.2 小節中指定。
org.omg.IOP 此包包含在 OMG 文檔 The Common Object Request Broker: Architecture and Specification http://cgi.omg.org/cgi-bin/doc?formal/99-10-07 的 13.6.小節中指定的 IOP 模塊。
org.omg.IOP.CodecFactoryPackage 此包包含 IOP::CodeFactory 介面中指定的異常（作為 Portable Interceptor 規范的一部分）。
org.omg.IOP.CodecPackage 此包根據 IOP::Codec IDL 介面定義生成。
org.omg.Messaging 此包包含 OMG Messaging Interceptor 規范 http://cgi.omg.org/cgi-bin/doc?formal/99-10-07 中指定的 Messaging 模塊。
org.omg.PortableInterceptor 提供一個注冊 ORB 鉤子 (hook) 的機制，通過這些鉤子 ORB 服務可以截取執行 ORB 的正常流。
org.omg.PortableInterceptor.ORBInitInfoPackage 此包包含 OMG Portable Interceptor 規范 http://cgi.omg.org/cgi-bin/doc?ptc/2000-08-06 的第 21.7.2 小節中指定的 PortableInterceptor 模塊的 ORBInitInfo 本地介面中的異常和 typedef。
org.omg.PortableServer 提供一些類和介面，用來生成跨多個供應商 ORB 的可移植應用程序的伺服器端。
org.omg.PortableServer.CurrentPackage 提供各種方法實現，這些實現能夠訪問調用方法的對象的身份。
org.omg.PortableServer.POAManagerPackage 封裝 POA 關聯的處理狀態。
org.omg.PortableServer.POAPackage 允許程序員構造可在不同 ORB 產品間移植的對象實現。
org.omg.PortableServer.portable 提供一些類和介面，用來生成跨多個供應商 ORB 的可移植應用程序的伺服器端。
org.omg.PortableServer.ServantLocatorPackage 提供定位 servant 的類和介面。
org.omg.SendingContext 為值類型的編組提供支持。
org.omg.stub.java.rmi 包含用於 java.rmi 包中出現的 Remote 類型的 RMI-IIOP Stub。
org.w3c.dom 為文檔對象模型 (DOM) 提供介面，該模型是 Java API for XML Processing 的組件 API。
org.w3c.dom.bootstrap
org.w3c.dom.events
org.w3c.dom.ls
org.xml.sax 此包提供了核心 SAX API。
org.xml.sax.ext 此包包含適合的 SAX 驅動程序不一定支持的 SAX2 設施的介面。
org.xml.sax.helpers 此包包含「幫助器」類，其中包括對引導基於 SAX 的應用程序的支持。

想要書用上面的包都要弄明白才行

Ⅳ 給出描述Java表達式的DFA~~~~~~~~~~在線等

這是DFA演算法，自己設定好值，看下結果

import java.util.*;
import java.io.*;

class DFA
{
boolean recognizeString(int move[][], int accept_state[], String word)
{

int s=0;
for (int i = 0; i <word.length(); i++)
{
char c = word.charAt(i);
s = move[s][c - 'a'];
}
for (int j = 0; j < accept_state.length; j++)
if (s == accept_state[j]) return true;
return false;
}
public static void main(String args[]) throws IOException
{
int n, m;
BufferedReader in = new BufferedReader(new FileReader("DFA.in"));
StringTokenizer st = new StringTokenizer(in.readLine());
n = Integer.parseInt(st.nextToken());
m = Integer.parseInt(st.nextToken());
while (n != 0)
{
int[][] move = new int[n][m];
for(int i=0; i<n; i++)
{
st = new StringTokenizer(in.readLine());
for (int j=0; j<m; j++)
move[i][j] = Integer.parseInt(st.nextToken());
}
String[] temp = in.readLine().split("\s");
int[] accept = new int[temp.length];
for (int i=0; i<accept.length; i++) accept[i] = Integer.parseInt(temp[i]);
String word = in.readLine();
while (word.compareTo("#") != 0)
{
DFA dfa = new DFA();
if (dfa.recognizeString(move, accept, word)) System.out.println("YES"); else System.out.println("NO");
word = in.readLine();
}
st = new StringTokenizer(in.readLine());
n = Integer.parseInt(st.nextToken());
m = Integer.parseInt(st.nextToken());
}
}
}