下面列出了android.content.pm.InstrumentationInfo#java.util.Comparator 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
/**
* Populates an ordered sequenced list of blobs in the specified partition in {@code nextEntries} {@link List},
* ordered by update time of blobs. Returns the updated {@link com.github.ambry.replication.FindToken}.
* @param partitionPath the partition to query.
* @param findToken the {@link com.github.ambry.replication.FindToken} specifying the boundary for the query.
* @param maxTotalSizeOfEntries the cumulative size limit for the list of blobs returned.
* @return {@link FindResult} instance that contains updated {@link CosmosUpdateTimeFindToken} object which can act as a bookmark for
* subsequent requests, and {@link List} of {@link CloudBlobMetadata} entries.
* @throws CloudStorageException
*/
private FindResult findUpdateTimeBasedEntries(String partitionPath, FindToken findToken, long maxTotalSizeOfEntries) {
List<CloudBlobMetadata> nextEntries = new ArrayList<>();
CosmosUpdateTimeFindToken cosmosUpdateTimeFindToken = (CosmosUpdateTimeFindToken) findToken;
List<CloudBlobMetadata> entries = new LinkedList<>();
for (BlobId blobId : map.keySet()) {
if (map.get(blobId).getFirst().getLastUpdateTime() >= cosmosUpdateTimeFindToken.getLastUpdateTime()) {
if (cosmosUpdateTimeFindToken.getLastUpdateTimeReadBlobIds().contains(map.get(blobId).getFirst().getId())) {
continue;
}
entries.add(map.get(blobId).getFirst());
}
}
Collections.sort(entries, Comparator.comparingLong(CloudBlobMetadata::getLastUpdateTime));
List<CloudBlobMetadata> cappedRsults = CloudBlobMetadata.capMetadataListBySize(entries, maxTotalSizeOfEntries);
nextEntries.addAll(cappedRsults);
return new FindResult(nextEntries,
CosmosUpdateTimeFindToken.getUpdatedToken(cosmosUpdateTimeFindToken, cappedRsults));
}
public CardTableRowSorter(CardTableModel model) {
super(model);
// define the different column comparators
// skip the name row because the default sorter does a great job here
setComparator(1, new Comparator<StringifiedScheduleDate>() {
public int compare(StringifiedScheduleDate o1, StringifiedScheduleDate o2) {
return o1.compareTo(o2);
}
});
setComparator(2, new IntegerComparator());
setComparator(3, new IntegerComparator());
// apply the default sorting
List<SortKey> sortKeys = new ArrayList<SortKey>();
sortKeys.add(new RowSorter.SortKey(0, SortOrder.ASCENDING));
setSortKeys(sortKeys);
sort();
}
public void insertFailedMessages(List<BaseMessage> messages) {
synchronized (mFailedMessageList) {
for (BaseMessage message : messages) {
String requestId = getRequestId(message);
if (requestId.isEmpty()) {
continue;
}
mResendingMessageSet.add(requestId);
mFailedMessageList.add(message);
}
Collections.sort(mFailedMessageList, new Comparator<BaseMessage>() {
@Override
public int compare(BaseMessage m1, BaseMessage m2) {
long x = m1.getCreatedAt();
long y = m2.getCreatedAt();
return (x < y) ? 1 : ((x == y) ? 0 : -1);
}
});
}
notifyDataSetChanged();
}
/**
* Given a candidate set of tasks, find and order the ones that
* can be speculated and return the same.
*/
protected synchronized List<TaskInProgress> findSpeculativeTaskCandidates
(Collection<TaskInProgress> list) {
ArrayList<TaskInProgress> candidates = new ArrayList<TaskInProgress>();
long now = JobTracker.getClock().getTime();
Iterator<TaskInProgress> iter = list.iterator();
while (iter.hasNext()) {
TaskInProgress tip = iter.next();
if (tip.canBeSpeculated(now)) {
candidates.add(tip);
}
}
if (candidates.size() > 0 ) {
Comparator<TaskInProgress> LateComparator =
new EstimatedTimeLeftComparator(now);
Collections.sort(candidates, LateComparator);
}
return candidates;
}
public NonTransactionalAdapterQueue(Collection<String> adapterIds, AdapterCallPersisterFactory persistence, int transientQueueLength, int triggerReloadQueueLength, TransactionController ctrl, Batcher batcher) {
this.transientQueueLength = transientQueueLength;
this.triggerReloadQueueLength = triggerReloadQueueLength;
this.persistence = persistence;
this.adapterIds = new ArrayList<String>(adapterIds);
this.ctrl = ctrl;
this.batcher = batcher;
this.queue = new PriorityBlockingQueue<AdapterCall>(transientQueueLength, new Comparator<AdapterCall>() {
@Override
public int compare(AdapterCall o1, AdapterCall o2) {
if (o1.getPriority() < o2.getPriority())
return -1;
if (o1.getPriority() > o2.getPriority())
return 1;
return 0;
}
});
this.reloadThread = new ReloadThread();
}
public static List<ThemeDescriptor> getSortedValues(final boolean defaultsFirst)
{
List<SuntimesTheme.ThemeDescriptor> themeDefs = getValues();
Collections.sort(themeDefs, new Comparator<ThemeDescriptor>()
{
@Override
public int compare(SuntimesTheme.ThemeDescriptor o1, SuntimesTheme.ThemeDescriptor o2)
{
if (defaultsFirst)
{
if (o1.isDefault() && !o2.isDefault())
return -1;
else if (o2.isDefault() && !o1.isDefault())
return 1;
}
return o1.displayString().compareToIgnoreCase(o2.displayString());
}
});
return themeDefs;
}
/**
* @param cache Ignite cache.
* @throws Exception If failed.
*/
private void testPaginationGet(IgniteCache<Integer, Integer> cache) throws Exception {
for (int i = 0; i < 50; i++)
cache.put(i, i);
QueryCursor<Cache.Entry<Integer, Integer>> q =
cache.query(new SqlQuery<Integer, Integer>(Integer.class, "_key >= 0"));
List<Cache.Entry<Integer, Integer>> list = new ArrayList<>(q.getAll());
Collections.sort(list, new Comparator<Cache.Entry<Integer, Integer>>() {
@Override public int compare(Cache.Entry<Integer, Integer> e1, Cache.Entry<Integer, Integer> e2) {
return e1.getKey().compareTo(e2.getKey());
}
});
for (int i = 0; i < 50; i++) {
Cache.Entry<Integer, Integer> e = list.get(i);
assertEquals(i, (int)e.getKey());
assertEquals(i, (int)e.getValue());
}
}
/**
* O(nlogk)的算法,特别适合处理海量数据
* 基于堆或者红黑树
* @param array
* @param k
* @return
*/
public ArrayList<Integer> getLeastNumbers(int[] array, int k) {
if(array == null || array.length == 0 || k > array.length || k <= 0) {
return new ArrayList<>();
}
PriorityQueue<Integer> kLeastNumbers = new PriorityQueue<>(k, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2.compareTo(o1);
}
});
for (int i = 0; i < array.length; i++) {
if(kLeastNumbers.size() < k) {
kLeastNumbers.offer(array[i]);
} else {
if(kLeastNumbers.peek() > array[i]) {
kLeastNumbers.poll();
kLeastNumbers.offer(array[i]);
}
}
}
return new ArrayList<>(kLeastNumbers);
}
/**
* Create the iterator
*/
public MultiRowColumnIterator( final Keyspace keyspace, final ColumnFamily<R, C> cf,
final ConsistencyLevel consistencyLevel, final ColumnParser<C, T> columnParser,
final ColumnSearch<T> columnSearch, final Comparator<T> comparator,
final Collection<R> rowKeys, final int pageSize ) {
this.cf = cf;
this.pageSize = pageSize;
this.columnParser = columnParser;
this.columnSearch = columnSearch;
this.comparator = comparator;
this.rowKeys = rowKeys;
this.keyspace = keyspace;
this.consistencyLevel = consistencyLevel;
this.moreToReturn = true;
// seenResults = new HashMap<>( pageSize * 10 );
}
public void testBooleanMethods() {
BinaryOperator<Boolean> and = Boolean::logicalAnd;
BinaryOperator<Boolean> or = Boolean::logicalOr;
BinaryOperator<Boolean> xor = Boolean::logicalXor;
Comparator<Boolean> cmp = Boolean::compare;
assertTrue(and.apply(true, true));
assertFalse(and.apply(true, false));
assertFalse(and.apply(false, true));
assertFalse(and.apply(false, false));
assertTrue(or.apply(true, true));
assertTrue(or.apply(true, false));
assertTrue(or.apply(false, true));
assertFalse(or.apply(false, false));
assertFalse(xor.apply(true, true));
assertTrue(xor.apply(true, false));
assertTrue(xor.apply(false, true));
assertFalse(xor.apply(false, false));
assertEquals(Boolean.TRUE.compareTo(Boolean.TRUE), cmp.compare(true, true));
assertEquals(Boolean.TRUE.compareTo(Boolean.FALSE), cmp.compare(true, false));
assertEquals(Boolean.FALSE.compareTo(Boolean.TRUE), cmp.compare(false, true));
assertEquals(Boolean.FALSE.compareTo(Boolean.FALSE), cmp.compare(false, false));
}
private ProcessStubs concreteProcessStubs(Business business, DateRange dateRange, ApplicationStub applicationStub)
throws Exception {
Set<String> ids = new HashSet<>();
ids.addAll(this.listProcessFromTask(business, dateRange, applicationStub));
ids.addAll(this.listProcessFromTaskCompleted(business, dateRange, applicationStub));
List<ProcessStub> list = new ArrayList<>();
for (String str : ids) {
String name = this.getProcessName(business, dateRange, str);
ProcessStub stub = new ProcessStub();
stub.setName(name);
stub.setValue(str);
stub.setApplicationCategory(applicationStub.getCategory());
stub.setApplicationName(applicationStub.getName());
stub.setApplicationValue(applicationStub.getValue());
stub.setActivityStubs(this.concreteActivityStubs(business, dateRange, stub));
list.add(stub);
}
list = list.stream()
.sorted(Comparator.comparing(ProcessStub::getName, Comparator.nullsLast(String::compareTo)))
.collect(Collectors.toList());
ProcessStubs stubs = new ProcessStubs();
stubs.addAll(list);
return stubs;
}
/**
* Sort the optima from best to worst, followed by {@code null} elements.
*
* @param goal Goal type.
*/
private void sortPairs(final GoalType goal) {
Arrays.sort(optima, new Comparator<RealPointValuePair>() {
public int compare(final RealPointValuePair o1,
final RealPointValuePair o2) {
if (o1 == null) {
return (o2 == null) ? 0 : 1;
} else if (o2 == null) {
return -1;
}
final double v1 = o1.getValue();
final double v2 = o2.getValue();
return (goal == GoalType.MINIMIZE) ?
Double.compare(v1, v2) : Double.compare(v2, v1);
}
});
}
/**
* This only works with text nodes
* @param nodes
* @return the order of nodes maybe changes
*/
public static NodeList distinctValues(NodeList nodes) {
SortedSet<Node> distinctNodeSet = new TreeSet<>(new Comparator<Node>() {
@Override
public int compare(Node node, Node t1) {
String nodeValue = node.getNodeValue();
String nodeValue1 = t1.getNodeValue();
return Objects.equals(nodeValue1, nodeValue) ? 0 : -1;
}
});
for (int i = 0; i < nodes.getLength(); i++) {
distinctNodeSet.add(nodes.item(i));
}
return new SetNodeList(distinctNodeSet);
}
/**
* 获取从map中获取Top N 个关键字
* @param keywords
* @param count
* @return
*/
private List<String> extractTopN(Map<String, Integer> keywords, int count) {
if (count > keywords.size())
count = keywords.size();
List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(
keywords.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
@Override
public int compare(Entry<String, Integer> o1,
Entry<String, Integer> o2) {
return o2.getValue() - o1.getValue();
}
});
List<String> result = new ArrayList<String>();
for (Map.Entry<String, Integer> entry : list.subList(0, count)) {
result.add(entry.getKey());
}
return result;
}
public String reorganizeString(String S) {
int[][] table = new int[26][2];
for (int i = 0; i < S.length(); i++) table[S.charAt(i) - 'a'][1]++;
for (int i = 0; i < 26; i++) table[i][0] = i;
Arrays.sort(table, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
return o2[1] == o1[1] ? o1[0] - o2[0] : o2[1] - o1[1];
}
});
if (table[0][1] > (S.length() + 1) / 2) return "";
char[] tmp = new char[S.length()];
int cursor = 0;
for (int i = 0; i < 26; i++) {
for (int j = 0; j < table[i][1]; j++) {
if (cursor >= tmp.length) cursor = 1;
tmp[cursor] = (char) (table[i][0] + 'a');
cursor += 2;
}
}
return new String(tmp);
}
/**
* Calculates the imputing values by frequencies keeping in the given dataset.
*
* @param dataset The dataset of frequencies for each feature aggregated in each partition..
* @return Most frequent value for each feature.
*/
private double[] calculateImputingValuesByTheMostFrequentValues(
Dataset<EmptyContext, ImputerPartitionData> dataset) {
Map<Double, Integer>[] frequencies = getAggregatedFrequencies(dataset);
double[] res = new double[frequencies.length];
for (int i = 0; i < frequencies.length; i++) {
Optional<Map.Entry<Double, Integer>> max = frequencies[i].entrySet()
.stream()
.max(Comparator.comparingInt(Map.Entry::getValue));
if (max.isPresent())
res[i] = max.get().getKey();
}
return res;
}
@Override
public int compare(final UnitType u1, final UnitType u2) {
return Comparator.<UnitType, UnitAttachment>comparing(
UnitAttachment::get, Comparator.comparing(UnitAttachment::getIsInfrastructure))
.thenComparing(Matches.unitTypeIsAaForAnything()::test)
.thenComparing(
UnitAttachment::get,
Comparator.comparing(UnitAttachment::getIsAir)
.thenComparing(UnitAttachment::getIsSea)
.thenComparingInt(UnitAttachment::getAttack))
.thenComparing(NamedAttachable::getName)
.compare(u1, u2);
}
private Entity findTarget(final Vec3d pos, final Vec3d viewNormal, final Angle angles) {
return getWorld()
.loadedEntityList
.stream()
.filter(entity -> filterTarget(pos, viewNormal, angles, entity))
.min(Comparator.comparingDouble(entity -> selecting(pos, viewNormal, angles, entity)))
.orElse(null);
}
public SortedMapTypeInfo(
TypeInformation<K> keyTypeInfo,
TypeInformation<V> valueTypeInfo,
Comparator<K> comparator) {
super(keyTypeInfo, valueTypeInfo);
Preconditions.checkNotNull(comparator, "The comparator cannot be null.");
this.comparator = comparator;
}
@SuppressWarnings("unchecked")
public static <T> Comparator<T> forType(Type.PrimitiveType type) {
Comparator<?> cmp = COMPARATORS.get(type);
if (cmp != null) {
return (Comparator<T>) cmp;
} else if (type instanceof Types.FixedType) {
return (Comparator<T>) Comparators.unsignedBytes();
} else if (type instanceof Types.DecimalType) {
return (Comparator<T>) Comparator.naturalOrder();
}
throw new UnsupportedOperationException("Cannot determine comparator for type: " + type);
}
@NonNull
public static List<PersonModel> sortPeopleByDisplayName (@NonNull List<PersonModel> people) {
List<PersonModel> sortedPeople = new ArrayList<>(people);
Collections.sort(sortedPeople, new Comparator<PersonModel>() {
@Override
public int compare(@NonNull PersonModel lhs, @NonNull PersonModel rhs) {
return CorneaUtils.getPersonDisplayName(lhs).toUpperCase().compareTo(CorneaUtils.getPersonDisplayName(rhs).toUpperCase());
}
});
return sortedPeople;
}
public static List<YouTubeData> sortByTitle(List<YouTubeData> videoIDs) {
Collections.sort(videoIDs, new Comparator<YouTubeData>() {
public int compare(YouTubeData lhs, YouTubeData rhs) {
return lhs.mTitle.compareTo(rhs.mTitle);
}
});
return videoIDs;
}
@Nullable
@Override
protected Comparator<Driver> getDriverComparator() {
return new Comparator<Driver>() {
@Override
public int compare(Driver firstDriver, Driver secondDriver) {
String firstDriverName = firstDriver.getClass().getName();
String secondDriverName = secondDriver.getClass().getName();
return firstDriverName.contains("postgres") ? -1 :
secondDriverName.contains("postgres") ? 1 :
0;
}
};
}
private void sortHierarchiesByLevel(HierarchyDesc[] hierarchies) {
if (hierarchies != null) {
Arrays.sort(hierarchies, new Comparator<HierarchyDesc>() {
@Override
public int compare(HierarchyDesc h1, HierarchyDesc h2) {
Integer level1 = Integer.parseInt(h1.getLevel());
Integer level2 = Integer.parseInt(h2.getLevel());
return level1.compareTo(level2);
}
});
}
}
/**
* Invalidate a given number of oldest (last-click-time) sessions except admin-sessions.
*
* @param nbrSessions
* number of sessions whisch will be invalidated
* @return Number of invalidated sessions.
*/
public static int invalidateOldestSessions(int nbrSessions) {
int invalidateCounter = 0;
// 1. Copy authUserSessions in sorted TreeMap
// This is the Comparator that will be used to sort the TreeSet:
Comparator<UserSession> sessionComparator = new Comparator<UserSession>() {
@Override
public int compare(UserSession o1, UserSession o2) {
Long long1 = new Long(o1.getSessionInfo().getLastClickTime());
Long long2 = new Long(o2.getSessionInfo().getLastClickTime());
return long1.compareTo(long2);
}
};
// clusterNOK ?? invalidate only locale sessions ?
TreeSet<UserSession> sortedSet = new TreeSet<UserSession>(sessionComparator);
sortedSet.addAll(authUserSessions);
int i = 0;
for (Iterator<UserSession> iterator = sortedSet.iterator(); iterator.hasNext() && i++ < nbrSessions;) {
try {
UserSession userSession = (UserSession) iterator.next();
if (!userSession.getRoles().isOLATAdmin() && !userSession.getSessionInfo().isWebDAV()) {
userSession.signOffAndClear();
invalidateCounter++;
}
} catch (Throwable th) {
log.warn("Error signOffAndClear ", th);
}
}
return invalidateCounter;
}
public static ISourceReference[] sortByOffset(ISourceReference[] methods){
Arrays.sort(methods, new Comparator<ISourceReference>(){
public int compare(ISourceReference o1, ISourceReference o2){
try{
return o2.getSourceRange().getOffset() - o1.getSourceRange().getOffset();
} catch (JavaModelException e){
return o2.hashCode() - o1.hashCode();
}
}
});
return methods;
}
@Test
public void testReadUnionOperatorState() throws Exception {
try (OneInputStreamOperatorTestHarness<Integer, Void> testHarness = getTestHarness()) {
testHarness.open();
testHarness.processElement(1, 0);
testHarness.processElement(2, 0);
testHarness.processElement(3, 0);
OperatorSubtaskState subtaskState = testHarness.snapshot(0, 0);
OperatorState state = new OperatorState(OperatorIDGenerator.fromUid("uid"), 1, 4);
state.putState(0, subtaskState);
OperatorStateInputSplit split = new OperatorStateInputSplit(subtaskState.getManagedOperatorState(), 0);
UnionStateInputFormat<Integer> format = new UnionStateInputFormat<>(state, descriptor);
format.setRuntimeContext(new MockStreamingRuntimeContext(false, 1, 0));
format.open(split);
List<Integer> results = new ArrayList<>();
while (!format.reachedEnd()) {
results.add(format.nextRecord(0));
}
results.sort(Comparator.naturalOrder());
Assert.assertEquals("Failed to read correct list state from state backend", Arrays.asList(1, 2, 3), results);
}
}
public static<T> void assertSorted(Iterator<T> i, Comparator<? super T> comp) {
if (!i.hasNext())
return;
T last = i.next();
while (i.hasNext()) {
T t = i.next();
assertTrue(comp.compare(last, t) <= 0);
assertTrue(comp.compare(t, last) >= 0);
last = t;
}
}
private Size calculationSize(StreamConfigurationMap map) {
if (map != null) {
return Collections.max(Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)),
new Comparator<Size>() {
@Override
public int compare(Size lhs, Size rhs) {
// return Long.signum((long) rhs.getWidth() * rhs.getHeight() -
// (long) lhs.getWidth() * lhs.getHeight());
return Long.signum((long) lhs.getWidth() * lhs.getHeight() -
(long) rhs.getWidth() * rhs.getHeight());
}
});
}
return null;
}
final KeySpliterator<K,V> keySpliterator() {
Comparator<? super K> cmp = comparator;
for (;;) { // ensure h corresponds to origin p
HeadIndex<K,V> h; Node<K,V> p;
Node<K,V> b = (h = head).node;
if ((p = b.next) == null || p.value != null)
return new KeySpliterator<K,V>(cmp, h, p, null, (p == null) ?
0 : Integer.MAX_VALUE);
p.helpDelete(b, p.next);
}
}