JAVA规则引擎简化代码,java代码设计原则

那位高手能把下面的java程序代码简化一下：

要化简最多就是把循环改写成一个递归方法,但是递归逻辑难以理解,运算速度又慢,不推荐

创新互联公司专注于企业全网整合营销推广、网站重做改版、临沭网站定制设计、自适应品牌网站建设、HTML5、商城网站建设、集团公司官网建设、成都外贸网站建设公司、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为临沭等各大城市提供网站开发制作服务。

另外如果把两题全部打印出来,估计一台微机能跑个几分钟,楼主确定真的想测试一下吗

Java规则引擎如何集成

Java 规则引擎是一种嵌入在 Java 程序中的组件，它的任务是把当前提交给引擎的 Java 数据对象 ( 原料 ) 与加载在引擎中的业务规则（ app ）进行测试和比对，激活那些符合当前数据状态下的业务规则，根据业务规则中声明的执行逻辑，触发应用程序中对应的操作。

引言：

目前， Java 社区推动并发展了一种引人注目的新技术 ——Java 规则引擎（ Rule Engine ）。利用它就可以在应用系统中分离商业决策者的商业决策逻辑和应用开发者的技术决策，并把这些商业决策放在中心数据库或其他统一的地方，让它们能在运行时可以动态地管理和修改，从而为企业保持灵活性和竞争力提供有效的技术支持。

规则引擎的原理

1 、基于规则的专家系统（ RBES ）简介

Java 规则引擎起源于基于规则的专家系统，而基于规则的专家系统又是专家系统的其中一个分支。专家系统属于人工智能的范畴，它模仿人类的推理方式，使用试探性的方法进行推理，并使用人类能理解的术语解释和证明它的推理结论。为了更深入地了解 Java 规则引擎，下面简要地介绍基于规则的专家系统。 RBES 包括三部分：Rule Base （ knowledge base ）、 Working Memory （ fact base ）和 Inference Engine 。它们的结构如下系统所示：

图 1 基于规则的专家系统构成

如图 1 所示，推理引擎包括三部分：模式匹配器（ Pattern Matcher ）、议程（ Agenda ）和执行引擎（Execution Engine ）。推理引擎通过决定哪些规则满足事实或目标，并授予规则优先级，满足事实或目标的规则被加入议程。模式匹配器决定选择执行哪个规则，何时执行规则；议程管理模式匹配器挑选出来的规则的执行次序；执行引擎负责执行规则和其他动作。

和人类的思维相对应，推理引擎存在两者推理方式：演绎法（ Forward-Chaining ）和归纳法（ Backward-Chaining ）。演绎法从一个初始的事实出发，不断地应用规则得出结论（或执行指定的动作）。而归纳法则是根据假设，不断地寻找符合假设的事实。 Rete 算法是目前效率最高的一个 Forward-Chaining 推理算法，许多 Java 规则引擎都是基于 Rete 算法来进行推理计算的。

推理引擎的推理步骤如下：

(1) 将初始数据（ fact ）输入 Working Memory 。

(2) 使用 PatternMatcher 比较规则库（ rule base ）中的规则（ rule ）和数据（ fact ）。

(3) 如果执行规则存在冲突（ conflict ），即同时激活了多个规则，将冲突的规则放入冲突集合。

(4) 解决冲突，将激活的规则按顺序放入 Agenda 。

(5) 使用执行引擎执行 Agenda 中的规则。重复步骤 2 至 5 ，直到执行完毕所有 Agenda 中的规则。

上述即是规则引擎的原始架构， Java 规则引擎就是从这一原始架构演变而来的。

2 、规则引擎相关构件

规则引擎是一种根据规则中包含的指定过滤条件，判断其能否匹配运行时刻的实时条件来执行规则中所规定的动作的引擎。与规则引擎相关的有四个基本概念，为更好地理解规则引擎的工作原理，下面将对这些概念进行逐一介绍。

1) 信息元（ InformationUnit ）

信息元是规则引擎的基本建筑块，它是一个包含了特定事件的所有信息的对象。这些信息包括：消息、产生事件的应用程序标识、事件产生事件、信息元类型、相关规则集、通用方法、通用属性以及一些系统相关信息等等。

2) 信息服务（ InformationServices ）

信息服务产生信息元对象。每个信息服务产生它自己类型相对应的信息元对象。即特定信息服务根据信息元所产生每个信息元对象有相同的格式，但可以有不同的属性和规则集。需要注意的是，在一台机器上可以运行许多不同的信息服务，还可以运行同一信息服务的不同实例。但无论如何，每个信息服务只产生它自己类型相对应的信息元。

3) 规则集（ Rule Set ）

顾名思义，规则集就是许多规则的集合。每条规则包 含一个条件过滤器 和多个动作 。一个条件过滤器可以包含多个过滤条件。条件过滤器是多个布尔表达式的组合，其组合结果仍然是一个布尔类型的。在程序运行时， 动作将会在条件过滤器值为 true 的情况下执行。除了一般的执行动作，还有三类比较特别的动作，它们分别是：放弃动作（ Discard Action ）、包含动作（ Include Action ）和使信息元对象内容持久化的动作。前两种动作类型的区别将在 2.3 规则引擎工作机制小节介绍。

4) 队列管理器（ QueueManager ）

队列管理器用来管理来自不同信息服务的信息元对象的队列。

下面将研究规则引擎的这些相关构件是如何协同工作的。

如图 2 所示，处理过程分为四个阶段进行：信息服务接受事件并将其转化为信息元，然后这些信息元被传给队列管理器，最后规则引擎接收这些信息元并应用它们自身携带的规则加以执行，直到队列管理器中不再有信息元。

图 2 处理过程协作图

3 、规则引擎的工作机制

下面专门研究规则引擎的内部处理过程。如图 3 所示，规则引擎从队列管理器中依次接收信息元，然后依规则的定义顺序检查信息元所带规则集中的规则（规则已经排队就绪等待信息元的到来）。如图所示，规则引擎检查第一个规则并对其条件过滤器求值，如果值为假，所有与此规则相关的动作皆被忽略并继续执行下一条规则。如果第二条规则的过滤器值为真，所有与此规则相关的动作皆依定义顺序执行，执行完毕继续下一条规则。该信息元中的所有规则执行完毕后，信息元将被销毁 ，然后从队列管理器接收下一个信息元。在这个过程中并未考虑两个特殊动作：放弃动作（ Discard Action ）和包含动作（ Include Action ）。放弃动作如果被执行，将会跳过其所在信息元中接下来的所有规则，并销毁所在信息元，规则引擎继续接收队列管理器中的下一个信息元 ( 就是短路了 ) 。包含动作其实就是动作中包含其它现存规则集的动作。包含动作如果被执行，规则引擎将暂停并进入被包含的规则集，执行完毕后，规则引擎还会返回原来暂停的地方继续执行。这一过程将递归进行。

图 3 规则引擎工作机制

