包命名

    包名按照域名的范围从大到小逐步列出，恰好和Internet上的域名命名规则相反。

    由一组以“。”连接的标识符构成，通常第一个标识符为符合网络域名的两个或者三个英文小写字母。

    People  TestPage  XMLExample

    类，接口命名

    类的名字必须由大写字母开头而单词中的其他字母均为小写；如果类名称由多个单词组成，则每个单词的首字母均应为大写例如TestPage；如果类名称中包含单词缩写，则这个所写词的每个字母均应大写，如：XMLExample,还有一点命名技巧就是由于类是设计用来代表对象的，所以在命名类时应尽量选择名词。

    People  TestPage  XMLExample

    方法名

    方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头。可以为动词或动词+名词组合。

    设置/获取某个值的Method，应该遵循setV/getV规范

    返回长度的Method，应该命名为length

    测试某个布尔值的Method，应该命名为isV

    将对象转换为某个特定类型的Mehod应该命名为toF

    getDate（）；  length（）；  isReady（）；  toOracleFormat（）；

    变量名

    1.普通变量命名应该采用首字母小写，其他字母首字母大写的方式。

    2.final static变量的名字应该都大写，并且指出完整含义。如果一个常量名称由多个单词组成，则应该用下划线来分割这些单词如。

    NUM_DAYS_IN_WEEK  MAX_VALU

    3. 如果需要对变量名进行缩写时，一定要注意整个代码中缩写规则的一致性

    context=ctx  message=msg

    4. 通过在结尾处放置一个量词，就可创建更加统一的变量

    First（一组变量中的第一个）  Last（一组变量中的最后一个）  Next（一组变量中的下一个变量）  Prev（一组变量中的上一个）  Cur（一组变量中的当前变量）

    5. 无论什么时候，均提倡应用常量取代数字、固定字符串。也就是说，程序中除0，1以外，尽量不应该出现其他数字。

    6. 索引变量：i、j、k等只作为小型循环的循环索引变量。

    7. 逻辑变量：避免用flag来命名状态变量，用is来命名逻辑变量。

    if（isClosed）{  dosomeworks;  return;  }

    数组

    总是使用以下方式定义数组：

    int[] arr = new int[10];

    禁止使用C语言的是形式：

    禁止  int arr[] = new int[10];

    集合

    数组或者容器推荐命名方式为名词+s的方式，例如：

    List<Person> persons = getPerson（）；  for（Person person : persons）{  dosomeworks;  }

    泛型

    应该尽量简明扼要（最好是一个字母），以利于与普通的class或interface区分

    Container中的Element应该用E表示；Map里的key用K表示，value用V；Type用T表示；异常用X表示

    如果需要接收多个Type类型的参数，应该用邻接T的大写字母——例如S——来依次表示，当然也可以用T1, T2这样的方式

    public class HashSet<E> extends AbstractSet<E> {…}   public class HashMap<K, V> extends AbstractMap<K, V> {…}   public class ThreadLocal<T> {…}   public interface Functor<T, X extends Throwable> {       T val（） throws X;   }

    推荐的命名

    1.当要区别接口和实现类的时候，可以在类的后面加上“Impl”。

    interface Container  class ContainerImpl

    2.Exception类最好能用“Exception”做为类命名的结尾

    DataNotFoundException  InvalidArgumentException

    3.抽象类最好能用“Abstract”做为类命名的开头

    AbstractBeanDefinition  AbstractBeanFactory

    4. Test类最好能用“Test”做为类命名的结尾

    ContainerTest

    5.简称与缩写（不推荐使用）

    cp代表colorPoint   buf代表buffer   off代表offset   len代表length

    除非是在循环中，否则一般不推荐使用单个字母作为变量名，不过也有例外，即约定俗成的单个字母

    b代表byte  c代表char  d代表double  e代表Exception   f代表float  i, j, k代表整数   l代表long  o代表Object   s代表String   v代表某些类型的特定值

    代码风格

    花括号

    花括号统一采用以下格式：

    if（bool experssion）{  dosomework;  }

    除非花括号中为空，不然任何情况下不能省略花括号，并且花括号必须换行，例如：

    if（i==0）{  return;  }  while（true） {}

    以下写法禁止出现：

    禁止  if（i != 0） return;  禁止  if（i !=0） {return;}

    括号

    括号的前，后一个字符不需要空格，例如：

    Person p = new Person（“Jack”， 17）；

    空格

    逗号之后紧跟一个空格。

    Person p = new Person（“Jack”， 16, “China”）；

    2.　二元操作符前后跟空格。

    int i = a + b – c * d;

    3. 一元操作符不需要空格，for语句分号后有空格。

    for（int i = 0; I < 10; i++）{  dosomework;  }

    4. 括号前后不需要空格

    类

    类的定义结构按照顺序为：

    1） 常量

    2） 成员变量

    3） 构造函数

    4） 成员函数

    5） get和set方法

    各个部分之间留出一个空行。

    例如：

    规范类模板：

    class Person{      private final static int MAX_AGE = 100;       private String firstname = “Jack”；       public Person（）{}  public Person（String firstname）{      this.firstname = firstname;  }   public void doExercise（）{      dosomeworks;      run（）；  }  private void run（）{      dosomeworks;  }   public getFirstname（）{      return firstname;  }  public setFirstname（String firstname）{      this.firstname = firstname;  }  }

    2.构造函数

    1） 参数为空的构造函数出现在最上方

    2） 有调用关系的构造函数相邻

    3） 参数尽量由少到多从上至下排序

    3.使用成员变量

    在类的方法内引用成员变量了命名冲突以外，不使用this。非特殊情况在类的方法内都不使用get和set方法存取成员变量。

    4.方法

    有调用关系的方法尽量放在相邻的位置，public和private方法可以交叉放置。

    5.get和set方法，所有需要公开的成员变量都要符合良好的javabean规范，提供get和set方法，尽量使用IDE工具自动生成。

    Javadoc注释

    在每个程序的最开始部分，一般都用Javadoc注释对程序的总体描述以及版权信息，之后在主程序中可以为每个类、接口、方法、字段添加 Javadoc注释，每个注释的开头部分先用一句话概括该类、接口、方法、字段所完成的功能，这句话应单独占据一行以突出其概括作用，在这句话后面可以跟随更加详细的描述段落。在描述性段落之后还可以跟随一些以Javadoc注释标签开头的特殊段落，例如上面例子中的@auther和@version，这些段落将在生成文档中以特定方式显示

