this.ordering = ordering;
  }

  @Override
  public int compare(@Nullable T left, @Nullable T right) {
    if (left == right) {
      return 0;
    }
    if (left == null) {
      return LEFT_IS_GREATER;
    }
    if (right == null) {
      return RIGHT_IS_GREATER;
    }
    return ordering.compare(left, right);
  }

  @Override

    this.ordering = ordering;
  }

  @Override
  public int compare(@Nullable T left, @Nullable T right) {
    if (left == right) {
      return 0;
    }
    if (left == null) {
      return LEFT_IS_GREATER;
    }
    if (right == null) {
      return RIGHT_IS_GREATER;
    }
    return ordering.compare(left, right);
  }

  @Override

        analysis.sort((a, b) -> Long.compare(b.potentialSavings, a.potentialSavings));
        return analysis;
    }

    private List<ValueFrequency> getMostFrequentValues(Map<String, StringStats> stats, int limit) {
        return stats.entrySet().stream()
                .map(e -> new ValueFrequency(e.getKey(), e.getValue().getOccurrences()))
                .sorted((a, b) -> Long.compare(b.frequency, a.frequency))

    public void test_compareTo() {
        // Test compareTo method for enum constants
        assertEquals(0, SsoResponseType.METADATA.compareTo(SsoResponseType.METADATA));
        assertEquals(0, SsoResponseType.LOGOUT.compareTo(SsoResponseType.LOGOUT));
        assertTrue(SsoResponseType.METADATA.compareTo(SsoResponseType.LOGOUT) < 0);
        assertTrue(SsoResponseType.LOGOUT.compareTo(SsoResponseType.METADATA) > 0);
    }

    @Test

### Trabajando con *enumeraciones* de Python { #working-with-python-enumerations }

El valor del *path parameter* será un *miembro* de enumeración.

#### Comparar *miembros* de enumeraciones { #compare-enumeration-members }

Puedes compararlo con el *miembro* de enumeración en tu enum creada `ModelName`:

{* ../../docs_src/path_params/tutorial005_py310.py hl[17] *}

    this.comparators =
        Iterables.toArray(comparators, (Comparator<? super T>[]) new Comparator<?>[0]);
  }

  @Override
  public int compare(@ParametricNullness T left, @ParametricNullness T right) {
    for (int i = 0; i < comparators.length; i++) {
      int result = comparators[i].compare(left, right);
      if (result != 0) {
        return result;
      }
    }
    return 0;
  }

  @Override

      buffer[bufferSize++] = elem;
      // uncheckedCastNullableTToT is safe because bufferSize > 0.
      if (comparator.compare(elem, uncheckedCastNullableTToT(threshold)) > 0) {
        threshold = elem;
      }
      // uncheckedCastNullableTToT is safe because bufferSize > 0.
    } else if (comparator.compare(elem, uncheckedCastNullableTToT(threshold)) < 0) {
      // Otherwise, we can ignore elem; we've seen k better elements.

          for (int i = 0; i < size; i++) {
            // We're careful to put only K instances in.
            if (i > 0 && comparator.compare((K) sortedKeys[i - 1], (K) sortedKeys[i]) == 0) {
              throw new IllegalArgumentException(
                  "keys required to be distinct but compared as equal: "
                      + sortedKeys[i - 1]
                      + " and "
                      + sortedKeys[i]);
            }

        }

        if (
        /* s1 != null && */ s2 == null) {
            return 1;
        }

        return s1.compareTo(s2);
    }

    // ---------------------------------------------------------------------
    @Override
    public int compareTo(MetadataGraphVertex vertex) {
        if (vertex == null || vertex.getMd() == null) {
            return 1;
        }

- github.com/evanphx/json-patch: [v4.2.0+incompatible → e83c0a1](https://github.com/evanphx/json-patch/compare/v4.2.0...e83c0a1)
- github.com/fsnotify/fsnotify: [v1.4.7 → v1.4.9](https://github.com/fsnotify/fsnotify/compare/v1.4.7...v1.4.9)
- github.com/go-kit/kit: [v0.8.0 → v0.9.0](https://github.com/go-kit/kit/compare/v0.8.0...v0.9.0)