public List<CandidateAnswer> getTopNCandidateAnswer(int topN) { //按CandidateAnswer的分值排序,返回topN List<CandidateAnswer> result = new ArrayList<>(); Collections.sort(candidateAnswers); Collections.reverse(candidateAnswers); int len = candidateAnswers.size(); if (topN > len) { topN = len; } for (int i = 0; i < candidateAnswers.size(); i++) { result.add(candidateAnswers.get(i)); } return result; }
private static String commonSuperClass(ClassReaderSource classSource, String a, String b) { if (a.equals(b)) { return a; } List<String> firstPath = pathToRoot(classSource, a); List<String> secondPath = pathToRoot(classSource, b); Collections.reverse(firstPath); Collections.reverse(secondPath); int min = Math.min(firstPath.size(), secondPath.size()); for (int i = 1; i < min; ++i) { if (!firstPath.get(i).equals(secondPath.get(i))) { return firstPath.get(i - 1); } } return firstPath.get(0); }
public static List<Mention> getOrderedAntecedents( Mention m, int antecedentSentence, int mPosition, List<List<Mention>> orderedMentionsBySentence, Dictionaries dict) { List<Mention> orderedAntecedents = new ArrayList<>(); // ordering antecedents if (antecedentSentence == m.sentNum) { // same sentence orderedAntecedents.addAll(orderedMentionsBySentence.get(m.sentNum).subList(0, mPosition)); if(dict.relativePronouns.contains(m.spanToString())) Collections.reverse(orderedAntecedents); else { orderedAntecedents = sortMentionsByClause(orderedAntecedents, m); } } else { // previous sentence orderedAntecedents.addAll(orderedMentionsBySentence.get(antecedentSentence)); } return orderedAntecedents; }
AnnotationAttributes result = new AnnotationAttributes(attributesList.get(0)); List<String> annotationTypes = new ArrayList<>(attributesMap.keySet()); Collections.reverse(annotationTypes); Set<String> metaAnns = metaAnnotationMap.get(currentAnnotationType); if (metaAnns != null && metaAnns.contains(annotationName)) { AnnotationAttributes currentAttributes = currentAttributesList.get(0); for (String overridableAttributeName : overridableAttributeNames) { Object value = currentAttributes.get(overridableAttributeName);
private void replaceFieldGet() { List<Integer> getAddresses = new LinkedList<>(); for (int address : addresses) { if (canReplaceFieldGet(address)) { getAddresses.add(address); } } if (0 == getAddresses.size()) { return; } madeChanges = true; unreflectedFieldCount += getAddresses.size(); Collections.reverse(getAddresses); for (int address : getAddresses) { BuilderInstruction replacement = buildFieldGetReplacement(address); removeMoveResultIfNecessary(address); manipulator.replaceInstruction(address, replacement); } }
/** * Removes all entries from c except for the top {@code num}. */ public static <E extends Comparable<E>> void retainTopKeyComparable(Counter<E> c, int num) { int numToPurge = c.size() - num; if (numToPurge <= 0) { return; } List<E> l = Counters.toSortedListKeyComparable(c); Collections.reverse(l); for (int i = 0; i < numToPurge; i++) { c.remove(l.get(i)); } }
_writeReplace.setAccessible(true); List primitiveFields = new ArrayList(); List compoundFields = new ArrayList(); || (field.getType().getName().startsWith("java.lang.") && !field.getType().equals(Object.class))) primitiveFields.add(field); else compoundFields.add(field); List fields = new ArrayList(); fields.addAll(primitiveFields); fields.addAll(compoundFields); Collections.reverse(fields); _fields = new Field[fields.size()]; fields.toArray(_fields);
/** * The X-Forwarded-For header contains a comma separated list of IP addresses. This * method parses those IP addresses into a list. If no X-Forwarded-For header is * found, an empty list is returned. If multiple X-Forwarded-For headers are found, an * empty list is returned out of caution. * @return The parsed values of the X-Forwarded-Header. */ @Override public InetSocketAddress resolve(ServerWebExchange exchange) { List<String> xForwardedValues = extractXForwardedValues(exchange); Collections.reverse(xForwardedValues); if (!xForwardedValues.isEmpty()) { int index = Math.min(xForwardedValues.size(), maxTrustedIndex) - 1; return new InetSocketAddress(xForwardedValues.get(index), 0); } return defaultRemoteIpResolver.resolve(exchange); }
Map<Integer, CorefCluster> corefClusters, Dictionaries dict) { List<Mention> orderedAntecedents = new ArrayList<>(); orderedAntecedents = sortMentionsForPronoun(orderedAntecedents, m1, true); if(dict.relativePronouns.contains(m1.spanToString())) Collections.reverse(orderedAntecedents); } else { // previous sentence orderedAntecedents.addAll(orderedMentionsBySentence.get(antecedentSentence));
/** * A List of the keys in c, sorted from highest count to lowest. * * @return A List of the keys in c, sorted from highest count to lowest. */ public static <E extends Comparable<E>> List<E> toSortedListKeyComparable(Counter<E> c) { List<E> l = new ArrayList<>(c.keySet()); Comparator<E> comp = toComparatorWithKeys(c); Collections.sort(l, comp); Collections.reverse(l); return l; }