package utils; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.PriorityQueue; import java.util.HashMap; import java.util.Random; public class CommonUtils { /** * Sort the HashMap<K, V> by its values, from Large->Small. * @return List<Map.Entry<K, V>> with sorted entries. */ public static<K, V extends Comparable<? super V>> List<Map.Entry<K, V>> SortMapByValue(Map<K, V> map) { List<Map.Entry<K, V>> infoIds = new ArrayList<Map.Entry<K, V>>(map.entrySet()); Comparator<Map.Entry<K, V>> c = new Comparator<Map.Entry<K, V>>() { public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) { return o2.getValue().compareTo(o1.getValue()); }}; Collections.sort(infoIds, c); return infoIds; } /** * Get the topK keys (by its value) of a map. Does not consider the keys which are in ignoreKeys. * @param map * @return */ public static<K, V extends Comparable<? super V>> ArrayList<K> TopKeysByValue(Map<K, V> map, int topK, ArrayList<K> ignoreKeys) { HashSet<K> ignoreSet; if (ignoreKeys == null) { ignoreSet = new HashSet<K>(); } else { ignoreSet = new HashSet<K> (ignoreKeys); } TopKPriorityQueue<K, V> topQueue = new TopKPriorityQueue<K, V>(topK); for (Map.Entry<K, V> entry : map.entrySet()) { if (!ignoreSet.contains(entry.getKey())) { topQueue.add(entry); } } ArrayList<K> topKeys = new ArrayList<K>(); for (Map.Entry<K, V> entry : topQueue.sortedList()) { topKeys.add(entry.getKey()); } return topKeys; /* //Another implementation that first sorting. List<Map.Entry<K, V>> topEntities = SortMapByValue(map); ArrayList<K> topKeys = new ArrayList<K>(); for (Map.Entry<K, V> entity : topEntities) { if (topKeys.size() >= topK) break; if (!ignoreSet.contains(entity.getKey())) { topKeys.add(entity.getKey()); } } return topKeys; */ } /** * Convert an int[] to ArrayList<Integer> */ public static ArrayList<Integer> ArrayToArraylist(int[] array) { if (array == null) { return new ArrayList<Integer>(); } ArrayList<Integer> list = new ArrayList<Integer>(array.length); for (int val : array) { list.add(val); } return list; } /** * Count number of matches of findStr in str. * @param str * @param findStr * @return */ public static int CountMatchesInString(String str, String findStr) { int lastIndex = 0; int count = 0; while(lastIndex != -1) { lastIndex = str.indexOf(findStr,lastIndex); if( lastIndex != -1) { count ++; lastIndex+=findStr.length(); } } return count; } /** * Convert a string to k-gram set. * @param str * @param size */ public static ArrayList<String> StringToGramSet(String str, int k) { ArrayList<String> grams = new ArrayList<String>(); String[] words = str.split(" "); for(int i = 0; i <= words.length-k; i ++) { String gram = words[i]; for (int j = 1; j < k; j++) { gram += " " + words[i+j]; } grams.add(gram.trim()); } return grams; } /** * Randomly shuffle an int array. * @param array */ public static void ShuffleArray(int[] array) { int index, temp; Random random = new Random(); for (int i = array.length - 1; i > 0; i--) { index = random.nextInt(i + 1); temp = array[index]; array[index] = array[i]; array[i] = temp; } } }