对在飞Q登录信息界面中输入的各项信息进行初步检验。若发现错误，输入数据全部清空，以让用户重新输入一次。若未发现错误，转入主界面。其中的错误种类有：

1.输入数据不匹配

帐号 数据库没有该帐号

密码 与对应账号的密码不匹配

2 输入数据不能为空

if (账号为空)

{

请输入账号再登陆

}

else if (账号长度小于6或对于20)

{

请输入正确的账号,账号可以位数字或Email地址。

}

else if (密码为空)

{

请输入密码后再登陆

}

else

{

通知服务器 账号为：xxx 密码为：xxx的请求登陆

}

服务器方面：

接收数据并存入loginpot中

判断接收的密码和服务器中的密码是否相同，相同则返回登录成功，并发送一系列信息（见下），不相同则返回登录失败，有相同的帐号登录的话，会向第一个客户端发送kill指令，当确认第一个客户端下线之后，第二个客户端就可以登录了

　　在学习了J2SE之后，你可以尝试着慢慢过渡到J2EE，当然，学习J2EE海需要很多非JAVA技术的支撑，比如数据库技术，网页编程技术等等，待会我会详细介绍这两方面的内容。J2EE有三个必学的框架，如果你说你学了J2EE，但又不会这三个框架的话，那会让人笑掉大牙，这三个框架分别是 Struts、Spring和Hibernate，虽然这三个框架应用很广，但不代表这三个框架就代表了J2EE，J2EE还有很多其他的东西，比如 EJB，作为一款重量级（此重量级不是指重量级选手那个意思，此重量级非彼重量级）框架，虽然这个应用慢慢的再被其他框架所取代，但EJB3.0的出现也给它带回一些生机，作为一个分布式应用的框架，也是大家要去学习和了解的知识。

　　当然，刚才说到J2EE包含的范围很广，即使我把我所了解的所有技术说出来，也并不能代表J2EE，这是一个很深很广的学问，需要大家以后再工作的时候慢慢去发现了。我所了解的还包括：

　　JDBC:Java数据库连接对象，基础中的基础，Hibernate也只是对它的封装而已

　　JNDI: Java 命名与目录接口，J2EE重要规范之一

　　EJBS: 上面已经提到过了

　　RMI: 提供远程调用方法的支持，主要用于程序分布式开发

　　JMS: Java消息服务，中间件技术

　　JAVA IDL: 提供J2EE平台与CORBA交互能力和互联能力的技术

　　JTS: 组件事务监视器

　　JTA: 事务划分的一个技术

　　JAVAMAIL: Java中的邮件技术

　　JAF: Java启动框架,没研究过

　　Log4j，一款日志处理的框架应用

　　Junit：单元测试的好帮手

　　freemarker、velocity：两款不错的模板引擎

　　与Flash的交互Flex：目前很多的SNS应用就是使用到了这个技术

　　Web services:想知道我们论坛天气预报的效果是怎么做的吗？请关注这个技术

　　SOA:面向服务架构，未来技术发展的趋势之一

　　……

　　不过前面介绍到得这些都不是J2EE的基础,是属于框架应用级别的.要真正把上面说到的知识掌握好,还是的学习J2EE最核心的东西:JDBC、JSP、 servlet和JavaBean,后面三个也是学习SSH的基础(Struts\Spring\Hibernate的简称).鉴于J2EE的内容太过复杂,建议大家最初只学习: JSP, servlet和JavaBean，等这个基础掌握好再把SSH学习了，再对其他J2EE技术有个大致的了解就可以出去找工作了。当然，找工作的前提除了把Java学习好，还会有一些其他的技术也是必须要掌握的

 对于JAVA，现在的我就是一个小白，跟着视频写着写自己第一个“Hello world”的小程序，就已经犯了六七处错了。。。。。。不过我是小白，犯点错是很正常的。

            接下来我就把我犯的错记录下来。