Java 规则引擎的工作机制与上述规则引擎机制十分类似，只不过对上述概念进行了重新包装组合。 Java 规则引擎对提交给引擎的 Java 数据对象进行检索，根据这些对象的当前属性值和它们之间的关系，从加载到引擎的规则集中发现符合条件的规则，创建这些规则的执行实例。这些实例将在引擎接到执行指令时、依照某种优先序依次执行。一般来讲， Java 规则引擎内部由下面几个部分构成：

工作内存（ Working Memory ）即工作区，用于存放被引擎引用的数据对象集合；

规则执行队列，用于存放被激活的规则执行实例 ;

静态规则区，用于存放所有被加载的业务规则，这些规则将按照某种数据结构组织，

当工作区中的数据发生改变后，引擎需要迅速根据工作区中的对象现状，调整规则执行队列中的规则执行实例。Java 规则引擎的结构示意图如图 4 所示。

图 4 Java 规则引擎工作机制

当引擎执行时，会根据规则执行队列中的优先顺序逐条执行规则执行实例，由于规则的执行部分可能会改变工作区的数据对象，从而会使队列中的某些规则执行实例因为条件改变而失效，必须从队列中撤销，也可能会激活原来不满足条件的规则，生成新的规则执行实例进入队列。于是就产生了一种 “ 动态 ” 的规则执行链，形成规则的推理机制。这种规则的 “ 链式 ” 反应完全是由工作区中的数据驱动的。

任何一个规则引擎都需要很好地解决规则的推理机制 和规则条件匹配的效率问题 。规则条件匹配的效率决定了引擎的性能，引擎需要迅速测试工作区中的数据对象，从加载的规则集中发现符合条件的规则，生成规则执行实例。1982 年美国卡耐基 • 梅隆大学的 Charles L. Forgy 发明了一种叫 Rete 算法，很好地解决了这方面的问题。目前世界顶尖的商用业务规则引擎产品基本上都使用 Rete 算法。

详解什么是Java规则引擎

Java规则引擎API(JSR-94)允许客户程序使用统一的方式和不同厂商的规则引擎产品交互，一定程度上给规则引擎厂商提供了标准化规范。但其几乎没有定义什么是规则引擎，当然也没有深入到规则是如何构建和操纵的，规则调用的效用，规则与Java语言的绑定等方面。并且JSR-94在对J2EE的支持上也不足。规则语言的标准化，JSR-94的进一步的充实深化都有待研究。

Java代码优化有哪些常用的方法

1、 尽量指定类的final修饰符 带有final修饰符的类是不可派生的。

在Java核心API中，有许多应用final的例子，例如java.lang.String。为String类指定final防止了人们覆盖length()方法。另外，如果指定一个类为final，则该类所有的方法都是final。Java编译器会寻找机会内联（inline）所有的final方法（这和具体的编译器实现有关）。此举能够使性能平均提高50% 。

2、 尽量重用对象。

特别是String 对象的使用中，出现字符串连接情况时应用StringBuffer 代替。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响。

3、 尽量使用局部变量，调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。

其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。另外，依赖于具体的编译器/JVM，局部变量还可能得到进一步优化。请参见《尽可能使用堆栈变量》。

4、 不要重复初始化变量

默认情况下，调用类的构造函数时， Java会把变量初始化成确定的值：所有的对象被设置成null，整数变量（byte、short、int、long）设置成0，float和double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键词创建一个对象时，构造函数链中的所有构造函数都会被自动调用。

5、 在JAVA + ORACLE 的应用系统开发中，java中内嵌的SQL语句尽量使用大写的形式，以减轻ORACLE解析器的解析负担。

6、 Java 编程过程中，进行数据库连接、I/O流操作时务必小心，在使用完毕后，即使关闭以释放资源。

因为对这些大对象的操作会造成系统大的开销，稍有不慎，会导致严重的后果。

7、 由于JVM的有其自身的GC机制，不需要程序开发者的过多考虑，从一定程度上减轻了开发者负担，但同时也遗漏了隐患，过分的创建对象会消耗系统的大量内存，严重时会导致内存泄露，因此，保证过期对象的及时回收具有重要意义。

JVM回收垃圾的条件是：对象不在被引用；然而，JVM的GC并非十分的机智，即使对象满足了垃圾回收的条件也不一定会被立即回收。所以，建议我们在对象使用完毕，应手动置成null。

8、 在使用同步机制时，应尽量使用方法同步代替代码块同步。

9、 尽量减少对变量的重复计算

例如：for(int i = 0;i list.size; i ++) {

…

}

应替换为：

for(int i = 0,int len = list.size();i len; i ++){

…

}

10、尽量采用lazy loading 的策略，即在需要的时候才开始创建。

例如： String str = “aaa”;

if(i == 1) {

list.add(str);

}

应替换为：

if(i == 1) {

String str = “aaa”;

list.add(str);

}

11、慎用异常

异常对性能不利。抛出异常首先要创建一个新的对象。Throwable接口的构造函数调用名为fillInStackTrace()的本地（Native）方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。只要有异常被抛出，VM就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。 异常只能用于错误处理，不应该用来控制程序流程。

12、不要在循环中使用：

Try {

} catch() {

}

应把其放置在最外层。

13、StringBuffer 的使用：

StringBuffer表示了可变的、可写的字符串。

有三个构造方法 :

StringBuffer (); //默认分配16个字符的空间

StringBuffer (int size); //分配size个字符的空间

StringBuffer (String str); //分配16个字符+str.length()个字符空间

你可以通过StringBuffer的构造函数来设定它的初始化容量，这样可以明显地提升性能。

这里提到的构造函数是StringBuffer(int length)，length参数表示当前的StringBuffer能保持的字符数量。你也可以使用ensureCapacity(int minimumcapacity)方法在StringBuffer对象创建之后设置它的容量。首先我们看看StringBuffer的缺省行为，然后再找出一条更好的提升性能的途径。

StringBuffer在内部维护一个字符数组，当你使用缺省的构造函数来创建StringBuffer对象的时候，因为没有设置初始化字符长度，StringBuffer的容量被初始化为16个字符，也就是说缺省容量就是16个字符。当StringBuffer达到最大容量的时候，它会将自身容量增加到当前的2倍再加2，也就是（2*旧值+2）。如果你使用缺省值，初始化之后接着往里面追加字符，在你追加到第16个字符的时候它会将容量增加到34（2*16+2），当追加到34个字符的时候就会将容量增加到70（2*34+2）。无论何事只要StringBuffer到达它的最大容量它就不得不创建一个新的字符数组然后重新将旧字符和新字符都拷贝一遍――这也太昂贵了点。所以总是给StringBuffer设置一个合理的初始化容量值是错不了的，这样会带来立竿见影的性能增益。StringBuffer初始化过程的调整的作用由此可见一斑。所以，使用一个合适的容量值来初始化StringBuffer永远都是一个最佳的建议。

14、合理的使用Java类 java.util.Vector。

简单地说，一个Vector就是一个java.lang.Object实例的数组。Vector与数组相似，它的元素可以通过整数形式的索引访问。但是，Vector类型的对象在创建之后，对象的大小能够根据元素的增加或者删除而扩展、缩小。请考虑下面这个向Vector加入元素的例子：

