最多、最少使用优先级算法

 

因为工作的的需要，友好的用户体验是产品成败的关键，今天写了一个最多使用优先级算法已解决目前用户经常使用的检索内容，希望有所帮助。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

/**
 * @功能描述：最多、最少使用优先级算法实现
 * @创建人员： jolie
 * @编程人员：
 * @修改人员：
 * @创建时间：2012-2-26 上午11:11:01
 * @修改时间：
 * @备注：以20作为基数处理最多、最少使用优先级算法的实现，
 * @版本：
 * @param <T>
 */
public class MRUAndLRUAlgorithm<T> {

    // 记录请求项
    private static ArrayList list = new ArrayList();

    // 统计最近20次
    private static final int MAX_SIZE=20;

    // 记录每一项请求的次数
    private Map<T, Integer> originalMap=new HashMap<T, Integer>();

    // 请求项 排序序列列表
    private List<Entry<T, Integer>> sortList;

    /**
     * @方法描述：移除最近20次之前第一次请求的信息
     */
    protected void remove() {
        int count=originalMap.get(list.get(0));
        count=count - 1;
        originalMap.remove(list.get(0));
        originalMap.put((T)list.get(0), count);
        list.remove(0);
    }

    /**
     * @方法描述：添加最新请求的内容
     * @param t
     */
    protected void add(T t) {
        if(isFull())
            remove();
        list.add(t);
        countHandler(t);

    }

    /**
     * @方法描述：计数处理
     * @param t 请求的内容值
     */
    protected void countHandler(T t) {
        if(originalMap.containsKey(t)) {
            int count=originalMap.get(t);
            count=count + 1;
            originalMap.remove(t);
            originalMap.put(t, count);
        } else {
            originalMap.put(t, 1);
        }
    }

    /**
     * @方法描述：判断最近是否请求已满
     * @return
     */
    protected boolean isFull() {
        if(MAX_SIZE == list.size()) {
            return true;
        }
        return false;

    }

    /**
     *
     * @方法描述：获取最多请求的内容值
     * @param t
     * @return
     *
     */
    public T mruValue(T t) {
        if(t != null){
        this.add(t);
        }
        sort();
        return this.sortList.get(0).getKey();
    }
   
    /**
     *
     * @方法描述：获取最少请求的内容值
     * @param t
     * @return
     *
     */
    public T lruValue(T t) {
        this.add(t);
        sort();
        return this.sortList.get(sortList.size()-1).getKey();
    }

    protected void sort() {
        Set<Entry<T, Integer>> entrys=originalMap.entrySet();
        if(entrys.isEmpty())
            return;
        sortList = new ArrayList<Entry<T,Integer>>() ;
        Iterator<Entry<T, Integer>> ir=entrys.iterator();
        while(ir.hasNext()) {
            sortList.add(ir.next());
        }
        Collections.sort(sortList, new ValueComparator());
    }

    /**
     *
     * @方法描述：获取排序之后的请求列表值
     * @return
     *
     */
    public List<Entry<T, Integer>> getSortList() {
        return sortList;
    }

    /**
     * @功能描述：降序比较
     */
    class ValueComparator implements Comparator<Entry<T, Integer>> {

        public int compare(Entry<T, Integer> o1, Entry<T, Integer> o2) {

            return o2.getValue() - o1.getValue();
        }

    }
   
   
    public static void main(String[] args){
        MRUAndLRUAlgorithm<String> m = new MRUAndLRUAlgorithm<String>();
        m.add("5");
        m.add("5");
        m.add("3");
        m.add("5");
        m.add("3");
        m.add("2");
        m.add("5");
        m.add("1");
        m.add("5");
       System.out.println(m.mruValue("2")) ;
       
       
    }

}