Java API for Comparator and Slice

I have implemented the Java API for Comparator and Slice.
(I have also signed the Facebook Contributors Agreement)

I offer two implementations which are selectable by a developer through implementing either of the abstract classes `org.rocksdb.Comparator` or `org.rocksdb.DirectComparator` for Comparators and likewise `org.rocksdb.Slice` or `org.rocksdb.DirectSlice` for Slices.

The classes named Direct, use a DirectByteBuffer to transfer data between C++ and Java, and may be faster when large keys or values are used. The non-Direct classes simply use java byte arrays, and appear to be faster for small keys and values due to the lower object-creation overhead.

Note: Using a `DirectComparator`, will result in receiving `DirectSlices`s in it's `compare` method callback.

Non-Direct Example:
```java

final Comparator myComparator = new TestComparator();
...
options.setComparator(myComparator);
...

public class TestComparator extends Comparator {
    @Override
    public String name() {
      return "Test-Comparator";
    }

    @Override
    public int compare(final Slice a, final Slice b) {
      final byte[] keyA = getKey(a);
      final byte[] keyB = getKey(b);
      return new BigInteger(keyA).compareTo(new BigInteger(keyB));
    }

    private byte[] getKey(final Slice s) {
      return s.data();
    }
  }

...

myComparator.dispose();
```

Direct Example:
```java

final DirectComparator myComparator = new TestDirectComparator();
...
options.setComparator(myComparator);
...

public class TestDirectComparator extends DirectComparator {
    @Override
    public String name() {
      return "Test-Direct-Comparator";
    }

    @Override
    public int compare(final DirectSlice a, final DirectSlice b) {
      final byte[] keyA = getKey(a);
      final byte[] keyB = getKey(b);

      return new BigInteger(keyA).compareTo(new BigInteger(keyB));
    }

    private byte[] getKey(final DirectSlice s) {
      final byte[] key = new byte[KEY_LENGTH];
      s.data().get(key);
      return key;
    }
  }

...

myComparator.dispose();
```

I have not written any serious C++ for many years, so this was a bit of a challenge! I hope the code, is acceptable, let me know of any revisions you require. The only thing I know I am unsure of currently is line 139 of java/rocksjni/slice.cc.
Yes, you are right and we will have to release data in dispose call. If you call env->ReleaseByteArrayElements in dispose function then you will also have to remember jbytearray. Will it better if you memcpy the ptrData obtained from env->GetByteArrayElements? This way you won't have to call env->ReleaseByteArrayElements in dispose function and you can just call delete on the natively allocated char*:

1. jbyte* ptrData = env->GetByteArrayElements(data, &isCopy);
2. char* buf = new char[len];
3. memcpy from ptrData, buf
4. Initialize Slice with buf
5.relesaeByteArrayElements

In dispose, just delete buf and you are done.

Thoughts?