Java ArrayUtil.MAX_ARRAY_LENGTH属性代码示例

/**
 * Reads a vint via {@link #readVInt()} and applies basic checks to ensure the read array size is sane.
 * This method uses {@link #ensureCanReadBytes(int)} to ensure this stream has enough bytes to read for the read array size.
 */
private int readArraySize() throws IOException {
    final int arraySize = readVInt();
    if (arraySize > ArrayUtil.MAX_ARRAY_LENGTH) {
        throw new IllegalStateException("array length must be <= to " + ArrayUtil.MAX_ARRAY_LENGTH  + " but was: " + arraySize);
    }
    if (arraySize < 0) {
        throw new NegativeArraySizeException("array size must be positive but was: " + arraySize);
    }
    // lets do a sanity check that if we are reading an array size that is bigger that the remaining bytes we can safely
    // throw an exception instead of allocating the array based on the size. A simple corrutpted byte can make a node go OOM
    // if the size is large and for perf reasons we allocate arrays ahead of time
    ensureCanReadBytes(arraySize);
    return arraySize;
}
 

/**
 * Creates a new {@link CachedOrds} from the {@link BinaryDocValues}.
 * Assumes that the {@link BinaryDocValues} is not {@code null}.
 */
public CachedOrds(OrdinalsSegmentReader source, int maxDoc) throws IOException {
  offsets = new int[maxDoc + 1];
  int[] ords = new int[maxDoc]; // let's assume one ordinal per-document as an initial size

  // this aggregator is limited to Integer.MAX_VALUE total ordinals.
  long totOrds = 0;
  final IntsRef values = new IntsRef(32);
  for (int docID = 0; docID < maxDoc; docID++) {
    offsets[docID] = (int) totOrds;
    source.get(docID, values);
    long nextLength = totOrds + values.length;
    if (nextLength > ords.length) {
      if (nextLength > ArrayUtil.MAX_ARRAY_LENGTH) {
        throw new IllegalStateException("too many ordinals (>= " + nextLength + ") to cache");
      }
      ords = ArrayUtil.grow(ords, (int) nextLength);
    }
    System.arraycopy(values.ints, 0, ords, (int) totOrds, values.length);
    totOrds = nextLength;
  }
  offsets[maxDoc] = (int) totOrds;
  
  // if ords array is bigger by more than 10% of what we really need, shrink it
  if ((double) totOrds / ords.length < 0.9) { 
    this.ordinals = new int[(int) totOrds];
    System.arraycopy(ords, 0, this.ordinals, 0, (int) totOrds);
  } else {
    this.ordinals = ords;
  }
}
 

public PriorityQueue(int maxSize, boolean prepopulate) {
  final int heapSize;
  if (0 == maxSize) {
    // We allocate 1 extra to avoid if statement in top()
    heapSize = 2;
  } else {
    if (maxSize > ArrayUtil.MAX_ARRAY_LENGTH) {
      // Don't wrap heapSize to -1, in this case, which
      // causes a confusing NegativeArraySizeException.
      // Note that very likely this will simply then hit
      // an OOME, but at least that's more indicative to
      // caller that this values is too big.  We don't +1
      // in this case, but it's very unlikely in practice
      // one will actually insert this many objects into
      // the PQ:
      // Throw exception to prevent confusing OOME:
      throw new IllegalArgumentException("maxSize must be <= " + ArrayUtil.MAX_ARRAY_LENGTH + "; got: " + maxSize);
    } else {
      // NOTE: we add +1 because all access to heap is
      // 1-based not 0-based.  heap[0] is unused.
      heapSize = maxSize + 1;
    }
  }
  // T is unbounded type, so this unchecked cast works always:
  @SuppressWarnings("unchecked") final T[] h = (T[]) new Object[heapSize];
  this.heap = h;
  this.maxSize = maxSize;

  if (prepopulate) {
    // If sentinel objects are supported, populate the queue with them
    T sentinel = getSentinelObject();
    if (sentinel != null) {
      heap[1] = sentinel;
      for (int i = 2; i < heap.length; i++) {
        heap[i] = getSentinelObject();
      }
      size = maxSize;
    }
  }
}