Java Code Examples for java.util.TreeMap#keySet()

public TreeMap<String, Integer> getWorstBugs(ArrayList<JUnitResultData> junitOutFileSummaries, int minimumInstances) {
  // Build a map of the bug to its frequency
  TreeMap<String, Integer> bugToFailCount = new TreeMap<String, Integer>();
  for (JUnitResultData fileSummary : junitOutFileSummaries) {
    for (JUnitResult testFailure : fileSummary.getFailures()) {
      if (testFailure.getAssociatedKnownFailure() != null &&
          testFailure.getAssociatedKnownFailure().getBug() != null) {
        String bugNumber = testFailure.getAssociatedKnownFailure().getBug();
        if (bugNumber.trim().length() > 0) {
          Integer priorCount = bugToFailCount.get(bugNumber) == null ? 0: bugToFailCount.get(bugNumber);
          bugToFailCount.put(bugNumber, priorCount+1);
        }
      }
    }
  }
  // Filter the bugmap by minimum count
  TreeMap<String, Integer> returnMap = new TreeMap<String, Integer>();
  for (String bugNum : bugToFailCount.keySet()) {
    if (bugToFailCount.get(bugNum) >= minimumInstances) {
      returnMap.put(bugNum, bugToFailCount.get(bugNum));
    }
  }
  return returnMap;
}
 

public void checkEquals(LongMap<String> v1, TreeMap<Long, String> v2) {
    assertEquals(v1.size(), v2.size());
    for (long k : v2.keySet()) {
        assertEquals(v1.get(k), v2.get(k));
    }

    int counter = 0;
    Iterator<String> it = v1.valuesIterator();
    while (it.hasNext()) {
        String v = it.next();
        long key = Long.parseLong(v);
        assertEquals(v1.get(key), v);
        assertEquals("" + key, v);
        counter++;
    }
    assertEquals(counter, v2.size());
}
 

private void printRebalanceResult(TreeMap<String, ConsumerRunningInfo> criTable) {
    if (criTable == null || criTable.isEmpty()) {
        System.out.printf("Empty Result: criTable is empty.\n");
        return;
    }
    Map<MessageQueue, String> rbResult = new TreeMap<MessageQueue, String>();
    for (String cid : criTable.keySet()) {
        for (MessageQueue messageQueue : criTable.get(cid).getMqTable().keySet()) {
            rbResult.put(messageQueue, cid);
        }
    }
    String format = "%30s|%20s|%10s| %s\n";
    System.out.printf("--------------------------------------------------------------------------------------------------\n");
    System.out.printf(format, "Topic","Broker Name", "QueueId", "ConsumerClientId");
    System.out.printf("--------------------------------------------------------------------------------------------------\n");
    for (Entry<MessageQueue, String> entry : rbResult.entrySet()) {
        System.out.printf(format, entry.getKey().getTopic(), entry.getKey().getBrokerName(),
                entry.getKey().getQueueId(), entry.getValue());
    }

}
 

private JSONObject extractSummaryData(HashMap<String, SummaryStatisticsDTO> summaryMap, SummaryStatisticsDTO total) throws JSONException {
    JSONObject extract = new JSONObject();
    JSONArray dataArray = new JSONArray();
    Gson gson = new Gson();
    //sort keys
    TreeMap<String, SummaryStatisticsDTO> sortedKeys = new TreeMap<>(summaryMap);
    for (String key : sortedKeys.keySet()) {
        SummaryStatisticsDTO sumStats = summaryMap.get(key);
        //percentage values
        sumStats.updatePercentageStatistics();
        dataArray.put(new JSONObject(gson.toJson(sumStats)));
    }
    total.updatePercentageStatistics();

    extract.put("split", dataArray);
    extract.put("total", new JSONObject(gson.toJson(total)));
    return extract;
}
 

