Java自定义实现Comparable接口的类，实现多维排序_Linux编程_Linux公社-Linux系统门户网站
你好，游客
Java自定义实现Comparable接口的类，实现多维排序
来源：Linux社区&
作者：dliyuedong
Java中提供了Arrays和Collections类能够帮助我们来实现排序，但是前提是数组或者集合中的元素都必须实现Comparable接口，基本的数据类型对应的类都已经实现了Comparable接口了，所以我们才能够直接对含有基本类型的数组和集合进行排序，大家可以看一下Integer的部分源码，如下:
&*&* @author& Lee Boynton&* @author& Arthur van Hoff&* @author& Josh Bloch&* @author& Joseph D. Darcy&* @since JDK1.0&*/public final class Integer extends Number implements Comparable&Integer& {& & /**& &
* A constant holding the minimum value an {@code int} can& &
* have, -2&sup&31&/sup&.& &
*/& & public static final int&
MIN_VALUE = 0x;
其他的基本类型对应的类也实现了Comparable接口。
这几天做阿里巴巴大数据比赛，想了一种比较简单的办法，根据用户购买商品的数目以及商品的流行度来进行选择用户最感兴趣的几个产品，我定义的排序如下:
①用户购买该商品的数目多比购买商品数目少的大
②购买的数目相同的情况下，比较商品流行度，流行度大的商品比流行度小的商品大
③以上两者都相等，则两商品相等
于是，我首先顶定义一个TopKBrand的类，如下：
package cn.edu.ustc.
/**&* 实现比较接口，降序排列&* &* @author Yuedong Li&* &*/public class TopKBrand implements Comparable&Object& {&private int brandId; //商品id&private int brandN //商品购买数目&private int brandPopularN //商品流行度
&public TopKBrand(int brandId, int brandNumber, int brandPopularNumber) {& super();& this.brandId = brandId;& this.brandNumber = brandN& this.brandPopularNumber = brandPopularN&}
&public int getBrandId() {& return brandId;&}
&public int getBrandNumber() {& return brandN&}
&public int getBrandPopularNumber() {& return brandPopularN&}
&@Override&public int compareTo(Object o) {& TopKBrand brand = (TopKBrand)& if (brand.getBrandNumber() != this.brandNumber)& &return brand.getBrandNumber() - this.brandN
& if (brand.getBrandPopularNumber() != this.brandPopularNumber)& &return brand.getBrandPopularNumber() - this.brandPopularN
& return 0;&}}
这样我们就可以对含TopKBrand的数据或者即和进行排序了。直接使用Arrays.sort(arr)或者Collections.sort(list) ，下面是我的使用集合的操作过程：
package cn.edu.ustc.
import java.util.ArrayLimport java.util.Cimport java.util.L
import cn.edu.ustc.bean.TopKB
public class TopKBrandTest {
&public static void main(String[] args) {& List&TopKBrand& list = new ArrayList&TopKBrand&();& //TopKBrand参数(商品id 购买数量 流行度)& list.add(new TopKBrand(1, 1, 1));& list.add(new TopKBrand(1, 3, 1));& list.add(new TopKBrand(1, 2, 2));& list.add(new TopKBrand(1, 2, 1));& list.add(new TopKBrand(1, 3, 3));
& Collections.sort(list);
& for (int i = 0; i & list.size(); i++) {& &TopKBrand brand = list.get(i);& &System.out.println(brand.getBrandId() + " "& & &+ brand.getBrandNumber() + " "& & &+ brand.getBrandPopularNumber());& }&}
1 3 31 3 11 2 21 2 11 1 1
通过实现Comparable接口，我们可以实现类的多维排序，非常的方便。
本文永久更新链接地址：
相关资讯 & & &
　　　同意评论声明
　　　发表
尊重网上道德，遵守中华人民共和国的各项有关法律法规
承担一切因您的行为而直接或间接导致的民事或刑事法律责任
本站管理人员有权保留或删除其管辖留言中的任意内容
本站有权在网站内转载或引用您的评论
参与本评论即表明您已经阅读并接受上述条款【图文】023_ILOG 和其他软件的接口_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
023_ILOG 和其他软件的接口
大小：926.00KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢JAVA抽象类和接口
编辑：www.fx114.net
本篇文章主要介绍了"JAVA抽象类和接口"，主要涉及到JAVA抽象类和接口方面的内容，对于JAVA抽象类和接口感兴趣的同学可以参考一下。
一个Java接口(Interface)是一些方法特征的集合，一个接口只有方法的特征，而没有方法的实现，因此当这些方法在不同的地方被实现时，可以具有完全不同的行为。
&&&&&&& 比如java.lang.Runnable是一个接口，其源代码为：
public interface Runnable {&
&&& public abstract
void run();& }&&
public interface Runnable {
public abstract void run();
&&&&&&& 在Java语言规范中，一个方法的特征仅包括方法的名字、参数的数目、种类和顺序不同，而不包括方法的返回类型、参数的名字以及所抛出的异常。当Java编译器检查方法的重载(Overload)时，会根据这些条件判断两个方法是否是重载方法。但是在Java编译器检查方法的重写(Override)时，会进一步检查两个方法(超类和子类)的返回类型和抛出异常是否相同。
&&&&&&& 说明：重载是同一个类的不同方法之间由于其方法名相同，参数的数目、种类、顺序的不同；当方法被调用时，JVM根据不同的参数样式来选择合适的方法来执行。重写(Override)，也就是覆盖，是子类将父类中的方法在子类中重新实现。子类必须和父类完全相同，并且其可见性不能小于父类的可见性，即若父类是protected则子类只能是protected/public的；若父类有异常抛出，子类抛出的异常必须和父类异常相同或是其子类异常。
&&&&&&& Java接口的方法必须是public abastract的，且接口不能有构造方法；变量必须是是public static final的(实际上就是常量)。
&&&&&&& Java接口的常见用法:
&&&&&&& (1).单方法接口，如java.lang.Runnable、java.awt.event.ActionListener等
&&&&&&& (2).标识接口，如java.io.Serializable等
&&&&&&& (3).常量接口，即使有Java接口来声明一些常量，如com.lcr.sat.SatConstants
&&&&&&& 在Java语言中，类有两种，一种是具体类，另一种是抽象类。具体类可以实例化，抽象类不可以实例化。抽象类仅提供一个类型的部分实型。抽象类可以有实例变量，以及一个或多个构造方法。抽象类应该拥有尽可能多的共同代码，拥有尽可能少的数据。
&&&&&&& 面向对象设计的一个最核心的原则OCP(开闭原则Open-Closed Principle)，抽象类是其中的关键所在。
&&&&&&& 在Java语言中，继承可以分为两种：一种是类对接口的实现，称作接口继承；另一种是类对类的继承，称作实现继承。继承代表“一般化/特殊化”的关系，其中基类代表一般，而衍生类代表特殊，衍生将基类特殊化或扩展化。使用继承关系的条件如下：
&&&&&&& (1).has-a使用聚合关系，is-a使用继承关系。
&&&&&&& has-a是对象和它的成员的从属关系 ,同一种类的对象，通过它们的属性的不同值来区别。比如一台PC机的操作系统是Windows，另一台PC机的操作系统是Linux。操作系统是PC机的一个成员变量，根据这一成员变量的不同值，可以区分不同的PC机对象。
&&&&&&& is-a是一种继承关系。比如PC机是计算机，工作站也是计算机。PC机和工作站是两种不同类型的计算机，但都继承了计算机的共同特性。因此在用Java语言实现时，应该将PC机和工作站定义成两种类，均继承计算机类。
&&&&&&& (2).子类需要扩展超类，但不必重写(Override)超类的方法。
&&&&&&& 从语法定义看抽象类和接口
public abstract
class DemoAbstractClass {& &&& abstract void methodOne ();&
&&& abstract void methodTwo ();&
&&& void methodThree () {& &&&&&&& & &&& }& }&
public abstract class DemoAbstractClass {
abstract void methodOne ();
abstract void methodTwo ();
void methodThree () {
public interface DemoInterface {&
&&& void methodOne ();& &&& void methodTwo ();& &&& void methodThree ();& }&
public interface DemoInterface {
void methodOne ();
void methodTwo ();
void methodThree ();
&&&&&&& 在abstract class方式中，DemoAbstractClass可以有自己的数据成员，也可以有非 abstract的成员方法，而在interface方式的实现中，DemoInterface只能够有静态的不能被修改的数据成员（也就是必须是public static final 的，不过在interface中一般不定义数据成员），所有的成员方法都是abstract的。从某种意义上说，interface是一种特殊形式的 abstract class。
&&&&&&& 从设计理念看抽象类和接口
abstract class DoorAbstractClass{&
&&& abstract void open();&
&&& abstract void close()；&
abstract class DoorAbstractClass{
abstract void open();
abstract void close()；
interface DoorInterface{& &&& void open();& &&& void close();& }&&
interface DoorInterface{
void open();
void close();
&&&&&&&& 其他具体的Door类型可以extends使用abstract class方式定义的DoorAbstractClass或者implements使用interface方式定义的DoorInterface，抽象类和接口看起来并没有什么区别。
&&&&&&&& 如果现在要求Door要具有报警的功能，我们可以在抽象类Door中增加一个报警方法alerm()，如下：
abstract class DoorAbstractClass{&
&&& abstract void open();&
&&& abstract void close()；&
&&& abstract void alerm()；&
abstract class DoorAbstractClass{
abstract void open();
abstract void close()；
abstract void alerm()；
interface DoorInterface{& &&& void open();& &&& void close();& &&& void alerm();& }&&
interface DoorInterface{
void open();
void close();
void alerm();
&&&&&&&& 然后再通过子类实现抽象类或接口即可。
class AlarmDoor extends DoorAbstractClass{&
&&& void open(){…}& &&& void close(){…}& &&& void alerm(){…}& }&&
class AlarmDoor extends DoorAbstractClass{
void open(){…}
void close(){…}
void alerm(){…}
class AlarmDoor implements DoorInterface{&
&&& void open(){…}& &&& void close(){…}& &&& void alerm(){…}& }&
class AlarmDoor implements DoorInterface{
void open(){…}
void close(){…}
void alerm(){…}
&&&&&&&& 这种方法违反了面向对象设计中的一个核心原则ISP(接口隔离原则 Interface Segregation Principle)，在Door的定义中把Door概念本身固有的行为方法和另外一个概念&报警器&的行为方 法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为&报警器&这个概念的改变（比如修改alarm方法的参数）而改变，反之依然。
&&&&&&&& 既然open、close和alarm属于两个不同的概念，根据ISP原则应该把它们分别定 义在代表这两个概念的抽象类中。定义方式有：这两个概念都使用abstract class 方式定义；两个概念都使用interface方式定义；一个概念使用abstract class方式定义，另一个概念使用interface方式定义。
&&&&&&&& 由于Java语言不支持多重继承，所以两个概念都使用abstract class方式定义是不可行的。后面两种方式都是可行的，但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。
&&&&&&&& 如果两个概念都使用interface方式来定义，那么就反映出两个问题：1、我们可能没有 理解清楚问题领域，AlarmDoor在概念本质上到底是Door还是报警器？2、如果我们对于问题领域的理解没有问题，比如：我们通过对于问题领域的分 析发现AlarmDoor在概念本质上和Door是一致的。那么都使用interface方式实现时，就没有能够正确的揭示我们的设计意图，因为在这两个概念的定义上反映不出上述含义。
&&&&&&&& 如果我们对于问题领域的理解是：AlarmDoor在概念本质上是Door，同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢？前面已经说过，abstract class在Java语言中表示一种继承关系，而继承关系在本质上是&is-a&关系。所以对于Door这个概念，我们应该使用abstarct class方式来定义。另外，AlarmDoor又具有报警功能，说明它又能够完成报警概念中定义的行为，所以报警概念可以通过interface方式定义。如下所示：
abstract class Door {&
&&& abstract void open();&
&&& abstract void close()；&
}& interface Alarm {& &&& void alarm();& }& class Alarm Door extends Door
implements Alarm{& &&& void open(){…}& &&& void close(){…}& &&& void alarm(){…}& }&
abstract class Door {
abstract void open();
abstract void close()；
interface Alarm {
void alarm();
class Alarm Door extends Door implements Alarm{
void open(){…}
void close(){…}
void alarm(){…}
&&&&&&& 总结：其实abstract class表示的是&is-a&关系，interface表示的是&like-a&关系，大家在选择时可以作为一个依据，当然这是建立在对问题领域的理解上的，比如：如果我们认为AlarmDoor在概念本质上是报警器，同时又具有Door的功能，那么上述的定义方式就要反过来了。
&&&&&&& 举例1.
&&&&&&& 我定义了一个抽象类：BOEntity，该类对应于数据库中的一条记录，即通过set/get方式来设置/获得字段对应的字段值。
public abstract
class BOEntity {& &&& H& & &&& public BOEntity() {& &&&&&&& values = new Hashtable();&
&&& }& & &&& public Object getField(String name) {&
&&&&&&& return values.get(name);&
&&& }& & &&& public int getIntField(String name) {&
&&&&&&& return ((Integer) values.get(name)).intValue();&
&&& }& & &&& public long getLongField(String name) {&
&&&&&&& Object l = values.get(name);& &&&&&&& if (l instanceof Long) {&
&&&&&&&&&&& return ((Long) l).longValue();&
&&&&&&& } else if (l
instanceof Integer) {& &&&&&&&&&&& return ((Integer) l).intValue();&
&&&&&&& }& &&&&&&& return Long.MIN_VALUE;&
&&& }& & &&& public String getStringField(String name) {&
&&&&&&& if (values.get(name) ==
null) {& &&&&&&&&&&& return &&;&
&&&&&&& }& &&&&&&& return String.valueOf(values.get(name));&
&&& }& & &&& public boolean getBooleanField(String name) {&
&&&&&&& Object v = values.get(name);& &&&&&&& if (v == null) {&
&&&&&&&&&&& v = new Boolean(false);&
&&&&&&& }& &&&&&&& return ((Boolean) v).booleanValue();&
&&& }& & &&& public void setField(String name, Object data) {&
&&&&&&& values.put(name, data);& &&& }& }&
public abstract class BOEntity {
public BOEntity() {
values = new Hashtable();
public Object getField(String name) {
return values.get(name);
public int getIntField(String name) {
return ((Integer) values.get(name)).intValue();
public long getLongField(String name) {
Object l = values.get(name);
if (l instanceof Long) {
return ((Long) l).longValue();
} else if (l instanceof Integer) {
return ((Integer) l).intValue();
return Long.MIN_VALUE;
public String getStringField(String name) {
if (values.get(name) == null) {
return &&;
return String.valueOf(values.get(name));
public boolean getBooleanField(String name) {
Object v = values.get(name);
if (v == null) {
v = new Boolean(false);
return ((Boolean) v).booleanValue();
public void setField(String name, Object data) {
values.put(name, data);
&&&&&&& 在我们程序的其他地方，我们使用User、Gorup、LogEntry分别继承了该抽象类BOEntity，并实现了IUser、IGroup、ILogEntry接口。
public class LogEntry
extends BOEntity implements ILogEntry, LCRConstants {&
&&& IFieldDef getFieldDef(String fieldname);& }&
public class LogEntry extends BOEntity implements ILogEntry, LCRConstants {
IFieldDef getFieldDef(String fieldname);
&&&&&&& 说明：这里对于抽象类和接口的理解与AlarmDoor中的理解刚好反了过来，即这里的LogEntry本质上&is-a& BOEntity，另外它还有一些ILogEntry的功能。LogEntry调用其父类的方法可以获得给定字段名称的字段值，但是，通过ILogEntry定义的getFieldDef(String fieldName)方法可以取得LogEntry的字段定义，包括字段的名称、在数据库中对应的列名称、字段类型、数据长度、是否必须等ILogEntry才有的功能。
&&&&&&& 若User继承BOEntity而实现IUser接口的时候，User调用父类BOEntity取得其值的方式是一样的，同样可以通过IUser定义不同于ILogEntry的方法。
&&&&&&& User user = new User();然后给user添加name/value，并将User的name/value的形式调用bo的setField()方法，这样在以后需要值的地方就可以直接通过bo来获得；当需要查看User类的字段的详细信息的时候，可以使用IUser定义而User类自身实现的方法来查看了。
&&&&&&& 总结：抽象类为子类提供了统一的数据调用，而接口提供额外的、不同于其他实现的附件功能。
一、不得利用本站危害国家安全、泄露国家秘密，不得侵犯国家社会集体的和公民的合法权益，不得利用本站制作、复制和传播不法有害信息！
二、互相尊重，对自己的言论和行为负责。
本文标题：
本页链接：规则引擎——IBM ODM(ILog)——基本使用步骤 - CSDN博客
规则引擎——IBM ODM(ILog)——基本使用步骤
本文简要介绍开发人员和业务人员使用的ODM工具，主要包括rule Designer建立规则应用、发布RES、生成调用规则的WebService客户端。
1. 建立xom java bean项目。
2. 建立rule project
选择1中的java项目
3. 在2中项目内将bom的属性中文化
输入对应中文
中文化所有属性。
4. 定义入参、出参
rule project -& 右键属性 -&规则集参数
5. 建立规则包
6. 建立business rule、decision table、dicision tree
7. 编辑决策表
双击药编辑的列输入相关内容
8. 建立规则流
将建立的规则包拖拽到画布上.
9. 建立java项目,本地调用
10. 创建rule app部署到res上.
11.登陆res查看规则webservice服务
resAdmin\resAdmin
12. cxf生成规则调用websercie客户端
wsdl2java -p com.demo.odm.test -d c:/workplace -client&-autoNameResolutionhttp://ip:9080/DecisionService/ws/miniloanruleapp/1.0/miniloanrules/1.0?WSDL
13.rule designer和rts(Decision Center)进行项目同步
右键rule项目，decision center -》 connect...
本文已收录于以下专栏：
相关文章推荐
转自/soul-tap/p/4956052.html
IBM规则引擎（ODM）入门系列一（1）：如何编写规则项目
最近，因项目需要，研究...
IBM(TM) WebSphere(TM) ILOG是业界最有影响力的业务规则商业软件，它提供了最好的业务规则管理系统，在Java领域更是有广泛的成功案例。网上关于ILOG的技术资料非常多，大家都比较了解ILOG...
4.1添加查询
规则项目的部署会根据一个用户自定义的查询条件抽取出来一个规则集进行部署，所以要首先定义一个查询。
操作方法：在规则项目图中找到“添加查询”à输入查询名称à确定à在规则中输入满足条件...
1 现状分析... 3
1.1 现状... 3
1.2 问题... 3
1.3 解决方案... 3
1.4 适用情景... 3
2 什么是规则引擎... 3...
Intel(R) Xeon(R) CPU E7-4850 v3 @ 2.20GHz
CentOS release 6.4 (Final)
2.6.32-358.el6.x86_64
Ilog JRules 是最有名的商用BRMS，刚拿了JOLT；
Drools 是最活跃的开源规则引擎，一路高歌猛进；
Jess 是Clips的java实现，就如JRuby之于Ruby，是AI系的代...
规则即业务，在规则引擎中，主要是对业务以及业务流程的处理，让业务人员参与编写业务规则的环境，语法简单易懂，其核心就是一系列的“如果” “那么”的语法。与java中的if、else语句相通。“如果”语句...
共有90款 工作流引擎开源软件，第1页
java工作流引擎,开源工作流引擎,工作流引擎是什么,工作流引擎设计,工作流引擎介绍,.net工作流引擎,工作流引擎比较,工作流引擎内核揭秘,.net开源...
他的最新文章
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)}