原来还有这样的记词方法_Java版记不规则动词_博主推荐

昨天在看一本英语书的不规则动词的时候，突然产生的灵感：就是想把这样记单词简单方式，用程序代码实现，然后，使用户可以与之进行交互

这样，在用户背不规则动词的时候就会轻松把它给记住。基于这一点，于是我就思考了一下，画了画图，理了一下思路。然后就开始着手开干。

现在基本成型了，也可以和大家见面了。

先看看一些截图，这样比较直接一点

项目结构：



效果图：

用户可以输入命令：

"all" : 输出所有的不规则动词信息

"pronunciation" : 单词的发音，该命令时一个发音开关，如果连续输入，效果则是：开，关，开，关...

"exit" : 退出系统

其他：如果用户输入的在库中没有，系统则会给出一些联想的词汇供用户选择，如："drea", 则供选择的是 "dream"

如果用户输入的在库中，如："dream", 系统会输出"dream"的详细信息，这样用户就可以轻松和系统交互，并且在这一

过程中把单词给记住。









看完效果图，我想大家都基本上了解这个小程序的功能和作用吧！

=================================================

Source Code

Description：

User input some commands in the console,then the system will receive the command

and process it, and display the result to user.

e.g:

ONE : When user input the command "all", then the system will display all irregular verbs.

TWO : When user input the command "pronunciation", then the system will change the status of the pronunciation.

THREE : When user input the a irregular verb, then the system will diplay the detial of the word.

=================================================

/IrregularVerbs/src/com/b510/irregularverbs/client/Client.java

/**
*
*/
package com.b510.irregularverbs.client;

import java.util.Scanner;

import com.b510.irregularverbs.utils.CommonUtil;
import com.b510.irregularverbs.utils.IrregularVerbUtil;
import com.b510.irregularverbs.utils.PrintUtil;

