How to use

binarySearch

method

in

java.util.Arrays

private static int[] toFieldPosMap(int[] selectedFields) {
  int[] fieldIdxs = Arrays.copyOf(selectedFields, selectedFields.length);
  Arrays.sort(fieldIdxs);
  int[] fieldPosMap = new int[selectedFields.length];
  for (int i = 0; i < selectedFields.length; i++) {
    int pos = Arrays.binarySearch(fieldIdxs, selectedFields[i]);
    fieldPosMap[pos] = i;
  }
  return fieldPosMap;
}

  public static boolean findPair(int[] s1, int[] s2, int x) {
    /*
      Sort one array let say s2
      for each el in s1
        do a binary search in s2 for x-el
        if found return el and (x-el)
     */
    Arrays.sort(s2);
    for (int f : s1) {
      int s = x - f;
      if (Arrays.binarySearch(s2, s) >= 0) {
        return true;
      }
    }
    return false;
  }
}

public Keywords(Map<String, Token> keywords){
  this.keywords = keywords;
  this.hashArray = new long[keywords.size()];
  this.tokens = new Token[keywords.size()];
  int index = 0;
  for (String k : keywords.keySet()) {
    hashArray[index++] = Utils.fnv_64_lower(k);
  }
  Arrays.sort(hashArray);
  for (Map.Entry<String, Token> entry : keywords.entrySet()) {
    long k = Utils.fnv_64_lower(entry.getKey());
    index = Arrays.binarySearch(hashArray, k);
    tokens[index] = entry.getValue();
  }
}

