Returns the element at the specified index.  Bounds checking is performed.
@param index Index of the element being retrieved
@return The retrieved element
429113
public T get( int index ) {
		if( index >= size )
			throw new IllegalArgumentException("Index out of bounds: index "+index+" size "+size);
		return data[index];
	}
1053936
public Object get (Object array, int index)
    {
        return (array == null) ? null : Array.get(array, index);
    }
1047017
public <T> T get(int index) {
        if (size() <= index) {
            return null;
        }
        return (T) args.get(index);
    }
617622
public T get(int index) throws IndexOutOfBoundsException {
        if (index >= mSize || index < 0) {
            throw new IndexOutOfBoundsException("Asked to get item at " + index + " but size is "
                    + mSize);
        }
        return mData[index];
    }
1092632
public ByteBuffer getElementAt(int index) {
        if (index >= elementsInBucket) {
            return null;
        } else {
            int chunk = index * gp.getElementSize() / memory[0].length;
            int offset = index * gp.getElementSize() % memory[0].length;
            return ByteBuffer.wrap(memory[chunk], offset, gp.getElementSize()).asReadOnlyBuffer();
        }
    }
720417
@SuppressWarnings("unchecked")
  public static Object getElement(Object iterable, int index) {
    if (iterable.getClass().isArray())
      return getElementFromArrary(iterable, index);
    if (iterable instanceof Collection)
      return getElementFromCollection((Collection<Object>) iterable, index);

    return null;
  }
392426
public int get(int index) throws NoSuchElementException {
        if (tc.isEntryEnabled())
            SibTr.entry(tc, "get");

        int retValue = 0;

        // We need to work out which array this item will be in
        int arrayNumber = index / arraySize;

        // Bounds check
        if ((index + 1) > elements) {
            throw new NoSuchElementException();
        } else if (index < 0) {
            throw new NoSuchElementException();
        }
        // Is it in the current array?
        else if (allArrays.size() == arrayNumber) {
            retValue = current[index - (arrayNumber * arraySize)];
        }
        // Else get the array from the Vector and
        // return the value
        else {
            int[] tempArray = (int[]) allArrays.get(arrayNumber);
            retValue = tempArray[index - (arrayNumber * arraySize)];
        }

        if (tc.isDebugEnabled())
            SibTr.debug(tc, "rc=", retValue);
        if (tc.isEntryEnabled())
            SibTr.exit(tc, "get");

        return retValue;
    }
524479
public String get(int idx)
    {
        if ( idx < 0 || idx >= parts.size() ) {
            throw new IndexOutOfBoundsException();
        }
        
        return parts.get(idx);
    }
1318018
@Override
	public final byte get(int index) {
		final long pos = address + index;
		if (index >= 0 && pos < addressLimit) {
			return UNSAFE.getByte(heapMemory, pos);
		}
		else if (address > addressLimit) {
			throw new IllegalStateException("segment has been freed");
		}
		else {
			// index is in fact invalid
			throw new IndexOutOfBoundsException();
		}
	}
446388
@Override
    public byte[] get(int index) {
        rangeCheck(index);
        
        try {
            long address = getAddress(index);
            int segPos = _addressFormat.getOffset(address);
            int segInd = _addressFormat.getSegment(address);
            
            // no data found
            if(segPos < Segment.dataStartPosition) return null;
            
            // get data segment
            Segment seg = _segmentManager.getSegment(segInd);
            if(seg == null) return null;
            
            // read data length
            int size = _addressFormat.getDataSize(address);
            int len = (size == 0) ? seg.readInt(segPos) : size;
            
            // read data into byte array
            byte[] data = new byte[len];
            if (len > 0) {
                seg.read(segPos + 4, data);
            }
            
            return data;
        } catch(Exception e) {
            _log.warn(e.getMessage());
            return null;
        }
    }
431222
public String get(final long index) {
        return doWithJedis(new JedisCallable<String>() {
            @Override
            public String call(Jedis jedis) {
                return jedis.lindex(getKey(), index);
            }
        });
    }
1021057
public int getFromIndex(int index) {
        Object node = objs[index];
        return node == null || node == DELETED ? -1 : ints[index];
    }
208270
public Object get(int index) {
    try {
      return getValue(index);
    } catch (JMFException e) {
      FFDCFilter.processException(e, "get", "125", this);
      return null;
    }
  }
528035
@Override
    public String getString(int index) throws IndexOutOfBoundsException {
        indexCheck();
        return rows.get(row).getString(index);
    }
288209
@SuppressWarnings("unchecked")
	@Override
	public <T> T get(int index) {
		return (T) array.get(index).getObject();
	}
653303
public E get(int index)
    {
        lock.readLock().lock();
        try
        {
            if (index >= size)
                return null;

            index++;
            int c = 0;
            Node<E> finger = head;
            for (int i = maxHeight - 1 ; i >= 0 ; i--)
            {
                while (c + finger.size[i] <= index)
                {
                    c += finger.size[i];
                    finger = finger.next(i);
                }
            }

            assert c == index;
            return finger.value;
        }
        finally
        {
            lock.readLock().unlock();
        }
    }
531510
@Override
    public byte get(int index) {
        Preconditions.checkElementIndex(index, this.length, "index");
        return this.array[index + this.startOffset];
    }