private void createClassGroupContent(TreeMap<String, String> mapFNameToContent, String links, String projectDetail,
        TreeMap<String, ClassGroup> mapGroupNameToClassGroup,
        ArrayList<ClassModel> cModels, IProgressMonitor monitor) {

    for (String strGroup : mapGroupNameToClassGroup.keySet()) {
        ClassGroup cg = mapGroupNameToClassGroup.get(strGroup);
        if (cg.getContentSource() != null) {
            String cgContent = parseHTMLFile(cg.getContentSource());
            if (cgContent != "") {
                String strHtml = Constants.getHeader(projectDetail) + links + "<td class='contentTD'>" +
                        "<h2 class='section-title'>" +
                        escapeHTML(cg.getName()) + "</h2>" + cgContent + "</td>";
                strHtml += Constants.FOOTER;
                mapFNameToContent.put(cg.getContentFilename(), strHtml);
                if (monitor != null)
                    monitor.worked(1);
            }
        }
    }
}
 

@Override
protected void initializeProcedureOutParams(StatementResult sr) {
  final TreeMap<Integer, OutputParameter> outParams = this.outParams;
  if (outParams != null) {
    if ((this.outParamValues = sr.getProcedureOutParams()) != null) {
      setCurrentSource(gfxdConstants.BULK_CLOSE_STATEMENT, statementId,
          null);
      this.outParamsPositionInRow = new TIntIntHashMap(outParams.size());
      // starting index at 1 since get on TIntIntHashMap will give 0 if absent
      int outIndex = 1;
      for (Integer parameterIndex : outParams.keySet()) {
        this.outParamsPositionInRow.put(parameterIndex.intValue(), outIndex);
        outIndex++;
      }
    }
  }
}
 

public List<Integer> topKFrequent(int[] nums, int k) {

        TreeMap<Integer, Integer> map = new TreeMap<>();
        for(int num: nums){
            if(map.containsKey(num))
                map.put(num, map.get(num) + 1);
            else
                map.put(num, 1);
        }

        PriorityQueue<Freq> pq = new PriorityQueue<>();
        for(int key: map.keySet()){
            if(pq.getSize() < k)
                pq.enqueue(new Freq(key, map.get(key)));
            else if(map.get(key) > pq.getFront().freq){
                pq.dequeue();
                pq.enqueue(new Freq(key, map.get(key)));
            }
        }

        LinkedList<Integer> res = new LinkedList<>();
        while(!pq.isEmpty())
            res.add(pq.dequeue().e);
        return res;
    }
 

private static void analyzeNStartSequences(TreeMap<Integer, ArrayList<BigInteger>> length2NList) {
	for (int length : length2NList.keySet()) {
		ArrayList<BigInteger> nList = length2NList.get(length);
		//LOG.debug("length=" + length + ": n0List = " + nList);
		int period = findPeriod(nList);
		if (period>0) {
			List<BigInteger> nPeriodList = nList.subList(0, period);
			BigInteger periodDiff = nList.get(period).subtract(nList.get(0));
			LOG.info("length=" + length + ": #n0=" + nList.size() + ", period=" + period + ", periodDiff=" + periodDiff + ", nPeriodList = " + nPeriodList);
		} else {
			LOG.info("length=" + length + ": #n0=" + nList.size() + ", period not identified");
		}
	}
}
 

/**
 * Returns all groups for site
 * @return
 */
public SelectItem[] getGroupsForSite() {
	SelectItem[] groupSelectItems = new SelectItem[0];
	TreeMap sortedSelectItems = new TreeMap();
	Site site;
	try {
		site = SiteService.getSite(toolManager.getCurrentPlacement()
				.getContext());
		Collection groups = site.getGroups();
		if (groups != null && groups.size() > 0) {
			groupSelectItems = new SelectItem[groups.size()];
			Iterator groupIter = groups.iterator();
			while (groupIter.hasNext()) {
				Group group = (Group) groupIter.next();
				String title = group.getTitle();
				String groupId = group.getId();
                String uniqueTitle = title + groupId;
                sortedSelectItems.put(uniqueTitle.toUpperCase(), new SelectItem(group.getId(), title));
			}
			Set keySet = sortedSelectItems.keySet();
			groupIter = keySet.iterator();
			int i = 0;
			while (groupIter.hasNext()) {
				groupSelectItems[i++] = (SelectItem) sortedSelectItems.get(groupIter.next());
			}
		}
	} catch (IdUnusedException ex) {
		// No site available
	}
	return groupSelectItems;
}
 

