Try:

Collections.sort(myListOfByteArrays, new Comparator<byte[]> {
   // compares byte arrays using lexical ordering
   public int compare(byte[] arr1, byte[] arr2) {
      int len = Math.min(arr1.length, arr2.length);
      for(int i = 0; i < len; i++) {
        int cmp = arr1[i] - arr2[i];
        if (cmp != 0) { return cmp; }
      }
      return arr1.length - arr2.length;
   }
 });

Warning: written directly in newsreader, not tested :)

When you have sorted the lists, you can run through them, using
a pair of iterators and see if they match, perhaps using the
same comparator again.

/L

    It seems you don't care about the order of items in
the two Lists, but only about their presence: a,b is
to be considered "equal" to b,a.  (In fact, it seems
you want a,b,a to be "equal" to a,b.  Stranger still,
the code says that a,b is "equal" to a,b,c but that
a,b,c is "unequal" to a,b -- are you sure you've coded
what you actually intend?)

    That aside, you can certainly sort the Lists of
byte arrays.  There are two Collections.sort() methods:
one that uses the natural order of collections of
Comparable objects (which doesn't help you), but another
which uses a Comparator object that you can supply.
By sorting both Lists, you can turn the O(N*N) process
shown above into an O(N*log(N)) process; whether this
is or isn't worth while depends on the value of N and
of the messy details hidden behind the Big-O's.

    It seems attractive to use a Set (where order doesn't
matter) instead of a List (where it does), but that will
require wrapping each byte array in a class with a little
intelligence.  Still, that may not be a drawback: Just
how "raw" are these arrays supposed to be, anyhow?  If
they have some kind of significance, perhaps the wrapping
class will turn out to have other uses anyhow.

Use the Comparator method overloaded version of sort:

Collections.sort(byteArrays, new Comparator<byte[]>() {
   public int compare(byte[] o1, byte[] o2) {
    // do your byte comparison here.
   }
});

On Tue, 11 Dec 2007 06:59:43 -0800 (PST), mikew01
<mikew01@blueyonder.co.uk> wrote, quoted or indirectly quoted someone
who said :

You can use a Comparator with Arrays.sort

For sorting byte arrays, a Radixsort will be very quick. See
http://mindprod.com/jgloss/radixsort.html