This method removes an element from a list of strings.

@param list      The list to remove from.
@param index     The index of the element to remove from the list.
@param delimiter The list delimiter.
@return The new list.
339173
@Action(name = "List Remover",
            outputs = {
                    @Output(RESPONSE),
                    @Output(RETURN_RESULT),
                    @Output(RETURN_CODE)
            },
            responses = {
                    @Response(text = SUCCESS, field = RETURN_CODE, value = RETURN_CODE_SUCCESS, matchType = MatchType.COMPARE_EQUAL),
                    @Response(text = FAILURE, field = RETURN_CODE, value = RETURN_CODE_FAILURE, matchType = MatchType.COMPARE_EQUAL, isOnFail = true, isDefault = true)
            })
    public Map<String, String> removeElement(@Param(value = LIST, required = true) String list,
                                             @Param(value = ELEMENT, required = true) String index,
                                             @Param(value = DELIMITER, required = true) String delimiter) {
        Map<String, String> result = new HashMap<>();
        try {
            if (StringUtils.isEmpty(list) || StringUtils.isEmpty(index) || StringUtils.isEmpty(delimiter)) {
                throw new RuntimeException(EMPTY_INPUT_EXCEPTION);
            } else {
                String[] elements = StringUtils.split(list, delimiter);
                elements = ArrayUtils.remove(elements, Integer.parseInt(index));
                result.put(RESPONSE, SUCCESS);
                result.put(RETURN_RESULT, StringUtils.join(elements, delimiter));
                result.put(RETURN_CODE, RETURN_CODE_SUCCESS);
            }
        } catch (Exception e) {
            result.put(RESPONSE, FAILURE);
            result.put(RETURN_RESULT, e.getMessage());
            result.put(RETURN_CODE, RETURN_CODE_FAILURE);
        }
        return result;
    }
589663
public E remove(int index) {
        if (index >= mSize)
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
                    + mSize);

        E ret = mElements.remove(index < 0 ? index + mSize : index);
        mSize--;
        return ret;
    }
240200
public boolean remove(int index) {

        Widget w = getWidget(index);
        if (w != null) {
            return remove(getWidget(index));
        }
        return false;
    }
899697
@Deprecated
    public static String first(String list, String delimiter) {
	return first(list, delimiter, true, 1);
    }
955236
public static List<String> splitAsList(String text, String delimiter) {
        List<String> answer = new ArrayList<String>();
        if (text != null && text.length() > 0) {
            answer.addAll(Arrays.asList(text.split(delimiter)));
        }
        return answer;
    }
231037
public Object remove(int index) {
        if (index < 0 || index >= values.size()) {
            return null;
        }
        return values.remove(index);
    }
400128
private void remove(int listIndex)
    {
        if (listIndex == 0)
        {
            // Trivially remove from head.
            ivElements[ivHeadIndex++] = null;
        }
        else if (listIndex == ivTailIndex - 1)
        {
            // Trivially remove from tail.
            ivElements[--ivTailIndex] = null;
        }
        else
        {
            // Determine whether shifting the head or the tail requires the lower
            // number of element copies.

            int size = size();
            int halfSize = size >> 1;
            if (listIndex < halfSize)
            {
                // The index is less than half.  Shift the elements at the head of
                // the array up one index to cover the removed element.
                System.arraycopy(ivElements, ivHeadIndex, ivElements, ivHeadIndex + 1, listIndex);
                ivElements[ivHeadIndex++] = null;
            }
            else
            {
                // The index is more than half.  Shift the elements at the tail of
                // the array down one index to cover the removed element.
                int arrayIndex = ivHeadIndex + listIndex;
                System.arraycopy(ivElements, arrayIndex + 1, ivElements, arrayIndex, size - listIndex - 1);
                ivElements[--ivTailIndex] = null;
            }
        }

        if (isEmpty())
        {
            // Reset ivHeadIndex to 0 to avoid element copies in add().
            ivHeadIndex = 0;
            ivTailIndex = 0;
        }
    }
1180571
function remove(item, list) {
  var i = list.indexOf(item);
  if (~i) list.splice(i, 1);
}
709111
@NotNull
    public static List<String> toList(@Nullable final String stringList, @NotNull final String delimiter) {
        return new ArrayList<>(Arrays.asList(toArray(stringList, delimiter)));
    }
811476
public static String toDelimitedString(Collection<?> list, String delim) {
        if (list == null || list.isEmpty()) {
            return EMPTY;
        }
        StringBuilder sb = new StringBuilder();
        boolean first = true;
        for (Object o : list) {
            if (!first) {
                sb.append(delim);
            }
            sb.append(o);
            first = false;
        }
        return sb.toString();
    }
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;
    }
294256
public void remove( int idx ) 
    {
        if ( idx < 0 || idx > size )
            throw new IndexOutOfBoundsException();
        int numMove = size - idx - 1;
        if ( numMove > 0 )
            System.arraycopy(items, idx + 1, items, idx, numMove);
        size--;
    }
1372363
function (index) {
        validateListIndex(this, index);

        var i = index,
            len = --this.length;

        for (; i < len; i++) {
            this[i] = this[i + 1];
        }

        delete this[len];
    }
466483
protected String join(Collection<?> list, String delimiter) {
        return Joiner.on(delimiter).join(list);
    }
685138
public static <T> void remove(List<T> list, List<Integer> removes) {
        // 不是ArrayList的先转换为ArrayList
        if (!(list instanceof ArrayList)) {
            list = new ArrayList<>(list);
        }
        int flag = 0;
        // 删除
        for (int i = 0; i < removes.size(); i++) {
            if (flag < removes.get(i)) {
                flag = removes.get(i);
                list.remove(flag - i);
            } else {
                throw new CollectionException("删除集合中多个元素时指针应该按照从小到大的顺序排序");
            }
        }
    }
1163997
public static int removeDuplicateNodeList(List<String> list) {

        int originCount = list.size();
        // add elements to all, including duplicates
        HashSet<String> hs = new LinkedHashSet<String>();
        hs.addAll(list);
        list.clear();
        list.addAll(hs);

        return originCount - list.size();
    }
350987
public static String joiningWithDelimiter(CharSequence delimiter,
            List<String> stringList) {
        return joiningWith(stringList.stream(), delimiter);
    }