com.baidu.jprotobuf.pbrpc.utils.ArrayUtils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jprotobuf-rpc-core Show documentation
The core module of jprotobuf rpc socket implementation
There is a newer version: 4.2.2
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */
package com.baidu.jprotobuf.pbrpc.utils;

/**
 * 
 * Operations on arrays, primitive arrays (like int[]) and
 * primitive wrapper arrays (like Integer[]).
 * 
 * 
 * 
 * This class tries to handle null input gracefully. An exception
 * will not be thrown for a null array input. However, an Object
 * array that contains a null element may throw an exception. Each
 * method documents its behaviour.
 * 
 * 
 * @author xiemalin
 * @since 2.10
 */
public class ArrayUtils {
    
    /**
     * An empty immutable byte array.
     */
    public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];

    /**
     * 
     * Produces a new byte array containing the elements between
     * the start and end indices.
     * 
     * 
     * 
     * The start index is inclusive, the end index exclusive. Null array input
     * produces null output.
     * 
     * 
     * @param array
     *            the array
     * @param startIndexInclusive
     *            the starting index. Undervalue (<0) is promoted to 0,
     *            overvalue (>array.length) results in an empty array.
     * @param endIndexExclusive
     *            elements up to endIndex-1 are present in the returned
     *            subarray. Undervalue (< startIndex) produces empty array,
     *            overvalue (>array.length) is demoted to array length.
     * @return a new array containing the elements between the start and end
     *         indices.
     * @since 2.1
     */
    public static byte[] subarray(byte[] array, int startIndexInclusive, int endIndexExclusive) {
        if (array == null) {
            return null;
        }
        if (startIndexInclusive < 0) {
            startIndexInclusive = 0;
        }
        if (endIndexExclusive > array.length) {
            endIndexExclusive = array.length;
        }
        int newSize = endIndexExclusive - startIndexInclusive;
        if (newSize <= 0) {
            return EMPTY_BYTE_ARRAY;
        }

        byte[] subarray = new byte[newSize];
        System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
        return subarray;
    }
}