D:\java\day01>javac demo.java
demo.java:1: 需要 <标识符>
class
     ^
1 错误

         这不，我下载了个editplus，先新建了一个JAVA的文本，里面自动生成了一个经典的“Hello World”的代码。我还挺高兴，准备先运行看看效果，结果连编译都没有通过。。。

先看看这段代码吧

 class
        {   

          public static void main(String[] args)
                    {       
              System.out.println("Hello World!");
                     }
         }

        看了报错，再看代码，错误也就一目了然了。原来我连类名都没有起。。。。。。亏我还在DOS里打了demo......

         加上类名后，编译没有报错，太好了，至少没有语法错误。可是问题又来了。。。

D:\java\day01>java demo

Exception in thread "main" java.lang.NoClassDefFoundError: demo (wrong name: Dem
o)
        at java.lang.ClassLoader.defineClass1(Native Method)
        at java.lang.ClassLoader.defineClass(Unknown Source)
        at java.security.SecureClassLoader.defineClass(Unknown Source)
        at java.net.URLClassLoader.defineClass(Unknown Source)
        at java.net.URLClassLoader.access$000(Unknown Source)
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.net.URLClassLoader.findClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClassInternal(Unknown Source)
Could not find the main class: demo.  Program will exit.

        运行时又出现报错了，而且还是这么篇幅巨大，崩溃~~~ 不过仔细一看发现报错里的(wrong name: Dem
o)  好吧，不过这也体现了JAVA严格区分大小写，让我对这一点认识加深了。

 D:\java\day01>java Demo
Hello World!

   
    看见这两单词是真不容易啊，小激动 。当然，这代码是自动生成的，所心我又自己用记事本，照着视频里一个字母一个字母地敲，结果。。。你懂的，又有报错了。。。

D:\java\day01>javac Demo1.java
Demo1.java:5: 需要 ';'
                System.out.println("hello world")
                                                 ^
1 错误

   这个报错还是很明显的，需要“;”，不过，具本“;”应该怎么用，我还是需要多多观察。可是加上了以后还是报错了

D:\java\day01>javac demo1.java
demo1.java:5: 软件包 system 不存在
                system.out.println("hello world");
                      ^
1 错误

 仔细对照后才发现，原来是system的首字没有大写。所有都更正后，运行正常。

         以上我的第一个JAVA程序的编写过程，只为自己高兴。（顺便吐槽TX的日志排版真让人蛋疼）

    在Java 5.0之前启动一个任务是通过调用Thread类的start()方法来实现的，任务的提于交和执行是同时进行的，如果你想对任务的执行进行调度或是控制 同时执行的线程数量就需要额外编写代码来完成。5.0里提供了一个新的任务执行架构使你可以轻松地调度和控制任务的执行，并且可以建立一个类似数据库连接 池的线程池来执行任务。这个架构主要有三个接口和其相应的具体类组成。这三个接口是Executor, ExecutorService、ScheduledExecutorService，让我们先用一个图来显示它们的关系：

图的左侧是接口，图的右侧是这些接口的具体类。注意Executor是没有直接具体实现的。

Executor接口：是用来执行Runnable任务的，它只定义一个方法：

• execute(Runnable command)：执行Ruannable类型的任务

ExecutorService接口：ExecutorService继承了Executor的方法，并提供了执行Callable任务和中止任务执行的服务，其定义的方法主要有：

• submit(task)：可用来提交Callable或Runnable任务，并返回代表此任务的Future对象
• invokeAll(collection of tasks)：批处理任务集合，并返回一个代表这些任务的Future对象集合
• shutdown()：在完成已提交的任务后关闭服务，不再接受新任务
• shutdownNow()：停止所有正在执行的任务并关闭服务。
• isTerminated()：测试是否所有任务都执行完毕了。
• isShutdown()：测试是否该ExecutorService已被关闭

ScheduledExecutorService接口在ExecutorService的基础上，ScheduledExecutorService提供了按时间安排执行任务的功能，它提供的方法主要有：

• schedule(task, initDelay): 安排所提交的Callable或Runnable任务在initDelay指定的时间后执行。
• scheduleAtFixedRate()：安排所提交的Runnable任务按指定的间隔重复执行
• scheduleWithFixedDelay()：安排所提交的Runnable任务在每次执行完后，等待delay所指定的时间后重复执行。

重要的Executors类

虽然以上提到的接口有其实现的具体类，但为了方便Java 5.0建议使用Executors的工具类来得到Executor接口的具体对象，需要注意的是Executors是一个类，不是Executor的复数 形式。Executors提供了以下一些static的方法：

