java.lang.Integer.reverse java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 ScheduledThreadPoolExecutor s =new ScheduledThreadPoolExecutor(corePoolSize)
ThreadFactory threadFactory;new ScheduledThreadPoolExecutor(corePoolSize, threadFactory)
String str;new ScheduledThreadPoolExecutor(1, new ThreadFactoryBuilder().setNameFormat(str).build())
Smart code suggestions by Tabnine
}

byte bitsRev = (byte) (Integer.reverse(aByte) >>> (Integer.SIZE - Byte.SIZE));

@Override
public Object read(ByteBuffer buff, int tag) {
  switch (tag) {
  case TAG_FLOAT_0:
    return 0f;
  case TAG_FLOAT_1:
    return 1f;
  case TAG_FLOAT_FIXED:
    return buff.getFloat();
  }
  return Float.intBitsToFloat(Integer.reverse(DataUtils
      .readVarInt(buff)));
}

int probeThree(short element, int removedIndex)
{
  int nextIndex = Integer.reverse(SpreadFunctions.shortSpreadOne(element));
  int spreadTwo = Integer.reverse(SpreadFunctions.shortSpreadTwo(element)) | 1;
  while(true)
  {
    nextIndex = this.mask(nextIndex + spreadTwo);
    short keyAtIndex = this.keys[nextIndex];
    if (keyAtIndex == element)
    {
      return nextIndex;
    }
    if (keyAtIndex == EMPTY_KEY)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (keyAtIndex == REMOVED_KEY && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

int probeThree(int element, int removedIndex)
{
  int nextIndex = Integer.reverse(SpreadFunctions.intSpreadOne(element));
  int spreadTwo = Integer.reverse(SpreadFunctions.intSpreadTwo(element)) | 1;
  while(true)
  {
    nextIndex = this.mask(nextIndex + spreadTwo);
    int valueAtIndex = this.table[nextIndex];
    if (valueAtIndex == element)
    {
      return nextIndex;
    }
    if (valueAtIndex == EMPTY)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (valueAtIndex == REMOVED && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

int probeThree(int element, int removedIndex)
{
  int nextIndex = Integer.reverse(SpreadFunctions.intSpreadOne(element));
  int spreadTwo = Integer.reverse(SpreadFunctions.intSpreadTwo(element)) | 1;
  while(true)
  {
    nextIndex = this.mask(nextIndex + spreadTwo);
    int valueAtIndex = this.table[nextIndex];
    if (valueAtIndex == element)
    {
      return nextIndex;
    }
    if (valueAtIndex == EMPTY)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (valueAtIndex == REMOVED && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

int probeThree(short element, int removedIndex)
{
  int nextIndex = Integer.reverse(SpreadFunctions.shortSpreadOne(element));
  int spreadTwo = Integer.reverse(SpreadFunctions.shortSpreadTwo(element)) | 1;
  while(true)
  {
    nextIndex = this.mask(nextIndex + spreadTwo);
    short valueAtIndex = this.table[nextIndex];
    if (valueAtIndex == element)
    {
      return nextIndex;
    }
    if (valueAtIndex == EMPTY)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (valueAtIndex == REMOVED && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

int probeThree(float element, int removedIndex)
{
  int nextIndex = (int) SpreadFunctions.floatSpreadOne(element);
  int spreadTwo = Integer.reverse(SpreadFunctions.floatSpreadTwo(element)) | 1;
  while (true)
  {
    nextIndex = this.mask(nextIndex + spreadTwo);
    float keyAtIndex = this.keys[nextIndex];
    if (Float.compare(keyAtIndex, element) == 0)
    {
      return nextIndex;
    }
    if (Float.compare(keyAtIndex, EMPTY_KEY) == 0)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (Float.compare(keyAtIndex, REMOVED_KEY) == 0 && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

int probeThree(float element, int removedIndex)
{
  int nextIndex = (int) SpreadFunctions.floatSpreadOne(element);
  int spreadTwo = Integer.reverse(SpreadFunctions.floatSpreadTwo(element)) | 1;
  while (true)
  {
    nextIndex = this.mask(nextIndex + spreadTwo);
    float keyAtIndex = this.keys[nextIndex];
    if (Float.compare(keyAtIndex, element) == 0)
    {
      return nextIndex;
    }
    if (Float.compare(keyAtIndex, EMPTY_KEY) == 0)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (Float.compare(keyAtIndex, REMOVED_KEY) == 0 && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

int probeThree(float element, int removedIndex)
{
  int nextIndex = (int) SpreadFunctions.floatSpreadOne(element);
  int spreadTwo = Integer.reverse(SpreadFunctions.floatSpreadTwo(element)) | 1;
  while (true)
  {
    nextIndex = this.mask(nextIndex + spreadTwo);
    float keyAtIndex = this.keys[nextIndex];
    if (Float.compare(keyAtIndex, element) == 0)
    {
      return nextIndex;
    }
    if (Float.compare(keyAtIndex, EMPTY_KEY) == 0)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (Float.compare(keyAtIndex, REMOVED_KEY) == 0 && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

  @Override
  public Value readValue(ByteBuffer buff, int tag) {
    switch (tag) {
    case TAG_FLOAT_0:
      return ValueFloat.get(0f);
    case TAG_FLOAT_1:
      return ValueFloat.get(1f);
    case TAG_FLOAT_FIXED:
      return ValueFloat.get(buff.getFloat());
    }
    return ValueFloat.get(Float.intBitsToFloat(Integer.reverse(DataUtils.readVarInt(buff))));
  }
};

int probeThree(short element, int removedIndex)
{
  int nextIndex = (int) SpreadFunctions.shortSpreadOne(element);
  int spreadTwo = Integer.reverse(SpreadFunctions.shortSpreadTwo(element)) | 1;
  while(true)
  {
    nextIndex = this.mask(nextIndex + spreadTwo);
    short keyAtIndex = this.keys[nextIndex];
    if (keyAtIndex == element)
    {
      return nextIndex;
    }
    if (keyAtIndex == EMPTY_KEY)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (keyAtIndex == REMOVED_KEY && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

int probeThree(int element, int removedIndex)
{
  int nextIndex = (int) SpreadFunctions.intSpreadOne(element);
  int spreadTwo = Integer.reverse(SpreadFunctions.intSpreadTwo(element)) | 1;
  while (true)
  {
    nextIndex = this.mask(nextIndex + spreadTwo);
    int keyAtIndex = this.keys[nextIndex];
    if (keyAtIndex == element)
    {
      return nextIndex;
    }
    if (keyAtIndex == EMPTY_KEY)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (keyAtIndex == REMOVED_KEY && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

int probeThree(char element, int removedIndex)
{
  int nextIndex = (int) SpreadFunctions.charSpreadOne(element);
  int spreadTwo = Integer.reverse(SpreadFunctions.charSpreadTwo(element)) | 1;
  while (true)
  {
    nextIndex = this.mask(nextIndex + spreadTwo);
    char keyAtIndex = this.keys[nextIndex];
    if (keyAtIndex == element)
    {
      return nextIndex;
    }
    if (keyAtIndex == EMPTY_KEY)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (keyAtIndex == REMOVED_KEY && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

int probeThree(char element, int removedIndex)
{
  int nextIndex = (int) SpreadFunctions.charSpreadOne(element);
  int spreadTwo = Integer.reverse(SpreadFunctions.charSpreadTwo(element)) | 1;
  while(true)
  {
    nextIndex = this.mask(nextIndex + spreadTwo);
    char keyAtIndex = this.keys[nextIndex];
    if (keyAtIndex == element)
    {
      return nextIndex;
    }
    if (keyAtIndex == EMPTY_KEY)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (keyAtIndex == REMOVED_KEY && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

int probeThree(short element, int removedIndex)
{
  int nextIndex = (int) SpreadFunctions.shortSpreadOne(element) << 1;
  int spreadTwo = Integer.reverse(SpreadFunctions.shortSpreadTwo(element)) | 1;
  while (true)
  {
    nextIndex = this.mask((nextIndex >> 1) + spreadTwo) << 1;
    short keyAtIndex = this.keysValues[nextIndex];
    if (keyAtIndex == element)
    {
      return nextIndex;
    }
    if (keyAtIndex == EMPTY_KEY)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (keyAtIndex == REMOVED_KEY && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

int probeThree(char element, int removedIndex)
{
  int nextIndex = (int) SpreadFunctions.charSpreadOne(element);
  int spreadTwo = Integer.reverse(SpreadFunctions.charSpreadTwo(element)) | 1;
  while (true)
  {
    nextIndex = this.mask(nextIndex + spreadTwo);
    char keyAtIndex = this.keys[nextIndex];
    if (keyAtIndex == element)
    {
      return nextIndex;
    }
    if (keyAtIndex == EMPTY_KEY)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (keyAtIndex == REMOVED_KEY && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

int probeThree(short element, int removedIndex)
{
  int nextIndex = (int) SpreadFunctions.shortSpreadOne(element);
  int spreadTwo = Integer.reverse(SpreadFunctions.shortSpreadTwo(element)) | 1;
  while (true)
  {
    nextIndex = this.mask(nextIndex + spreadTwo);
    short keyAtIndex = this.keys[nextIndex];
    if (keyAtIndex == element)
    {
      return nextIndex;
    }
    if (keyAtIndex == EMPTY_KEY)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (keyAtIndex == REMOVED_KEY && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

int probeThree(short element, int removedIndex)
{
  int nextIndex = (int) SpreadFunctions.shortSpreadOne(element);
  int spreadTwo = Integer.reverse(SpreadFunctions.shortSpreadTwo(element)) | 1;
  while (true)
  {
    nextIndex = this.mask(nextIndex + spreadTwo);
    short keyAtIndex = this.keys[nextIndex];
    if (keyAtIndex == element)
    {
      return nextIndex;
    }
    if (keyAtIndex == EMPTY_KEY)
    {
      return removedIndex == -1 ? nextIndex : removedIndex;
    }
    if (keyAtIndex == REMOVED_KEY && removedIndex == -1)
    {
      removedIndex = nextIndex;
    }
  }
}

private void write0(DataBuffer buff, float x) {
  int f = Float.floatToIntBits(x);
  if (f == FLOAT_ZERO_BITS) {
    buff.put((byte) TAG_FLOAT_0);
  } else if (f == FLOAT_ONE_BITS) {
    buff.put((byte) TAG_FLOAT_1);
  } else {
    int value = Integer.reverse(f);
    if (value >= 0 && value <= DataUtils.COMPRESSED_VAR_INT_MAX) {
      buff.put((byte) FLOAT).putVarInt(value);
    } else {
      buff.put((byte) TAG_FLOAT_FIXED).putFloat(x);
    }
  }
}

@Override
public void write(WriteBuffer buff, Object obj) {
  if (!(obj instanceof Float)) {
    super.write(buff, obj);
    return;
  }
  float x = (Float) obj;
  int f = Float.floatToIntBits(x);
  if (f == ObjectDataType.FLOAT_ZERO_BITS) {
    buff.put((byte) TAG_FLOAT_0);
  } else if (f == ObjectDataType.FLOAT_ONE_BITS) {
    buff.put((byte) TAG_FLOAT_1);
  } else {
    int value = Integer.reverse(f);
    if (value >= 0 && value <= DataUtils.COMPRESSED_VAR_INT_MAX) {
      buff.put((byte) TYPE_FLOAT).putVarInt(value);
    } else {
      buff.put((byte) TAG_FLOAT_FIXED).putFloat(x);
    }
  }
}

Javadoc

Reverses the order of the bits of the specified integer.

Popular methods of Integer

parseInt
Parses the specified string as a signed integer value using the specified radix. The ASCII character
toString
Converts the specified signed integer into a string representation based on the specified radix. The
valueOf
Parses the specified string as a signed integer value using the specified radix.
intValue
Gets the primitive value of this int.
<init>
Constructs a new Integer from the specified string.
toHexString
Returns a string representation of the integer argument as an unsigned integer in base 16.The unsign
equals
Compares this instance with the specified object and indicates if they are equal. In order to be equ
compareTo
Compares this Integer object to another object. If the object is an Integer, this function behaves l
hashCode
compare
Compares two int values.
longValue
Returns the value of this Integer as along.
decode
Parses the specified string and returns a Integer instance if the string can be decoded into an inte

Popular in Java

Start an intent from android
onCreateOptionsMenu (Activity)
addToBackStack (FragmentTransaction)
getSharedPreferences (Context)
Container (java.awt)
A generic Abstract Window Toolkit(AWT) container object is a component that can contain other AWT co
List (java.util)
An ordered collection (also known as a sequence). The user of this interface has precise control ove
Properties (java.util)
A Properties object is a Hashtable where the keys and values must be Strings. Each property can have
UUID (java.util)
UUID is an immutable representation of a 128-bit universally unique identifier (UUID). There are mul
Collectors (java.util.stream)
Option (scala)

How to use reversemethodin java.lang.Integer

Best Java code snippets using java.lang.Integer.reverse (Showing top 20 results out of 1,683)

How to use
reverse
method
in
java.lang.Integer