Java Comparateur de tableau d'octets (lexicographique)

J'ai une table de hachage avec byte[] touches. J'aimerais faire le tri par le biais d'un TreeMap.

Quel est le moyen le plus efficace pour mettre en œuvre le comparateur pour l'ordre lexicographique?

OriginalL'auteur marcorossi | 2011-02-24

  1. 20

    À l'aide de Goyave, vous pouvez utiliser soit:

    La UnsignedBytes comparateur semble avoir une forme optimisée à l'aide de Unsafe qu'il utilise s'il se peut. Les commentaires dans le code indiquent qu'il peut être au moins deux fois plus rapide qu'un Java normal de mise en œuvre.

    - nous avons la solution en "Java",dans l'affirmative, veuillez poster un exemple de travail.
    Comme ColinD dit dans le commentaire de ma réponse, ma solution est la même que la non optimisé dans la Goyave. Ainsi, vous pouvez directement utiliser le mien, qui est un exemple de travail, ou de suivre ColinD de liens.

    OriginalL'auteur ColinD

  2. 15

    Trouvé ce beau morceau de code dans Apache Hbase:

        public int compare(byte[] left, byte[] right) {
        for (int i = 0, j = 0; i < left.length && j < right.length; i++, j++) {
            int a = (left[i] & 0xff);
            int b = (right[j] & 0xff);
            if (a != b) {
                return a - b;
            }
        }
        return left.length - right.length;
    }
    C'est fondamentalement ce que la non-version optimisée de Goyave est UnsignedBytes.lexicographicalComparator().
    Hmm, pourquoi ont-ils utiliser i et j, quand une variable aurait été suffisant. Par ailleurs, la conservation int length = Math.min(left.length, right.length) et en comparant i < length permettrait d'améliorer ce pour les grands tableaux
    vous vous attendriez à ce que le champ longueur de la matrice serait aussi cher

    OriginalL'auteur marcorossi

  3. -1

    Je suis en supposant que le problème est seulement avec le "byte vs octet" comparaison. Traiter avec les baies est simple, je ne vais pas le couvrir. À l'égard de l'octet vs octet, ma première pensée est pour ce faire:

    public class ByteComparator implements Comparator<byte> {
  public int compare(byte b1, byte b2) {
    return new Byte(b1).compareTo(b2);
  }
}

    Mais qui ne sera pas lexicographique: 0xFF (l'octet signé pour -1) sera considéré comme étant plus faible que 0x00, quand lexicographiquement il est plus grand. Je pense que cela devrait faire l'affaire:

    public class ByteComparator implements Comparator<byte> {
  public int compare(byte b1, byte b2) {
    //convert to unsigned bytes (0 to 255) before comparing them.
    int i1 = b1 < 0 ? 256 + b1 : b1;
    int i2 = b2 < 0 ? 256 + b2 : b2;
    return i2 - i1;
  }
}

    Il y a probablement quelque chose dans Apache commons-lang ou des communes bibliothèques mathématiques qui fait cela, mais je ne sais pas hors de la main.

    OriginalL'auteur Julius Musseau

  4. -2

    Vous pouvez utiliser un comparateur qui comares le Personnage.toLowerCase() de chacun des octets du tableau (en Supposant que le byte[] est en ASCII) si non, vous aurez besoin de faire le personnage de décodage de vous-même ou utiliser new String(bytes, charSet).toLowerCase() mais ce n'est pas de chances d'être efficace.

    OriginalL'auteur Peter Lawrey