• callable(Runnable task): 将Runnable的任务转化成Callable的任务
• newSingleThreadExecutor: 产生一个ExecutorService对象，这个对象只有一个线程可用来执行任务，若任务多于一个，任务将按先后顺序执行。
• newCachedThreadPool(): 产生一个ExecutorService对象，这个对象带有一个线程池，线程池的大小会根据需要调整，线程执行完任务后返回线程池，供执行下一次任务使用。
• newFixedThreadPool(int poolSize)：产生一个ExecutorService对象，这个对象带有一个大小为poolSize的线程池，若任务数量大于poolSize，任务会被放在一个queue里顺序执行。
• newSingleThreadScheduledExecutor：产生一个ScheduledExecutorService对象，这个对象的线程池大小为1，若任务多于一个，任务将按先后顺序执行。
• newScheduledThreadPool(int poolSize): 产生一个ScheduledExecutorService对象，这个对象的线程池大小为poolSize，若任务数量大于poolSize，任务会在一个queue里等待执行

举例说明：

应用Executors来建立Thread pool

有时候您需要建立一堆Thread来执行一些小任务，然而频繁的建立Thread有时会是个开销，因为Thread的建立必须与作业系统互动，如果能建立一个Thread pool来管理这些小的Thread并加以重复使用，对于系统效能会是个改善的方式。

您可以使用Executors来建立Thread pool，Executors有几个static方法，列出如下：

举个简单的实例，下面的程式使用newFixedThreadPool方法建立Thread pool，当中包括五个可以重复使用的Thread，您可以指定Runnable物件给它，程式中会产生十个Runnable物件，由于Thread pool中只有五个可用的Thread，所以后来建立的五个Runnable必须等待有空闲的Thread才会被执行：

• ExecutorDemo.java

package onlyfun.caterpillar;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorDemo {
 public static void main(String[] args) {
  ExecutorService service = Executors.newFixedThreadPool(5);

  for(int i = 0; i < 10; i++) {
   final int count = i;
   service.submit
(new Runnable() {
    public void run() {
     System.out.println(count);
     try {
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }

    }
   });
  }

  service.shutdown(); // 最后记得关闭Thread pool

 }
}

submit()方法也接受实作Callable介面的物件，最后传回Future物件，可以取得Callable执行过后的传回结果。

