/**  
 *@Description:   
 */  
package cn.lulei.search.engine.model;  
  
public class SortBean { 
  private String id; 
  private int times; 
   
  public String getId() { 
    return id; 
  } 
  public void setId(String id) { 
    this.id = id; 
  } 
  public int getTimes() { 
    return times; 
  } 
  public void setTimes(int times) { 
    this.times = times; 
  } 
} 

 /**  
 *@Description:   
 */  
package cn.lulei.search.engine;  
 
import java.util.ArrayList; 
import java.util.Collections; 
import java.util.Comparator; 
import java.util.HashMap; 
import java.util.HashSet; 
import java.util.List; 
 
import cn.lulei.search.engine.model.SortBean; 
  
public class SerachBase { 
  //details 存儲搜素對象的詳細信息，其中key作為區(qū)分Object的唯一標(biāo)識 
  private HashMap<String, Object> details = new HashMap<String, Object>(); 
  //對于參與搜索的關(guān)鍵詞，這里采用的稀疏數(shù)組存儲，也可以采用HashMap來存儲，定義格式如下 
  //private static HashMap<Integer, HashSet<String>> keySearch = new HashMap<Integer, HashSet<String>>(); 
  //HashMap中額key值相當(dāng)于稀疏數(shù)組中的下標(biāo)，value相當(dāng)于稀疏數(shù)組在該位置的值 
  private final static int maxLength = Character.MAX_VALUE; 
  @SuppressWarnings("unchecked") 
  private HashSet<String>[] keySearch = new HashSet[maxLength]; 
   
  /** 
   *@Description: 實現(xiàn)單例模式，采用Initialization on Demand Holder加載 
   *@Version:1.1.0 
   */ 
  private static class lazyLoadSerachBase { 
    private static final SerachBase serachBase = new SerachBase(); 
  } 
   
  /** 
   * 這里把構(gòu)造方法設(shè)置成私有為的是單例模式 
   */ 
  private SerachBase() { 
     
  } 
   
  /** 
   * @return  
   * @Description: 獲取單例 
   */ 
  public static SerachBase getSerachBase() { 
    return lazyLoadSerachBase.serachBase; 
  } 
   
  /** 
   * @param id 
   * @return  
   * @Description: 根據(jù)id獲取詳細 
   */ 
  public Object getObject(String id) { 
    return details.get(id); 
  } 
   
  /** 
   * @param ids 
   * @return  
   * @Description: 根據(jù)ids獲取詳細，id之間用","隔開 
   */ 
  public List<Object> getObjects(String ids) { 
    if (ids == null || "".equals(ids)) { 
      return null; 
    } 
    List<Object> objs = new ArrayList<Object>(); 
    String[] idArray = ids.split(","); 
    for (String id : idArray) { 
      objs.add(getObject(id)); 
    } 
    return objs; 
  } 
   
  /** 
   * @param key 
   * @return  
   * @Description: 根據(jù)搜索詞查找對應(yīng)的id，id之間用","分割 
   */ 
  public String getIds(String key) { 
    if (key == null || "".equals(key)) { 
      return null; 
    } 
    //查找 
    //idTimes存儲搜索詞每個字符在id中是否出現(xiàn) 
    HashMap<String, Integer> idTimes = new HashMap<String, Integer>(); 
    //ids存儲出現(xiàn)搜索詞中的字符的id 
    HashSet<String> ids = new HashSet<String>(); 
     
    //從搜索庫中去查找 
    for (int i = 0; i < key.length(); i++) { 
      int at = key.charAt(i); 
      //搜索詞庫中沒有對應(yīng)的字符，則進行下一個字符的匹配 
      if (keySearch[at] == null) { 
        continue; 
      } 
      for (Object obj : keySearch[at].toArray()) { 
        String id = (String) obj; 
        int times = 1; 
        if (ids.contains(id)) { 
          times += idTimes.get(id); 
          idTimes.put(id, times); 
        } else { 
          ids.add(id); 
          idTimes.put(id, times); 
        } 
      } 
    } 
     
    //使用數(shù)組排序 
    List<SortBean> sortBeans = new ArrayList<SortBean>(); 
    for (String id : ids) { 
      SortBean sortBean = new SortBean(); 
      sortBeans.add(sortBean); 
      sortBean.setId(id); 
      sortBean.setTimes(idTimes.get(id)); 
    } 
    Collections.sort(sortBeans, new Comparator<SortBean>(){ 
      public int compare(SortBean o1, SortBean o2){ 
        return o2.getTimes() - o1.getTimes(); 
      } 
    }); 
     
    //構(gòu)建返回字符串 
    StringBuffer sb = new StringBuffer(); 
    for (SortBean sortBean : sortBeans) { 
      sb.append(sortBean.getId()); 
      sb.append(","); 
    } 
     
    //釋放資源 
    idTimes.clear(); 
    idTimes = null; 
    ids.clear(); 
    ids = null; 
    sortBeans.clear(); 
    sortBeans = null; 
     
    //返回 
    return sb.toString(); 
  } 
   
  /** 
   * @param id 
   * @param searchKey 
   * @param obj 
   * @Description: 添加搜索記錄 
   */ 
  public void add(String id, String searchKey, Object obj) { 
    //參數(shù)有部分為空，不加載 
    if (id == null || searchKey == null || obj == null) { 
      return; 
    } 
    //保存對象 
    details.put(id, obj); 
    //保存搜索詞 
    addSearchKey(id, searchKey); 
  } 
   
  /** 
   * @param id 
   * @param searchKey 
   * @Description: 將搜索詞加入到搜索域中 
   */ 
  private void addSearchKey(String id, String searchKey) { 
    //參數(shù)有部分為空，不加載 
    //這里是私有方法，可以不做如下判斷，但為了設(shè)計規(guī)范，還是加上 
    if (id == null || searchKey == null) { 
      return; 
    } 
    //下面采用的是字符分詞，這里也可以使用現(xiàn)在成熟的其他分詞器 
    for (int i = 0; i < searchKey.length(); i++) { 
      //at值相當(dāng)于是數(shù)組的下標(biāo)，id組成的HashSet相當(dāng)于數(shù)組的值 
      int at = searchKey.charAt(i); 
      if (keySearch[at] == null) { 
        HashSet<String> value = new HashSet<String>(); 
        keySearch[at] = value; 
      } 
      keySearch[at].add(id); 
    } 
  } 
   
   
 
} 

 /**  
 *@Description:   
 */  
package cn.lulei.search.engine.test;  
 
import java.util.List; 
 
import cn.lulei.search.engine.SerachBase; 
  
public class Test { 
  public static void main(String[] args) { 
    // TODO Auto-generated method stub  
    SerachBase serachBase = SerachBase.getSerachBase(); 
    serachBase.add("1", "你好！", "你好！"); 
    serachBase.add("2", "你好！我是張三。", "你好！我是張三。"); 
    serachBase.add("3", "今天的天氣挺好的。", "今天的天氣挺好的。"); 
    serachBase.add("4", "你是誰？", "你是誰？"); 
    serachBase.add("5", "高數(shù)這門學(xué)科很難", "高數(shù)確實很難。"); 
    serachBase.add("6", "測試", "上面的只是測試"); 
    String ids = serachBase.getIds("你的高數(shù)"); 
    System.out.println(ids); 
    List<Object> objs = serachBase.getObjects(ids); 
    if (objs != null) { 
      for (Object obj : objs) { 
        System.out.println((String) obj); 
      } 
    } 
  } 
 
} 

5,3,2,1,4,
高數(shù)確實很難。
今天的天氣挺好的。
你好！我是張三。
你好！
你是誰？