/** {@inheritDoc} */
public boolean retainAll( byte[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  byte[] data = _data;
  for ( int i = _pos; i-- > 0; ) {
    if ( Arrays.binarySearch( array, data[i] ) < 0 ) {
      remove( i, 1 );
      changed = true;
    }
  }
  return changed;
}

/** {@inheritDoc} */
public boolean retainAll( float[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  float[] data = _data;
  for ( int i = _pos; i-- > 0; ) {
    if ( Arrays.binarySearch( array, data[i] ) < 0 ) {
      remove( i, 1 );
      changed = true;
    }
  }
  return changed;
}

/** {@inheritDoc} */
public boolean retainAll( char[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  char[] data = _data;
  for ( int i = _pos; i-- > 0; ) {
    if ( Arrays.binarySearch( array, data[i] ) < 0 ) {
      remove( i, 1 );
      changed = true;
    }
  }
  return changed;
}

/** {@inheritDoc} */
public boolean retainAll( int[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  int[] data = _data;
  for ( int i = _pos; i-- > 0; ) {
    if ( Arrays.binarySearch( array, data[i] ) < 0 ) {
      remove( i, 1 );
      changed = true;
    }
  }
  return changed;
}

/** {@inheritDoc} */
public boolean retainAll( short[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  short[] data = _data;
  for ( int i = _pos; i-- > 0; ) {
    if ( Arrays.binarySearch( array, data[i] ) < 0 ) {
      remove( i, 1 );
      changed = true;
    }
  }
  return changed;
}

/** {@inheritDoc} */
public boolean retainAll( double[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  double[] data = _data;
  for ( int i = _pos; i-- > 0; ) {
    if ( Arrays.binarySearch( array, data[i] ) < 0 ) {
      remove( i, 1 );
      changed = true;
    }
  }
  return changed;
}

/** {@inheritDoc} */
public boolean retainAll( long[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  long[] data = _data;
  for ( int i = _pos; i-- > 0; ) {
    if ( Arrays.binarySearch( array, data[i] ) < 0 ) {
      remove( i, 1 );
      changed = true;
    }
  }
  return changed;
}

public void addAccept(String name) {
  if (name == null || name.length() == 0) {
    return;
  }
  long hash = TypeUtils.fnv1a_64(name);
  if (Arrays.binarySearch(this.acceptHashCodes, hash) >= 0) {
    return;
  }
  long[] hashCodes = new long[this.acceptHashCodes.length + 1];
  hashCodes[hashCodes.length - 1] = hash;
  System.arraycopy(this.acceptHashCodes, 0, hashCodes, 0, this.acceptHashCodes.length);
  Arrays.sort(hashCodes);
  this.acceptHashCodes = hashCodes;
}

public void addDeny(String name) {
  if (name == null || name.length() == 0) {
    return;
  }
  long hash = TypeUtils.fnv1a_64(name);
  if (Arrays.binarySearch(this.denyHashCodes, hash) >= 0) {
    return;
  }
  long[] hashCodes = new long[this.denyHashCodes.length + 1];
  hashCodes[hashCodes.length - 1] = hash;
  System.arraycopy(this.denyHashCodes, 0, hashCodes, 0, this.denyHashCodes.length);
  Arrays.sort(hashCodes);
  this.denyHashCodes = hashCodes;
}

/** {@inheritDoc} */
public boolean retainAll( short[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  short[] set = _set;
  byte[] states = _states;
  for ( int i = set.length; i-- > 0; ) {
    if ( states[i] == FULL && ( Arrays.binarySearch( array, set[i] ) < 0) ) {
      removeAt( i );
      changed = true;
    }
  }
  return changed;
}

/** {@inheritDoc} */
public boolean retainAll( byte[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  byte[] values = _values;
  byte[] states = _states;
  for ( int i = values.length; i-- > 0; ) {
    if ( states[i] == FULL && ( Arrays.binarySearch( array, values[i] ) < 0) ) {
      removeAt( i );
      changed = true;
    }
  }
  return changed;
}

/** {@inheritDoc} */
public boolean retainAll( float[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  float[] values = _values;
  byte[] states = _states;
  for ( int i = values.length; i-- > 0; ) {
    if ( states[i] == FULL && ( Arrays.binarySearch( array, values[i] ) < 0) ) {
      removeAt( i );
      changed = true;
    }
  }
  return changed;
}

/** {@inheritDoc} */
public boolean retainAll( long[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  long[] set = _set;
  byte[] states = _states;
  for ( int i = set.length; i-- > 0; ) {
    if ( states[i] == FULL && ( Arrays.binarySearch( array, set[i] ) < 0) ) {
      removeAt( i );
      changed = true;
    }
  }
  return changed;
}

/** {@inheritDoc} */
public boolean retainAll( int[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  int[] set = _set;
  byte[] states = _states;
  for ( int i = set.length; i-- > 0; ) {
    if ( states[i] == FULL && ( Arrays.binarySearch( array, set[i] ) < 0) ) {
      removeAt( i );
      changed = true;
    }
  }
  return changed;
}

/** {@inheritDoc} */
public boolean retainAll( int[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  int[] values = _values;
  byte[] states = _states;
  for ( int i = values.length; i-- > 0; ) {
    if ( states[i] == FULL && ( Arrays.binarySearch( array, values[i] ) < 0) ) {
      removeAt( i );
      changed = true;
    }
  }
  return changed;
}

/** {@inheritDoc} */
public boolean retainAll( double[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  double[] set = _set;
  byte[] states = _states;
  for ( int i = set.length; i-- > 0; ) {
    if ( states[i] == FULL && ( Arrays.binarySearch( array, set[i] ) < 0) ) {
      removeAt( i );
      changed = true;
    }
  }
  return changed;
}

/** {@inheritDoc} */
public boolean retainAll( float[] array ) {
  boolean changed = false;
  Arrays.sort( array );
  float[] values = _values;
  byte[] states = _states;
  for ( int i = values.length; i-- > 0; ) {
    if ( states[i] == FULL && ( Arrays.binarySearch( array, values[i] ) < 0) ) {
      removeAt( i );
      changed = true;
    }
  }
  return changed;
}