Object bj = new Object();

Vector v = new Vector(100000);

for(int I=0;

I100000; I++) { v.add(0,obj); }

除非有绝对充足的理由要求每次都把新元素插入到Vector的前面，否则上面的代码对性能不利。在默认构造函数中，Vector的初始存储能力是10个元素，如果新元素加入时存储能力不足，则以后存储能力每次加倍。Vector类就对象StringBuffer类一样，每次扩展存储能力时，所有现有的元素都要复制到新的存储空间之中。下面的代码片段要比前面的例子快几个数量级：

Object bj = new Object();

Vector v = new Vector(100000);

for(int I=0; I100000; I++) { v.add(obj); }

同样的规则也适用于Vector类的remove()方法。由于Vector中各个元素之间不能含有“空隙”，删除除最后一个元素之外的任意其他元素都导致被删除元素之后的元素向前移动。也就是说，从Vector删除最后一个元素要比删除第一个元素“开销”低好几倍。

假设要从前面的Vector删除所有元素，我们可以使用这种代码：

for(int I=0; I100000; I++)

{

v.remove(0);

}

但是，与下面的代码相比，前面的代码要慢几个数量级：

for(int I=0; I100000; I++)

{

v.remove(v.size()-1);

}

从Vector类型的对象v删除所有元素的最好方法是：

v.removeAllElements();

假设Vector类型的对象v包含字符串“Hello”。考虑下面的代码，它要从这个Vector中删除“Hello”字符串：

String s = "Hello";

int i = v.indexOf(s);

if(I != -1) v.remove(s);

这些代码看起来没什么错误，但它同样对性能不利。在这段代码中，indexOf()方法对v进行顺序搜索寻找字符串“Hello”，remove(s)方法也要进行同样的顺序搜索。改进之后的版本是：

String s = "Hello";

int i = v.indexOf(s);

if(I != -1) v.remove(i);

这个版本中我们直接在remove()方法中给出待删除元素的精确索引位置，从而避免了第二次搜索。一个更好的版本是：

String s = "Hello"; v.remove(s);

最后，我们再来看一个有关Vector类的代码片段：

for(int I=0; I++;I v.length)

如果v包含100,000个元素，这个代码片段将调用v.size()方法100,000次。虽然size方法是一个简单的方法，但它仍旧需要一次方法调用的开销，至少JVM需要为它配置以及清除堆栈环境。在这里，for循环内部的代码不会以任何方式修改Vector类型对象v的大小，因此上面的代码最好改写成下面这种形式：

int size = v.size(); for(int I=0; I++;Isize)

虽然这是一个简单的改动，但它仍旧赢得了性能。毕竟，每一个CPU周期都是宝贵的。

15、当复制大量数据时，使用System.arraycopy()命令。

int[] src={1,3,5,6,7,8};

int[] dest = new int[6];

System.arraycopy(src, 0, dest, 0, 6);

src:源数组; srcPos:源数组要复制的起始位置;

dest:目的数组; destPos:目的数组放置的起始位置;

length:复制的长度.

注意：src and dest都必须是同类型或者可以进行转换类型的数组．

16、代码重构：增强代码的可读性。

public class ShopCart {

private List carts ;

…

public void add (Object item) {

if(carts == null) {

carts = new ArrayList();

}

crts.add(item);

}

public void remove(Object item) {

if(carts. contains(item)) {

carts.remove(item);

}

}

public List getCarts() {

//返回只读列表

return Collections.unmodifiableList(carts);

}

//不推荐这种方式

//this.getCarts().add(item);

}

17、不用new关键词创建类的实例

用new关键词创建类的实例时，构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口，我们可以调用它的clone()方法。clone()方法不会调用任何类构造函数。

在使用设计模式（Design Pattern）的场合，如果用Factory模式创建对象，则改用clone()方法创建新的对象实例非常简单。例如，下面是Factory模式的一个典型实现：

public static Credit getNewCredit() {

return new Credit();

}

改进后的代码使用clone()方法，如下所示：

private static Credit BaseCredit = new Credit();

public static Credit getNewCredit() {

return (Credit) BaseCredit.clone();

}

上面的思路对于数组处理同样很有用。

18、乘法和除法

考虑下面的代码：

for (val = 0; val 100000; val +=5) {

alterX = val * 8; myResult = val * 2;

}

用移位操作替代乘法操作可以极大地提高性能。下面是修改后的代码：

for (val = 0; val 100000; val += 5) {

alterX = val 3; myResult = val 1;

}

修改后的代码不再做乘以8的操作，而是改用等价的左移3位操作，每左移1位相当于乘以2。相应地，右移1位操作相当于除以2。值得一提的是，虽然移位操作速度快，但可能使代码比较难于理解，所以最好加上一些注释。

19、在JSP页面中关闭无用的会话。

一个常见的误解是以为session在有客户端访问时就被创建，然而事实是直到某server端程序调用HttpServletRequest.getSession(true)这样的语句时才被创建，注意如果JSP没有显示的使用 关闭session，则JSP文件在编译成Servlet时将会自动加上这样一条语句HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。由于session会消耗内存资源，因此，如果不打算使用session，应该在所有的JSP中关闭它。

对于那些无需跟踪会话状态的页面，关闭自动创建的会话可以节省一些资源。使用如下page指令：%@ page session="false"%

20、JDBC与I/O

如果应用程序需要访问一个规模很大的数据集，则应当考虑使用块提取方式。默认情况下，JDBC每次提取32行数据。举例来说，假设我们要遍历一个5000行的记录集，JDBC必须调用数据库157次才能提取到全部数据。如果把块大小改成512，则调用数据库的次数将减少到10次。

21、Servlet与内存使用

许多开发者随意地把大量信息保存到用户会话之中。一些时候，保存在会话中的对象没有及时地被垃圾回收机制回收。从性能上看，典型的症状是用户感到系统周期性地变慢，却又不能把原因归于任何一个具体的组件。如果监视JVM的堆空间，它的表现是内存占用不正常地大起大落。

解决这类内存问题主要有二种办法。第一种办法是，在所有作用范围为会话的Bean中实现HttpSessionBindingListener接口。这样，只要实现valueUnbound()方法，就可以显式地释放Bean使用的资源。

另外一种办法就是尽快地把会话作废。大多数应用服务器都有设置会话作废间隔时间的选项。另外，也可以用编程的方式调用会话的setMaxInactiveInterval()方法，该方法用来设定在作废会话之前，Servlet容器允许的客户请求的最大间隔时间，以秒计。

22、使用缓冲标记

一些应用服务器加入了面向JSP的缓冲标记功能。例如，BEA的WebLogic Server从6.0版本开始支持这个功能，Open Symphony工程也同样支持这个功能。JSP缓冲标记既能够缓冲页面片断，也能够缓冲整个页面。当JSP页面执行时，如果目标片断已经在缓冲之中，则生成该片断的代码就不用再执行。页面级缓冲捕获对指定URL的请求，并缓冲整个结果页面。对于购物篮、目录以及门户网站的主页来说，这个功能极其有用。对于这类应用，页面级缓冲能够保存页面执行的结果，供后继请求使用。

