How to use

reverseOrder

method

in

java.util.Collections

 @Override
 public List<String> order(List<String> insertionOrder) {
  Collections.sort(insertionOrder, Collections.reverseOrder());
  return insertionOrder;
 }
}

 sort(T[] a, Comparator<? super T> c) 

Arrays.sort(a, Collections.reverseOrder());

@Nonnull
private <T> List<Class<? extends T>> prioritize(Iterable<Class<? extends T>> iterable) {
 List<Class<? extends T>> serviceClasses = new ArrayList<>();
 for (Class<? extends T> serviceClass : iterable) {
  serviceClasses.add(serviceClass);
 }
 Comparator<Class<? extends T>> c = reverseOrder(comparing(PluginFinder::priority));
 c = c.thenComparing(Class::getName);
 serviceClasses.sort(c);
 return serviceClasses;
}

private static List<ElasticsearchAvailabilityObserver> initElasticsearchAvailabilityObservers(ConfigurationRegistry configurationRegistry) {
  final List<ElasticsearchAvailabilityObserver> elasticsearchAvailabilityObservers = new ArrayList<ElasticsearchAvailabilityObserver>();
  ServiceLoader<ElasticsearchAvailabilityObserver> observers = ServiceLoader
      .load(ElasticsearchAvailabilityObserver.class, CorePlugin.class.getClassLoader());
  for (ElasticsearchAvailabilityObserver elasticsearchAvailabilityObserver : observers) {
    elasticsearchAvailabilityObservers.add(elasticsearchAvailabilityObserver);
    elasticsearchAvailabilityObserver.init(configurationRegistry);
  }
  
  Collections.sort(elasticsearchAvailabilityObservers, Collections.reverseOrder(new Comparator<ElasticsearchAvailabilityObserver>() {
    @Override
    public int compare(ElasticsearchAvailabilityObserver o1, ElasticsearchAvailabilityObserver o2) {
      return (o1.getPriority() < o2.getPriority()) ? -1 : ((o1.getPriority() == o2.getPriority()) ? 0 : 1);
    }
  }));
  return elasticsearchAvailabilityObservers;
}

@Test
public void sortByKey() {
 List<Tuple2<Integer, Integer>> pairs = new ArrayList<>();
 pairs.add(new Tuple2<>(0, 4));
 pairs.add(new Tuple2<>(3, 2));
 pairs.add(new Tuple2<>(-1, 1));
 JavaPairRDD<Integer, Integer> rdd = sc.parallelizePairs(pairs);
 // Default comparator
 JavaPairRDD<Integer, Integer> sortedRDD = rdd.sortByKey();
 assertEquals(new Tuple2<>(-1, 1), sortedRDD.first());
 List<Tuple2<Integer, Integer>> sortedPairs = sortedRDD.collect();
 assertEquals(new Tuple2<>(0, 4), sortedPairs.get(1));
 assertEquals(new Tuple2<>(3, 2), sortedPairs.get(2));
 // Custom comparator
 sortedRDD = rdd.sortByKey(Collections.reverseOrder(), false);
 assertEquals(new Tuple2<>(-1, 1), sortedRDD.first());
 sortedPairs = sortedRDD.collect();
 assertEquals(new Tuple2<>(0, 4), sortedPairs.get(1));
 assertEquals(new Tuple2<>(3, 2), sortedPairs.get(2));
}

  available.add(encoding);
Collections.sort(available, Collections.reverseOrder());
resultingMappings.addAll(available);

@Test
public void testDepth() {
 List<Integer> totals = Lists.newArrayList();
 for (int i = 0; i < 1000; i++) {
  ChineseRestaurant x = new ChineseRestaurant(10);
  Multiset<Integer> counts = HashMultiset.create();
  for (int j = 0; j < 100; j++) {
   counts.add(x.sample());
  }
  List<Integer> tmp = Lists.newArrayList();
  for (Integer k : counts.elementSet()) {
   tmp.add(counts.count(k));
  }
  Collections.sort(tmp, Collections.reverseOrder());
  while (totals.size() < tmp.size()) {
   totals.add(0);
  }
  int j = 0;
  for (Integer k : tmp) {
   totals.set(j, totals.get(j) + k);
   j++;
  }
 }
 // these are empirically derived values, not principled ones
 assertEquals(25000.0, (double) totals.get(0), 1000);
 assertEquals(24000.0, (double) totals.get(1), 1000);
 assertEquals(8000.0, (double) totals.get(2), 200);
 assertEquals(1000.0, (double) totals.get(15), 50);
 assertEquals(1000.0, (double) totals.get(20), 40);
}

