Main.java Source code

Introduction

Here is the source code for Main.java

Source

//package com.java2s;
/*
 * @(#)$Id: ArrayUtils.java 3619 2008-03-26 07:23:03Z yui $
 * 
 * Copyright 2006-2008 Makoto YUI
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 * 
 * Contributors: Makoto YUI - ported from jakarta commons lang
 */

import java.lang.reflect.Array;

public class Main {
    /**
     * <p>
     * Removes the element at the specified position from the specified array. All subsequent elements
     * are shifted to the left (substracts one from their indices).
     * </p>
     * 
     * <p>
     * This method returns a new array with the same elements of the input array except the element on
     * the specified position. The component type of the returned array is always the same as that of
     * the input array.
     * </p>
     * 
     * <p>
     * If the input array is <code>null</code>, an IndexOutOfBoundsException will be thrown, because
     * in that case no valid index can be specified.
     * </p>
     * 
     * @param array
     *          the array to remove the element from, may not be <code>null</code>
     * @param index
     *          the position of the element to be removed
     * @return A new array containing the existing elements except the element at the specified
     *         position.
     * @throws IndexOutOfBoundsException
     *           if the index is out of range (index < 0 || index >= array.length), or if the array is
     *           <code>null</code>.
     * @since 2.1
     */
    public static <T> T[] remove(final T[] array, final int index) {
        int length = getLength(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 (T[]) result;
    }

    public static <T> T[] remove(final T[] array, final int from, final int to) {
        assert (to >= from) : to + " - " + from;
        int length = getLength(array);
        if (from < 0 || to >= length) {
            throw new IndexOutOfBoundsException("from: " + from + ", to: " + to + ", Length: " + length);
        }
        int remsize = to - from + 1;
        Object result = Array.newInstance(array.getClass().getComponentType(), length - remsize);
        System.arraycopy(array, 0, result, 0, from);
        if (to < length - 1) {
            System.arraycopy(array, to + 1, result, from, length - to - 1);
        }
        return (T[]) result;
    }

    public static long[] remove(final long[] vals, final int idx) {
        long[] newVals = new long[vals.length - 1];
        if (idx > 0) {
            System.arraycopy(vals, 0, newVals, 0, idx);
        }
        if (idx < newVals.length) {
            System.arraycopy(vals, idx + 1, newVals, idx, newVals.length - idx);
        }
        return newVals;
    }

    public static long[] remove(final long[] vals, final int from, final int to) {
        int remsize = to - from + 1;
        long[] newVals = new long[vals.length - remsize];
        if (from > 0) {
            System.arraycopy(vals, 0, newVals, 0, from);
        }
        if (to < newVals.length) {
            System.arraycopy(vals, to + 1, newVals, from, newVals.length - to);
        }
        return newVals;
    }

    /**
     * <p>
     * Returns the length of the specified array. This method can deal with <code>Object</code> arrays
     * and with primitive arrays.
     * </p>
     * 
     * <p>
     * If the input array is <code>null</code>, <code>0</code> is returned.
     * </p>
     * 
     * <pre>
     * ArrayUtils.getLength(null)            = 0
     * ArrayUtils.getLength([])              = 0
     * ArrayUtils.getLength([null])          = 1
     * ArrayUtils.getLength([true, false])   = 2
     * ArrayUtils.getLength([1, 2, 3])       = 3
     * ArrayUtils.getLength([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]) = 3
     * </pre>
     * 
     * @param array
     *          the array to retrieve the length from, may be null
     * @return The length of the array, or <code>0</code> if the array is <code>null</code>
     * @throws IllegalArgumentException
     *           if the object arguement is not an array.
     */
    public static int getLength(final Object array) {
        if (array == null) {
            return 0;
        }
        return Array.getLength(array);
    }
}