23、选择合适的引用机制

在典型的JSP应用系统中，页头、页脚部分往往被抽取出来，然后根据需要引入页头、页脚。当前，在JSP页面中引入外部资源的方法主要有两种：include指令，以及include动作。

include指令：例如%@ include file="copyright.html" %。该指令在编译时引入指定的资源。在编译之前，带有include指令的页面和指定的资源被合并成一个文件。被引用的外部资源在编译时就确定，比运行时才确定资源更高效。

include动作：例如jsp:include page="copyright.jsp" /。该动作引入指定页面执行后生成的结果。由于它在运行时完成，因此对输出结果的控制更加灵活。但时，只有当被引用的内容频繁地改变时，或者在对主页面的请求没有出现之前，被引用的页面无法确定时，使用include动作才合算。

24、及时清除不再需要的会话

为了清除不再活动的会话，许多应用服务器都有默认的会话超时时间，一般为30分钟。当应用服务器需要保存更多会话时，如果内存容量不足，操作系统会把部分内存数据转移到磁盘，应用服务器也可能根据“最近最频繁使用”（Most Recently Used）算法把部分不活跃的会话转储到磁盘，甚至可能抛出“内存不足”异常。在大规模系统中，串行化会话的代价是很昂贵的。当会话不再需要时，应当及时调用HttpSession.invalidate()方法清除会话。HttpSession.invalidate()方法通常可以在应用的退出页面调用。

25、不要将数组声明为：public static final 。

26、HashMap的遍历效率讨论

经常遇到对HashMap中的key和value值对的遍历操作，有如下两种方法：

MapString, String[] paraMap = new HashMapString, String[]();

//第一个循环

SetString appFieldDefIds = paraMap.keySet();

for (String appFieldDefId : appFieldDefIds) {

String[] values = paraMap.get(appFieldDefId);

......

}

//第二个循环

for(EntryString, String[] entry : paraMap.entrySet()){

String appFieldDefId = entry.getKey();

String[] values = entry.getValue();

.......

}

第一种实现明显的效率不如第二种实现。

分析如下 SetString appFieldDefIds = paraMap.keySet(); 是先从HashMap中取得keySet

代码如下：

public SetK keySet() {

SetK ks = keySet;

return (ks != null ? ks : (keySet = new KeySet()));

}

private class KeySet extends AbstractSetK {

public IteratorK iterator() {

return newKeyIterator();

}

public int size() {

return size;

}

public boolean contains(Object o) {

return containsKey(o);

}

public boolean remove(Object o) {

return HashMap.this.removeEntryForKey(o) != null;

}

public void clear() {

HashMap.this.clear();

}

}

其实就是返回一个私有类KeySet, 它是从AbstractSet继承而来，实现了Set接口。

再来看看for/in循环的语法

for(declaration : expression)

statement

在执行阶段被翻译成如下各式

for(IteratorE #i = (expression).iterator(); #i.hashNext();){

declaration = #i.next();

statement

}

因此在第一个for语句for (String appFieldDefId : appFieldDefIds) 中调用了HashMap.keySet().iterator()

而这个方法调用了newKeyIterator()

IteratorK newKeyIterator() {

return new KeyIterator();

}

private class KeyIterator extends HashIteratorK {

public K next() {

return nextEntry().getKey();

}

}

所以在for中还是调用了

在第二个循环for(EntryString, String[] entry : paraMap.entrySet())中使用的Iterator是如下的一个内部

类

private class EntryIterator extends HashIteratorMap.EntryK,V {

public Map.EntryK,V next() {

return nextEntry();

}

}

此时第一个循环得到key，第二个循环得到HashMap的Entry效率就是从循环里面体现出来的第二个循环此致可以直接取key和value值而第一个循环还是得再利用HashMap的get(Object key)来取value值现在看看HashMap的get(Object key)方法

public V get(Object key) {

Object k = maskNull(key);

int hash = hash(k);

int i = indexFor(hash, table.length); //Entry[] table

EntryK,V e = table;

while (true) {

if (e == null)

return null;

if (e.hash == hash eq(k, e.key))

return e.value;

e = e.next;

}

}

其实就是再次利用Hash值取出相应的Entry做比较得到结果，所以使用第一中循环相当于两次进入HashMap的Entry

中而第二个循环取得Entry的值之后直接取key和value，效率比第一个循环高。其实按照Map的概念来看也应该是用第二个循环好一点，它本来就是key和value的值对，将key和value分开操作在这里不是个好选择。

27、array(数组) 和 ArryList的使用

array（[]）：最高效；但是其容量固定且无法动态改变；

ArrayList：容量可动态增长；但牺牲效率；

基于效率和类型检验，应尽可能使用array，无法确定数组大小时才使用ArrayList！

ArrayList是Array的复杂版本

ArrayList内部封装了一个Object类型的数组，从一般的意义来说，它和数组没有本质的差别，甚至于ArrayList的许多方法，如Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。

ArrayList存入对象时，抛弃类型信息，所有对象屏蔽为Object，编译时不检查类型，但是运行时会报错。

注：jdk5中加入了对泛型的支持，已经可以在使用ArrayList时进行类型检查。

从这一点上看来，ArrayList与数组的区别主要就是由于动态增容的效率问题了

28、尽量使用HashMap 和ArrayList ,除非必要，否则不推荐使用HashTable和Vector ，后者由于使用同步机制，而导致了性能的开销。

29、StringBuffer 和StringBuilder的区别：

java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。

StringBuilder。与该类相比，通常应该优先使用 java.lang.StringBuilder类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。为了获得更好的性能，在构造 StirngBuffer 或 StirngBuilder 时应尽可能指定它的容量。当然，如果你操作的字符串长度不超过 16 个字符就不用了。 相同情况下使用 StirngBuilder 相比使用 StringBuffer 仅能获得 10%-15% 左右的性能提升，但却要冒多线程不安全的风险。而在现实的模块化编程中，负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行，因此：除非你能确定你的系统的瓶颈是在 StringBuffer 上，并且确定你的模块不会运行在多线程模式下，否则还是用 StringBuffer 吧。

30、尽量避免使用split

除非是必须的，否则应该避免使用split，split由于支持正则表达式，所以效率比较低，如果是频繁的几十，几百万的调用将会耗费大量资源，如果确实需要频繁的调用split，可以考虑使用apache的 StringUtils.split(string,char)，频繁split的可以缓存结果。

其他补充:

1、及时清除不再使用的对象，设为null

2、尽可能使用final,static等关键字

3、尽可能使用buffered对象

如何优化代码使JAVA源文件及编译后CLASS文件更小

1 尽量使用继承，继承的方法越多，你要写的代码量也就越少

2 打开JAVA编译器的优化选项： javac -O 这个选项将删除掉CLASS文件中的行号，并能把

一些private, static,final的小段方法申明为inline方法调用

