Remove an item at the given index

@param index     the index of the item to remove
@return          the removed item
765091
public M remove(int index){
        M item = items.remove(index);
        applyFilter();
        return item;
    }
1021802
public void removeAt(int index) {
        System.arraycopy(mKeys, index + 1, mKeys, index, mSize - (index + 1));
        System.arraycopy(mValues, index + 1, mValues, index, mSize - (index + 1));
        mSize--;
    }
1121099
public synchronized Layer remove(int index, boolean redraw) {
        Layer layer = this.layersList.remove(index);
        layer.unassign();
        if (redraw) {
            this.redrawer.redrawLayers();
        }
        return layer;
    }
614703
public double removeD(int index)
    {
        boundsCheck(index);
        double ret = array[index];
        for(int i = index; i < end-1; i++)
            array[i] = array[i+1];
        decreaseSize(1);
        return ret;
    }
680989
def delete(self, index=None):
        
        if index is None:
            javabridge.call(self.jobject, "delete", "()V")
        else:
            javabridge.call(self.jobject, "delete", "(I)V", index)
1027902
public void removeVertex(int index) {
        this.cornerX.remove(index);
        this.cornerY.remove(index);
        this.cornerZ.remove(index);
        if (isGradation() == true) this.cornerColor.remove(index);
        setNumberOfCorner(this.cornerX.size());
        calcG();
    }
880101
public void removeChildAt(int index) throws IndexOutOfBoundsException {
        Node<T> child = children.get(index);
        child.parent = null;
        children.remove(index);
    }
996511
public Option getItem(final int index) {
        checkIndex(index);
        OptionElement item = selectElement.getOptions().getItem(index);
        return itemMap.get(item);
    }
275623
public function remove($index) {
        $element = $this->get($index);
        if (!is_null($element)) { array_splice($this->_elements, $index, 1); }
        return $element;
    }
842067
public Object remove(int index) {
        return index >= 0 && index < this.length()
            ? this.myArrayList.remove(index)
            : null;
    }
240200
public boolean remove(int index) {

        Widget w = getWidget(index);
        if (w != null) {
            return remove(getWidget(index));
        }
        return false;
    }
1149738
public static Object remove(Object array, int index) {
        int length = length(array);
        if (index < 0 || index >= length) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
        }

        Object result = Array.newInstance(array.getClass().getComponentType(), length - 1);
        System.arraycopy(array, 0, result, 0, index);
        if (index < length - 1) {
            System.arraycopy(array, index + 1, result, index, length - index - 1);
        }

        return result;
    }
348876
private static void removeDifferingIndexIfAny(final MongoCollection collection, final Index index) {
        val indexes = (ListIndexesIterable<Document>) collection.listIndexes();
        var indexExistsWithDifferentOptions = false;

        for (val existingIndex : indexes) {
            val keyMatches = existingIndex.get("key").equals(index.getIndexKeys());
            val optionsMatch = index.getIndexOptions().entrySet().stream().allMatch(entry -> entry.getValue().equals(existingIndex.get(entry.getKey())));
            val noExtraOptions = existingIndex.keySet().stream().allMatch(key -> MONGO_INDEX_KEYS.contains(key) || index.getIndexOptions().keySet().contains(key));
            indexExistsWithDifferentOptions |= keyMatches && !(optionsMatch && noExtraOptions);
        }

        if (indexExistsWithDifferentOptions) {
            LOGGER.debug("Removing MongoDb index [{}] from [{}] because it appears to already exist in a different form", index.getIndexKeys(), collection.getNamespace());
            collection.dropIndex(index.getIndexKeys());
        }
    }
1276820
function removeAt(items, index) {
  var copy = items.slice();
  copy.splice(index, 1);
  return copy;
}
79884
private void removeProperty(ItemState item, int indexItem)
   {
      if (indexItem == -1)
      {
         items.remove(item);
      }
      else
      {
         items.remove(indexItem);
      }
      index.remove(item.getData().getIdentifier());
      index.remove(item.getData().getQPath());
      index.remove(new ParentIDQPathBasedKey(item));
      index.remove(new IDStateBasedKey(item.getData().getIdentifier(), item.getState()));
      lastChildPropertyStates.remove(item.getData().getIdentifier());
      childPropertyStates.remove(item.getData().getIdentifier());

      Map<String, ItemState> children = lastChildPropertyStates.get(item.getData().getParentIdentifier());
      if (children != null)
      {
         children.remove(item.getData().getIdentifier());
         if (children.isEmpty())
         {
            lastChildPropertyStates.remove(item.getData().getParentIdentifier());
         }
      }

      List<ItemState> listItemStates = childPropertyStates.get(item.getData().getParentIdentifier());
      if (listItemStates != null)
      {
         listItemStates.remove(item);
         if (listItemStates.isEmpty())
         {
            childPropertyStates.remove(item.getData().getParentIdentifier());
         }
      }
   }
1334084
@Override
    public T remove(int index) {
        /* Cache the value at the indicated position; this also does the bounds
         * check.
         */
        T result = get(index);

        /* Use a naive shuffle-down algorithm to reposition elements after
         * the removed one.
         */
        for (int i = index + 1; i < size(); ++i)
            set(i - 1, get(i));

        /* Clobber the last element to play nicely with the garbage collector. */
        set(size() - 1, null);

        /* Decrement our size. */
        --mSize;

        /* If we are now at 1/8 total capacity, shrink the structure. */
        if (size() * 8 <= mArrays.length * mArrays.length)
            shrink();
            /* Otherwise, if the size is now an even multiple of the array size,
             * we can drop the very last array.  This is the array whose offset
             * is one after the end of the elements.
             */
        else if (size() % mArrays.length == 0)
            mArrays[computeOffset(size())] = null;

        return result;
    }
1222208
public XEvent remove(int index) {
		try {
			XEvent result = events.remove(index);
			return result;
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
	}