protected static String mismatchVectorToString(TreeMap<Integer, Float> idToMismatchMap) {
	// build a string vector of model to data node mismatches
	String mismatchVectorAsString = "";
	for (Integer key : idToMismatchMap.keySet()) {
		if (mismatchVectorAsString.length() > 0) {
			mismatchVectorAsString = mismatchVectorAsString + ",";
		}
		mismatchVectorAsString = mismatchVectorAsString + key + "," + idToMismatchMap.get(key);
	}
	return mismatchVectorAsString;
}
 

public void makeCSVFailureReports(
    TreeMap<String, ArrayList<FailureReportingRow>> failureReportingMap)
    throws Exception {
  for (String outFileName : failureReportingMap.keySet()) {
    PrintWriter csvPW = new PrintWriter(new BufferedWriter(new FileWriter(
        getGfxdReportDir() + "/" + outFileName + ".csv")));
    csvPW.println("Test,Bug#,Bug State,Bug Priority,Failure description");
    for (FailureReportingRow rptRow : failureReportingMap.get(outFileName)) {
      csvPW.println(rptRow.getTestName() + "," + rptRow.getBugNum() + ","
          + rptRow.getBugState() + "," + rptRow.getBugPriority() + ","
          + rptRow.getFailureDescription());
    }
    csvPW.close();
  }
}
 

public List<VirtualCategory<Contact>> getContactGroup(List<Contact> list) {
    List<VirtualCategory<Contact>> cates = new ArrayList<>();
    if (!IMUtils.isEmpty(list)) {
        List<Contact> unA = new ArrayList<>();
        TreeMap<String, List<Contact>> maps = new TreeMap<>();
        for (Contact c : list) {
            String py = c.getPYInitial();
            char A = IMUtils.isEmpty(py) ? '#' : py.charAt(0);
            if (A >= 'A' && A <= 'Z' || A >= 'a' && A <= 'z') {
                String a = String.valueOf(A).toUpperCase();
                List<Contact> values = maps.get(a);
                if (values == null) {
                    values = new ArrayList<>();
                    maps.put(a, values);
                }
                values.add(c);
            } else {
                unA.add(c);
            }
        }
        for (String n : maps.keySet()) {
            cates.add(new VirtualCategory<>(n, maps.get(n)));
        }
        if (!IMUtils.isEmpty(unA)) {
            cates.add(new VirtualCategory<>("#", unA));
        }
    }
    return cates;
}
 

private TreeMap<String, List<TodolistDTO>> makeUserCompletedTodosMapSerilizable(TreeMap<Date, List<Todolist>> map) {
    TreeMap<String, List<TodolistDTO>> mapDTO = new TreeMap<String, List<TodolistDTO>>();
    Set<Date> dates = map.keySet();
    for (Date date : dates) {
        List<Todolist> completedTodos = map.get(date);
        mapDTO.put(new SimpleDateFormat("yyyy-MM-dd").format(date),
                Lists.transform(completedTodos, TodolistTransform.TODOLIST_DTO_TODOS_FUNCTION));
    }
    return mapDTO;
}
 

public void dump(PrintStream stream) {
    TreeMap<String, AtomicInteger> map = new TreeMap<>(counters);

    for (String id : map.keySet()) {
        stream.println(id + ": " + map.get(id)); // NOI18N
    }
}
 