3 把公用的代码提取出来

4 不要初始化很大的数组，尽管初始化一个数组在JAVA代码中只是一行的代码量，但

编译后的代码是一行代码插入一个数组的元素，所以如果你有大量的数据需要存在数组

中的话，可以先把这些数据放在String中，然后在运行期把字符串解析到数组中

5 日期类型的对象会占用很大的空间，如果你要存储大量的日期对象，可以考虑把它存储为

long型，然后在使用的时候转换为Date类型

6 类名，方法名和变量名尽量使用简短的名字，可以考虑使用Hashjava, Jobe, Obfuscate and Jshrink等工具自动完成这个工作

7 将static final类型的变量定义到Interface中去

8 算术运算 能用左移/右移的运算就不要用*和/运算，相同的运算不要运算多次

2. 不要两次初始化变量

Java通过调用独特的类构造器默认地初始化变量为一个已知的值。所有的对象被设置成null，integers (byte, short, int, long)被设置成0，float和double设置成0.0，Boolean变量设置成false。这对那些扩展自其它类的类尤其重要，这跟使用一个新的关键词创建一个对象时所有一连串的构造器被自动调用一样。

3. 在任何可能的地方让类为Final

标记为final的类不能被扩展。在《核心Java API》中有大量这个技术的例子，诸如java.lang.String。将String类标记为final阻止了开发者创建他们自己实现的长度方法。

更深入点说，如果类是final的，所有类的方法也是final的。Java编译器可能会内联所有的方法（这依赖于编译器的实现）。在我的测试里，我已经看到性能平均增加了50%。

9. 异常在需要抛出的地方抛出，try catch能整合就整合

try {

some.method1(); // Difficult for javac

} catch( method1Exception e ) { // and the JVM runtime

// Handle exception 1 // to optimize this

} // code

try {

some.method2();

} catch( method2Exception e ) {

// Handle exception 2

}

try {

some.method3();

} catch( method3Exception e ) {

// Handle exception 3

}

已下代码 更容易被编译器优化

try {

some.method1(); // Easier to optimize

some.method2();

some.method3();

} catch( method1Exception e ) {

// Handle exception 1

} catch( method2Exception e ) {

// Handle exception 2

} catch( method3Exception e ) {

// Handle exception 3

}

10. For循环的优化

Replace…

for( int i = 0; i collection.size(); i++ ) {

...

}

with…

for( int i = 0, n = collection.size(); i n; i++ ) {

...

}

5、 在JAVA + ORACLE 的应用系统开发中，java中内嵌的SQL语句尽量使用大写的形式，以减轻ORACLE解析器的解析负担。

10、尽量采用lazy loading 的策略，即在需要的时候才开始创建。

例如： String str = “aaa”;

if(i == 1) {

list.add(str);

}

应替换为：

if(i == 1) {

String str = “aaa”;

list.add(str);

}

12、不要在循环中使用：

Try {

} catch() {

}

应把其放置在最外层

java规则引擎---Jess

该尔杰斯开发环境（ JessDE ）提供的一套插件为流行的开源的IDE Eclipse的;特别是，这些都是Eclipse的插件版本为3.1或更高版本。请注意，只有JessDE作品的充分“的Eclipse SDK的” -规模较小的“平台运行二进制”是不够的。

要安装JessDE ，只需退出Eclipse的，解压缩所有文件Jess71p2/eclipse进入最高级别的Eclipse的安装目录。确认目录命名为“ plugins/gov.sandia.jess_7.1.0 ”存在，在你的Eclipse的安装目录，然后重新启动Eclipse的。 //////

这段翻译的结果，不是你的SDK 不是 full "Eclipse SDK"

Jess 7.0p1——Java平台规则引擎（一） 2008-07-12 22:21

分类：JESS 字号： 大大 中中 小小 1.入门

1.1.需求

Jess是一个用java语言编写的程序库。因此要使用Jess你需要Java虚拟机（JVM）。你可以从 Sun Microsystems上免费得到一个非常适合用于Windows， Linux，Solaris上的JVM。Jess 7是兼容所有版本的Java，从开始的JDK 1.4到现在的最新版本JDK1.5。版本更老的编号为4.x的Jess兼容JDK 1.0， 5.x版本兼容的是JDK1.1，Jess 6工作在JDK1.2及以上版本。

在使用Jess前请先确认JVM是否正确安装并能正常工作。

使用JessDE集成开发环境，你需要Eclipse SDK的3.1版或更新版本，这个可以从获得。安装JessDE前请确认Eclipse是已经安装并能正常工作。

Jess类库为另一种语言担任译员，这种语言我在本文档中称为Jess语言。Jess语言是一种高度专业化的Lisp形式语言。

我会认为读者你是将使用这两种或其中一种语言的一个程序员。并且所有的读者都至少有起码Java基础。另外你必须有一个Java运行系统和知道如何以一个简单的方法使用这个系统。你应该知道如何用它来：

· 运行一个Java应用程序

· 处理如CLASSPATH变量的配置问题

· 编译Java源文件集（可选）

如果你没有对Java的环境有基本的熟悉，那么我建议你购买了关于java的基础的书籍。对与各种平台的Java软件以及丰富的教程和文档可以免费从上获得。

对于那些将要使用jess语言编写程序的读者，我假定你们已经熟悉了一般程序编写的原理。我会说明整个Jess语言，所以熟悉Lisp是不需要（虽然熟悉是有些用的）。此外，在可能范围内，我将努力说明基于规则系统的最重要的概念，因为它们适用于Jess。再次，我将假定读者对这些概念有了一定的熟悉程度和了解更多。如果不熟悉基于规则系统，你也许应当考虑购买一本关于这一主题的书籍。

许多读者都希望提高Jess的能力，无论是通过向Jess语言加入的命令（用JAVA语言写）或以Java应用的方式嵌入Jess库。另外一些人会想用Jess语言的Java集成能力来从Jess语言程序调用Java函数。在本文档专门针对这类读者的一些章节中，我将承担适度Java编程的知识。我不会教Java语言任何方面的知识，有兴趣的读者可到您当地的书店参阅相关书籍。

这个文档包含了一个目录,在很多书上这些主题也都被列举出来。

1.2．准备

1.2.1．安装包的组成

Jess提供一个可用于所有支持平台的单独的.zip压缩包。这个单独的文件压缩包包含在Windows，UNIX，或Macintosh系统上使用Jess的所有你需要（除了JVM你必须自己安装）的资源。当Jess是解压后，你应该有一个命名为jess71a2 /的目录。在这个目录路径有下列文件和子目录：

README

快速开始指导.

LICENSE

关于Jess使用的您的权利信息.

bin

一个包含Windows 批处理文件(jess.bat)和一个UNIX脚本（Jess）的目录，你可以使用它们启动Jess命令提示符.

lib

该目录含有作为一个Java档案文件的Jess本身。注意，这不是一个“点击”存档文件，你不可以通过双击它运行Jess。这是要注意的。在这个目录的jsr94.jar包中又包含了符合JSR - 94 （javax.rules）的API。

