aviator 实现 List 的求和、排序、最大、最小值

最新推荐文章于 2023-12-29 10:32:55 发布

原创最新推荐文章于 2023-12-29 10:32:55 发布 · 3k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发工具

rules 专栏收录该内容

3 篇文章

订阅专栏

这篇博客介绍了如何在Java环境下，利用Aviator库对List数据进行求和、排序以及查找最大和最小值的操作。通过具体的代码示例，包括ICalculateService、CalculateImpl、CalculateRule、CalculateException、ErrorCode和CalculateTest等类的实现，展示了在MyEclipse IDE中进行此类计算的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

jdk build 1.7

IDE: myeclipse

详情见代码和附件：

ICalculateService.java

package com.bugyun.service;

import java.util.List;

import com.bugyun.ErrorCode;
import com.bugyun.exception.CalculateException;

/**
 * 
 * 项目名称：aviator-test 
 * 类名称：ICalculateService.java 
 * 类描述： 
 * 创建人：beyond 
 * 创建时间：2016-3-31 下午5:29:19 
 * 修改人： 
 * 修改时间： 
 * 修改备注： 
 * @version
 */
public abstract class ICalculateService {
	/**
	 * @description: 计算集合中的和
	 * @param strList
	 * @throws CalculateException    
	 * @return Long 
	 */
	public abstract Long sum(List<Object> strList) throws CalculateException ;

	/**
	 * @description: 对集合进行排序
	 * @param strList
	 * @throws CalculateException    
	 * @return List<Object> 
	 */
	public abstract List<Object> sort(List<Object> strList) throws CalculateException ;

	/**
	 * @description: 计算集合中的最大值
	 * @param list
	 * @throws CalculateException    
	 * @return int 
	 */
	public int max(List<Object> list) throws CalculateException {
		int value ;
		try {
			value = (Integer) list.get(list.size() - 1);
		} catch (Exception e) {
			throw new CalculateException(ErrorCode.CALCULATE_MAX);
		}
		
		return value ;
	}

	/**
	 * @description: 计算集合中的最小值
	 * @param list
	 * @throws CalculateException    
	 * @return int 
	 */
	public int min(List<Object> list) throws CalculateException {
		int value ;
		try {
			value = (Integer) list.get(0);
		} catch (Exception e) {
			throw new CalculateException(ErrorCode.CALCULATE_MIN);
		}
		return  value;
	}
}

CalculateImpl.java

package com.bugyun.service.impl;

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

import com.bugyun.rule.CalculateRule;
import com.bugyun.service.ICalculateService;
import com.googlecode.aviator.AviatorEvaluator;

public class CalculateImpl extends ICalculateService {

	public Long sum(List<Object> strList) {
		Map<String,Object> env = new HashMap<String, Object>();
		String sumName = CalculateRule.SUM;
		env.put(CalculateRule.LIST, strList);
		
		Object result = AviatorEvaluator.execute(sumName, env, true);
		return Long.valueOf(result.toString());
	}

	@Override
	public List<Object> sort(List<Object> strList) {
		Map<String,Object> env = new HashMap<String, Object>();
		env.put(CalculateRule.LIST, strList);
		String sortName = CalculateRule.SORT;
		
		Object result = AviatorEvaluator.execute(sortName, env, true);
//		Arrays.asList(result) 返回的是一个List<List<Object>>
		List<Object> sortList =  (List<Object>)Arrays.asList(result).get(0);
		
		return sortList;
	}

}

CalculateRule.java

package com.bugyun.rule;

public class CalculateRule {
	public final static String LIST = "list";
	public final static String SUM = new StringBuilder("reduce(").append(LIST).append(",+,0)").toString() ;
	public final static String SORT = new StringBuilder("sort(").append(LIST).append(")").toString() ;
}

CalculateException.java

package com.bugyun.exception;

public class CalculateException extends Exception{

	public CalculateException() {
		super();
	}

	public CalculateException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
	}

	public CalculateException(String message, Throwable cause) {
		super(message, cause);
	}

	public CalculateException(String message) {
		super(message);
	}

	public CalculateException(Throwable cause) {
		super(cause);
	}
}

ErrorCode.java

package com.bugyun;

/**
 * 项目名称：aviator-test 
 * 类名称：ErrorCode.java 
 * 类描述： 
 * 创建人：beyond 
 * 创建时间：2016-3-31 下午5:28:33 
 * 修改人： 
 * 修改时间： 
 * 修改备注： 
 * @version
 */
public class ErrorCode {
	public final static String CALCULATE_MAX = "90101"; // 规则计算: 最大值失败
	public final static String CALCULATE_MIN = "90102"; // 规则计算：最小值失败
	public final static String CALCULATE_SUM = "90103"; // 规则计算：求和失败
	public final static String CALCULATE_SORT = "90104"; // 规则计算：排序失败
}

CalculateTest.java

package com.bugyun.test;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.bugyun.exception.CalculateException;
import com.bugyun.service.ICalculateService;
import com.bugyun.service.impl.CalculateImpl;
import com.googlecode.aviator.AviatorEvaluator;

/**
 * 项目名称：aviator-test 
 * 类名称：CalculateTest.java 
 * 类描述： 
 * 创建人：beyond 
 * 创建时间：2016-3-31 下午5:30:05 
 * 修改人： 
 * 修改时间： 
 * 修改备注： 
 * @version
 */
public class CalculateTest {

	public static void main(String[] args) throws CalculateException {
		List<Object> ints = new ArrayList<Object>(); 
//		测试集合大小
		Long size = 1000000L ;
		for(int i=0 ; i<size ; i++){
			ints.add(i*2);
		}
		Collections.shuffle(ints);
		
//		返回系统当前时间
		System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date()) +"\n" );
		
        ICalculateService calculate = new CalculateImpl();
		List<Object> sortList = calculate.sort(ints);
//		System.out.println("==========> sortList : " + sortList);
		System.out.println("==========> sortList : " );
		System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date())+"\n" );
		
		Long sum = (long) calculate.sum(ints);
		System.out.println("==========> sum : " + sum);
		System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date()) +"\n" );
		
		Object max = calculate.max(sortList);
		System.out.println("==========> max : " + max);
		System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date()) +"\n" );
		
		int min = calculate.min(sortList);
		System.out.println("==========> min : " + min);
		System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date()) );
	}
}