@Test
public void testRulesRunOnNonOvershadowedSegmentsOnly()
         mockPeon
     ).collect(Collectors.toCollection(() -> new TreeSet<>(Collections.reverseOrder())))
 CoordinatorStats stats = afterParams.getCoordinatorStats();
 Assert.assertEquals(1, stats.getTiers("assignedCount").size());
 Assert.assertEquals(1, stats.getTieredStat("assignedCount", "_default_tier"));
 Assert.assertTrue(stats.getTiers("unassignedCount").isEmpty());
 Assert.assertTrue(stats.getTiers("unassignedSize").isEmpty());
 Assert.assertEquals(2, availableSegments.size());
 Assert.assertEquals(availableSegments, params.getAvailableSegments());
 Assert.assertEquals(availableSegments, afterParams.getAvailableSegments());

@Test
public void testFloat32() {
 Float[] vals =
   assertEquals("Surprising return value.",
    5, OrderedBytes.encodeFloat32(buf1, vals[i], ord));
   assertEquals("Broken test: serialization did not consume entire buffer.",
    buf1.getLength(), buf1.getPosition());
   assertEquals("Surprising serialized length.", 5, buf1.getPosition() - 1);
   assertEquals("Buffer underflow.", 0, a[0]);
   assertEquals("Buffer underflow.", 0, a[1]);
  Arrays.sort(encoded, Bytes.BYTES_COMPARATOR);
  Float[] sortedVals = Arrays.copyOf(vals, vals.length);
  if (ord == Order.ASCENDING) Arrays.sort(sortedVals);
  else Arrays.sort(sortedVals, Collections.reverseOrder());

  /**
   * Checks reverse order of exchangeFutures.
   *
   * @throws Exception If failed.
   */
  @Test
  public void testExchangeFutures() throws Exception {
    GridCachePartitionExchangeManager mgr = ((IgniteKernal)grid(0)).internalCache(DEFAULT_CACHE_NAME).context().shared().exchange();

    for (int i = 1; i <= 10; i++) {
      startGrid(i);

      List<GridDhtPartitionsExchangeFuture> futs = mgr.exchangeFutures();

      List<GridDhtPartitionsExchangeFuture> sortedFuts = new ArrayList<>(futs);

      Collections.sort(sortedFuts, Collections.reverseOrder());

      for (int j = 0; j < futs.size(); j++)
        assertEquals(futs.get(j), sortedFuts.get(j));
    }
  }
}

@Test
public void testRun()
     Stream.of(
       new ServerHolder(druidServer, mockPeon)
     ).collect(Collectors.toCollection(() -> new TreeSet<>(Collections.reverseOrder())))
   ));

 @Test
 public void testApplyDescending() {
  byte[][] vals = new byte[VALS.length][];
  byte[][] ordered = new byte[VALS.length][];
  for (int i = 0; i < VALS.length; i++) {
   vals[i] = Arrays.copyOf(VALS[i], VALS[i].length);
   ordered[i] = Arrays.copyOf(VALS[i], VALS[i].length);
   DESCENDING.apply(ordered[i]);
  }

  Arrays.sort(vals, Collections.reverseOrder(Bytes.BYTES_COMPARATOR));
  Arrays.sort(ordered, Bytes.BYTES_COMPARATOR);

  for (int i = 0; i < vals.length; i++) {
   DESCENDING.apply(ordered[i]);
   assertArrayEquals(vals[i], ordered[i]);
  }

  byte[] expected = new byte[] { VALS[0][0], DESCENDING.apply(VALS[0][1]), VALS[0][2] };
  byte[] rangeApply = Arrays.copyOf(VALS[0], VALS[0].length);
  DESCENDING.apply(rangeApply, 1, 1);
  assertArrayEquals(expected, rangeApply);
 }
}

Collections.sort(sortedKeys, Collections.reverseOrder());
        break;
      chunkList.add(it.next());
    ret.add(chunkList);