docs/

这是一个文档，以“index.html”为首页的Jess手册。.

examples/jess

一个包含使用Jess语言编写的小程序的目录.

examples/xml

一个包含使用JessML, Jess's XML规则语言编写的小程序的目录.

eclipse

JessDE, 是Jess集成开发环境, 提供支持Eclipse 3.0的插件集。看这里的安装说明。

src (Optional)

如果这个目录存在，它包含全部的Jess规则引擎和开发环境的源代码，包括一个构建它的Ant脚本。

1.2.2.命令行界面

Jess有一个交互的命令行界面。分布包括两个你能运行Jess命令提示符的脚本：其中一个用于Windows，另一个用于UNIX。它们两个都在bin/ directory目录下。运行适合你系统的那一个，然后你应该看到以下的界面：

C:\Jess71a2 bin\jess.bat

Jess, the Rule Engine for the Java Platform

Copyright (C) 2006 Sandia Corporation

Jess Version Jess71a2 9/5/2006

Jess

这就是Jess的命令。尝试计算一个前缀数学表达式"（+ 2 2）"。不要忘记那些括号！

Jess (+ 2 2)

4

Jess计算了此函数，并打印结果。在这份文档的下一章，我们会发现Jess规则语言本身的语法。

通过Jess命令行执行Jess代码编写的文件，可以使用批处理命令：

Jess (batch "examples/jess/sticks.clp")

Who moves first (Computer: c Human: h)?

在前面的例子应注意到，在Jess提示符后键入命令，Jess将在下一行响应命令。我将在整个这本文档中遵循本约定。

直接从操作系统提示符执行这样的Jess程序，你可以把程序的名字作为Jess脚本的一个参数，这样就可以启动：

C:\Jess71a2 bin\jess.bat examples\jess\sticks.clp

Jess, the Rule Engine for the Java Platform

Copyright (C) 2006 Sandia Corporation

Jess Version Jess71a2 8/28/2006

Who moves first (Computer: c Human: h)?

jess.console类是一个简单的jess命令行界面的图形版。你在窗口的底部输入一个命令，结果就会出现在滚动窗口之上。试着从Jess71a2路径下键入下面命令：

C:\Jess71a2 java -classpath lib\jess.jar jess.Console

1.2.3.Java程序设计语言与Jess

要在你的Java程序中把Jess做为库使用，文件jess.jar（在lib目录下）必须是以一个标准的扩展名安装在类路径之下，或者对你的开发工具配置后能够识别它。做好这些工作的细节是随系统和环境而定的，但在设置一个类路径时通常涉及修改环境变量，并且安装一个标准的扩展名，简单来说就是复制jess.jar到你的$(JAVA_HOME)/jre/lib/ext路径下。可查阅Java文档或介绍Java的文本以了解更多的细节。

1.2.4.Jess例子程序

有一些简单的例子程序（在examples/jess和examples/xml目录下），您可以用这些程序测试你的Jess是否已经安装正确。这些程序包括fullmab.clp，zebra.clp和wordgame.clp。fullmab.clp是关于猴子与香蕉问题的经典版本。要从命令行运行它，只需要输入：

C:\Jess71a2 bin\jess examples\jess\fullmab.clp

和要运行的问题，就会在屏幕上输出结果。任何Jess代码的文件都可以以这种方式运行。像使用批处理函数一样在命令行给一个Jess文件名就可以运行了。因此，一般你只需要保证文件是以：

Jess (reset)

(run)

结束或根本没有规则将运行。zebra.clp和wordgame.clp程序是两个典型的例子，它们是用来展示Jess如何处理复杂情况的程序。这些例子都产生大量的局部模式匹配，因此它们运行非常慢而且使用了大量的内存。另外的例子包括sticks.clp （互动游戏）和frame.clp （一个使用jess的java集成能力建立图形界面的演示）。

XML的例子在单独的子目录下，每个子目录中都包含有运行例子说明的自述文件。

2.Jess开发环境

Jess 7包括一个基于Eclipse的开发环境。这个开发环境有一个编辑器，一个调试器和一个Rete网络视图。在将来发布的版本中将包含更多组件（规则浏览器和其它工具）。

2.1.安装JessDE

Jess开发环境（JessDE）是作为一个插件集支持流行的开源的集成开发环境Eclipse；该插件支持Eclipse 3.1及其更新版本。应该注意的是JessDE仅仅工作在完全的" Eclipse SDK "上——较小的"二进制运行平台"是不能运行的。

安装JessDE，首先要退出Eclipse，然后从Jess71a2/eclipse解压缩所有文件到顶层的Eclipse的安装路径。确认在你的eclipse安装目录有一个名为" plugins/gov.sandia.jess_7.0.0 "的目录存在，然后重新启动Eclipse。

注意！如果你只是从以前的版本的JessDE更新，你必须在Eclipse的命令行使用"-clean "命令开关，强制更新缓存中有关JessDE插件的信息。如果你不这样做，很多的JessDE的选项可能被禁用，安装后你只需要这样做一次。

2.1.1.验证你的安装

在“Help”菜单下选择“about Eclipse SDK”。在" about Eclipse SDK "主窗口有一个有Jess标志的按钮。单击“Plug-in Details”，如果JessDE已安装妥当，你将发现三个或四个Jess相关插件在列表上——在我的Eclipse中，它们出现在底部。

然后使用“New Project”向导建立一个Java工程。在新的工程中创建一个新文件并命名为“hello.clp”。这个文件会在一个Jess的编辑器中打开，这个编辑器有一个带红色“J”字的银色小球的图标。输入一些Jess代码，如下：

(printout t "Hello, World" crlf)

你应该看到合适的语法被高亮显示。如果看到，祝贺你！工作一切正常！阅读更多JessDE其他功能的信息。

2.1.2.更多的细节

JessDE编辑器在你的Jess文件中能够标示出语法错误和警告。你很可能希望这些标记能出现在Eclipse的“Problems”视图中，尽管在默认情况下它们可能没有显示出来。安装完成JessDE后，重新启动Eclipse，在Problems的视图，在标题栏点击“Filters”的图标，然后选择标着" Jess Problem "（如果没有被选中的话）多选项。你的Problems视图应该马上就会显示Jess错误和警告。

要使用Rete网络视图，你需要安装Eclipse图形编辑框架（GEF）。你可以从Eclipse工程项目页面得到GEF，或通过Eclipse的内置式更新管理器安装它。然后打开这一视图，在“Jess Debugger”组之下Eclipse的“Show view”对话框找到它。那么在Jess编辑窗口中当光标停在某一内部规则时，Rete网络视图将会为这项规则显示出编译的网络。

2.2.使用JessDE

2.2.1.Jess语言编辑器

JessDE编辑器可以编辑“.clp”格式的文件。在默认情况下你建立的任何 “.clp”格式的文件都将使用JessDE编辑器打开。没有单独Jess的视图，或是Jess项目类型；我们期望大多数人都将使用JessDE工具来写Jess/Java混合应用组成的Jess程序，因此JessDE工具将用在Java项目的文件中。在Jess语言代码中JessDE使用你的Java项目的类路径以解决Java中类名称问题——例如，调用defclass函数。