public StreamElement(TreeMap<String, Serializable> output,DataField[] fields) {
	int nbFields = output.keySet().size();
	if(output.containsKey("timed"))
		nbFields--;
	String fieldNames[]  = new String[nbFields];
	Byte fieldTypes[]  = new Byte[nbFields];
	Serializable fieldValues[] = new Serializable[nbFields];
	TreeMap < String , Integer > indexedFieldNames = new TreeMap<String, Integer>(new CaseInsensitiveComparator());
	int idx = 0;

	long timestamp =System.currentTimeMillis();
	for (String key:output.keySet()) {
		Serializable value = output.get(key);

		if(key.equalsIgnoreCase("timed")){
			timestamp = (Long) value;
			timestampProvided=true;
		}else{ 
			fieldNames[idx] = key;
			fieldValues[idx] = value;
			for (int i=0;i<fields.length;i++) {
				if (fields[i].getName().equalsIgnoreCase(key))
					fieldTypes[idx] = fields[i].getDataTypeID();
			}
			indexedFieldNames.put(key, idx);
			idx++;
		}
	}
	this.fieldNames=fieldNames;
	this.fieldTypes=fieldTypes;
	this.fieldValues=fieldValues;
	this.indexedFieldNames=indexedFieldNames;
	this.timeStamp=timestamp;
}
 

public void putMap(TreeMap<Integer, String> input) {
    buffer = ByteBuffer.wrap(new byte[calculateSize(input) + getMetaDataSize()]);

    buffer.putInt(input.size());
    int position = getMetaDataSize();
    int address = position + input.size() * INTEGER_BYTES;


    for (Integer index : input.keySet()) {
        buffer.putInt(position, address);
        address = putString(address, input.get(index));
        position += INTEGER_BYTES;
    }
}
 

/** Loads the workspace screens db into a map of Rank -> ScreenId */
private static TreeMap<Integer, Long> loadWorkspaceScreensDb(Context context) {
    final ContentResolver contentResolver = context.getContentResolver();
    final Uri screensUri = LauncherSettings.WorkspaceScreens.CONTENT_URI;
    final Cursor sc = contentResolver.query(screensUri, null, null, null, null);
    TreeMap<Integer, Long> orderedScreens = new TreeMap<Integer, Long>();

    try {
        final int idIndex = sc.getColumnIndexOrThrow(
                LauncherSettings.WorkspaceScreens._ID);
        final int rankIndex = sc.getColumnIndexOrThrow(
                LauncherSettings.WorkspaceScreens.SCREEN_RANK);
        while (sc.moveToNext()) {
            try {
                long screenId = sc.getLong(idIndex);
                int rank = sc.getInt(rankIndex);
                orderedScreens.put(rank, screenId);
            } catch (Exception e) {
                Launcher.addDumpLog(TAG, "Desktop items loading interrupted - invalid screens: " + e, true);
            }
        }
    } finally {
        sc.close();
    }

    // Log to disk
    Launcher.addDumpLog(TAG, "11683562 - loadWorkspaceScreensDb()", true);
    ArrayList<String> orderedScreensPairs= new ArrayList<String>();
    for (Integer i : orderedScreens.keySet()) {
        orderedScreensPairs.add("{ " + i + ": " + orderedScreens.get(i) + " }");
    }
    Launcher.addDumpLog(TAG, "11683562 -   screens: " +
            TextUtils.join(", ", orderedScreensPairs), true);
    return orderedScreens;
}
 

public static void print(TreeMap<Integer,String> map) {
    for (Integer key : map.keySet()) {
        System.out.printf("%,12d  %-16s%n", key, map.get(key));
    }
}
 

public ParameterizedStringList getDetail(StereoMolecule mol) {
ParameterizedStringList detail = new ParameterizedStringList();
detail.add("cLogP Values are estimated applying an atom-type based increment system.",
					ParameterizedStringList.cStringTypeText);
detail.add("Atom-types are 64-bit numbers describing atoms and their near surrounding.",
					ParameterizedStringList.cStringTypeText);
detail.add("Recognized atom types and their contributions are:",ParameterizedStringList.cStringTypeText);

mol.normalizeAmbiguousBonds();
mol.ensureHelperArrays(Molecule.cHelperRings);

if (mol != null) {
	int errorCount = 0;
	TreeMap<Long,Integer> countMap = new TreeMap<Long,Integer>();
	NumberFormat formatter = new DecimalFormat("#0.000");
	for (int atom=0; atom<mol.getAtoms(); atom++) {
		try {
			long atomType = AtomTypeCalculator.getAtomType(mol, atom, ATOM_TYPE_MODE);
			Integer typeCount = countMap.get(new Long(atomType));
			if (typeCount == null)
				countMap.put(new Long(atomType), new Integer(1));
			else
				countMap.put(new Long(atomType), new Integer(typeCount.intValue()+1));
			}
		catch (Exception e) {
			errorCount++;
			}
		}

	if (errorCount != 0)
		detail.add("Warning: "+errorCount + " atom type(s) could not be determined.", ParameterizedStringList.cStringTypeText);

	for (Long type:countMap.keySet()) {
		if (sSortedTypeList.contains(type))
			detail.add(countMap.get(type) + " * "+
					formatter.format(INCREMENT[sSortedTypeList.getIndex(type)]) + " AtomType: 0x" + Long.toHexString(type),ParameterizedStringList.cStringTypeText);
		else
			detail.add("Warning: For atom type 0x"+Long.toHexString(type)+" ("+countMap.get(type)+" times found) is no increment available.", ParameterizedStringList.cStringTypeText);
		}
	}

return detail;
}
 