@Test
public void sortByKey() {
 List<Tuple2<Integer, Integer>> pairs = new ArrayList<>();
 pairs.add(new Tuple2<>(0, 4));
 pairs.add(new Tuple2<>(3, 2));
 pairs.add(new Tuple2<>(-1, 1));
 JavaPairRDD<Integer, Integer> rdd = sc.parallelizePairs(pairs);
 // Default comparator
 JavaPairRDD<Integer, Integer> sortedRDD = rdd.sortByKey();
 assertEquals(new Tuple2<>(-1, 1), sortedRDD.first());
 List<Tuple2<Integer, Integer>> sortedPairs = sortedRDD.collect();
 assertEquals(new Tuple2<>(0, 4), sortedPairs.get(1));
 assertEquals(new Tuple2<>(3, 2), sortedPairs.get(2));
 // Custom comparator
 sortedRDD = rdd.sortByKey(Collections.reverseOrder(), false);
 assertEquals(new Tuple2<>(-1, 1), sortedRDD.first());
 sortedPairs = sortedRDD.collect();
 assertEquals(new Tuple2<>(0, 4), sortedPairs.get(1));
 assertEquals(new Tuple2<>(3, 2), sortedPairs.get(2));
}

@Test
public void shouldGeneratePowerLawDistribution() {
  GraphDatabaseService database = new TestGraphDatabaseFactory().newImpermanentDatabase();
  try {
    new Neo4jGraphGenerator(database).generateGraph(getGeneratorConfiguration(100, 2));
    List<Integer> degrees = new LinkedList<>();
    try (Transaction tx = database.beginTx()) {
      for (Node node : database.getAllNodes()) {
        degrees.add(node.getDegree());
      }
      tx.success();
    }
    Collections.sort(degrees, Collections.reverseOrder());
    //todo make this an automated test
    //System.out.println(ArrayUtils.toString(degrees.toArray(new Integer[degrees.size()])));
  } finally {
    database.shutdown();
  }
}

private static List<GameInfo> getSavedGameOrRecording(Path saveOrRecordingPath) {
  SortedMap<FileTime, Path> savedGamePaths = Maps.newTreeMap(Collections.reverseOrder());
  try (DirectoryStream<Path> stream = Files.newDirectoryStream(saveOrRecordingPath)) {
    for (Path entry : stream) {
        if (!info.getTitle().isEmpty()) {
          Date date = new Date(world.getKey().toMillis());
          result.add(new GameInfo(info, date, world.getValue()));

@Test
public void testRunTwoTiersWithExistingSegments()
         mockPeon
     ).collect(Collectors.toCollection(() -> new TreeSet<>(Collections.reverseOrder()))),
     "normal",
     Stream.of(
         mockPeon
     ).collect(Collectors.toCollection(() -> new TreeSet<>(Collections.reverseOrder())))
 CoordinatorStats stats = afterParams.getCoordinatorStats();
 Assert.assertEquals(12L, stats.getTieredStat("assignedCount", "hot"));
 Assert.assertEquals(0L, stats.getTieredStat("assignedCount", "normal"));
 Assert.assertTrue(stats.getTiers("unassignedCount").isEmpty());
 Assert.assertTrue(stats.getTiers("unassignedSize").isEmpty());

@Test
public void testFloat64() {
 Double[] vals =
   assertEquals("Surprising return value.",
    9, OrderedBytes.encodeFloat64(buf1, vals[i], ord));
   assertEquals("Broken test: serialization did not consume entire buffer.",
    buf1.getLength(), buf1.getPosition());
   assertEquals("Surprising serialized length.", 9, buf1.getPosition() - 1);
   assertEquals("Buffer underflow.", 0, a[0]);
   assertEquals("Buffer underflow.", 0, a[1]);
  Arrays.sort(encoded, Bytes.BYTES_COMPARATOR);
  Double[] sortedVals = Arrays.copyOf(vals, vals.length);
  if (ord == Order.ASCENDING) Arrays.sort(sortedVals);
  else Arrays.sort(sortedVals, Collections.reverseOrder());

 @Override
 public List<String> order(List<String> insertionOrder) {
  Collections.sort(insertionOrder, Collections.reverseOrder());
  return insertionOrder;
 }
}

@Test
public void testRunRuleDoesNotExist()
         mockPeon
     ).collect(Collectors.toCollection(() -> new TreeSet<>(Collections.reverseOrder())))