编辑器有您期望的一个现代程序编辑器所应具有的全部功能。

可定制的语法变色

你可以使用Eclipse全局参数对话框中的“Jess Editor”表来改变默认的颜色。

提供模板，槽和函数名的帮助内容

在许多不同地方使用JessDE编辑器你可引用Eclipse的" Content Assist "功能；JessDE将使输入Jess代码变得更容易。在输入时可以使用快捷键Alt-' / '弹出选择列表清单。

自动修复代码的“Quick fix”助手

这个功能默认使用Ctrl-1快捷键，快速匹配能立即知道怎样定义未定义的deftemplates，并为现有的deftemplates（如果它们在相同的文件里被定义）增加新的槽。

实时错误检测标记和错误高亮显示

当你输入有错误和警告时将被高亮显示

代码自动格式化

当你输入时代码自动缩进。你可以从"Source"菜单下选择"Format"命令来格式化一个全部的缓冲区

使用大纲视图快速导航

Eclipse大纲视图列出了所有在缓冲区中定义的结构；你可以点击其中任何一个就能够迅速定位到它

圆括号匹配和自动插入

当你输入一个'('或’”’符号，JessDE就会插入匹配的符号。当你的光标移动到下一个圆括号时，JessDE会显示与之相匹配的圆括号。

通过悬停获得Jess函数和结构在线帮助

快速访问Jess手册中每一个函数和结构类型的描述。

支持deftemplates 和 deffunctions的悬停帮助

如果你将你的滑鼠移动到一个deftemplate或deffunction的名字上，任何代码处，JessDE都将显示一个关于这个模板或函数信息的"tooltip"。

Jess程序的运行和调试命令

你可以使用正常Eclipse 的" Run... "菜单或由右击导航项或在编辑窗口运行或调试Jess程序。

2.2.2.文件之间的关联

有时候一个*.clp文件依靠其他的*.clp文件中的代码先被阅读执行。例如，rules.clp 也许需要templates.clp中的定义。没有这些定义，rules.clp将会出现语法错误。为了解决这个问题，你可以使用require*函数。"require*"让你清楚的声明这些关联。

如果一个文件rules.clp依靠在Java中执行的Jess命令，你可以仅仅为了这个目标创建一个特殊的文件处理这个问题（你也许称之为ruledepends.clp），这个特殊的文件包括了编辑器中使rule.clp文件能够正确解析的所有声明。如果你添加"(require* ruledepends)"到rules.clp中，仅当这个外部文件存在的话才会解析，因为它有可能正在开发中。当你部署代码时，你不需要部署ruledepends.clp，只要rules.clp能够从Java代码中取得所需声明。

"require"机制代替了JessDE的早期版本中的"Source dependencies"属性表，"Source dependencies"属性表已不再被支持。

2.2.3.Rete网络视图

使用JessDE的"Rete Network View"你可以即时看到一个衍生自任何规则的Rete网的图形展示。当这个视图是打开时（你可以使用Eclipse中的"Windows | View | Other..."对话框打开它），它会显示基于编辑器插字符所在规则的Rete网络，你可以用这个实时看到修改规则所对应的Rete网络变化。图表的布局方式是远胜于你能从Jess视图命令中得到的----因为这样没有重叠和交叉线，而且每一列的高度都可变。

2.2.4.Jess调试器

JessDE调试器可以让你调试一个在.clp文件中定义的Jess程序。它具有您期望的图形调试器所具有的所有功能：你可以暂停和恢复程序，或以步进方式执行。当程序停止时，执行堆栈的内容将会显示出来，这样你就可以检查在每个堆栈结构中定义的变量。选择的堆栈结构也可以导航到被执行的源码处。在编辑器窗口的左手边缘处，你可以通过右键单击某一规则在任何.clp文件中设置（或清除）断点。断点仅能设在函数（内置或用户自定义）中，所以你不能在defrule 或者deftemplate结构中打断程序执行。然而，你能够在一个调用规则 的左边或右手边的函数中暂停。

3.Jess 语言基础

大多数时间你是在使用Jess语言编写Jess规则。如果你从来没有使用过Lisp，第一次使用Jess规则语言也许看起来就有点奇怪了，但它并不需要太长时间来学习。回报也是丰厚的，你将使用非常少的代码表达复杂的逻辑关系。

在这一章，我们将看到Jess语言的基础语法。在后面的章节中，我们再来学习怎样定义像事实与规则这样的高级概念，但现在我们将学习最基础的。

在本语言指导中，我将使用一个非正规的符号来描述语法。在 中的基本串是必须提供的数据类型，在方括号中（[]）的内容是可选的，以 + 结束表示可以出现一次或多次，以 * 结束表示可以出现零次或更多。一般来说， Jess的输入格式是自由的。换行不具有特殊的含义，仅被处理为空格，而异常将被标识。

3.1.符号

符号是Jess语言的一个核心概念。符号是非常类似于其他语言中的标识符。Jess符号包括字母，数字和下面的标点符号：$*=+/_?#.。一个符号不能以数字开始，可以以一些特殊的标点符号开始（这些字符作为操作员当出现在符号开始时有着特殊的意义）

Jess符号对于大小写敏感。foo，FOO，和Foo是不同的符号。

最佳的符号是由字母，数字，下划线和破折号组成。破折号是传统的分隔符。如下所示为合法的符号：

foo first-value contestant#1 _abc

Jess中有三种特殊的符号。零，和java中的空值有点类似；真和假是Jess中的布尔类型的值。

3.2.数字

Jess分别使用Java函数parseInt(java.lang.String), parseLong(java.lang.String)和parseDouble(java.lang.String)来解析整型，长整型和浮点型数字。参考本文档中关于这些方法精确的语法描述。如下为合法的数字：

3 4. 5.643 5654L 6.0E4 1D

3.3.字符串