/**********************************************************************************************************
 * @description generate the HTML string for the Class Menu to display on
 *              each page.
 * @param mapGroupNameToClassGroup
 *            map that holds all the Class names, and their respective Class
 *            Group.
 * @param cModels
 *            list of ClassModels
 * @return String of HTML
 */
private String getPageLinks(TreeMap<String, ClassGroup> mapGroupNameToClassGroup, ArrayList<ClassModel> cModels) {
    boolean createMiscellaneousGroup = false;

    // this is the only place we need the list of class models sorted by name.
    TreeMap<String, ClassModel> tm = new TreeMap<String, ClassModel>();
    for (ClassModel cm : cModels) {
        tm.put(cm.getClassName().toLowerCase(), cm);
        if (!createMiscellaneousGroup && cm.getClassGroup() == null)
            createMiscellaneousGroup = true;
    }
    cModels = new ArrayList<ClassModel>(tm.values());

    String links = "<td width='20%' vertical-align='top' >";
    links += "<div class='sidebar'><div class='navbar'><nav role='navigation'><ul id='mynavbar'>";
    links += "<li id='idMenuindex'><a href='.' onclick=\"gotomenu('index.html', event);return false;\" class='nav-item'>Home</a></li>";

    // add a bucket ClassGroup for all Classes without a ClassGroup specified
    if (createMiscellaneousGroup)
        mapGroupNameToClassGroup.put("Miscellaneous", new ClassGroup("Miscellaneous", null));

    // create a sorted list of ClassGroups

    for (String strGroup : mapGroupNameToClassGroup.keySet()) {
        ClassGroup cg = mapGroupNameToClassGroup.get(strGroup);
        String strGoTo = "onclick=\"gotomenu(document.location.href, event);return false;\"";
        if (cg.getContentFilename() != null)
            strGoTo = "onclick=\"gotomenu('" + cg.getContentFilename() + ".html" + "', event);return false;\"";
        links += "<li class='header' id='idMenu" + cg.getContentFilename() +
                "'><a class='nav-item nav-section-title' href='.' " +
                strGoTo + " class='nav-item'>" + strGroup + "<span class='caret'></span></a></li>";
        links += "<ul>";

        // even though this algorithm is O(n^2), it was timed at just 12
        // milliseconds, so not an issue!
        for (ClassModel cModel : cModels) {
            if (strGroup.equals(cModel.getClassGroup())
                    || (cModel.getClassGroup() == null && strGroup == "Miscellaneous")) {
                if (cModel.getNameLine() != null && cModel.getNameLine().trim().length() > 0) {
                    String fileName = cModel.getClassName();
                    links += "<li class='subitem classscope" + cModel.getScope() + "' id='idMenu" + fileName +
                            "'><a href='.' onclick=\"gotomenu('" + fileName + ".html', event);return false;\" class='nav-item sub-nav-item scope" +
                            cModel.getScope() + "'>" +
                            fileName + "</a></li>";
                }
            }
        }

        links += "</ul>";
    }

    links += "</ul></nav></div></div></div>";

    links += "</td>";
    return links;
}