/**
* User input some commands in the console,then the system will receive<br>
* the command and process it, and display the result to user.<br>
* for example:
* <li>all : show the all of the Irregular Verbs</li>
* <li>pronunciation : the switch of the pronunciation.and the system default status<br>
*     is not pronunciation.</li>
* <li>The Irregular Verbs : user input the irregular verb,for example: "swim", "cost", "became".etc.</li>
* @author Hongten
* @created Feb 27, 2014
*/
public class Client {

private Scanner inputStreamScanner;
private boolean controlFlag = false;

public static void main(String[] args) {
Client client = new Client();
client.listenConsoleAndHandleContent();
}

public Client() {
inputStreamScanner = new Scanner(System.in);
}

/**
* Listen to the console and handle the content,what user inputed.
*/
public void listenConsoleAndHandleContent() {
PrintUtil.printInfo(CommonUtil.DESCRIPTION);
try {
while (!controlFlag && inputStreamScanner.hasNext()) {
processingConsoleInput();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
closeScanner();
}
}

/**
* The system receive the content, and process it.
*/
private void processingConsoleInput() {
String inputContent = inputStreamScanner.nextLine();
if (!inputContent.isEmpty()) {
if (pronounce(inputContent)) {
IrregularVerbUtil.reLoadVerbs();
} else {
if (showAll(inputContent)) {
return;
}
controlFlag = exit(inputContent);
if (!controlFlag) {
notExit(inputContent);
}
}
}
}

/**
* When user input the command "all"(ignore case),the system will handle the command "all",<br>
* and display the all of the irregular verbs.
* @param inputContent the command "all"(ignore case)
* @return true, if user input the command "all"(ignore case);return false,if user input other command.
*/
private boolean showAll(String inputContent) {
if (CommonUtil.ALL.equalsIgnoreCase(inputContent)) {
IrregularVerbUtil.showAll();
return true;
} else {
return false;
}
}

/**
* When user input the command "pronunciation"(ignore case), the system will handle the command "pronunciation",<br>
* and reload all of the irregular verbs. and display the message "After loading vocabulary!".
* @param inputContent the command "pronunciation"(ignore case)
* @return true, if user input the command "pronunciation"(ignore case);return false, if user input other command.
*/
private boolean pronounce(String inputContent) {
if (CommonUtil.PRONUNCIATION.equalsIgnoreCase(inputContent)) {
IrregularVerbUtil.proFlag = !IrregularVerbUtil.proFlag;
return true;
} else {
return false;
}
}

private void notExit(String inputContent) {
IrregularVerbUtil verbsLib = IrregularVerbUtil.getInstance();
verbsLib.match(inputContent);
}

private boolean exit(String inputContent) {
if (CommonUtil.EXIT.equalsIgnoreCase(inputContent)) {
controlFlag = true;
systemExit();
}
return controlFlag;
}

private void systemExit() {
System.out.println(CommonUtil.EXIT_SYSTEM);
System.exit(0);
}

private void closeScanner() {
inputStreamScanner.close();
}
}

/IrregularVerbs/src/com/b510/irregularverbs/lib/VocabularyLib.java

/**
*
*/
package com.b510.irregularverbs.lib;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import com.b510.irregularverbs.utils.CommonUtil;
import com.b510.irregularverbs.utils.IrregularVerbUtil;
import com.b510.irregularverbs.vo.IrregularVerbsVO;

/**
* Library for the irregular verbs.
* @author Hongten
* @created Feb 28, 2014
*/
public class VocabularyLib {

/**
* Load all of the irregular verbs.<br>
* There have FOUR types of the irregular verbs : "AAA", "ABA", "ABB", "ABC".<br>
* so,there are FOUR methods to load all irregular verbs.
* @return all of the irregular verbs.
*/
public static List<IrregularVerbsVO> getVocabularyLib() {
formatAAA();
formatABA();
formatABB();
formatABC();
return IrregularVerbUtil.verbs;
}

/**
* The "AAA" format for irregular verbs.
*
* @return
*/
private static List<IrregularVerbsVO> formatAAA() {
Map<String, String> aaaTypemap = libAAA();
Iterator<String> it = aaaTypemap.keySet().iterator();
while (it.hasNext()) {
handleAAA(aaaTypemap, it);
}
return IrregularVerbUtil.verbs;
}

/**
* @param aaaTypemap
* @param it
*/
private static void handleAAA(Map<String, String> aaaTypemap, Iterator<String> it) {
String key = it.next();
if (IrregularVerbUtil.proFlag) {
IrregularVerbUtil.verbs.add(new IrregularVerbsVO(key, key, key, aaaTypemap.get(key)));
} else {
IrregularVerbUtil.verbs.add(new IrregularVerbsVO(key, key, key, aaaTypemap.get(key)));
}
}

/**
* The "ABA" format for irregular verbs
*
* @return
*/
private static List<IrregularVerbsVO> formatABA() {
Map<String, String> abaTypemap = libABA();
Iterator<String> it = abaTypemap.keySet().iterator();
while (it.hasNext()) {
handleABA(abaTypemap, it);
}
return IrregularVerbUtil.verbs;
}

/**
* @param abaTypemap
* @param it
*/
private static void handleABA(Map<String, String> abaTypemap, Iterator<String> it) {
String key = it.next();
String[] keys = key.split(CommonUtil.COMMA);
if (IrregularVerbUtil.proFlag) {
IrregularVerbUtil.verbs.add(new IrregularVerbsVO(keys[0] + CommonUtil.COMMA + keys[1], keys[2] + CommonUtil.COMMA + keys[3], keys[0] + CommonUtil.COMMA + keys[1], abaTypemap
.get(key)));
} else {
IrregularVerbUtil.verbs.add(new IrregularVerbsVO(keys[0], keys[1], keys[0], abaTypemap.get(key)));
}
}

/**
* The "ABB" format for irregular verbs
*
* @return
*/
private static List<IrregularVerbsVO> formatABB() {
Map<String, String> abbTypemap = libABB();
Iterator<String> it = abbTypemap.keySet().iterator();
while (it.hasNext()) {
handleABB(abbTypemap, it);
}
return IrregularVerbUtil.verbs;
}

/**
* @param abbTypemap
* @param it
*/
private static void handleABB(Map<String, String> abbTypemap, Iterator<String> it) {
String key = it.next();
String[] keys = key.split(CommonUtil.COMMA);
if (IrregularVerbUtil.proFlag) {
IrregularVerbUtil.verbs.add(new IrregularVerbsVO(keys[0] + CommonUtil.COMMA + keys[1], keys[2] + CommonUtil.COMMA + keys[3], keys[2] + CommonUtil.COMMA + keys[3],
abbTypemap.get(key)));
} else {
IrregularVerbUtil.verbs.add(new IrregularVerbsVO(keys[0], keys[1], keys[1], abbTypemap.get(key)));
}
}

/**
* The "ABC" format for irregular verbs
*
* @return
*/
private static List<IrregularVerbsVO> formatABC() {
Map<String, String> abaTypemap = libABC();
Iterator<String> it = abaTypemap.keySet().iterator();
while (it.hasNext()) {
handleABC(abaTypemap, it);
}
return IrregularVerbUtil.verbs;
}

/**
* @param abaTypemap
* @param it
*/
private static void handleABC(Map<String, String> abaTypemap, Iterator<String> it) {
String key = it.next();
String[] keys = key.split(CommonUtil.COMMA);
if (IrregularVerbUtil.proFlag) {
IrregularVerbUtil.verbs.add(new IrregularVerbsVO(keys[0] + CommonUtil.COMMA + keys[1], keys[2] + CommonUtil.COMMA + keys[3], keys[4] + CommonUtil.COMMA + keys[5], abaTypemap
.get(key)));
} else {
IrregularVerbUtil.verbs.add(new IrregularVerbsVO(keys[0], keys[1], keys[2], abaTypemap.get(key)));
}
}

//============================================
// Library for all of the irregular verbs
//============================================
/**
* Library for "AAA" type.
* @return
*/
private static Map<String, String> libAAA() {
Map<String, String> aaaTypemap = new HashMap<String, String>();
aaaTypemap.put(IrregularVerbUtil.proFlag ? "cost,[kɔst]" : "cost", "花费");
aaaTypemap.put(IrregularVerbUtil.proFlag ? "cut,[kʌt]" : "cut", "割，切");
aaaTypemap.put(IrregularVerbUtil.proFlag ? "hurt,[hə:t]" : "hurt", "受伤");
aaaTypemap.put(IrregularVerbUtil.proFlag ? "hit,[hit]" : "hit", "打，撞");
aaaTypemap.put(IrregularVerbUtil.proFlag ? "let,[let]" : "let", "让");
aaaTypemap.put(IrregularVerbUtil.proFlag ? "put,[put]" : "put", "放下");
aaaTypemap.put(IrregularVerbUtil.proFlag ? "read,[ri:d]" : "read", "读");
aaaTypemap.put(IrregularVerbUtil.proFlag ? "set,[set]" : "set", "安排，安置");
aaaTypemap.put(IrregularVerbUtil.proFlag ? "spread,[spred]" : "spread", "展开，传播，涂");
aaaTypemap.put(IrregularVerbUtil.proFlag ? "spit,[spit]" : "spit", "吐痰");
aaaTypemap.put(IrregularVerbUtil.proFlag ? "shut,[ʃʌt]" : "shut", "关上, 闭起,停止营业");
return aaaTypemap;
}

/**
* Library for "ABA" type.
* @return
*/
private static Map<String, String> libABA() {
Map<String, String> abaTypemap = new HashMap<String, String>();
abaTypemap.put(IrregularVerbUtil.proFlag ? "become,[bi'kʌm],became,[bi'keim]" : "become,became", "变");
abaTypemap.put(IrregularVerbUtil.proFlag ? "come,[kʌm],came,[keim]" : "come,came", "来");
abaTypemap.put(IrregularVerbUtil.proFlag ? "run,[rʌn],ran,[ræn]" : "run,ran", "跑");
return abaTypemap;
}

/**
* Library for "ABB" type.
* @return
*/
private static Map<String, String> libABB() {
Map<String, String> abbTypemap = new HashMap<String, String>();
abbTypemap.put(IrregularVerbUtil.proFlag ? "burn,[bə:n],burnt,[bə:nt]" : "burn,burnt", "燃烧");
abbTypemap.put(IrregularVerbUtil.proFlag ? "deal,[di:l],dealt,[delt]" : "deal,dealt", "解决");
abbTypemap.put(IrregularVerbUtil.proFlag ? "dream,[dri:m],dreamed,[dremt]" : "dream,dreamed", "做梦");
abbTypemap.put(IrregularVerbUtil.proFlag ? "dream,[dri:m],dreamt,[dremt]" : "dream,dreamt", "做梦");
abbTypemap.put(IrregularVerbUtil.proFlag ? "hear,[hiə],heard,[hə:d]" : "hear,heard", "听见");
abbTypemap.put(IrregularVerbUtil.proFlag ? "hang,['hæŋ],hanged,[]" : "hang,hanged", "绞死，悬挂");
abbTypemap.put(IrregularVerbUtil.proFlag ? "hang,['hæŋ],hung,[hʌŋ]" : "hang,hung", "绞死，悬挂");
abbTypemap.put(IrregularVerbUtil.proFlag ? "learn,[lə:n],learned,[]" : "learn,learned", "学习");
abbTypemap.put(IrregularVerbUtil.proFlag ? "learn,[lə:n],learnt,[lə:nt]" : "learn,learnt", "学习");
abbTypemap.put(IrregularVerbUtil.proFlag ? "light,['lait],lit,[lit]" : "light,lit", "点燃, 照亮");
abbTypemap.put(IrregularVerbUtil.proFlag ? "light,['lait],lighted,[]" : "light,lighted", "点燃, 照亮");
abbTypemap.put(IrregularVerbUtil.proFlag ? "mean,[mi:n],meant,[ment]" : "mean,meant", "意思");
abbTypemap.put(IrregularVerbUtil.proFlag ? "prove,[pru:v],proved,[]" : "prove,proved", "证明, 证实,试验");
abbTypemap.put(IrregularVerbUtil.proFlag ? "shine,[ʃain],shone,[ʃəun]" : "shine,shone", "使照耀，使发光");
abbTypemap.put(IrregularVerbUtil.proFlag ? "shine,[ʃain],shined,[]" : "shine,shined", "使照耀，使发光");
abbTypemap.put(IrregularVerbUtil.proFlag ? "show,[ʃəu],showed,[]" : "show,showed", "展示, 给...看");
abbTypemap.put(IrregularVerbUtil.proFlag ? "smell,[smel],smelled,[]" : "smell,smelled", "闻, 嗅");
abbTypemap.put(IrregularVerbUtil.proFlag ? "smell,[smel],smelt,[smelt]" : "smell,smelt", "闻, 嗅");
abbTypemap.put(IrregularVerbUtil.proFlag ? "speed,[spi:d],sped,[sped]" : "speed,sped", "加速");
abbTypemap.put(IrregularVerbUtil.proFlag ? "speed,[spi:d],speeded,[]" : "speed,speeded", "加速");
abbTypemap.put(IrregularVerbUtil.proFlag ? "spell,[spel],spelled,[]" : "spell,spelled", "拼写");
abbTypemap.put(IrregularVerbUtil.proFlag ? "spell,[spel],spelt,[spelt]" : "spell,spelt", "拼写");
abbTypemap.put(IrregularVerbUtil.proFlag ? "wake,[weik],waked,[]" : "wake,waked", "醒来，叫醒, 激发");
abbTypemap.put(IrregularVerbUtil.proFlag ? "wake,[weik],woke,[wəuk]" : "wake,woken", "醒来，叫醒, 激发");
abbTypemap.put(IrregularVerbUtil.proFlag ? "build,[bild],built,[bilt]" : "build,built", "建筑");
abbTypemap.put(IrregularVerbUtil.proFlag ? "lend,[lend],lent,[lent]" : "lend,lent", "借给");
abbTypemap.put(IrregularVerbUtil.proFlag ? "rebuild,[ri:'bild],rebuilt,[ri:'bilt]" : "rebuild,rebuilt", "改建, 重建");
abbTypemap.put(IrregularVerbUtil.proFlag ? "send,[send],sent,[sent]" : "send,sent", "送");
abbTypemap.put(IrregularVerbUtil.proFlag ? "spend,[spend],spent,[spent]" : "spend,spent", "花费");
abbTypemap.put(IrregularVerbUtil.proFlag ? "bring,[briŋ],brought,[brɔ:t]" : "bring,brought", "带来");
abbTypemap.put(IrregularVerbUtil.proFlag ? "buy,[bai],bought,[bɔ:t]" : "buy,bought", "买");
abbTypemap.put(IrregularVerbUtil.proFlag ? "fight,[fait],fought,[fɔ:t]" : "fight,fought", "打架");
abbTypemap.put(IrregularVerbUtil.proFlag ? "think,[θiŋk],thought,[θɔ:t]    " : "think,though", "思考,想");
abbTypemap.put(IrregularVerbUtil.proFlag ? "catch,[kætʃ],caught,[kɔ:t]" : "catch,caught", "捉,抓");
abbTypemap.put(IrregularVerbUtil.proFlag ? "teach,[ti:tʃ],taught,[tɔ:t]" : "teach,taught", "教");
abbTypemap.put(IrregularVerbUtil.proFlag ? "dig,[diɡ],dug,[dʌɡ]" : "dig,dug", "掘(土), 挖(洞、沟等)");
abbTypemap.put(IrregularVerbUtil.proFlag ? "feed,[fi:d],fed,[fed]" : "feed,fed", "喂");
abbTypemap.put(IrregularVerbUtil.proFlag ? "find,[faind],found,[]" : "find,found", "发现，找到");
abbTypemap.put(IrregularVerbUtil.proFlag ? "get,[ɡet],got,[ɡɔt]" : "get,got", "得到");
abbTypemap.put(IrregularVerbUtil.proFlag ? "hold,[həuld],held,[held]" : "hold,held", "拥有，握住，支持");
abbTypemap.put(IrregularVerbUtil.proFlag ? "lead,[li:d],led,[led]" : "lead,led", "引导, 带领, 领导");
abbTypemap.put(IrregularVerbUtil.proFlag ? "meet,[mi:t],met,[met]" : "meet,met", "遇见");
abbTypemap.put(IrregularVerbUtil.proFlag ? "sit,[sit],sat,[sæt]" : "sit,sat", "坐");
abbTypemap.put(IrregularVerbUtil.proFlag ? "shoot,[ʃu:t],shot,[ʃɔt]" : "shoot,shot", "射击");
abbTypemap.put(IrregularVerbUtil.proFlag ? "spit,[spit],spit,[]" : "spit,spit", "吐痰");
abbTypemap.put(IrregularVerbUtil.proFlag ? "spit,[spit],spat,[spæt]" : "spit,spat", "吐痰");
abbTypemap.put(IrregularVerbUtil.proFlag ? "stick,[stik],stuck,[stʌk]" : "stick,stuck", "插进, 刺入, 粘住");
abbTypemap.put(IrregularVerbUtil.proFlag ? "win,[win],won,[wʌn]" : "win,won", "赢");
abbTypemap.put(IrregularVerbUtil.proFlag ? "feel,['fi:l],felt,[felt]" : "feel,felt", "感到");
abbTypemap.put(IrregularVerbUtil.proFlag ? "keep,[ki:p],kept,[kept]" : "keep,kept", "保持");
abbTypemap.put(IrregularVerbUtil.proFlag ? "leave,[li:v],left,[left]" : "leave,left", "离开");
abbTypemap.put(IrregularVerbUtil.proFlag ? "sleep,[sli:p],slept,[slept]" : "sleep,slept", "睡觉");
abbTypemap.put(IrregularVerbUtil.proFlag ? "sweep,[swi:p],swept,[swept]" : "sweep,swept", "扫");
abbTypemap.put(IrregularVerbUtil.proFlag ? "lay,[lei],laid,[leid]" : "lay,laid", "下蛋, 放置");
abbTypemap.put(IrregularVerbUtil.proFlag ? "pay,[pei],paid,[peid]" : "pay,paid", "付");
abbTypemap.put(IrregularVerbUtil.proFlag ? "say,[sei],said,[sed]" : "say,said", "说");
abbTypemap.put(IrregularVerbUtil.proFlag ? "stand,[stænd],stood,[stud]" : "stand,stood", "站");
abbTypemap.put(IrregularVerbUtil.proFlag ? "understand,[],understood,[ʌndə'stænd]" : "understand,understood", "明白");
abbTypemap.put(IrregularVerbUtil.proFlag ? "lose,[lu:z],lost,[lɔst]" : "lose,lost", "失去");
abbTypemap.put(IrregularVerbUtil.proFlag ? "have,[həv],had,[hæd]" : "have,had", "有");
abbTypemap.put(IrregularVerbUtil.proFlag ? "make,[meik],made,[meid]" : "make,made", "制造");
abbTypemap.put(IrregularVerbUtil.proFlag ? "sell,[sel],sold,[səuld]" : "sell,sold", "卖");
abbTypemap.put(IrregularVerbUtil.proFlag ? "tell,[tel],told,[təuld]" : "tell,told", "告诉");
abbTypemap.put(IrregularVerbUtil.proFlag ? "retell,[ri:'tel],retold,[ri:'təuld]" : "retell,retold", "重讲，重复，复述");
return abbTypemap;
}

/**
* Library for "ABC" type.
* @return
*/
private static Map<String, String> libABC() {
Map<String, String> abaTypemap = new HashMap<String, String>();
abaTypemap.put(IrregularVerbUtil.proFlag ? "blow,[bləu],blew,[blu:],blown,[]" : "blow,blew,blown", "吹");
abaTypemap.put(IrregularVerbUtil.proFlag ? "drive,[draiv],drove,[drəuv],driven,[drivən]" : "drive,drove,driven", "驾驶");
abaTypemap.put(IrregularVerbUtil.proFlag ? "draw,[drɔ:],drew,[dru:],drawn,[drɔ:n]" : "draw,drew,drawn", "画画");
abaTypemap.put(IrregularVerbUtil.proFlag ? "eat,[i:t],ate,[eit],eaten,['i:tən]" : "eat,ate,eaten", "吃");
abaTypemap.put(IrregularVerbUtil.proFlag ? "fall,[fɔ:l],Fell,[fel],fallen,['fɔ:lən]" : "fall,fell,fallen", "落下");
abaTypemap.put(IrregularVerbUtil.proFlag ? "give,[ɡiv],gave,[ɡeiv],given,['ɡivən]" : "give,gave,given", "给");
abaTypemap.put(IrregularVerbUtil.proFlag ? "get,[ɡet],got,[ɡɔt],gotten,['ɡɔtən]" : "get,got,gotten", "得到");
abaTypemap.put(IrregularVerbUtil.proFlag ? "show,[ʃəu],showed,[],shown,['ʃəun]" : "show,showed,shown", "展示, 给...看");
abaTypemap.put(IrregularVerbUtil.proFlag ? "fall,[fɔ:l],Fell,[fel],fallen,['fɔ:lən]" : "prove,proved,proven", "证明, 证实,试验");
abaTypemap.put(IrregularVerbUtil.proFlag ? "give,[ɡiv],gave,[ɡeiv],given,['ɡivən]" : "beat,beat,beaten", "打败");
abaTypemap.put(IrregularVerbUtil.proFlag ? "grow,[ɡrəu],grew,[ɡru:],grown,[ɡrəun]" : "grow,grew,grown", "生长");
abaTypemap.put(IrregularVerbUtil.proFlag ? "forgive,[fə'ɡiv],forgot,[fə'ɡɔt],forgiven,[]" : "forgive,forgot,forgiven", "原谅, 饶恕");
abaTypemap.put(IrregularVerbUtil.proFlag ? "know,[nəu],knew,[nju: nu:],known,[]" : "know,knew,known", "知道");
abaTypemap.put(IrregularVerbUtil.proFlag ? "mistake,[mi'steik],mistook,[mi'stuk],mistooken,[]" : "mistake,mistook,mistooken", "弄错; 误解,");
abaTypemap.put(IrregularVerbUtil.proFlag ? "overeat,['əuvə'i:t],overate,[əuvə'reit],overeaten,[]" : "overeat,overate,overeaten", "(使)吃过量");
abaTypemap.put(IrregularVerbUtil.proFlag ? "take,[teik],took,[tuk],taken,['teikn]" : "take,took,taken", "拿");
abaTypemap.put(IrregularVerbUtil.proFlag ? "throw,[θrəu],threw,[θru:],thrown,[θrəun]" : "throw,threw,thrown", "抛，扔");
abaTypemap.put(IrregularVerbUtil.proFlag ? "ride,[raid],rode,[rəud],ridden,['ridən]" : "ride,rode,ridden", "骑");
abaTypemap.put(IrregularVerbUtil.proFlag ? "see,[si:],saw,[sɔ:],seen,[si:n]" : "see,saw,seen", "看见");
abaTypemap.put(IrregularVerbUtil.proFlag ? "write,[rait],wrote,[rəut],written,['ritən]" : "write,wrote,writen", "写");
abaTypemap.put(IrregularVerbUtil.proFlag ? "break,[breik],broke,[brəuk],broken,['brəukən]" : "break,broke,broken", "打破");
abaTypemap.put(IrregularVerbUtil.proFlag ? "choose,[tʃu:z],chose,[tʃəuz],chosen,['tʃəuzən]" : "choose,chose,chosen", "选择");
abaTypemap.put(IrregularVerbUtil.proFlag ? "hide,[haid],hid,[hid],hidden,['hidən]" : "hide,hid,hidden", "隐藏");
abaTypemap.put(IrregularVerbUtil.proFlag ? "forget,[fə'ɡet],forgot,[fə'ɡɔt],forgotten,[fə'ɡɔtn]" : "forget,forgot,forgotten", "忘记");
abaTypemap.put(IrregularVerbUtil.proFlag ? "freeze,[fri:z],froze,[frəuz],frozen,['frəuzn]" : "freeze,froze,frozen", "冷冻,结冰，感到严寒");
abaTypemap.put(IrregularVerbUtil.proFlag ? "speak,[spi:k],spoke,[spəuk],spoken,['spəukən]" : "speak,spoke,spoken", "说");
abaTypemap.put(IrregularVerbUtil.proFlag ? "steal,[sti:l],stole,[],stolen,['stəulən]" : "steal,stole,stolen", "偷");
abaTypemap.put(IrregularVerbUtil.proFlag ? "begin,[bi'ɡin],began,[bi'ɡæn],begun,[bi'ɡʌn]" : "begin,began,gegun", "开始");
abaTypemap.put(IrregularVerbUtil.proFlag ? "drink,[driŋk],drank,[dræŋk],drunk,[drʌŋk]" : "drink,drank,drunk", "喝");
abaTypemap.put(IrregularVerbUtil.proFlag ? "sing,[siŋ],sang,[sæŋ],sung,[sʌŋ]" : "sing,sang,sung", "唱");
abaTypemap.put(IrregularVerbUtil.proFlag ? "sink,[siŋk],sank,[sæŋk],sunk,[sʌŋk]" : "sink,sank,sunk", "下沉, 沉没");
abaTypemap.put(IrregularVerbUtil.proFlag ? "swim,[swim],swam,[swæm],swum,[swʌm]" : "swim,swam,swum", "游泳");
abaTypemap.put(IrregularVerbUtil.proFlag ? "ring,[riŋ],rang,[ræŋ],rung,[rʌŋ]" : "ring,rang,rung", "打电话");
abaTypemap.put(IrregularVerbUtil.proFlag ? "be,[],was,[],been,[]" : "be,was,been", "是");
abaTypemap.put(IrregularVerbUtil.proFlag ? "be,[],was,[],been,[]" : "be,were,been", "是");
abaTypemap.put(IrregularVerbUtil.proFlag ? "bear,[bεə],bore,[bɔ:],born,[]" : "bear,bore,born", "负担, 忍受");
abaTypemap.put(IrregularVerbUtil.proFlag ? "bear,[bεə],bore,[bɔ:],born,[bɔ:n]" : "bear,bore,borne", "负担, 忍受");
abaTypemap.put(IrregularVerbUtil.proFlag ? "do,[du:],did,[did],done,[dʌn]" : "do,did,done", "做");
abaTypemap.put(IrregularVerbUtil.proFlag ? "fly,[flai],flew,[flu:],flown,[fləun]" : "fly,flew,flown", "飞");
abaTypemap.put(IrregularVerbUtil.proFlag ? "go,[ɡəu],went,[went],gone,[ɡɔn]" : "go,went,gone", "去");
abaTypemap.put(IrregularVerbUtil.proFlag ? "lie,[lai],lay,[lei],lain,[lein]" : "lie,lay,lain", "躺");
abaTypemap.put(IrregularVerbUtil.proFlag ? "wear,[wεə],wore,[wɔ:],worn,[wɔ:n]" : "wear,wore,worn", "穿");
return abaTypemap;
}
}

/IrregularVerbs/src/com/b510/irregularverbs/utils/CommonUtil.java

/**
*
*/
package com.b510.irregularverbs.utils;

/**
* @author Hongten
* @created Feb 27, 2014
*/
public class CommonUtil {

//Commands
public static final String EXIT = "exit";
public static final String PRONUNCIATION = "pronunciation";
public static final String ALL = "all";
//Description
public static final String DESCRIPTION = "Please input a Irregular Verb or Command:\n[e.g: 'came', 'all', 'pronunciation', 'exit']";
public static final String EXIT_SYSTEM = "exited system.";
public static final String LOADIGN_VERBS = "After loading vocabulary!";

public static final String NO_MATCHED = "No matched!";
public static final String ADVICE = "You may want to search the follow word(s):";
public static final String SPEND = "Spend >> [";
public static final String SPEND_END = "]ms";

public static final int STR_SIZE = 25;
public static final String COMMA = ",";
public static final String EMPTY = "";
public static final String BLANK = " ";

public static final String LINE_ONE = "=====================";
public static final String LINE_TWO = LINE_ONE + LINE_ONE;
public static final String LINE_THREE = LINE_TWO+ "\n";
}

/IrregularVerbs/src/com/b510/irregularverbs/utils/IrregularVerbUtil.java

/**
*
*/
package com.b510.irregularverbs.utils;

import java.util.ArrayList;
import java.util.List;

import com.b510.irregularverbs.lib.VocabularyLib;
import com.b510.irregularverbs.vo.IrregularVerbsVO;

/**
* The tool for the Irregular Verbs. Providing load and reload methods to get all irregular verbs.<br>
* it also provide the match method to handle the content, which user input in the console.<br>
* and display the result of matching.
* @author Hongten
* @created Feb 27, 2014
*/
public class IrregularVerbUtil {

private static IrregularVerbUtil irregularVerbs = new IrregularVerbUtil();
public static List<IrregularVerbsVO> verbs = new ArrayList<IrregularVerbsVO>();
// The switch of the pronunciation
public static boolean proFlag = false;

/**
* Load all of the irregular verbs.<br>
* @return all of the irregular verbs.
*/
public static List<IrregularVerbsVO> loadIrregularVerbsVOs() {
return VocabularyLib.getVocabularyLib();
}

private IrregularVerbUtil() {
}

public static IrregularVerbUtil getInstance() {
if (verbs.size() <= 0) {
loadIrregularVerbsVOs();
}
return irregularVerbs;
}

/**
* Reload all of the irregular verbs.
*/
public static void reLoadVerbs() {
verbs = null;
verbs = new ArrayList<IrregularVerbsVO>();
loadIrregularVerbsVOs();
PrintUtil.printInfo(CommonUtil.LOADIGN_VERBS);
PrintUtil.printInfo(CommonUtil.LINE_THREE);
}

/**
* Processing the input content,and display the result for matching.
* @param input input content.
*/
public void match(String input) {
long startTime = System.currentTimeMillis();
List<IrregularVerbsVO> temp = new ArrayList<IrregularVerbsVO>();
List<IrregularVerbsVO> mayBeVOs = new ArrayList<IrregularVerbsVO>();
for (IrregularVerbsVO vo : verbs) {
handleMatchWord(input, temp, vo);
// match same word(s)
input = input.toLowerCase();
if (vo.getPrototype().startsWith(input) || vo.getPostTense().startsWith(input) || vo.getPostParticiple().startsWith(input)) {
mayBeVOs.add(vo);
}
}
PrintUtil.printInfo(CommonUtil.LINE_TWO);
matchResult(temp, mayBeVOs);
long endTime = System.currentTimeMillis();
PrintUtil.printInfo(CommonUtil.SPEND + (endTime - startTime) + CommonUtil.SPEND_END);
PrintUtil.printInfo(CommonUtil.LINE_THREE);
}

/**
* There have two results for matching.<br>
* <li>First : matched, then display the result of matched.</li>
* <li>Second : not matched, then display the related irregular verb(s)</li>
* @param matchedList
* @param relatedList
*/
private void matchResult(List<IrregularVerbsVO> matchedList, List<IrregularVerbsVO> relatedList) {
if (matchedList.size() > 0) {
loopMatchResult(matchedList);
} else {
PrintUtil.printInfo(CommonUtil.NO_MATCHED);
if (relatedList.size() > 0) {
PrintUtil.printInfo(CommonUtil.LINE_ONE);
PrintUtil.printInfo(CommonUtil.ADVICE);
loopMatchResult(relatedList);
}
}
}

/**
* Display the match result
* @param list
*/
private static void loopMatchResult(List<IrregularVerbsVO> list) {
for (IrregularVerbsVO vo : list) {
PrintUtil.printInfo(addBlank(vo.getPrototype().replace(CommonUtil.COMMA, CommonUtil.EMPTY))
+ addBlank(vo.getPostTense().replace(CommonUtil.COMMA, CommonUtil.EMPTY))
+ addBlank(vo.getPostParticiple().replace(CommonUtil.COMMA, CommonUtil.EMPTY)) + vo.getMean());
}
}

/**
* @param input
* @param temp
* @param vo
*/
private void handleMatchWord(String input, List<IrregularVerbsVO> temp, IrregularVerbsVO vo) {
if (proFlag) {
if (input.equalsIgnoreCase(vo.getPrototype().split(CommonUtil.COMMA)[0]) || input.equalsIgnoreCase(vo.getPostTense().split(CommonUtil.COMMA)[0])
|| input.equalsIgnoreCase(vo.getPostParticiple().split(CommonUtil.COMMA)[0])) {
temp.add(vo);
}
} else {
if (input.equalsIgnoreCase(vo.getPrototype()) || input.equalsIgnoreCase(vo.getPostTense()) || input.equalsIgnoreCase(vo.getPostParticiple())) {
temp.add(vo);
}
}
}

/**
* Show all of the irregular verbs.
*/
public static void showAll() {
if (verbs.size() <= 0) {
loadIrregularVerbsVOs();
}
long startTime = System.currentTimeMillis();
PrintUtil.printInfo(CommonUtil.LINE_TWO);
loopMatchResult(verbs);
long endTime = System.currentTimeMillis();
PrintUtil.printInfo(CommonUtil.SPEND + (endTime - startTime) + CommonUtil.SPEND_END);
PrintUtil.printInfo(CommonUtil.LINE_THREE);
}

/**
* Add the blank
* @param str
* @return
*/
private static String addBlank(String str) {
int blank = CommonUtil.STR_SIZE - str.getBytes().length;
for (int i = 0; i < blank; i++) {
str += CommonUtil.BLANK;
}
return str.toString();
}
}

/IrregularVerbs/src/com/b510/irregularverbs/utils/PrintUtil.java

/**
*
*/
package com.b510.irregularverbs.utils;

/**
* @author Hongten
* @created 2014-2-27
*/
public class PrintUtil {

public static void printInfo(String info) {
System.out.println(info);
}

public static void printInfo(StringBuffer info) {
System.out.println(info);
}

public static void printInfo(char info) {
System.out.println(info);
}
}

/IrregularVerbs/src/com/b510/irregularverbs/vo/IrregularVerbsVO.java

/**
*
*/
package com.b510.irregularverbs.vo;

/**
* @author Hongten
* @created Feb 27, 2014
*/
public class IrregularVerbsVO {

private String prototype;
private String postTense;
private String postParticiple;
private String mean;

public IrregularVerbsVO(String prototype, String postTense, String postParticiple, String mean) {
super();
this.prototype = prototype;
this.postTense = postTense;
this.postParticiple = postParticiple;
this.mean = mean;
}

public String getPrototype() {
return prototype;
}

public void setPrototype(String prototype) {
this.prototype = prototype;
}

public String getPostTense() {
return postTense;
}

public void setPostTense(String postTense) {
this.postTense = postTense;
}

public String getPostParticiple() {
return postParticiple;
}

public void setPostParticiple(String postParticiple) {
this.postParticiple = postParticiple;
}

public String getMean() {
return mean;
}

public void setMean(String mean) {
this.mean = mean;
}

}

===============================================

Download Source Code : http://files.cnblogs.com/hongten/IrregularVerbs.zip

===============================================