Jess中的字符串是用双引呈来标识的(").。反斜线能够区分嵌入的引号。注意Jess的字符串和Java的字符串在一些重要的地方是不一样的。首先，不会认识转义序列。比如说你不能用一个"\n"字符串来换行。另一方面，真正的换行可以通过双引号中的字符串来实现。他们是字符串的一部分。如下为合法的字符串：

"foo" "Hello, World" "\"Nonsense,\" he said firmly." "Hello,

There"

最后一个字符串相当于Java中的字符串"Hello,\nThere".。

3.4.列表

Jess中的另一个基础语法元素是列表。列表是由圆括号和空，符号，数字，字符串和其他列表组成。如下所示为合法的列表：

(+ 3 2) (a b c) ("Hello, World") () (deftemplate foo (slot bar))

Jess中列表的第一个元素（Lisp中称为列表的car）通常被称列表的头。

3.5.注释

Jess支持两种类型的程序注释。Lisp风格的行注释和C风格的块注释。行注释是以分号开头，延伸到文本中本行的最后。这里有一个行注释的例子：

; This is a list

(a b c)

块注释就和他们在C语言中的用法一样：他们以两个特征符"/*"开始，以"*/"结束。块注释不能嵌套。

/*

Here is an example of a list (commented out):

(a b c)

*/

注释可以在Jess程序的任何地方出现，包括模板和规则的结构里。

3.6.函数调用

和Lisp一样，Jess中的所有代码（控制结构，分配，程序调用）都是以函数调用的方式进行的。没有操作器，一切都是函数调用。然而，有些函数的名字使它们看起来像是Java操作器，在这种情况下，它们就和它们的Java 副本工作的非常相似。

Jess中的函数调用可以理解为简单的列表。函数调用采用前缀表示，如果一个列表的头部是一个已经存在的函数的符号，那么它就可以称为是一个函数调用。举例来说，用+函数来算2和3相加的表达式应该写为(+ 2 3)。在计算时，这个表达式的结果是数字5（不是一个仅包含数字5的列表！）。通常来说，在合适的时候表达式都被看作是这样并通过上下文求值。你可以在Jess提示符后键入表达式。Jess计算表达式并打印出结果：

Jess (+ 2 3)

5

Jess (+ (+ 2 3) (* 3 3))

14

注意你可以嵌套调用函数；外部函数是形成内部函数调用计算的因素。

Jess自身带有大量的内置函数，它们可以用来做一切事情，如数学计算，程序控制和字符处理，让你能够使用Java的API函数。当然你也可以在Jess语言或者是Java语言中定义自己的函数。

其中一个最经常用的函数是printout，它是用来发送文本到Jess的标准输出窗口，或者是输出到一个文件中。完善的解释你必须等待，但是现在，你所要了解的都包含在下面这个例子中：

Jess (printout t "The answer is " 42 "!" crlf)

The answer is 42!

另一个常用的函数是batch，它是用来计算一个包含Jess代码文件的。要运行Jess源文件examples/jess/hello.clp，你可以键入：

ess (batch "examples/jess/hello.clp")

Hello, world!

Jess自带的其他的所有函数的详细说明都在Jess function guide.。

3.7.变量

Jess中程序变量是以问号开始的标识符。问号也是变量名的一部分。名字可以包括字母，数字，破折号，下划线，分号和星号的任何组合。

一个变量可以看作是一个简单的符号，数字，字符串或者是一个列表。你可以用bind函数来为变量指定一个值。

Jess (bind ?x "The value")

"The value"

变量在第一次使用前不需要声明（全局变量除外）。

想在Jess提示符后看到变量 的值，你只需要键入变量的名字：

Jess (bind ?a 123)

123

Jess ?a

123

3.7.1.全局变量（默认全局）

你在Jess提示符后或者任何Jess语言程序顶层创建的所有变量， 当重置命令运行的时候都将被清除。这样就使它们稍嫌短暂，对于暂时性变量它们很好用，在标准理解的前提下不是永久全局变量。要创建不被reset销毁的全局变量，你可以用全局结构：

(defglobal [?global-name = value]+)

全局变量的名称必须是以星号开头以星号结束。合法的全局变量如下：

?*a* ?*all-values* ?*counter*

当全局变量建立以后，它会被初始化赋值。当reset命令随后执行的时候，这个变量可能会用相同的值重新设置，当然这取决于reset-globals的属性设置。有一个称为set-reset-globals的函数可以用来设置这个属性。如例所示：

Jess (defglobal ?*x* = 3)

TRUE

Jess ?*x*

3

Jess (bind ?*x* 4)

4

Jess ?*x*

4

Jess (reset)

TRUE

Jess ?*x*

3

Jess (bind ?*x* 4)

4

Jess (set-reset-globals nil)

FALSE

Jess (reset)

TRUE

Jess ?*x*

4

您可以阅读Jess function guide.中有关set-reset-globals和相关的get-reset-globals函数的信息。

3.8.控制流

Java中控制流（分支和循环，异常处理等）都是由一些特殊的语法和关键字如if，while，for，和try等来引导的。在Jess中，就如我们前面说过的，所有的一切都是函数调用，控制流也不例外。因此，Jess包含有那些名为if，while，for，和try以及foreach等函数。这些函数就和Java体系中相同名称的结构工作起来类似。

3.8.1.简单循环

例如，如下 是Jess中的一个“while”循环示例：

Jess (bind ?i 3)

3

Jess (while ( ?i 0)

(printout t ?i crlf)

(-- ?i))

3

2

1

FALSE

While循环的第一个参数是一个布尔表达式。While函数计算它的第一个参数，如果它为真，就计算它所有其他的参数。它一直进行这个过程直到它的线一个参数值为假。一个while循环总是返回FALSE.

Jess中内置有一些其他的循环函数。详情参看Jess function index.中关于for和foreach的有关描述。Jess中有一个break函数，可以有来跳出循环，也可以很早的从一个规则的右手边返回

//原文地址

如何优化JAVA代码及提高执行效率

网站优化通常包含两方面的内容：减小代码的体积和提高代码的运行效率。减小代码的体积已经写过太多这类的文章了，下面就简单讨论下如何提高代码的效率。一、不用new关键词创建类的实例用new关键词创建类的实例时，构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口，我们可以调用它的clone()方法。clone()方法不会调用任何类构造函数。在使用设计模式(DesignPattern)的场合，如果用Factory模式创建对象，则改用clone()方法创建新的对象实例非常简单。二、使用非阻塞I/O版本较低的JDK不支持非阻塞I/OAPI。为避免I/O阻塞，一些应用采用了创建大量线程的办法(在较好的情况下，会使用一个缓冲池)。这种技术可以在许多必须支持并发I/O流的应用中见到，如Web服务器、报价和拍卖应用等。然而，创建Java线程需要相当可观的开销。JDK1.4引入了非阻塞的I/O库(java.nio)。如果应用要求使用版本较早的JDK，需要支持非阻塞I/O的软件包。三、慎用异常异常对性能不利。抛出异常首先要创建一个新的对象。Throwable接口的构造函数调用名为fillInStackTrace()的本地(Native)方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。只要有异常被抛出，VM就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。异常只能用于错误处理，不应该用来控制程序流程。四、不要重复初始化变量默认情况下，调用类的构造函数时，Java会把变量初始化成确定的值：所有的对象被设置成null，整数变量(byte、short、int、long)设置成0，float和double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键词创建一个对象时，构造函数链中的所有构造函数都会被自动调用。五、尽量指定类的final修饰符带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String。为String类指定final防止了人们覆盖length()方法。另外，如果指定一个类为final，则该类所有的方法都是final。Java编译器会寻找机会内联(inline)所有的final方法(这和具体的编译器实现有关)。此举能够使性能平均提高50%。六、尽量使用局部变量调用方法时传递的参数以及在调用中创建的临时变量都保存在栈(Stack)中，速度较快。其他变量，如静态变量、实例变量等，都在堆(Heap)中创建，速度较慢。另外，依赖于具体的编译器/JVM，局部变量还可能得到进一步优化，望采纳，谢谢。