如果想利用Executors进行排程，例如排定某个工作30秒后执行：

 ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor( );          scheduler.schedule(new Runnable( ) {                                 public void run() {                                     // 排程工作                                 }                             },                             30, TimeUnit.SECONDS);

或排定某个工作5秒后执行，之后每30秒执行一次：

 ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor( );          final ScheduledFuture future = scheduler.scheduleAtFixedRate(new Runnable( ) {                                 public void run() {                                     // 排程工作                                     System.out.println("t");                                 }                             },                             0, 5, TimeUnit.SECONDS);                   // 排定 60 秒后取消future          scheduler.schedule(new Runnable( ) {              public void run( ) {                future.cancel(false);              }            }, 60, TimeUnit.SECONDS);如上所示，想要取消排程任务，可以呼叫ScheduledFuture的cancel()方法。

    程序也很简单，就是遍历一下本地目录，然后产生一堆ftp命令。

    为了避免以后再做此类重复劳动，我记在这里。

    ----------------------------------------------------------

    function matchDemo（strFolderName）

    {

    var s;

    var re = /200\d{5}/ig;

    s = strFolderName.match（re）；

    return（s）；

    }

    function init（）

    {

    strScript ="open 192.168.1.32 \n";

    strScript+="user sybase 111111 \n";

    strScript+="bin\n";

    strScript+="prompt\n";

    strScript+="cd /hisdata/olddata \n";

    dicWhiteList = new ActiveXObject（"Scripting.Dictionary"）；

    dicWhiteList.add （"20051205_pihou", ""）；

    dicWhiteList.add （"20051206_pihou", ""）；

    dicWhiteList.add （"20060701_pihou", ""）；

    }

    function EnumSubFolder（oSubFolder）

    {

    var eFolders=new Enumerator（oSubFolder.SubFolders）；

    var s="";

    if（eFolders.atEnd（））

    {

    return s;

    }

    else

    {

    for （； !eFolders.atEnd（）； eFolders.moveNext（））

    {

    s+="lcd \"";

    s+=eFolders.item（）；

    s+="\"\n";

    s+="mput *.*\n";

    }

    return s;

    }

    }

    function checkList（strToBeChecked）

    {

    return !dicWhiteList.Exists（strToBeChecked）；

    }

    var strScript,dicWhitList;

    var sFolderPath="e:\\";

    var oFs=new ActiveXObject（"Scripting.FileSystemObject"）；

    init（）；

    if （oFs.FolderExists（sFolderPath））

    {

    //WScript.Echo（"valid folder"）；

    var oFolders=oFs.GetFolder（sFolderPath）；

    var eFolders=new Enumerator（oFolders.SubFolders）；

    if（eFolders.atEnd（））

    {

    strScript += "mkdir \"";

    strScript += oFs.GetBaseName（sFolderPath）；

    strScript += "\"\n";

    }

    else

    {

    for （； !eFolders.atEnd（）； eFolders.moveNext（））

    {

    strTargetFolderName=matchDemo（eFolders.item（）+""）；

    if（strTargetFolderName==null || checkList（oFs.GetBaseName（eFolders.item（））））

    continue;

    strTmpFolderName="\""+oFs.GetBaseName（eFolders.item（））+"\"";

    strScript += "mkdir "

    strScript += strTargetFolderName;

    strScript += "\n";

    strScript += "cd ";

    strScript += strTargetFolderName;

    strScript += "\n";

    strScript += EnumSubFolder（eFolders.item（））；

    strScript += "lcd "

    strScript += eFolders.item（）；

    strScript += "\n";

    strScript += "mput *.*\n";

    strScript += "cd  \nlcd \n";

    }

    }

    strScript+="bye\n";

    WScript.Echo（strScript）；

    }

    else

    {

    WScript.Echo（"Bad Folder Name"）；

    }

public static void main(String[] args) {
new Test().dateDiff(new SimpleDateFormat("yyyy-MM-dd").format(new Date()), "2011-4-28", "yyyy-MM-dd");
}
}

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

/**
*

*

JDK版本

1.4

* @author KIN
* @version 1.0
* @see
* @since 1.0
*/
public class CnToSpell2GUI extends JFrame {

private CnToSpell2GUI c = null;

public CnToSpell2GUI () {
super("Cn to Spell");
setSize(800,100);
getContentPane().setLayout(new FlowLayout());
// component layout
JTextArea from = new JTextArea(5,20);
JTextArea to = new JTextArea(5,20);
JButton b = new JButton("cn to pinyin");
getContentPane().add(new JLabel("From:"));
getContentPane().add(from);
getContentPane().add(b);
getContentPane().add(new JLabel("To:"));
getContentPane().add(to);
// action handle
b.addActionListener(new Cn2PinyinActionListener(from,to));
setVisible(true);
// set this for pack
c = this;
}

/**button action listener to convert text to pinyin from one textbox to another textbox*/
class Cn2PinyinActionListener implements ActionListener{

private JTextArea from = null;
private JTextArea to = null;
public Cn2PinyinActionListener(JTextArea from, JTextArea to) {
this.from = from;
this.to = to;
}
public void actionPerformed(ActionEvent e) {
if (from.getText().length() == 0) {
JOptionPane.showMessageDialog(from,"From text is empty!","Warning",JOptionPane.WARNING_MESSAGE);
}
String text = from.getText();
to.setText(CnToSpell.getFullSpell(text));
c.pack();
}
}

public static void main(String [] args) {
CnToSpell2GUI g = new CnToSpell2GUI();
}
}

------------------------------------------------------------------------
/**
* @(#)CnToSpell.java
* 版权声明 Easydozer 版权所有 违者必究
*
* 修订记录:
* 1)更改者：Easydozer
* 时　间：2004-10-20　
* 描　述：创建
*/
package com.easydozer.commons.util;

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Set;

/**
*
汉字转化为全拼
*

JDK版本:

1.4

* @author 谢计生
* @version 1.0
* @see
* @since 1.0
*/
public class CnToSpell
{
private static LinkedHashMap spellMap = null;

static
{
if(spellMap == null){
spellMap = new LinkedHashMap(400);
}
initialize();
System.out.println("Chinese transfer Spell Done.");
}

private CnToSpell()
{
}

private static void spellPut(String spell,int ascii)
{
spellMap.put(spell,new Integer(ascii));
}

private static void initialize()
{
spellPut("a", -20319);
spellPut("ai", -20317);
spellPut("an", -20304);
spellPut("ang", -20295);
spellPut("ao", -20292);
spellPut("ba", -20283);
spellPut("bai", -20265);
spellPut("ban", -20257);
spellPut("bang", -20242);
spellPut("bao", -20230);
spellPut("bei", -20051);
spellPut("ben", -20036);
spellPut("beng", -20032);
spellPut("bi", -20026);
spellPut("bian", -20002);
spellPut("biao", -19990);
spellPut("bie", -19986);
spellPut("bin", -19982);
spellPut("bing", -19976);
spellPut("bo", -19805);
spellPut("bu", -19784);
spellPut("ca", -19775);
spellPut("cai", -19774);
spellPut("can", -19763);
spellPut("cang", -19756);
spellPut("cao", -19751);
spellPut("ce", -19746);
spellPut("ceng", -19741);
spellPut("cha", -19739);
spellPut("chai", -19728);
spellPut("chan", -19725);
spellPut("chang", -19715);
spellPut("chao", -19540);
spellPut("che", -19531);
spellPut("chen", -19525);
spellPut("cheng", -19515);
spellPut("chi", -19500);
spellPut("chong", -19484);
spellPut("chou", -19479);
spellPut("chu", -19467);
spellPut("chuai", -19289);
spellPut("chuan", -19288);
spellPut("chuang", -19281);
spellPut("chui", -19275);
spellPut("chun", -19270);
spellPut("chuo", -19263);
spellPut("ci", -19261);
spellPut("cong", -19249);
spellPut("cou", -19243);
spellPut("cu", -19242);
spellPut("cuan", -19238);
spellPut("cui", -19235);
spellPut("cun", -19227);
spellPut("cuo", -19224);
spellPut("da", -19218);
spellPut("dai", -19212);
spellPut("dan", -19038);
spellPut("dang", -19023);
spellPut("dao", -19018);
spellPut("de", -19006);
spellPut("deng", -19003);
spellPut("di", -18996);
spellPut("dian", -18977);
spellPut("diao", -18961);
spellPut("die", -18952);
spellPut("ding", -18783);
spellPut("diu", -18774);
spellPut("dong", -18773);
spellPut("dou", -18763);
spellPut("du", -18756);
spellPut("duan", -18741);
spellPut("dui", -18735);
spellPut("dun", -18731);
spellPut("duo", -18722);
spellPut("e", -18710);
spellPut("en", -18697);
spellPut("er", -18696);
spellPut("fa", -18526);
spellPut("fan", -18518);
spellPut("fang", -18501);
spellPut("fei", -18490);
spellPut("fen", -18478);
spellPut("feng", -18463);
spellPut("fo", -18448);
spellPut("fou", -18447);
spellPut("fu", -18446);
spellPut("ga", -18239);
spellPut("gai", -18237);
spellPut("gan", -18231);
spellPut("gang", -18220);
spellPut("gao", -18211);
spellPut("ge", -18201);
spellPut("gei", -18184);
spellPut("gen", -18183);
spellPut("geng", -18181);
spellPut("gong", -18012);
spellPut("gou", -17997);
spellPut("gu", -17988);
spellPut("gua", -17970);
spellPut("guai", -17964);
spellPut("guan", -17961);
spellPut("guang", -17950);
spellPut("gui", -17947);
spellPut("gun", -17931);
spellPut("guo", -17928);
spellPut("ha", -17922);
spellPut("hai", -17759);
spellPut("han", -17752);
spellPut("hang", -17733);
spellPut("hao", -17730);
spellPut("he", -17721);
spellPut("hei", -17703);
spellPut("hen", -17701);
spellPut("heng", -17697);
spellPut("hong", -17692);
spellPut("hou", -17683);
spellPut("hu", -17676);
spellPut("hua", -17496);
spellPut("huai", -17487);
spellPut("huan", -17482);
spellPut("huang", -17468);
spellPut("hui", -17454);
spellPut("hun", -17433);
spellPut("huo", -17427);
spellPut("ji", -17417);
spellPut("jia", -17202);
spellPut("jian", -17185);
spellPut("jiang", -16983);
spellPut("jiao", -16970);
spellPut("jie", -16942);
spellPut("jin", -16915);
spellPut("jing", -16733);
spellPut("jiong", -16708);
spellPut("jiu", -16706);
spellPut("ju", -16689);
spellPut("juan", -16664);
spellPut("jue", -16657);
spellPut("jun", -16647);
spellPut("ka", -16474);
spellPut("kai", -16470);
spellPut("kan", -16465);
spellPut("kang", -16459);
spellPut("kao", -16452);
spellPut("ke", -16448);
spellPut("ken", -16433);
spellPut("keng", -16429);
spellPut("kong", -16427);
spellPut("kou", -16423);
spellPut("ku", -16419);
spellPut("kua", -16412);
spellPut("kuai", -16407);
spellPut("kuan", -16403);
spellPut("kuang", -16401);
spellPut("kui", -16393);
spellPut("kun", -16220);
spellPut("kuo", -16216);
spellPut("la", -16212);
spellPut("lai", -16205);
spellPut("lan", -16202);
spellPut("lang", -16187);
spellPut("lao", -16180);
spellPut("le", -16171);
spellPut("lei", -16169);
spellPut("leng", -16158);
spellPut("li", -16155);
spellPut("lia", -15959);
spellPut("lian", -15958);
spellPut("liang", -15944);
spellPut("liao", -15933);
spellPut("lie", -15920);
spellPut("lin", -15915);
spellPut("ling", -15903);
spellPut("liu", -15889);
spellPut("long", -15878);
spellPut("lou", -15707);
spellPut("lu", -15701);
spellPut("lv", -15681);
spellPut("luan", -15667);
spellPut("lue", -15661);
spellPut("lun", -15659);
spellPut("luo", -15652);
spellPut("ma", -15640);
spellPut("mai", -15631);
spellPut("man", -15625);
spellPut("mang", -15454);
spellPut("mao", -15448);
spellPut("me", -15436);
spellPut("mei", -15435);
spellPut("men", -15419);
spellPut("meng", -15416);
spellPut("mi", -15408);
spellPut("mian", -15394);
spellPut("miao", -15385);
spellPut("mie", -15377);
spellPut("min", -15375);
spellPut("ming", -15369);
spellPut("miu", -15363);
spellPut("mo", -15362);
spellPut("mou", -15183);
spellPut("mu", -15180);
spellPut("na", -15165);
spellPut("nai", -15158);
spellPut("nan", -15153);
spellPut("nang", -15150);
spellPut("nao", -15149);
spellPut("ne", -15144);
spellPut("nei", -15143);
spellPut("nen", -15141);
spellPut("neng", -15140);
spellPut("ni", -15139);
spellPut("nian", -15128);
spellPut("niang", -15121);
spellPut("niao", -15119);
spellPut("nie", -15117);
spellPut("nin", -15110);
spellPut("ning", -15109);
spellPut("niu", -14941);
spellPut("nong", -14937);
spellPut("nu", -14933);
spellPut("nv", -14930);
spellPut("nuan", -14929);
spellPut("nue", -14928);
spellPut("nuo", -14926);
spellPut("o", -14922);
spellPut("ou", -14921);
spellPut("pa", -14914);
spellPut("pai", -14908);
spellPut("pan", -14902);
spellPut("pang", -14894);
spellPut("pao", -14889);
spellPut("pei", -14882);
spellPut("pen", -14873);
spellPut("peng", -14871);
spellPut("pi", -14857);
spellPut("pian", -14678);
spellPut("piao", -14674);
spellPut("pie", -14670);
spellPut("pin", -14668);
spellPut("ping", -14663);
spellPut("po", -14654);
spellPut("pu", -14645);
spellPut("qi", -14630);
spellPut("qia", -14594);
spellPut("qian", -14429);
spellPut("qiang", -14407);
spellPut("qiao", -14399);
spellPut("qie", -14384);
spellPut("qin", -14379);
spellPut("qing", -14368);
spellPut("qiong", -14355);
spellPut("qiu", -14353);
spellPut("qu", -14345);
spellPut("quan", -14170);
spellPut("que", -14159);
spellPut("qun", -14151);
spellPut("ran", -14149);
spellPut("rang", -14145);
spellPut("rao", -14140);
spellPut("re", -14137);
spellPut("ren", -14135);
spellPut("reng", -14125);
spellPut("ri", -14123);
spellPut("rong", -14122);
spellPut("rou", -14112);
spellPut("ru", -14109);
spellPut("ruan", -14099);
spellPut("rui", -14097);
spellPut("run", -14094);
spellPut("ruo", -14092);
spellPut("sa", -14090);
spellPut("sai", -14087);
spellPut("san", -14083);
spellPut("sang", -13917);
spellPut("sao", -13914);
spellPut("se", -13910);
spellPut("sen", -13907);
spellPut("seng", -13906);
spellPut("sha", -13905);
spellPut("shai", -13896);
spellPut("shan", -13894);
spellPut("shang", -13878);
spellPut("shao", -13870);
spellPut("she", -13859);
spellPut("shen", -13847);
spellPut("sheng", -13831);
spellPut("shi", -13658);
spellPut("shou", -13611);
spellPut("shu", -13601);
spellPut("shua", -13406);
spellPut("shuai", -13404);
spellPut("shuan", -13400);
spellPut("shuang", -13398);
spellPut("shui", -13395);
spellPut("shun", -13391);
spellPut("shuo", -13387);
spellPut("si", -13383);
spellPut("song", -13367);
spellPut("sou", -13359);
spellPut("su", -13356);
spellPut("suan", -13343);
spellPut("sui", -13340);
spellPut("sun", -13329);
spellPut("suo", -13326);
spellPut("ta", -13318);
spellPut("tai", -13147);
spellPut("tan", -13138);
spellPut("tang", -13120);
spellPut("tao", -13107);
spellPut("te", -13096);
spellPut("teng", -13095);
spellPut("ti", -13091);
spellPut("tian", -13076);
spellPut("tiao", -13068);
spellPut("tie", -13063);
spellPut("ting", -13060);
spellPut("tong", -12888);
spellPut("tou", -12875);
spellPut("tu", -12871);
spellPut("tuan", -12860);
spellPut("tui", -12858);
spellPut("tun", -12852);
spellPut("tuo", -12849);
spellPut("wa", -12838);
spellPut("wai", -12831);
spellPut("wan", -12829);
spellPut("wang", -12812);
spellPut("wei", -12802);
spellPut("wen", -12607);
spellPut("weng", -12597);
spellPut("wo", -12594);
spellPut("wu", -12585);
spellPut("xi", -12556);
spellPut("xia", -12359);
spellPut("xian", -12346);
spellPut("xiang", -12320);
spellPut("xiao", -12300);
spellPut("xie", -12120);
spellPut("xin", -12099);
spellPut("xing", -12089);
spellPut("xiong", -12074);
spellPut("xiu", -12067);
spellPut("xu", -12058);
spellPut("xuan", -12039);
spellPut("xue", -11867);
spellPut("xun", -11861);
spellPut("ya", -11847);
spellPut("yan", -11831);
spellPut("yang", -11798);
spellPut("yao", -11781);
spellPut("ye", -11604);
spellPut("yi", -11589);
spellPut("yin", -11536);
spellPut("ying", -11358);
spellPut("yo", -11340);
spellPut("yong", -11339);
spellPut("you", -11324);
spellPut("yu", -11303);
spellPut("yuan", -11097);
spellPut("yue", -11077);
spellPut("yun", -11067);
spellPut("za", -11055);
spellPut("zai", -11052);
spellPut("zan", -11045);
spellPut("zang", -11041);
spellPut("zao", -11038);
spellPut("ze", -11024);
spellPut("zei", -11020);
spellPut("zen", -11019);
spellPut("zeng", -11018);
spellPut("zha", -11014);
spellPut("zhai", -10838);
spellPut("zhan", -10832);
spellPut("zhang", -10815);
spellPut("zhao", -10800);
spellPut("zhe", -10790);
spellPut("zhen", -10780);
spellPut("zheng", -10764);
spellPut("zhi", -10587);
spellPut("zhong", -10544);
spellPut("zhou", -10533);
spellPut("zhu", -10519);
spellPut("zhua", -10331);
spellPut("zhuai", -10329);
spellPut("zhuan", -10328);
spellPut("zhuang", -10322);
spellPut("zhui", -10315);
spellPut("zhun", -10309);
spellPut("zhuo", -10307);
spellPut("zi", -10296);
spellPut("zong", -10281);
spellPut("zou", -10274);
spellPut("zu", -10270);
spellPut("zuan", -10262);
spellPut("zui", -10260);
spellPut("zun", -10256);
spellPut("zuo", -10254);
}

/**
* 获得单个汉字的Ascii.
* @param cn char
* 汉字字符
* @return int
* 错误返回 0,否则返回ascii
*/
public static int getCnAscii(char cn)
{
byte[] bytes = (String.valueOf(cn)).getBytes();
if(bytes == null || bytes.length > 2 || bytes.length <= 0){ //错误
return 0;
}
if(bytes.length == 1){ //英文字符
return bytes[0];
}
if(bytes.length == 2){ //中文字符
int hightByte = 256 + bytes[0];
int lowByte = 256 + bytes[1];

int ascii = (256 * hightByte + lowByte) - 256 * 256;

//System.out.println("ASCII=" + ascii);

return ascii;
}

return 0; //错误
}

/**
* 根据ASCII码到SpellMap中查找对应的拼音
* @param ascii int
* 字符对应的ASCII
* @return String
* 拼音,首先判断ASCII是否>0&<160,如果是返回对应的字符,
*
否则到SpellMap中查找,如果没有找到拼音,则返回null,如果找到则返回拼音.
*/
public static String getSpellByAscii(int ascii)
{
if(ascii > 0 && ascii < 160){ //单字符
return String.valueOf((char)ascii);
}

if(ascii < -20319 || ascii > -10247){ //不知道的字符
return null;
}

Set keySet = spellMap.keySet();
Iterator it = keySet.iterator();

String spell0 = null;;
String spell = null;

int asciiRang0 = -20319;
int asciiRang;
while(it.hasNext()){

spell = (String)it.next();
Object valObj = spellMap.get(spell);
if(valObj instanceof Integer){
asciiRang = ((Integer)valObj).intValue();

if(ascii >= asciiRang0 && ascii < asciiRang){ //区间找到
return(spell0 == null) ? spell : spell0;
}
else{
spell0 = spell;
asciiRang0 = asciiRang;
}
}
}

return null;

}

/**
* 返回字符串的全拼,是汉字转化为全拼,其它字符不进行转换
* @param cnStr String
* 字符串
* @return String
* 转换成全拼后的字符串
*/
public static String getFullSpell(String cnStr)
{
if(null == cnStr || "".equals(cnStr.trim())){
return cnStr;
}

char[] chars = cnStr.toCharArray();
StringBuffer retuBuf = new StringBuffer();
for(int i = 0,Len = chars.length;i < Len;i++){
int ascii = getCnAscii(chars[i]);
if(ascii == 0){ //取ascii时出错
retuBuf.append(chars[i]);
}
else{
String spell = getSpellByAscii(ascii);
if(spell == null){
retuBuf.append(chars[i]);
}
else{
retuBuf.append(spell);
} // end of if spell == null
} // end of if ascii <= -20400
} // end of for

return retuBuf.toString();
}

public static String getFirstSpell(String cnStr)
{
return null;
}

public static void main(String[] args)
{
String str = null;
str = "谢海101普降喜雨";
System.out.println("Spell=" + CnToSpell.getFullSpell(str));

str = "张牙舞爪》。，";
System.out.println("Spell=" + CnToSpell.getFullSpell(str));

str = "李鹏，可耻下场。";
System.out.println("Spell=" + CnToSpell.getFullSpell(str));

str = "猪油，猪八戒。";
System.out.println("Spell=" + CnToSpell.getFullSpell(str));
}
}