Java/Collections Data Structure/Array Insert Remove

Adds all the elements of the given arrays into a new boolean-value array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Adds all the elements of the given arrays into a new array.

*

The new array contains all of the element of array1 followed * by all of the elements array2. When an array is returned, it is always * a new array.

  *

*

   * ArrayUtils.addAll(array1, null)   = cloned copy of array1
   * ArrayUtils.addAll(null, array2)   = cloned copy of array2
   * ArrayUtils.addAll([], [])         = []
   * 

  *
  * @param array1  the first array whose elements are added to the new array.
  * @param array2  the second array whose elements are added to the new array.
  * @return The new boolean[] array.
  * @since 2.1
  */
 public static boolean[] addAll(boolean[] array1, boolean[] array2) {
     if (array1 == null) {
         return clone(array2);
     } else if (array2 == null) {
         return clone(array1);
     }
     boolean[] joinedArray = new boolean[array1.length + array2.length];
     System.arraycopy(array1, 0, joinedArray, 0, array1.length);
     System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
     return joinedArray;
 }
 /**

*

Shallow clones an array returning a typecast result and handling * null.

  *

*

The objects in the array are not cloned, thus there is no special * handling for multi-dimensional arrays.

  * 

*

This method returns null for a null input array.

  * 
  * @param array  the array to shallow clone, may be null
  * @return the cloned array, null if null input
  */
 public static boolean[] clone(boolean[] array) {
     if (array == null) {
         return null;
     }
     return (boolean[]) array.clone();
 }

}

 </source>
   
  
 
  

Adds all the elements of the given arrays into a new byte-type array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Adds all the elements of the given arrays into a new array.

*

The new array contains all of the element of array1 followed * by all of the elements array2. When an array is returned, it is always * a new array.

  *

*

   * ArrayUtils.addAll(array1, null)   = cloned copy of array1
   * ArrayUtils.addAll(null, array2)   = cloned copy of array2
   * ArrayUtils.addAll([], [])         = []
   * 

  *
  * @param array1  the first array whose elements are added to the new array.
  * @param array2  the second array whose elements are added to the new array.
  * @return The new byte[] array.
  * @since 2.1
  */
 public static byte[] addAll(byte[] array1, byte[] array2) {
     if (array1 == null) {
         return clone(array2);
     } else if (array2 == null) {
         return clone(array1);
     }
     byte[] joinedArray = new byte[array1.length + array2.length];
     System.arraycopy(array1, 0, joinedArray, 0, array1.length);
     System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
     return joinedArray;
 }

 /**

*

Shallow clones an array returning a typecast result and handling * null.

  *

*

The objects in the array are not cloned, thus there is no special * handling for multi-dimensional arrays.

  * 

*

This method returns null for a null input array.

  * 
  * @param array  the array to shallow clone, may be null
  * @return the cloned array, null if null input
  */
 public static byte[] clone(byte[] array) {
     if (array == null) {
         return null;
     }
     return (byte[]) array.clone();
 }

}

 </source>
   
  
 
  

Adds all the elements of the given arrays into a new char-type array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Adds all the elements of the given arrays into a new array.

*

The new array contains all of the element of array1 followed * by all of the elements array2. When an array is returned, it is always * a new array.

  *

*

   * ArrayUtils.addAll(array1, null)   = cloned copy of array1
   * ArrayUtils.addAll(null, array2)   = cloned copy of array2
   * ArrayUtils.addAll([], [])         = []
   * 

  *
  * @param array1  the first array whose elements are added to the new array.
  * @param array2  the second array whose elements are added to the new array.
  * @return The new char[] array.
  * @since 2.1
  */
 public static char[] addAll(char[] array1, char[] array2) {
     if (array1 == null) {
         return clone(array2);
     } else if (array2 == null) {
         return clone(array1);
     }
     char[] joinedArray = new char[array1.length + array2.length];
     System.arraycopy(array1, 0, joinedArray, 0, array1.length);
     System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
     return joinedArray;
 }

 /**

*

Shallow clones an array returning a typecast result and handling * null.

  *

*

The objects in the array are not cloned, thus there is no special * handling for multi-dimensional arrays.

  * 

*

This method returns null for a null input array.

  * 
  * @param array  the array to shallow clone, may be null
  * @return the cloned array, null if null input
  */
 public static char[] clone(char[] array) {
     if (array == null) {
         return null;
     }
     return (char[]) array.clone();
 }

}

 </source>
   
  
 
  

Adds all the elements of the given arrays into a new double-type array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Adds all the elements of the given arrays into a new array.

*

The new array contains all of the element of array1 followed * by all of the elements array2. When an array is returned, it is always * a new array.

  *

*

   * ArrayUtils.addAll(array1, null)   = cloned copy of array1
   * ArrayUtils.addAll(null, array2)   = cloned copy of array2
   * ArrayUtils.addAll([], [])         = []
   * 

  *
  * @param array1  the first array whose elements are added to the new array.
  * @param array2  the second array whose elements are added to the new array.
  * @return The new double[] array.
  * @since 2.1
  */
 public static double[] addAll(double[] array1, double[] array2) {
     if (array1 == null) {
         return clone(array2);
     } else if (array2 == null) {
         return clone(array1);
     }
     double[] joinedArray = new double[array1.length + array2.length];
     System.arraycopy(array1, 0, joinedArray, 0, array1.length);
     System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
     return joinedArray;
 }
 /**

*

Shallow clones an array returning a typecast result and handling * null.

  *

*

The objects in the array are not cloned, thus there is no special * handling for multi-dimensional arrays.

  * 

*

This method returns null for a null input array.

  * 
  * @param array  the array to shallow clone, may be null
  * @return the cloned array, null if null input
  */
 public static double[] clone(double[] array) {
     if (array == null) {
         return null;
     }
     return (double[]) array.clone();
 }

}

 </source>
   
  
 
  

Adds all the elements of the given arrays into a new float-type array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Adds all the elements of the given arrays into a new array.

*

The new array contains all of the element of array1 followed * by all of the elements array2. When an array is returned, it is always * a new array.

  *

*

   * ArrayUtils.addAll(array1, null)   = cloned copy of array1
   * ArrayUtils.addAll(null, array2)   = cloned copy of array2
   * ArrayUtils.addAll([], [])         = []
   * 

  *
  * @param array1  the first array whose elements are added to the new array.
  * @param array2  the second array whose elements are added to the new array.
  * @return The new float[] array.
  * @since 2.1
  */
 public static float[] addAll(float[] array1, float[] array2) {
     if (array1 == null) {
         return clone(array2);
     } else if (array2 == null) {
         return clone(array1);
     }
     float[] joinedArray = new float[array1.length + array2.length];
     System.arraycopy(array1, 0, joinedArray, 0, array1.length);
     System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
     return joinedArray;
 }
 /**

*

Shallow clones an array returning a typecast result and handling * null.

  *

*

The objects in the array are not cloned, thus there is no special * handling for multi-dimensional arrays.

  * 

*

This method returns null for a null input array.

  * 
  * @param array  the array to shallow clone, may be null
  * @return the cloned array, null if null input
  */
 public static float[] clone(float[] array) {
     if (array == null) {
         return null;
     }
     return (float[]) array.clone();
 }

}

 </source>
   
  
 
  

Adds all the elements of the given arrays into a new int-type array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Adds all the elements of the given arrays into a new array.

*

The new array contains all of the element of array1 followed * by all of the elements array2. When an array is returned, it is always * a new array.

  *

*

   * ArrayUtils.addAll(array1, null)   = cloned copy of array1
   * ArrayUtils.addAll(null, array2)   = cloned copy of array2
   * ArrayUtils.addAll([], [])         = []
   * 

  *
  * @param array1  the first array whose elements are added to the new array.
  * @param array2  the second array whose elements are added to the new array.
  * @return The new int[] array.
  * @since 2.1
  */
 public static int[] addAll(int[] array1, int[] array2) {
     if (array1 == null) {
         return clone(array2);
     } else if (array2 == null) {
         return clone(array1);
     }
     int[] joinedArray = new int[array1.length + array2.length];
     System.arraycopy(array1, 0, joinedArray, 0, array1.length);
     System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
     return joinedArray;
 }
 /**

*

Shallow clones an array returning a typecast result and handling * null.

  *

*

The objects in the array are not cloned, thus there is no special * handling for multi-dimensional arrays.

  * 

*

This method returns null for a null input array.

  * 
  * @param array  the array to shallow clone, may be null
  * @return the cloned array, null if null input
  */
 public static int[] clone(int[] array) {
     if (array == null) {
         return null;
     }
     return (int[]) array.clone();
 }

}

 </source>
   
  
 
  

Adds all the elements of the given arrays into a new long-type array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Adds all the elements of the given arrays into a new array.

*

The new array contains all of the element of array1 followed * by all of the elements array2. When an array is returned, it is always * a new array.

  *

*

   * ArrayUtils.addAll(array1, null)   = cloned copy of array1
   * ArrayUtils.addAll(null, array2)   = cloned copy of array2
   * ArrayUtils.addAll([], [])         = []
   * 

  *
  * @param array1  the first array whose elements are added to the new array.
  * @param array2  the second array whose elements are added to the new array.
  * @return The new long[] array.
  * @since 2.1
  */
 public static long[] addAll(long[] array1, long[] array2) {
     if (array1 == null) {
         return clone(array2);
     } else if (array2 == null) {
         return clone(array1);
     }
     long[] joinedArray = new long[array1.length + array2.length];
     System.arraycopy(array1, 0, joinedArray, 0, array1.length);
     System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
     return joinedArray;
 }
 /**

*

Shallow clones an array returning a typecast result and handling * null.

  *

*

The objects in the array are not cloned, thus there is no special * handling for multi-dimensional arrays.

  * 

*

This method returns null for a null input array.

  * 
  * @param array  the array to shallow clone, may be null
  * @return the cloned array, null if null input
  */
 public static long[] clone(long[] array) {
     if (array == null) {
         return null;
     }
     return (long[]) array.clone();
 }

}

 </source>
   
  
 
  

Adds all the elements of the given arrays into a new short-type array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Adds all the elements of the given arrays into a new array.

*

The new array contains all of the element of array1 followed * by all of the elements array2. When an array is returned, it is always * a new array.

  *

*

   * ArrayUtils.addAll(array1, null)   = cloned copy of array1
   * ArrayUtils.addAll(null, array2)   = cloned copy of array2
   * ArrayUtils.addAll([], [])         = []
   * 

  *
  * @param array1  the first array whose elements are added to the new array.
  * @param array2  the second array whose elements are added to the new array.
  * @return The new short[] array.
  * @since 2.1
  */
 public static short[] addAll(short[] array1, short[] array2) {
     if (array1 == null) {
         return clone(array2);
     } else if (array2 == null) {
         return clone(array1);
     }
     short[] joinedArray = new short[array1.length + array2.length];
     System.arraycopy(array1, 0, joinedArray, 0, array1.length);
     System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
     return joinedArray;
 }
 /**

*

Shallow clones an array returning a typecast result and handling * null.

  *

*

The objects in the array are not cloned, thus there is no special * handling for multi-dimensional arrays.

  * 

*

This method returns null for a null input array.

  * 
  * @param array  the array to shallow clone, may be null
  * @return the cloned array, null if null input
  */
 public static short[] clone(short[] array) {
     if (array == null) {
         return null;
     }
     return (short[]) array.clone();
 }

}

 </source>
   
  
 
  

Array Copy Utilities

   <source lang="java">
  

// Revised from marf import java.util.ruparator; import java.util.Vector;

/**

*

marf.util.Arrays is an extension of java.util.Arrays * to group a lot of commonly used arrays-related functionality in one place. This class * can do whatever java.util.Arrays can, plus allows copying array portions, * including cases when the source and destination arrays are of different types, and providing * array-to-Vector and array-to-delimited-String conversions. For the type-conversion * routines a proper casting to the destination type is performed when needed. It also * allows inheritance from the class, so that anyone wishing to extend it is welcome to * do so without the pain of re-wrapping the methods.

*
* TODO: optimize.
*

*

NOTE: the java.util.Arrays compliance is true as of JDK 1.4.

*

*

NOTE: it does not actually inherit (extend) from java.util.Arrays, but rather wraps * existing methods, plus adds the copy() wrappers of System.arraycopy(), * and arrayToVector() methods.

*

*

$Id: Arrays.java,v 1.38 2006/09/09 17:26:58 mokhov Exp $

*
* @author Serguei Mokhov
* @author Shuxin Fan
*
* @version $Revision: 1.38 $
* @since 0.3.0.1
*
* @see java.util.Arrays
* @see System#arraycopy(Object, int, Object, int, int)
*/

public class Arrays {

 /**
  * The protected default constructor is provided
  * to allow making extension of this class if
  * developers desire to do so. Normally, you would
  * not need to instantiate this class, but in order
  * not to re-wrap our calls in possible extensions
  * this constructor is available.
  */
 protected Arrays()
 {
 }
 /*
  * -------
  * Copying
  * -------
  */
 /**
  * Generic copy() routine is based on System.arraycopy().
  *
  * @param poDestination destination array of copy
  * @param piDestinationStartIndex where in the destination array start placing the values
  * @param poSource source of elements
  * @param piSourceStartIndex where in the source array start copying the values from
  * @param piHowMany how many elements should be copied from the source to destination
  */
 public static void copy
 (
   Object poDestination,
   final int piDestinationStartIndex,
   Object poSource,
   final int piSourceStartIndex,
   final int piHowMany
 )
 {
   System.arraycopy
   (
     poSource,
     piSourceStartIndex,
     poDestination,
     piDestinationStartIndex,
     piHowMany
   );
 }
 /**
  * Generic copy() routine is based on System.arraycopy()
  * for Object arrays.
  *
  * @param paoDestination destination array of objects to copy to
  * @param piDestinationStartIndex where in the destination array start placing the values
  * @param paoSource source of Object elements
  * @param piSourceStartIndex where in the source array start copying the values from
  * @param piHowMany how many elements should be copied from the source to destination
  */
 public static void copy
 (
   Object[] paoDestination,
   final int piDestinationStartIndex,
   Object[] paoSource,
   final int piSourceStartIndex,
   final int piHowMany
 )
 {
   System.arraycopy
   (
     paoSource,
     piSourceStartIndex,
     paoDestination,
     piDestinationStartIndex,
     piHowMany
   );
 }
 /**
  * Copies N boolean elements from source to destination starting at certain index in the destination.
  * A wrapper call to System.arraycopy().
  *
  * @param pabDestination array to copy to
  * @param piDestinationStartIndex starting index in the destination to start copying to
  * @param pabSource array of booleans to copy from
  * @param piSourceStartIndex starting index in the source to start copying from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy
 (
   boolean[] pabDestination,
   final int piDestinationStartIndex,
   boolean[] pabSource,
   final int piSourceStartIndex,
   final int piHowMany
 )
 {
   System.arraycopy
   (
     pabSource,
     piSourceStartIndex,
     pabDestination,
     piDestinationStartIndex,
     piHowMany
   );
 }
 /**
  * Copies N byte elements from source to destination starting at certain index in the destination.
  * A wrapper call to System.arraycopy().
  *
  * @param patDestination array to copy to
  * @param piDestinationStartIndex starting index in the destination to start copying to
  * @param patSource array of bytes to copy from
  * @param piSourceStartIndex starting index in the source to start copying from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy
 (
   byte[] patDestination,
   final int piDestinationStartIndex,
   byte[] patSource,
   final int piSourceStartIndex,
   final int piHowMany
 )
 {
   System.arraycopy
   (
     patSource,
     piSourceStartIndex,
     patDestination,
     piDestinationStartIndex,
     piHowMany
   );
 }
 /**
  * Copies N character elements from source to destination starting at certain index in the destination.
  * A wrapper call to System.arraycopy().
  *
  * @param pacDestination array to copy to
  * @param piDestinationStartIndex starting index in the destination to start copying to
  * @param pacSource array of characters to copy from
  * @param piSourceStartIndex starting index in the source to start copying from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy
 (
   char[] pacDestination,
   final int piDestinationStartIndex,
   char[] pacSource,
   final int piSourceStartIndex,
   final int piHowMany
 )
 {
   System.arraycopy
   (
     pacSource,
     piSourceStartIndex,
     pacDestination,
     piDestinationStartIndex,
     piHowMany
   );
 }
 /**
  * Copies N integer elements from source to destination starting at certain index in the destination.
  * A wrapper call to System.arraycopy().
  *
  * @param paiDestination array to copy to
  * @param piDestinationStartIndex starting index in the destination to start copying to
  * @param paiSource array of integers to copy from
  * @param piSourceStartIndex starting index in the source to start copying from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy
 (
   int[] paiDestination,
   final int piDestinationStartIndex,
   int[] paiSource,
   final int piSourceStartIndex,
   final int piHowMany
 )
 {
   System.arraycopy
   (
     paiSource,
     piSourceStartIndex,
     paiDestination,
     piDestinationStartIndex,
     piHowMany
   );
 }
 /**
  * Copies N short elements from source to destination starting at certain index in the destination.
  * A wrapper call to System.arraycopy().
  *
  * @param pasDestination array to copy to
  * @param piDestinationStartIndex starting index in the destination to start copying to
  * @param pasSource array of shorts to copy from
  * @param piSourceStartIndex starting index in the source to start copying from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy
 (
   short[] pasDestination,
   final int piDestinationStartIndex,
   short[] pasSource,
   final int piSourceStartIndex,
   final int piHowMany
 )
 {
   System.arraycopy
   (
     pasSource,
     piSourceStartIndex,
     pasDestination,
     piDestinationStartIndex,
     piHowMany
   );
 }
 /**
  * Copies N long elements from source to destination starting at certain index in the destination.
  * A wrapper call to System.arraycopy().
  *
  * @param palDestination array to copy to
  * @param piDestinationStartIndex starting index in the destination to start copying to
  * @param palSource array of longs to copy from
  * @param piSourceStartIndex starting index in the source to start copying from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy
 (
   long[] palDestination,
   final int piDestinationStartIndex,
   long[] palSource,
   final int piSourceStartIndex,
   final int piHowMany
 )
 {
   System.arraycopy
   (
     palSource,
     piSourceStartIndex,
     palDestination,
     piDestinationStartIndex,
     piHowMany
   );
 }
 /**
  * Copies N float elements from source to destination starting at certain index in the destination.
  * A wrapper call to System.arraycopy().
  *
  * @param pafDestination array to copy to
  * @param piDestinationStartIndex starting index in the destination to start copying to
  * @param pafSource array of float to copy from
  * @param piSourceStartIndex starting index in the source to start copying from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy
 (
   float[] pafDestination,
   final int piDestinationStartIndex,
   float[] pafSource,
   final int piSourceStartIndex,
   final int piHowMany
 )
 {
   System.arraycopy
   (
     pafSource,
     piSourceStartIndex,
     pafDestination,
     piDestinationStartIndex,
     piHowMany
   );
 }
 /**
  * Copies N double elements from source to destination starting at certain index in the destination.
  * A wrapper call to System.arraycopy().
  *
  * @param padDestination array to copy to
  * @param piDestinationStartIndex starting index in the destination to start copying to
  * @param padSource array of doubles to copy from
  * @param piSourceStartIndex starting index in the source to start copying from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  *
  * @throws ArrayIndexOutOfBoundsException if one of the indices is out of range
  */
 public static void copy
 (
   double[] padDestination,
   final int piDestinationStartIndex,
   double[] padSource,
   final int piSourceStartIndex,
   final int piHowMany
 )
 {
   System.arraycopy
   (
     padSource,
     piSourceStartIndex,
     padDestination,
     piDestinationStartIndex,
     piHowMany
   );
 }
 /**
  * Generic copy() routine is based on System.arraycopy().
  *
  * @param poDestination destination array of copy
  * @param piStartIndex where in the destination array start placing the values
  * @param poSource source of elements
  * @param piHowMany how many elements should be copied from the source to destination
  */
 public static void copy(Object poDestination, final int piStartIndex, Object poSource, final int piHowMany)
 {
   copy(poDestination, piStartIndex, poSource, 0, piHowMany);
 }
 /**
  * Generic copy() routine is based on System.arraycopy()
  * for Object arrays.
  *
  * @param paoDestination destination array of objects to copy to
  * @param piStartIndex where in the destination array start placing the values
  * @param paoSource source of Object elements
  * @param piHowMany how many elements should be copied from the source to destination
  */
 public static void copy(Object[] paoDestination, final int piStartIndex, Object[] paoSource, final int piHowMany)
 {
   copy(paoDestination, piStartIndex, paoSource, 0, piHowMany);
 }
 /**
  * Copies N character elements from source to destination starting at certain index in the destination.
  *
  * @param pacDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param pacSource array of characters to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(char[] pacDestination, final int piStartIndex, char[] pacSource, final int piHowMany)
 {
   copy(pacDestination, piStartIndex, pacSource, 0, piHowMany);
 }
 /**
  * Copies N boolean elements from source to destination starting at certain index in the destination.
  *
  * @param pabDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param pabSource array of booleans to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(boolean[] pabDestination, final int piStartIndex, boolean[] pabSource, final int piHowMany)
 {
   copy(pabDestination, piStartIndex, pabSource, 0, piHowMany);
 }
 /**
  * Copies N byte elements from source to destination starting at certain index in the destination.
  *
  * @param patDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param patSource array of bytes to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(byte[] patDestination, final int piStartIndex, byte[] patSource, final int piHowMany)
 {
   copy(patDestination, piStartIndex, patSource, 0, piHowMany);
 }
 /**
  * Copies N integer elements from source to destination starting at certain index in the destination.
  *
  * @param paiDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param paiSource array of integers to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(int[] paiDestination, final int piStartIndex, int[] paiSource, final int piHowMany)
 {
   copy(paiDestination, piStartIndex, paiSource, 0, piHowMany);
 }
 /**
  * Copies N short elements from source to destination starting at certain index in the destination.
  *
  * @param pasDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param pasSource array of shorts to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(short[] pasDestination, final int piStartIndex, short[] pasSource, final int piHowMany)
 {
   copy(pasDestination, piStartIndex, pasSource, 0, piHowMany);
 }
 /**
  * Copies N long elements from source to destination starting at certain index in the destination.
  *
  * @param palDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param palSource array of longs to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(long[] palDestination, final int piStartIndex, long[] palSource, final int piHowMany)
 {
   copy(palDestination, piStartIndex, palSource, 0, piHowMany);
 }
 /**
  * Copies N float elements from source to destination starting at certain index in the destination.
  *
  * @param pafDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param pafSource array of floats to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(float[] pafDestination, final int piStartIndex, float[] pafSource, final int piHowMany)
 {
   copy(pafDestination, piStartIndex, pafSource, 0, piHowMany);
 }
 /**
  * Copies N double elements from source to destination starting at certain index in the destination.
  *
  * @param padDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param padSource array of doubles to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(double[] padDestination, final int piStartIndex, double[] padSource, final int piHowMany)
 {
   copy(padDestination, piStartIndex, padSource, 0, piHowMany);
 }
 /**
  * Generic copy() routine is based on System.arraycopy()
  * for Object arrays.
  *
  * @param paoDestination destination array of objects to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param paoSource source of object elements
  */
 public static void copy(Object[] paoDestination, final int piStartIndex, Object[] paoSource)
 {
   copy(paoDestination, piStartIndex, paoSource, paoSource.length);
 }
 /**
  * Copies source to destination starting at certain index in the destination.
  *
  * @param pabDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param pabSource array of booleans to copy from
  */
 public static void copy(boolean[] pabDestination, final int piStartIndex, boolean[] pabSource)
 {
   copy(pabDestination, piStartIndex, pabSource, pabSource.length);
 }
 /**
  * Copies source to destination starting at certain index in the destination.
  *
  * @param patDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param patSource array of bytes to copy from
  */
 public static void copy(byte[] patDestination, final int piStartIndex, byte[] patSource)
 {
   copy(patDestination, piStartIndex, patSource, patSource.length);
 }
 /**
  * Copies source to destination starting at certain index in the destination.
  *
  * @param pacDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param pacSource array of characters to copy from
  */
 public static void copy(char[] pacDestination, final int piStartIndex, char[] pacSource)
 {
   copy(pacDestination, piStartIndex, pacSource, pacSource.length);
 }
 /**
  * Copies source to destination starting at certain index in the destination.
  *
  * @param paiDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param paiSource array of integers to copy from
  */
 public static void copy(int[] paiDestination, final int piStartIndex, int[] paiSource)
 {
   copy(paiDestination, piStartIndex, paiSource, paiSource.length);
 }
 /**
  * Copies source to destination starting at certain index in the destination.
  *
  * @param pasDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param pasSource array of shorts to copy from
  */
 public static void copy(short[] pasDestination, final int piStartIndex, short[] pasSource)
 {
   copy(pasDestination, piStartIndex, pasSource, pasSource.length);
 }
 /**
  * Copies source to destination starting at certain index in the destination.
  *
  * @param palDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param palSource array of longs to copy from
  */
 public static void copy(long[] palDestination, final int piStartIndex, long[] palSource)
 {
   copy(palDestination, piStartIndex, palSource, palSource.length);
 }
 /**
  * Copies source to destination starting at certain index in the destination.
  *
  * @param pafDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param pafSource array of floats to copy from
  */
 public static void copy(float[] pafDestination, final int piStartIndex, float[] pafSource)
 {
   copy(pafDestination, piStartIndex, pafSource, pafSource.length);
 }
 /**
  * Copies source to destination starting at certain index in the destination.
  *
  * @param padDestination array to copy to
  * @param piStartIndex starting index in the destination to start copying to
  * @param padSource array of doubles to copy from
  */
 public static void copy(double[] padDestination, final int piStartIndex, double[] padSource)
 {
   copy(padDestination, piStartIndex, padSource, padSource.length);
 }
 /**
  * Generic copy() routine is based on System.arraycopy().
  *
  * @param poDestination destination array of copy
  * @param poSource source of elements
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(Object poDestination, Object poSource, final int piHowMany)
 {
   copy(poDestination, 0, poSource, piHowMany);
 }
 /**
  * Generic copy() routine is based on System.arraycopy()
  * for Object arrays.
  *
  * @param paoDestination array to copy to
  * @param paoSource source of object elements
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(Object[] paoDestination, Object[] paoSource, final int piHowMany)
 {
   copy(paoDestination, 0, paoSource, piHowMany);
 }
 /**
  * Copies N character elements from source to destination.
  *
  * @param pacDestination array to copy to
  * @param pacSource array of characters to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(char[] pacDestination, char[] pacSource, final int piHowMany)
 {
   copy(pacDestination, 0, pacSource, piHowMany);
 }
 /**
  * Copies N boolean elements from source to destination.
  *
  * @param pabDestination array to copy to
  * @param pabSource array of boolean to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(boolean[] pabDestination, boolean[] pabSource, final int piHowMany)
 {
   copy(pabDestination, 0, pabSource, piHowMany);
 }
 /**
  * Copies N byte elements from source to destination.
  *
  * @param patDestination array to copy to
  * @param patSource array of bytes to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(byte[] patDestination, byte[] patSource, final int piHowMany)
 {
   copy(patDestination, 0, patSource, piHowMany);
 }
 /**
  * Copies N short elements from source to destination.
  *
  * @param pasDestination array to copy to
  * @param pasSource array of shorts to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(short[] pasDestination, short[] pasSource, final int piHowMany)
 {
   copy(pasDestination, 0, pasSource, piHowMany);
 }
 /**
  * Copies N long elements from source to destination.
  *
  * @param palDestination array to copy to
  * @param palSource array of longs to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(long[] palDestination, long[] palSource, final int piHowMany)
 {
   copy(palDestination, 0, palSource, piHowMany);
 }
 /**
  * Copies N float elements from source to destination.
  *
  * @param pafDestination array to copy to
  * @param pafSource array of floats to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(float[] pafDestination, float[] pafSource, final int piHowMany)
 {
   copy(pafDestination, 0, pafSource, piHowMany);
 }
 /**
  * Copies N double elements from source to destination.
  *
  * @param padDestination array to copy to
  * @param padSource array of doubles to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(double[] padDestination, double[] padSource, final int piHowMany)
 {
   copy(padDestination, 0, padSource, piHowMany);
 }
 /**
  * Copies N int elements from source to destination.
  *
  * @param paiDestination array to copy to
  * @param paiSource array of ints to copy from
  * @param piHowMany N; the number of elements to copy from the source to the destination
  */
 public static void copy(int[] paiDestination, int[] paiSource, final int piHowMany)
 {
   copy(paiDestination, 0, paiSource, 0, piHowMany);
 }
 /*
  * -------------
  * Concatenation
  * -------------
  */
 /**
  * Concatenates two arrays of objects and returns a newly
  * allocated array of the concatenated pieces.
  * @param paoLHS first array piece
  * @param paoRHS second array piece
  * @return new combined array
  * @since 0.3.0.4
  */
 public static Object[] concatenate(final Object[] paoLHS, final Object[] paoRHS)
 {
   Object[] aoConcatenated = new Object[paoLHS.length + paoRHS.length];
   System.arraycopy(paoLHS, 0, aoConcatenated, 0, paoLHS.length);
   System.arraycopy(paoRHS, 0, aoConcatenated, paoLHS.length,paoRHS.length);
   return aoConcatenated;
 }
 /**
  * Concatenates two arrays of Strings and returns a newly
  * allocated array of the concatenated pieces.
  * @param pastrLHS first array piece
  * @param pastrRHS second array piece
  * @return new combined array
  * @since 0.3.0.4
  */
 public static String[] concatenate(final String[] pastrLHS, final String[] pastrRHS)
 {
   String[] astrConcatenated = new String[pastrLHS.length + pastrRHS.length];
   System.arraycopy(pastrLHS, 0, astrConcatenated, 0, pastrLHS.length);
   System.arraycopy(pastrRHS, 0, astrConcatenated, pastrLHS.length, pastrRHS.length);
   return astrConcatenated;
 }
 /**
  * Concatenates two arrays of doubles and returns a newly
  * allocated array of the concatenated pieces.
  * @param padLHS first array piece
  * @param padRHS second array piece
  * @return new combined array
  * @since 0.3.0.4
  */
 public static double[] concatenate(final double[] padLHS, final double[] padRHS)
 {
   double[] adConcatenated = new double[padLHS.length + padRHS.length];
   System.arraycopy(padLHS, 0, adConcatenated, 0, padLHS.length);
   System.arraycopy(padRHS, 0, adConcatenated, padLHS.length, padRHS.length);
   return adConcatenated;
 }
 /**
  * Concatenates two arrays of booleans and returns a newly
  * allocated array of the concatenated pieces.
  * @param pabLHS first array piece
  * @param pabRHS second array piece
  * @return new combined array
  * @since 0.3.0.4
  */
 public static boolean[] concatenate(final boolean[] pabLHS, final boolean[] pabRHS)
 {
   boolean[] abConcatenated = new boolean[pabLHS.length + pabRHS.length];
   System.arraycopy(pabLHS, 0, abConcatenated, 0, pabLHS.length);
   System.arraycopy(pabRHS, 0, abConcatenated, pabLHS.length, pabRHS.length);
   return abConcatenated;
 }
 /**
  * Concatenates two arrays of bytes and returns a newly
  * allocated array of the concatenated pieces.
  * @param patLHS first array piece
  * @param patRHS second array piece
  * @return new combined array
  * @since 0.3.0.4
  */
 public static byte[] concatenate(final byte[] patLHS, final byte[] patRHS)
 {
   byte[] atConcatenated = new byte[patLHS.length + patRHS.length];
   System.arraycopy(patLHS, 0, atConcatenated, 0, patLHS.length);
   System.arraycopy(patRHS, 0, atConcatenated, patLHS.length, patRHS.length);
   return atConcatenated;
 }
 /**
  * Concatenates two arrays of characters and returns a newly
  * allocated array of the concatenated pieces.
  * @param pacLHS first array piece
  * @param pacRHS second array piece
  * @return new combined array
  * @since 0.3.0.4
  */
 public static char[] concatenate(final char[] pacLHS, final char[] pacRHS)
 {
   char[] acConcatenated = new char[pacLHS.length + pacRHS.length];
   System.arraycopy(pacLHS, 0, acConcatenated, 0, pacLHS.length);
   System.arraycopy(pacRHS, 0, acConcatenated, pacLHS.length, pacRHS.length);
   return acConcatenated;
 }
 /**
  * Concatenates two arrays of integers and returns a newly
  * allocated array of the concatenated pieces.
  * @param paiLHS first array piece
  * @param paiRHS second array piece
  * @return new combined array
  * @since 0.3.0.4
  */
 public static int[] concatenate(final int[] paiLHS, final int[] paiRHS)
 {
   int[] aiConcatenated = new int[paiLHS.length + paiRHS.length];
   System.arraycopy(paiLHS, 0, aiConcatenated, 0, paiLHS.length);
   System.arraycopy(paiRHS, 0, aiConcatenated, paiLHS.length, paiRHS.length);
   return aiConcatenated;
 }
 /**
  * Concatenates two arrays of shorts and returns a newly
  * allocated array of the concatenated pieces.
  * @param pasLHS first array piece
  * @param pasRHS second array piece
  * @return new combined array
  * @since 0.3.0.4
  */
 public static short[] concatenate(final short[] pasLHS, final short[] pasRHS)
 {
   short[] asConcatenated = new short[pasLHS.length + pasRHS.length];
   System.arraycopy(pasLHS, 0, asConcatenated, 0, pasLHS.length);
   System.arraycopy(pasRHS, 0, asConcatenated, pasLHS.length, pasRHS.length);
   return asConcatenated;
 }
 /**
  * Concatenates two arrays of floats and returns a newly
  * allocated array of the concatenated pieces.
  * @param pafLHS first array piece
  * @param pafRHS second array piece
  * @return new combined array
  * @since 0.3.0.4
  */
 public static float[] concatenate(final float[] pafLHS, final float[] pafRHS)
 {
   float[] afConcatenated = new float[pafLHS.length + pafRHS.length];
   System.arraycopy(pafLHS, 0, afConcatenated, 0, pafLHS.length);
   System.arraycopy(pafRHS, 0, afConcatenated, pafLHS.length, pafRHS.length);
   return afConcatenated;
 }
 /**
  * Concatenates two arrays of longs and returns a newly
  * allocated array of the concatenated pieces.
  * @param palLHS first array piece
  * @param palRHS second array piece
  * @return new combined array
  * @since 0.3.0.4
  */
 public static long[] concatenate(final long[] palLHS, final long[] palRHS)
 {
   long[] alConcatenated = new long[palLHS.length + palRHS.length];
   System.arraycopy(palLHS, 0, alConcatenated, 0, palLHS.length);
   System.arraycopy(palRHS, 0, alConcatenated, palLHS.length, palRHS.length);
   return alConcatenated;
 }
 /*
  * --------
  * Equality
  * --------
  */
 /**
  * The equals() routine is based on java.util.Arrays.equals().
  *
  * @param pabArray1 the first array of booleans to be compared for equality
  * @param pabArray2 the second array of booleans to be compared for equality
  * @return a boolean value  true  if the two arrays are equal
  */
 public static boolean equals(boolean[] pabArray1, boolean[] pabArray2)
 {
   return java.util.Arrays.equals(pabArray1, pabArray2);
 }
 /**
  * The equals() routine is based on java.util.Arrays.equals().
  *
  * @param patArray1 the first array of bytes to be compared for equality
  * @param patArray2 the second array of bytes to be compared for equality
  * @return a boolean value  true  if the two arrays are equal
  */
 public static boolean equals(byte[] patArray1, byte[] patArray2)
 {
   return java.util.Arrays.equals(patArray1, patArray2);
 }
 /**
  * The equals() routine is based on java.util.Arrays.equals().
  *
  * @param pacArray1 the first array of characters to be compared for equality
  * @param pacArray2 the second array of characters to be compared for equality
  * @return a boolean value  true  if the two arrays are equal
  */
 public static boolean equals(char[] pacArray1, char[] pacArray2)
 {
   return java.util.Arrays.equals(pacArray1, pacArray2);
 }
 /**
  * The equals() routine is based on java.util.Arrays.equals().
  *
  * @param padArray1 the first array of doubles to be compared for equality
  * @param padArray2 the second array of doubles to be compared for equality
  * @return a boolean value  true  if the two arrays are equal
  */
 public static boolean equals(double[] padArray1, double[] padArray2)
 {
   return java.util.Arrays.equals(padArray1, padArray2);
 }
 /**
  * The equals() routine is based on java.util.Arrays.equals().
  *
  * @param pafArray1 the first array of floats to be compared for equality
  * @param pafArray2 the second array of floats to be compared for equality
  * @return a boolean value  true  if the two arrays are equal
  */
 public static boolean equals(float[] pafArray1, float[] pafArray2)
 {
   return java.util.Arrays.equals(pafArray1, pafArray2);
 }
 /**
  * The equals() routine is based on java.util.Arrays.equals().
  *
  * @param paiArray1 the first array of integers to be compared for equality
  * @param paiArray2 the second array of integers to be compared for equality
  * @return a boolean value  true  if the two arrays are equal
  */
 public static boolean equals(int[] paiArray1, int[] paiArray2)
 {
   return java.util.Arrays.equals(paiArray1, paiArray2);
 }
 /**
  * The equals() routine is based on java.util.Arrays.equals().
  *
  * @param palArray1 the first array of longs to be compared for equality
  * @param palArray2 the second array of longs to be compared for equality
  * @return a boolean value  true  if the two arrays are equal
  */
 public static boolean equals(long[] palArray1, long[] palArray2)
 {
   return java.util.Arrays.equals(palArray1, palArray2);
 }
 /**
  * The equals() routine is based on java.util.Arrays.equals().
  *
  * @param paoArray1 the first array of Objects to be compared for equality
  * @param paoArray2 the second array of Objects to be compared for equality
  * @return a boolean value  true  if the two arrays are equal
  */
 public static boolean equals(Object[] paoArray1, Object[] paoArray2)
 {
   return java.util.Arrays.equals(paoArray1, paoArray2);
 }
 /**
  * The equals() routine is based on java.util.Arrays.equals().
  *
  * @param pasArray1 the first array of shorts to be compared for equality
  * @param pasArray2 the second array of shorts to be compared for equality
  * @return a boolean value  true  if the two arrays are equal
  */
 public static boolean equals(short[] pasArray1, short[] pasArray2)
 {
   return java.util.Arrays.equals(pasArray1, pasArray2);
 }
 /*
  * -------------
  * Array filling
  * -------------
  */
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param pabArray the array of booleans to be filled
  * @param pbValue the value of boolean  to fill into the array of booleans
  */
 public static void fill(boolean[] pabArray, boolean pbValue)
 {
   java.util.Arrays.fill(pabArray, pbValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param pabArray the array of booleans to be filled
  * @param piFromIndex the index of the array from here the value to be filled
  * @param piToIndex the index one after the last element of the array to be filled
  * @param pbValue the value of boolean  to fill into the array of booleans
  */
 public static void fill(boolean[] pabArray, int piFromIndex, int piToIndex, boolean pbValue)
 {
   java.util.Arrays.fill(pabArray, piFromIndex, piToIndex, pbValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param patArray the array of bytes to be filled
  * @param ptValue the value of byte to fill into the array of bytes
  */
 public static void fill(byte[] patArray, byte ptValue)
 {
   java.util.Arrays.fill(patArray, ptValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param patArray the array of bytes to be filled
  * @param piFromIndex the index of the array from here the value to be filled
  * @param piToIndex the index one after the last element of the array to be filled
  * @param ptValue the value of byte to fill into the array of bytes
  */
 public static void fill(byte[] patArray, int piFromIndex, int piToIndex, byte ptValue)
 {
   java.util.Arrays.fill(patArray, piFromIndex, piToIndex, ptValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param pacArray the array of characters to be filled
  * @param pcValue the value of character to fill into the array of characters
  */
 public static void fill(char[] pacArray, char pcValue)
 {
   java.util.Arrays.fill(pacArray, pcValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param pacArray the array of characters to be filled
  * @param piFromIndex the index of the array from here the value to be filled
  * @param piToIndex the index one after the last element of the array to be filled
  * @param pcValue the value of character to fill into the array of characters
  */
 public static void fill(char[] pacArray, int piFromIndex, int piToIndex, char pcValue)
 {
   java.util.Arrays.fill(pacArray, piFromIndex, piToIndex, pcValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param padArray the array of doubles to be filled
  * @param pdValue the value of double to fill into the array of doubles
  */
 public static void fill(double[] padArray, double pdValue)
 {
   java.util.Arrays.fill(padArray, pdValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param padArray the array of doubles to be filled
  * @param piFromIndex the index of the array from here the value to be filled
  * @param piToIndex the index one after the last element of the array to be filled
  * @param pdValue the value of double to fill into the array of doubles
  */
 public static void fill(double[] padArray, int piFromIndex, int piToIndex, double pdValue)
 {
   java.util.Arrays.fill(padArray, piFromIndex, piToIndex, pdValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param pafArray the array of floats to be filled
  * @param pfValue the value of float to fill into the array of floats
  */
 public static void fill(float[] pafArray, float pfValue)
 {
   java.util.Arrays.fill(pafArray, pfValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param pafArray the array of floats to be filled
  * @param piFromIndex the index of the array from here the value to be filled
  * @param piToIndex the index one after the last element of the array to be filled
  * @param pfValue the value of float to fill into the array of floats
  */
 public static void fill(float[] pafArray, int piFromIndex, int piToIndex, float pfValue)
 {
   java.util.Arrays.fill(pafArray, piFromIndex, piToIndex, pfValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param paiArray the array of integers to be filled
  * @param piValue the value of integer to fill into the array of integers
  */
 public static void fill(int[] paiArray, int piValue)
 {
   java.util.Arrays.fill(paiArray, piValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param paiArray the array of integers to be filled
  * @param piFromIndex the index of the array from here the value to be filled
  * @param piToIndex the index one after the last element of the array to be filled
  * @param piValue the value of integer to fill into the array of integers
  */
 public static void fill(int[] paiArray, int piFromIndex, int piToIndex, int piValue)
 {
   java.util.Arrays.fill(paiArray, piFromIndex, piToIndex, piValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param palArray the array of longs to be filled
  * @param piFromIndex the index of the array from here the value to be filled
  * @param piToIndex the index one after the last element of the array to be filled
  * @param plValue the value of long to fill into the array of longs
  */
 public static void fill(long[] palArray, int piFromIndex, int piToIndex, long plValue)
 {
   java.util.Arrays.fill(palArray, piFromIndex, piToIndex, plValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param palArray the array of longs to be filled
  * @param plValue the value of long to fill into the array of longs
  */
 public static void fill(long[] palArray, long plValue)
 {
   java.util.Arrays.fill(palArray, plValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param paoArray the array to be filled
  * @param piFromIndex the index of the array from here the value to be filled
  * @param piToIndex the index one after the last element of the array to be filled
  * @param paValue the value to fill into the array
  */
 public static void fill(Object[] paoArray, int piFromIndex, int piToIndex, Object paValue)
 {
   java.util.Arrays.fill(paoArray, piFromIndex, piToIndex, paValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param paoArray the array to be filled
  * @param poValue the value to fill into the array
  */
 public static void fill(Object[] paoArray, Object poValue)
 {
   java.util.Arrays.fill(paoArray, poValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param pasArray the array of shorts to be filled
  * @param piFromIndex the index of the array from here the value to be filled
  * @param piToIndex the index one after the last element of the array to be filled
  * @param psValue the value of short  to fill into the array of shorts
  */
 public static void fill(short[] pasArray, int piFromIndex, int piToIndex, short psValue)
 {
   java.util.Arrays.fill(pasArray, piFromIndex, piToIndex, psValue);
 }
 /**
  * The fill() is based on java.util.Arrays.fill().
  *
  * @param pasArray the array of shorts to be filled
  * @param psValue the value of short  to fill into the array of shorts
  */
 public static void fill(short[] pasArray, short psValue)
 {
   java.util.Arrays.fill(pasArray, psValue);
 }
 /**
  * Sets all elements of the parameter at pseudo-random order.
  * The range of the values is [- Double.MAX_VALUE / 2, Double.MAX_VALUE / 2].
  * @param padArray the array to fill
  * @since 0.3.0.6
  */
 public static void fillRandom(double[] padArray)
 {
   for(int i = 0; i < padArray.length; i++)
   {
     padArray[i] = (Math.random() - 0.5) * Double.MAX_VALUE;
   }
 }
 
 /*
  * -------
  * Sorting
  * -------
  */
 /**
  * A wrapper of java.util.Arrays.sort(Object[], Comparator).
  *
  * @param paoArrayToSort array of objects to sort
  * @param poComparator comparator object to use while sorting
  */
 public static void sort(Object[] paoArrayToSort, Comparator poComparator)
 {
   java.util.Arrays.sort(paoArrayToSort, poComparator);
 }
 /**
  * A wrapper of java.util.Arrays.sort(double[]).
  *
  * @param padArrayToSort array of doubles to sort
  */
 public static void sort(double[] padArrayToSort)
 {
   java.util.Arrays.sort(padArrayToSort);
 }
 /**
  * A wrapper of java.util.Arrays.sort(float[]).
  *
  * @param pafArrayToSort array of float to sort
  */
 public static void sort(float[] pafArrayToSort)
 {
   java.util.Arrays.sort(pafArrayToSort);
 }
 /**
  * A wrapper of java.util.Arrays.sort(int[]).
  *
  * @param paiArrayToSort array of integers to sort
  */
 public static void sort(int[] paiArrayToSort)
 {
   java.util.Arrays.sort(paiArrayToSort);
 }
 /**
  * A wrapper of java.util.Arrays.sort(byte[]).
  *
  * @param patArrayToSort array of bytes to sort
  */
 public static void sort(byte[] patArrayToSort)
 {
   java.util.Arrays.sort(patArrayToSort);
 }
 /**
  * A wrapper of java.util.Arrays.sort(char[]).
  *
  * @param pacArrayToSort array of characters to sort
  */
 public static void sort(char[] pacArrayToSort)
 {
   java.util.Arrays.sort(pacArrayToSort);
 }
 /**
  * A wrapper of java.util.Arrays.sort(double[]).
  *
  * @param palArrayToSort array of longs to sort
  */
 public static void sort(long[] palArrayToSort)
 {
   java.util.Arrays.sort(palArrayToSort);
 }
 /**
  * A wrapper of java.util.Arrays.sort(short[]).
  *
  * @param pasArrayToSort array of shorts to sort
  */
 public static void sort(short[] pasArrayToSort)
 {
   java.util.Arrays.sort(pasArrayToSort);
 }
 /**
  * A wrapper of java.util.Arrays.sort(object []).
  *
  * @param paoArrayToSort array of objects to sort
  */
 public static void sort(Object[] paoArrayToSort)
 {
   java.util.Arrays.sort(paoArrayToSort);
 }
 /*
  * ----------
  * Conversion
  * ----------
  */
 /**
  * Converts array of doubles to Vector.
  *
  * @param padData array of double data
  * @return equivalent collection of Double objects
  * @since 0.3.0.3
  */
 public static Vector arrayToVector(final double[] padData)
 {
   Vector oVector = new Vector(padData.length);
   for(int i = 0; i < padData.length; i++)
   {
     oVector.add(new Double(padData[i]));
   }
   return oVector;
 }
 /**
  * Converts array of ints to Vector.
  *
  * @param paiData array of int data
  * @return equivalent collection of Integer objects
  * @since 0.3.0.3
  */
 public static Vector arrayToVector(final int[] paiData)
 {
   Vector oVector = new Vector(paiData.length);
   for(int i = 0; i < paiData.length; i++)
   {
     oVector.add(new Integer(paiData[i]));
   }
   return oVector;
 }
 /**
  * Converts array of floats to Vector.
  *
  * @param pafData array of float data
  * @return equivalent collection of Float objects
  * @since 0.3.0.3
  */
 public static Vector arrayToVector(final float[] pafData)
 {
   Vector oVector = new Vector(pafData.length);
   for(int i = 0; i < pafData.length; i++)
   {
     oVector.add(new Float(pafData[i]));
   }
   return oVector;
 }
 /**
  * Converts array of shorts to Vector.
  *
  * @param pasData array of short data
  * @return equivalent collection of Short objects
  * @since 0.3.0.3
  */
 public static Vector arrayToVector(final short[] pasData)
 {
   Vector oVector = new Vector(pasData.length);
   for(int i = 0; i < pasData.length; i++)
   {
     oVector.add(new Short(pasData[i]));
   }
   return oVector;
 }
 /**
  * Converts array of longs to Vector.
  *
  * @param palData array of long data
  * @return equivalent collection of Long objects
  * @since 0.3.0.3
  */
 public static Vector arrayToVector(final long[] palData)
 {
   Vector oVector = new Vector(palData.length);
   for(int i = 0; i < palData.length; i++)
   {
     oVector.add(new Long(palData[i]));
   }
   return oVector;
 }
 /**
  * Converts array of characters to Vector.
  *
  * @param pacData array of character data
  * @return equivalent collection of Character objects
  * @since 0.3.0.3
  */
 public static Vector arrayToVector(final char[] pacData)
 {
   Vector oVector = new Vector(pacData.length);
   for(int i = 0; i < pacData.length; i++)
   {
     oVector.add(new Character(pacData[i]));
   }
   return oVector;
 }
 /**
  * Converts array of bytes to Vector.
  *
  * @param patData array of byte data
  * @return equivalent collection of Byte objects
  * @since 0.3.0.3
  */
 public static Vector arrayToVector(final byte[] patData)
 {
   Vector oVector = new Vector(patData.length);
   for(int i = 0; i < patData.length; i++)
   {
     oVector.add(new Byte(patData[i]));
   }
   return oVector;
 }
 /**
  * Converts array of Strings to Vector.
  *
  * @param pastrData array of String data
  * @return equivalent collection of String objects
  * @since 0.3.0.3
  */
 public static Vector arrayToVector(final String[] pastrData)
 {
   Vector oVector = new Vector(pastrData.length);
   for(int i = 0; i < pastrData.length; i++)
   {
     oVector.add(new String(pastrData[i]));
   }
   return oVector;
 }
 /**
  * Converts array of Objects to Vector.
  *
  * @param paoData array of Object data
  * @return equivalent collection of objects
  * @since 0.3.0.6
  */
 public static Vector arrayToVector(final Object[] paoData)
 {
   Vector oVector = new Vector(paoData.length);
   for(int i = 0; i < paoData.length; i++)
   {
     oVector.add(paoData[i]);
   }
   return oVector;
 }
 /**
  * Converts array of Strings to a single string separated by
  * the specified delimeter.
  *
  * @param pastrData string data to concatenate
  * @param pstrDelimeter data elements separator
  * @return the resulting combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToDelimitedString(final String[] pastrData, final String pstrDelimeter)
 {
   String strRetVal = pastrData[0];
   if(pastrData.length > 0)
   {
     for(int i = 1; i < pastrData.length; i++)
     {
       strRetVal += pstrDelimeter + pastrData[i];
     }
   }
   return strRetVal;
 }
 /**
  * Converts array of integers to a single string separated by
  * the specified delimeter.
  *
  * @param paiData int data to append
  * @param pstrDelimeter data elements separator
  * @return the resulting combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToDelimitedString(final int[] paiData, final String pstrDelimeter)
 {
   StringBuffer oRetVal = new StringBuffer();
   if(paiData.length > 0)
   {
     oRetVal.append(paiData[0]);
 
     for(int i = 1; i < paiData.length; i++)
     {
       oRetVal.append(pstrDelimeter).append(paiData[i]);
     }
   }
   return oRetVal.toString();
 }
 /**
  * Converts array of Objects to a single string separated by
  * the specified delimeter.
  *
  * @param paoData Object data to append
  * @param pstrDelimeter data elements separator
  * @return the resulting combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToDelimitedString(final Object[] paoData, final String pstrDelimeter)
 {
   StringBuffer oRetVal = new StringBuffer();
   if(paoData.length > 0)
   {
     oRetVal.append(paoData[0]);
 
     for(int i = 1; i < paoData.length; i++)
     {
       oRetVal.append(pstrDelimeter).append(paoData[i]);
     }
   }
   return oRetVal.toString();
 }
 /**
  * Converts array of longs to a single string separated by
  * the specified delimeter.
  *
  * @param palData long data to append
  * @param pstrDelimeter data elements separator
  * @return the resulting combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToDelimitedString(final long[] palData, final String pstrDelimeter)
 {
   StringBuffer oRetVal = new StringBuffer();
   if(palData.length > 0)
   {
     oRetVal.append(palData[0]);
 
     for(int i = 1; i < palData.length; i++)
     {
       oRetVal.append(pstrDelimeter).append(palData[i]);
     }
   }
   return oRetVal.toString();
 }
 /**
  * Converts array of floats to a single string separated by
  * the specified delimeter.
  *
  * @param pafData float data to append
  * @param pstrDelimeter data elements separator
  * @return the resulting combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToDelimitedString(final float[] pafData, final String pstrDelimeter)
 {
   StringBuffer oRetVal = new StringBuffer();
   if(pafData.length > 0)
   {
     oRetVal.append(pafData[0]);
 
     for(int i = 1; i < pafData.length; i++)
     {
       oRetVal.append(pstrDelimeter).append(pafData[i]);
     }
   }
   return oRetVal.toString();
 }
 /**
  * Converts array of doubles to a single string separated by
  * the specified delimeter.
  *
  * @param padData double data to append
  * @param pstrDelimeter data elements separator
  * @return the resulting combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToDelimitedString(final double[] padData, final String pstrDelimeter)
 {
   StringBuffer oRetVal = new StringBuffer();
   if(padData.length > 0)
   {
     oRetVal.append(padData[0]);
 
     for(int i = 1; i < padData.length; i++)
     {
       oRetVal.append(pstrDelimeter).append(padData[i]);
     }
   }
   return oRetVal.toString();
 }
 /**
  * Converts array of bytes to a single string separated by
  * the specified delimeter.
  *
  * @param patData byte data to append
  * @param pstrDelimeter data elements separator
  * @return the resulting combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToDelimitedString(final byte[] patData, final String pstrDelimeter)
 {
   StringBuffer oRetVal = new StringBuffer();
   if(patData.length > 0)
   {
     oRetVal.append(patData[0]);
 
     for(int i = 1; i < patData.length; i++)
     {
       oRetVal.append(pstrDelimeter).append(patData[i]);
     }
   }
   return oRetVal.toString();
 }
 /**
  * Converts array of booleans to a single string separated by
  * the specified delimeter.
  *
  * @param pabData boolean data to append
  * @param pstrDelimeter data elements separator
  * @return the resulting combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToDelimitedString(final boolean[] pabData, final String pstrDelimeter)
 {
   StringBuffer oRetVal = new StringBuffer();
   if(pabData.length > 0)
   {
     oRetVal.append(pabData[0]);
 
     for(int i = 1; i < pabData.length; i++)
     {
       oRetVal.append(pstrDelimeter).append(pabData[i]);
     }
   }
   return oRetVal.toString();
 }
 /**
  * Converts array of characters to a single string separated by
  * the specified delimeter.
  *
  * @param pacData charater data to append
  * @param pstrDelimeter data elements separator
  * @return the resulting combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToDelimitedString(final char[] pacData, final String pstrDelimeter)
 {
   StringBuffer oRetVal = new StringBuffer();
   if(pacData.length > 0)
   {
     oRetVal.append(pacData[0]);
 
     for(int i = 1; i < pacData.length; i++)
     {
       oRetVal.append(pstrDelimeter).append(pacData[i]);
     }
   }
   return oRetVal.toString();
 }
 /**
  * Converts array of Strings to a single space-separated String.
  *
  * @param pastrData array of String data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToString(final String[] pastrData)
 {
   return arrayToDelimitedString(pastrData, " ");
 }
 /**
  * Converts array of Objects to a single space-separated String.
  *
  * @param paoData array of Object data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToString(final Object[] paoData)
 {
   return arrayToDelimitedString(paoData, " ");
 }
 /**
  * Converts array of integers to a single space-separated String.
  *
  * @param paiData array of integer data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToString(final int[] paiData)
 {
   return arrayToDelimitedString(paiData, " ");
 }
 /**
  * Converts array of longs to a single space-separated String.
  *
  * @param palData array of long data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToString(final long[] palData)
 {
   return arrayToDelimitedString(palData, " ");
 }
 /**
  * Converts array of floats to a single space-separated String.
  *
  * @param pafData array of float data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToString(final float[] pafData)
 {
   return arrayToDelimitedString(pafData, " ");
 }
 /**
  * Converts array of doubles to a single space-separated String.
  *
  * @param padData array of double data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToString(final double[] padData)
 {
   return arrayToDelimitedString(padData, " ");
 }
 /**
  * Converts array of bytes to a single space-separated String.
  *
  * @param patData array of byte data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToString(final byte[] patData)
 {
   return arrayToDelimitedString(patData, " ");
 }
 /**
  * Converts array of booleans to a single space-separated String.
  *
  * @param pabData array of boolean data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToString(final boolean[] pabData)
 {
   return arrayToDelimitedString(pabData, " ");
 }
 /**
  * Converts array of characters to a single space-separated String.
  *
  * @param pacData array of charater data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToString(final char[] pacData)
 {
   return arrayToDelimitedString(pacData, " ");
 }
 /**
  * Converts array of Strings to a single comma-separated String.
  *
  * @param pastrData array of String data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToCSV(final String[] pastrData)
 {
   return arrayToDelimitedString(pastrData, ",");
 }
 /**
  * Converts array of Objects to a single comma-separated String.
  *
  * @param paoData array of Object data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToCSV(final Object[] paoData)
 {
   return arrayToDelimitedString(paoData, ",");
 }
 /**
  * Converts array of integers to a single comma-separated String.
  *
  * @param paiData array of integer data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToCSV(final int[] paiData)
 {
   return arrayToDelimitedString(paiData, ",");
 }
 /**
  * Converts array of longs to a single comma-separated String.
  *
  * @param palData array of long data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToCSV(final long[] palData)
 {
   return arrayToDelimitedString(palData, ",");
 }
 /**
  * Converts array of floats to a single comma-separated String.
  *
  * @param pafData array of float data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToCSV(final float[] pafData)
 {
   return arrayToDelimitedString(pafData, ",");
 }
 /**
  * Converts array of doubles to a single comma-separated String.
  *
  * @param padData array of double data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToCSV(final double[] padData)
 {
   return arrayToDelimitedString(padData, ",");
 }
 /**
  * Converts array of bytes to a single comma-separated String.
  *
  * @param patData array of byte data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToCSV(final byte[] patData)
 {
   return arrayToDelimitedString(patData, ",");
 }
 /**
  * Converts array of booleans to a single comma-separated String.
  *
  * @param pabData array of boolean data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToCSV(final boolean[] pabData)
 {
   return arrayToDelimitedString(pabData, ",");
 }
 /**
  * Converts array of charaters to a single comma-separated String.
  *
  * @param pacData array of charater data
  * @return equivalent combined string
  *
  * @since 0.3.0.5
  */
 public static String arrayToCSV(final char[] pacData)
 {
   return arrayToDelimitedString(pacData, ",");
 }
 /**
  * Provides an array-of-objects-to-List bridge.
  * Wraps java.util.Arrays.asList().
  *
  * @param paoObjects array of objects
  * @return corresponding List collection
  * @since 0.3.0.3
  */
 public static java.util.List asList(Object[] paoObjects)
 {
   return java.util.Arrays.asList(paoObjects);
 }
 /**
  * General copy-conversion method that copies N int elements
  * from an array of ints into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param piDestinationFrom index in the destination to start place elements at
  * @param paiSource sourc earray of ints
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     padDestination[piDestinationFrom + i] = paiSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N int elements
  * from an array of ints into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param paiSource sourc earray of ints
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, int[] paiSource, int piHowMany)
 {
   copy(padDestination, 0, paiSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all int elements
  * from an array of ints into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param paiSource source array of ints
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, int[] paiSource)
 {
   copy(padDestination, 0, paiSource, 0, paiSource.length);
 }
 /**
  * General copy-conversion method that copies N int elements
  * from an array of ints into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param piDestinationFrom index in the destination to start place elements at
  * @param paiSource source array of ints
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pafDestination[piDestinationFrom + i] = paiSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N int elements
  * from an array of ints into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param paiSource source array of ints
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, int[] paiSource, int piHowMany)
 {
   copy(pafDestination, 0, paiSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all int elements
  * from an array of ints into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param paiSource source array of ints
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, int[] paiSource)
 {
   copy(pafDestination, 0, paiSource, 0, paiSource.length);
 }
 /**
  * General copy-conversion method that copies N int elements
  * from an array of ints into array of longs.
  *
  * @param palDestination destination array of longs
  * @param piDestinationFrom index in the destination to start place elements at
  * @param paiSource source array of ints
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     palDestination[piDestinationFrom + i] = paiSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N int elements
  * from an array of ints into array of longs.
  *
  * @param palDestination destination array of longs
  * @param paiSource source array of ints
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, int[] paiSource, int piHowMany)
 {
   copy(palDestination, 0, paiSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all int elements
  * from an array of ints into array of longs.
  *
  * @param palDestination destination array of longs
  * @param paiSource source array of ints
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, int[] paiSource)
 {
   copy(palDestination, 0, paiSource, 0, paiSource.length);
 }
 /**
  * General copy-conversion method that copies N int elements
  * from an array of ints into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param piDestinationFrom index in the destination to start place elements at
  * @param paiSource source array of ints
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pasDestination[piDestinationFrom + i] = (short)paiSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N int elements
  * from an array of ints into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param paiSource source array of ints
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, int[] paiSource, int piHowMany)
 {
   copy(pasDestination, 0, paiSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all int elements
  * from an array of ints into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param paiSource source array of ints
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, int[] paiSource)
 {
   copy(pasDestination, 0, paiSource, 0, paiSource.length);
 }
 /**
  * General copy-conversion method that copies N int elements
  * from an array of ints into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param piDestinationFrom index in the destination to start place elements at
  * @param paiSource source array of ints
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     patDestination[piDestinationFrom + i] = (byte)(paiSource[piSourceFrom + i]);
 }
 /**
  * Copy-conversion method that copies N int elements
  * from an array of ints into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param paiSource source array of ints
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, int[] paiSource, int piHowMany)
 {
   copy(patDestination, 0, paiSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all int elements
  * from an array of ints into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param paiSource sourc earray of ints
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, int[] paiSource)
 {
   copy(patDestination, 0, paiSource, 0, paiSource.length);
 }
 /**
  * General copy-conversion method that copies N int elements
  * from an array of ints into array of characters.
  *
  * @param pacDestination destination array of characters
  * @param piDestinationFrom index in the destination to start place elements at
  * @param paiSource source array of ints
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pacDestination[piDestinationFrom + i] = (char)paiSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N int elements
  * from an array of ints into array of characters.
  *
  * @param pacDestination destination array of characters
  * @param paiSource sourc earray of ints
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, int[] paiSource, int piHowMany)
 {
   copy(pacDestination, 0, paiSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all int elements
  * from an array of ints into array of characters.
  *
  * @param pacDestination destination array of characters
  * @param paiSource sourc earray of ints
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, int[] paiSource)
 {
   copy(pacDestination, 0, paiSource, 0, paiSource.length);
 }
 /**
  * General copy-conversion method that copies N double elements
  * from an array of doubles into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param piDestinationFrom index in the destination to start place elements at
  * @param padSource source array of doubles
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     paiDestination[piDestinationFrom + i] =(int)padSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N double elements
  * from an array of doubles into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param padSource source array of doubles
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, double[] padSource, int piHowMany)
 {
   copy(paiDestination, 0, padSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all double elements
  * from an array of doubles into array of ints.
  *
  * @param paiDestination destination array of ints
  * @param padSource source array of doubles
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, double[] padSource)
 {
   copy(paiDestination, 0, padSource, 0, padSource.length);
 }
 /**
  * General copy-conversion method that copies N double elements
  * from an array of doubles into array of characters.
  *
  * @param pacDestination destination array of characters
  * @param piDestinationFrom index in the destination to start place elements at
  * @param padSource source array of doubles
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pacDestination[piDestinationFrom + i] =(char)padSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N double elements
  * from an array of doubles into array of characters.
  *
  * @param pacDestination destination array of characters
  * @param padSource source array of doubles
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, double[] padSource, int piHowMany)
 {
   copy(pacDestination, 0, padSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all double elements
  * from an array of doubles into array of characters.
  *
  * @param pacDestination destination array of characters
  * @param padSource source array of doubles
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, double[] padSource)
 {
   copy(pacDestination, 0, padSource, 0, padSource.length);
 }
 /**
  * General copy-conversion method that copies N double elements
  * from an array of doubles into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param piDestinationFrom index in the destination to start place elements at
  * @param padSource source array of doubles
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     patDestination[piDestinationFrom + i] =(byte)padSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N double elements
  * from an array of doubles into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param padSource source array of doubles
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, double[] padSource, int piHowMany)
 {
   copy(patDestination, 0, padSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all double elements
  * from an array of doubles into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param padSource source array of doubles
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, double[] padSource)
 {
   copy(patDestination, 0, padSource, 0, padSource.length);
 }
 /**
  * General copy-conversion method that copies N double elements
  * from an array of doubles into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param piDestinationFrom index in the destination to start place elements at
  * @param padSource source array of doubles
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pafDestination[piDestinationFrom + i] = (float)padSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N double elements
  * from an array of doubles into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param padSource source array of doubles
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, double[] padSource, int piHowMany)
 {
   copy(pafDestination, 0, padSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all double elements
  * from an array of doubles into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param padSource source array of doubles
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, double[] padSource)
 {
   copy(pafDestination, 0, padSource, 0, padSource.length);
 }
 /**
  * General copy-conversion method that copies N double elements
  * from an array of doubles into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param piDestinationFrom index in the destination to start place elements at
  * @param padSource source array of doubles
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pasDestination[piDestinationFrom + i] =(short)padSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N double elements
  * from an array of doubles into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param padSource source array of doubles
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, double[] padSource, int piHowMany)
 {
   copy(pasDestination, 0, padSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all double elements
  * from an array of doubles into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param padSource source array of doubles
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, double[] padSource)
 {
   copy(pasDestination, 0, padSource, 0, padSource.length);
 }
 /**
  * General copy-conversion method that copies N double elements
  * from an array of doubles into array of longs.
  *
  * @param palDestination destination array of longs
  * @param piDestinationFrom index in the destination to start place elements at
  * @param padSource source array of doubles
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     palDestination[piDestinationFrom + i] =(long)padSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N double elements
  * from an array of doubles into array of longs.
  *
  * @param palDestination destination array of longs
  * @param padSource source array of doubles
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, double[] padSource, int piHowMany)
 {
   copy(palDestination, 0, padSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all double elements
  * from an array of doubles into array of longs.
  *
  * @param palDestination destination array of longs
  * @param padSource source array of doubles
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, double[] padSource)
 {
   copy(palDestination, 0, padSource, 0, padSource.length);
 }

 /**
  * General copy-conversion method that copies N float elements
  * from an array of floats into array of characters.
  *
  * @param pacDestination destination array of characters
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pafSource source array of floats
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pacDestination[piDestinationFrom + i] = (char)pafSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N float elements
  * from an array of floats into array of characters.
  *
  * @param pacDestination destination array of characters
  * @param pafSource source array of floats
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, float[] pafSource, int piHowMany)
 {
   copy(pacDestination, 0, pafSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all float elements
  * from an array of floats into array of characters.
  *
  * @param pacDestination destination array of characters
  * @param pafSource source array of floats
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, float[] pafSource)
 {
   copy(pacDestination, 0, pafSource, 0, pafSource.length);
 }
 /**
  * General copy-conversion method that copies N float elements
  * from an array of floats into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pafSource source array of floats
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     patDestination[piDestinationFrom + i] = (byte)pafSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N float elements
  * from an array of floats into array of bytes.
  *
  * @param patDestination destination array of characters
  * @param pafSource source array of bytes
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, float[] pafSource, int piHowMany)
 {
   copy(patDestination, 0, pafSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all float elements
  * from an array of floats into array of characters.
  *
  * @param patDestination destination array of bytes
  * @param pafSource source array of floats
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, float[] pafSource)
 {
   copy(patDestination, 0, pafSource, 0, pafSource.length);
 }
 /**
  * General copy-conversion method that copies N float elements
  * from an array of floats into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pafSource source array of floats
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     paiDestination[piDestinationFrom + i] =(int)pafSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N float elements
  * from an array of floats into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param pafSource source array of floats
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, float[] pafSource, int piHowMany)
 {
   copy(paiDestination, 0, pafSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all float elements
  * from an array of floats into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param pafSource source array of floats
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, float[] pafSource)
 {
   copy(paiDestination, 0, pafSource, 0, pafSource.length);
 }
 /**
  * General copy-conversion method that copies N float elements
  * from an array of floats into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pafSource source array of floats
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pasDestination[piDestinationFrom + i] = (short)pafSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N float elements
  * from an array of floats into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param pafSource source array of floats
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, float[] pafSource, int piHowMany)
 {
   copy(pasDestination, 0, pafSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all float elements
  * from an array of floats into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param pafSource source array of floats
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, float[] pafSource)
 {
   copy(pasDestination, 0, pafSource, 0, pafSource.length);
 }
 /**
  * General copy-conversion method that copies N float elements
  * from an array of floats into array of longs.
  *
  * @param palDestination destination array of longs
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pafSource source array of floats
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     palDestination[piDestinationFrom + i] =(long)pafSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N float elements
  * from an array of floats into array of longs.
  *
  * @param palDestination destination array of longs
  * @param pafSource source array of floats
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, float[] pafSource, int piHowMany)
 {
   copy(palDestination, 0, pafSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all float elements
  * from an array of floats into array of longs.
  *
  * @param palDestination destination array of longs
  * @param pafSource source array of floats
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, float[] pafSource)
 {
   copy(palDestination, 0, pafSource, 0, pafSource.length);
 }
 /**
  * General copy-conversion method that copies N float elements
  * from an array of floats into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pafSource source array of floats
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     padDestination[piDestinationFrom + i] = pafSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N float elements
  * from an array of floats into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param pafSource source array of floats
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, float[] pafSource, int piHowMany)
 {
   copy(padDestination, 0, pafSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all float elements
  * from an array of floats into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param pafSource source array of floats
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, float[] pafSource)
 {
   copy(padDestination, 0, pafSource, 0, pafSource.length);
 }
 /**
  * General copy-conversion method that copies N short elements
  * from an array of shorts into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pasSource source array of shorts
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     padDestination[piDestinationFrom + i] = pasSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N short elements
  * from an array of shorts into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param pasSource source array of shorts
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, short[] pasSource, int piHowMany)
 {
   copy(padDestination, 0, pasSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all short elements
  * from an array of shorts into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param pasSource source array of shorts
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, short[] pasSource)
 {
   copy(padDestination, 0, pasSource, 0, pasSource.length);
 }
 /**
  * General copy-conversion method that copies N short elements
  * from an array of shorts into array of characters.
  *
  * @param pacDestination destination array of characters
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pasSource source array of shorts
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pacDestination[piDestinationFrom + i] = (char)pasSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N short elements
  * from an array of shorts into array of characters.
  *
  * @param pacDestination destination array of characters
  * @param pasSource source array of shorts
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, short[] pasSource, int piHowMany)
 {
   copy(pacDestination, 0, pasSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all short elements
  * from an array of shorts into array of characters.
  *
  * @param pacDestination destination array of characters
  * @param pasSource source array of shorts
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, short[] pasSource)
 {
   copy(pacDestination, 0, pasSource, 0, pasSource.length);
 }
 /**
  * General copy-conversion method that copies N short elements
  * from an array of shorts into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pasSource source array of shorts
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     patDestination[piDestinationFrom + i] =(byte)pasSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N short elements
  * from an array of shorts into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param pasSource source array of shorts
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, short[] pasSource, int piHowMany)
 {
   copy(patDestination, 0, pasSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all short elements
  * from an array of shorts into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param pasSource source array of shorts
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, short[] pasSource)
 {
   copy(patDestination, 0, pasSource, 0, pasSource.length);
 }
 /**
  * General copy-conversion method that copies N short elements
  * from an array of shorts into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pasSource source array of shorts
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     paiDestination[piDestinationFrom + i] = pasSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N short elements
  * from an array of shorts into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param pasSource source array of shorts
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, short[] pasSource, int piHowMany)
 {
   copy(paiDestination, 0, pasSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all short elements
  * from an array of shorts into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param pasSource source array of shorts
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, short[] pasSource)
 {
   copy(paiDestination, 0, pasSource, 0, pasSource.length);
 }
 /**
  * General copy-conversion method that copies N short elements
  * from an array of shorts into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pasSource source array of shorts
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pafDestination[piDestinationFrom + i] = pasSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N short elements
  * from an array of shorts into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param pasSource source array of shorts
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, short[] pasSource, int piHowMany)
 {
   copy(pafDestination, 0, pasSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all short elements
  * from an array of shorts into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param pasSource source array of shorts
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, short[] pasSource)
 {
   copy(pafDestination, 0, pasSource, 0, pasSource.length);
 }
 /**
  * General copy-conversion method that copies N short elements
  * from an array of shorts into array of longs.
  *
  * @param palDestination destination array of longs
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pasSource source array of shorts
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     palDestination[piDestinationFrom + i] = pasSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N short elements
  * from an array of shorts into array of longs.
  *
  * @param palDestination destination array of longs
  * @param pasSource source array of shorts
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, short[] pasSource, int piHowMany)
 {
   copy(palDestination, 0, pasSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all short elements
  * from an array of shorts into array of longs.
  *
  * @param palDestination destination array of longs
  * @param pasSource source array of shorts
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, short[] pasSource)
 {
   copy(palDestination, 0, pasSource, 0, pasSource.length);
 }
 /**
  * General copy-conversion method that copies N byte elements
  * from an array of bytes into array of longs.
  *
  * @param palDestination destination array of longs
  * @param piDestinationFrom index in the destination to start place elements at
  * @param patSource source array of bytes
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     palDestination[piDestinationFrom + i] = patSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N byte elements
  * from an array of bytes into array of longs.
  *
  * @param palDestination destination array of longs
  * @param patSource source array of bytes
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, byte[] patSource, int piHowMany)
 {
   copy(palDestination, 0, patSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all byte elements
  * from an array of bytes into array of longs.
  *
  * @param palDestination destination array of longs
  * @param patSource source array of bytes
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, byte[] patSource)
 {
   copy(palDestination, 0, patSource, 0, patSource.length);
 }
 /**
  * General copy-conversion method that copies N byte elements
  * from an array of bytes into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param piDestinationFrom index in the destination to start place elements at
  * @param patSource source array of bytes
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     padDestination[piDestinationFrom + i] = patSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N byte elements
  * from an array of bytes into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param patSource source array of bytes
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, byte[] patSource, int piHowMany)
 {
   copy(padDestination, 0, patSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all byte elements
  * from an array of bytes into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param patSource source array of bytes
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, byte[] patSource)
 {
   copy(padDestination, 0, patSource, 0, patSource.length);
 }
 /**
  * General copy-conversion method that copies N byte elements
  * from an array of bytes into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param piDestinationFrom index in the destination to start place elements at
  * @param patSource source array of bytes
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pasDestination[piDestinationFrom + i] = patSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N byte elements
  * from an array of bytes into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param patSource source array of bytes
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, byte[] patSource, int piHowMany)
 {
   copy(pasDestination, 0, patSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all byte elements
  * from an array of bytes into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param patSource source array of bytes
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, byte[] patSource)
 {
   copy(pasDestination, 0, patSource, 0, patSource.length);
 }
 /**
  * General copy-conversion method that copies N byte elements
  * from an array of bytes into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param piDestinationFrom index in the destination to start place elements at
  * @param patSource source array of bytes
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pafDestination[piDestinationFrom + i] = patSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N byte elements
  * from an array of bytes into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param patSource source array of bytes
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, byte[] patSource, int piHowMany)
 {
   copy(pafDestination, 0, patSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all byte elements
  * from an array of bytes into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param patSource source array of bytes
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, byte[] patSource)
 {
   copy(pafDestination, 0, patSource, 0, patSource.length);
 }
 /**
  * General copy-conversion method that copies N byte elements
  * from an array of bytes into array of characters.
  *
  * @param pacDestination destination array of characters
  * @param piDestinationFrom index in the destination to start place elements at
  * @param patSource source array of bytes
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pacDestination[piDestinationFrom + i] = (char)patSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N byte elements
  * from an array of bytes into array of characters.
  *
  * @param pacDestination destination array of characters
  * @param patSource source array of bytes
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, byte[] patSource, int piHowMany)
 {
   copy(pacDestination, 0, patSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all byte elements
  * from an array of bytes into array of bytes.
  *
  * @param pacDestination destination array of characters
  * @param patSource source array of bytes
  * @since 0.3.0.3
  */
 public static void copy(char[] pacDestination, byte[] patSource)
 {
   copy(pacDestination, 0, patSource, 0, patSource.length);
 }
 /**
  * General copy-conversion method that copies N byte elements
  * from an array of bytes into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param piDestinationFrom index in the destination to start place elements at
  * @param patSource source array of bytes
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     paiDestination[piDestinationFrom + i] = patSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N byte elements
  * from an array of bytes into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param patSource source array of bytes
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, byte[] patSource, int piHowMany)
 {
   copy(paiDestination, 0, patSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all byte elements
  * from an array of bytes into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param patSource source array of bytes
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, byte[] patSource)
 {
   copy(paiDestination, 0, patSource, 0, patSource.length);
 }
 /**
  * General copy-conversion method that copies N character elements
  * from an array of characters into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pacSource source array of characters
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     paiDestination[piDestinationFrom + i] = pacSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N character elements
  * from an array of characters into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param pacSource source array of characters
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, char[] pacSource, int piHowMany)
 {
   copy(paiDestination, 0, pacSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all character elements
  * from an array of characters into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param pacSource source array of characters
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, char[] pacSource)
 {
   copy(paiDestination, 0, pacSource, 0, pacSource.length);
 }
 /**
  * General copy-conversion method that copies N character elements
  * from an array of characters into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pacSource source array of characters
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     patDestination[piDestinationFrom + i] = (byte)pacSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N character elements
  * from an array of characters into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param pacSource source array of characters
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, char[] pacSource, int piHowMany)
 {
   copy(patDestination, 0, pacSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all character elements
  * from an array of characters into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param pacSource source array of characters
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, char[] pacSource)
 {
   copy(patDestination, 0, pacSource, 0, pacSource.length);
 }
 /**
  * General copy-conversion method that copies N character elements
  * from an array of characters into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pacSource source array of characters
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pasDestination[piDestinationFrom + i] = (short)pacSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N character elements
  * from an array of characters into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param pacSource source array of characters
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, char[] pacSource, int piHowMany)
 {
   copy(pasDestination, 0, pacSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all character elements
  * from an array of characters into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param pacSource source array of characters
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, char[] pacSource)
 {
   copy(pasDestination, 0, pacSource, 0, pacSource.length);
 }
 /**
  * General copy-conversion method that copies N character elements
  * from an array of characters into array of longs.
  *
  * @param palDestination destination array of longs
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pacSource source array of characters
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     palDestination[piDestinationFrom + i] = pacSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N character elements
  * from an array of characters into array of longs.
  *
  * @param palDestination destination array of longs
  * @param pacSource source array of characters
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, char[] pacSource, int piHowMany)
 {
   copy(palDestination, 0, pacSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all character elements
  * from an array of characters into array of longs.
  *
  * @param palDestination destination array of longs
  * @param pacSource source array of characters
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, char[] pacSource)
 {
   copy(palDestination, 0, pacSource, 0, pacSource.length);
 }
 /**
  * General copy-conversion method that copies N character elements
  * from an array of characters into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pacSource source array of characters
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pafDestination[piDestinationFrom + i] = pacSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N character elements
  * from an array of characters into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param pacSource source array of characters
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, char[] pacSource, int piHowMany)
 {
   copy(pafDestination, 0, pacSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all character elements
  * from an array of characters into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param pacSource source array of characters
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, char[] pacSource)
 {
   copy(pafDestination, 0, pacSource, 0, pacSource.length);
 }
 /**
  * General copy-conversion method that copies N character elements
  * from an array of characters into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pacSource source array of characters
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     padDestination[piDestinationFrom + i] = pacSource[piSourceFrom + i];
 }
 /**
  * Copy-conversion method that copies N character elements
  * from an array of characters into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param pacSource source array of characters
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, char[] pacSource, int piHowMany)
 {
   copy(padDestination, 0, pacSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all character elements
  * from an array of characters into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param pacSource source array of characters
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, char[] pacSource)
 {
   copy(padDestination, 0, pacSource, 0, pacSource.length);
 }
 /**
  * General copy-conversion method that copies N int elements
  * from an array of ints into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param piDestinationFrom index in the destination to start place elements at
  * @param paiSource source array of ints
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pstrDestination[piDestinationFrom + i] = paiSource[piSourceFrom + i] + "";
 }
 /**
  * Copy-conversion method that copies N int elements
  * from an array of ints into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param paiSource source array of ints
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, int[] paiSource, int piHowMany)
 {
   copy(pstrDestination, 0, paiSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all int elements
  * from an array of ints into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param paiSource source array of ints
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, int[] paiSource)
 {
   copy(pstrDestination, 0, paiSource, 0, paiSource.length);
 }
 /**
  * General copy-conversion method that copies N char elements
  * from an array of chars into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pacSource source array of chars
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pstrDestination[piDestinationFrom + i] = pacSource[piSourceFrom + i] + "";
 }
 /**
  * Copy-conversion method that copies N char elements
  * from an array of chars into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param pacSource source array of chars
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, char[] pacSource, int piHowMany)
 {
   copy(pstrDestination, 0, pacSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all char elements
  * from an array of chars into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param pacSource source array of chars
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, char[] pacSource)
 {
   copy(pstrDestination, 0, pacSource, 0, pacSource.length);
 }
 /**
  * General copy-conversion method that copies N byte elements
  * from an array of bytes into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param piDestinationFrom index in the destination to start place elements at
  * @param patSource source array of bytes
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pstrDestination[piDestinationFrom + i] = patSource[piSourceFrom + i] + "";
 }
 /**
  * Copy-conversion method that copies N byte elements
  * from an array of bytes into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param patSource source array of bytes
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, byte[] patSource, int piHowMany)
 {
   copy(pstrDestination, 0, patSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all byte elements
  * from an array of ints into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param patSource source array of bytes
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, byte[] patSource)
 {
   copy(pstrDestination, 0, patSource, 0, patSource.length);
 }
 /**
  * General copy-conversion method that copies N short elements
  * from an array of shorts into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pasSource source array of shorts
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pstrDestination[piDestinationFrom + i] = pasSource[piSourceFrom + i] + "";
 }
 /**
  * Copy-conversion method that copies N short elements
  * from an array of shorts into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param patSource source array of shorts
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, short[] patSource, int piHowMany)
 {
   copy(pstrDestination, 0, patSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all short elements
  * from an array of shorts into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param pasSource source array of shorts
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, short[] pasSource)
 {
   copy(pstrDestination, 0, pasSource, 0, pasSource.length);
 }
 /**
  * General copy-conversion method that copies N long elements
  * from an array of longs into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param piDestinationFrom index in the destination to start place elements at
  * @param palSource source array of longs
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, int piDestinationFrom, long[] palSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pstrDestination[piDestinationFrom + i] = palSource[piSourceFrom + i] + "";
 }
 /**
  * Copy-conversion method that copies N long elements
  * from an array of longs into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param palSource source array of longs
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, long[] palSource, int piHowMany)
 {
   copy(pstrDestination, 0, palSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all long elements
  * from an array of longs into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param palSource source array of longs
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, long[] palSource)
 {
   copy(pstrDestination, 0, palSource, 0, palSource.length);
 }
 /**
  * General copy-conversion method that copies N float elements
  * from an array of floats into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pafSource source array of floats
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pstrDestination[piDestinationFrom + i] = pafSource[piSourceFrom + i] + "";
 }
 /**
  * Copy-conversion method that copies N float elements
  * from an array of floats into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param pafSource source array of floats
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, float[] pafSource, int piHowMany)
 {
   copy(pstrDestination, 0, pafSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all float elements
  * from an array of floats into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param pafSource source array of floats
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, float[] pafSource)
 {
   copy(pstrDestination, 0, pafSource, 0, pafSource.length);
 }
 /**
  * General copy-conversion method that copies N double elements
  * from an array of doubles into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param piDestinationFrom index in the destination to start place elements at
  * @param padSource source array of doubles
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pstrDestination[piDestinationFrom + i] = padSource[piSourceFrom + i] + "";
 }
 /**
  * Copy-conversion method that copies N double elements
  * from an array of doubles into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param padSource source array of doubles
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, double[] padSource, int piHowMany)
 {
   copy(pstrDestination, 0, padSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all double elements
  * from an array of doubles into array of Strings.
  *
  * @param pstrDestination destination array of Strings
  * @param padSource source array of doubles
  * @since 0.3.0.3
  */
 public static void copy(String[] pstrDestination, double[] padSource)
 {
   copy(pstrDestination, 0, padSource, 0, padSource.length);
 }
 /**
  * General copy-conversion method that copies N String elements
  * from an array of Strings into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pastrSource source array of Strings
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  *
  * @throws NumberFormatException if one of the Strings doesn"t have a properly formatted number
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, int piDestinationFrom, String[] pastrSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     padDestination[piDestinationFrom + i] = Double.parseDouble(pastrSource[piSourceFrom + i]);
 }
 /**
  * Copy-conversion method that copies N String elements
  * from an array of Strings into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param pastrSource source array of Strings
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, String[] pastrSource, int piHowMany)
 {
   copy(padDestination, 0, pastrSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all String elements
  * from an array of Strings into array of doubles.
  *
  * @param padDestination destination array of doubles
  * @param pastrSource source array of Strings
  * @since 0.3.0.3
  */
 public static void copy(double[] padDestination, String[] pastrSource)
 {
   copy(padDestination, 0, pastrSource, 0, pastrSource.length);
 }
 /**
  * General copy-conversion method that copies N String elements
  * from an array of Strings into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pastrSource source array of Strings
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  *
  * @throws NumberFormatException if one of the Strings doesn"t have a properly formatted number
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, int piDestinationFrom, String[] pastrSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pafDestination[piDestinationFrom + i] = Float.parseFloat(pastrSource[piSourceFrom + i]);
 }
 /**
  * Copy-conversion method that copies N String elements
  * from an array of Strings into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param pastrSource source array of Strings
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(float[] pafDestination, String[] pastrSource, int piHowMany)
 {
   copy(pafDestination, 0, pastrSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all String elements
  * from an array of Strings into array of floats.
  *
  * @param pafDestination destination array of floats
  * @param pastrSource source array of Strings
  */
 public static void copy(float[] pafDestination, String[] pastrSource)
 {
   copy(pafDestination, 0, pastrSource, 0, pastrSource.length);
 }
 /**
  * General copy-conversion method that copies N String elements
  * from an array of Strings into array of longs.
  *
  * @param palDestination destination array of longs
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pastrSource source array of Strings
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  *
  * @throws NumberFormatException if one of the Strings doesn"t have a properly formatted number
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, int piDestinationFrom, String[] pastrSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     palDestination[piDestinationFrom + i] = Long.parseLong(pastrSource[piSourceFrom + i]);
 }
 /**
  * Copy-conversion method that copies N String elements
  * from an array of Strings into array of longs.
  *
  * @param palDestination destination array of longs
  * @param pastrSource source array of Strings
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, String[] pastrSource, int piHowMany)
 {
   copy(palDestination, 0, pastrSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all String elements
  * from an array of Strings into array of longs.
  *
  * @param palDestination destination array of longs
  * @param pastrSource source array of Strings
  * @since 0.3.0.3
  */
 public static void copy(long[] palDestination, String[] pastrSource)
 {
   copy(palDestination, 0, pastrSource, 0, pastrSource.length);
 }
 /**
  * General copy-conversion method that copies N String elements
  * from an array of Strings into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pastrSource source array of Strings
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  *
  * @throws NumberFormatException if one of the Strings doesn"t have a properly formatted number
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, int piDestinationFrom, String[] pastrSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     paiDestination[piDestinationFrom + i] = Integer.parseInt(pastrSource[piSourceFrom + i]);
 }
 /**
  * Copy-conversion method that copies N String elements
  * from an array of Strings into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param pastrSource source array of Strings
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, String[] pastrSource, int piHowMany)
 {
   copy(paiDestination, 0, pastrSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all String elements
  * from an array of Strings into array of integers.
  *
  * @param paiDestination destination array of integers
  * @param pastrSource source array of Strings
  * @since 0.3.0.3
  */
 public static void copy(int[] paiDestination, String[] pastrSource)
 {
   copy(paiDestination, 0, pastrSource, 0, pastrSource.length);
 }
 /**
  * General copy-conversion method that copies N String elements
  * from an array of Strings into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pastrSource source array of Strings
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  *
  * @throws NumberFormatException if one of the Strings doesn"t have a properly formatted number
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, int piDestinationFrom, String[] pastrSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     pasDestination[piDestinationFrom + i] = Short.parseShort(pastrSource[piSourceFrom + i]);
 }
 /**
  * Copy-conversion method that copies N String elements
  * from an array of Strings into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param pastrSource source array of Strings
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, String[] pastrSource, int piHowMany)
 {
   copy(pasDestination, 0, pastrSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all String elements
  * from an array of Strings into array of shorts.
  *
  * @param pasDestination destination array of shorts
  * @param pastrSource source array of Strings
  * @since 0.3.0.3
  */
 public static void copy(short[] pasDestination, String[] pastrSource)
 {
   copy(pasDestination, 0, pastrSource, 0, pastrSource.length);
 }
 /**
  * General copy-conversion method that copies N String elements
  * from an array of Strings into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param piDestinationFrom index in the destination to start place elements at
  * @param pastrSource source array of Strings
  * @param piSourceFrom index in the source to start take elements from
  * @param piHowMany N; how many elements to copy
  *
  * @throws NumberFormatException if one of the Strings doesn"t have a properly formatted number
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, int piDestinationFrom, String[] pastrSource, int piSourceFrom, int piHowMany)
 {
   for(int i = 0; i < piHowMany; i++)
     patDestination[piDestinationFrom + i] = Byte.parseByte(pastrSource[piSourceFrom + i]);
 }
 /**
  * Copy-conversion method that copies N String elements
  * from an array of Strings into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param pastrSource source array of Strings
  * @param piHowMany N; how many elements to copy
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, String[] pastrSource, int piHowMany)
 {
   copy(patDestination, 0, pastrSource, 0, piHowMany);
 }
 /**
  * Copy-conversion method that copies all String elements
  * from an array of Strings into array of bytes.
  *
  * @param patDestination destination array of bytes
  * @param pastrSource source array of Strings
  * @since 0.3.0.3
  */
 public static void copy(byte[] patDestination, String[] pastrSource)
 {
   copy(patDestination, 0, pastrSource, 0, pastrSource.length);
 }
 /*
  * -------------
  * Binary Search
  * -------------
  */
 /**
  * The binarySearch() routine is based on java.util.Arrays.binarySearch().
  *
  * @param pafArray the array of floats to be searched
  * @param pfValue the value of float to be searched in the array of floats
  * @return index of the searched value if it is in the array of floats
  * @since 0.3.0.3
  */
 public static int binarySearch(float[] pafArray, float pfValue)
 {
   return java.util.Arrays.binarySearch(pafArray, pfValue);
 }
 /**
  * The binarySearch() routine is based on java.util.Arrays.binarySearch().
  *
  * @param padArray the array of doubles to be searched
  * @param pdValue the value of double to be searched in the array of doubles
  * @return index of the searched value if it is in the array of doubles
  * @since 0.3.0.3
  */
 public static int binarySearch(double[] padArray, double pdValue)
 {
   return java.util.Arrays.binarySearch(padArray, pdValue);
 }
 /**
  * The binarySearch() routine is based on java.util.Arrays.binarySearch().
  *
  * @param pasArray the array of shorts to be searched
  * @param psValue the value of shorts to be searched in the array of shorts
  * @return index of the searched value if it is in the array of shorts
  * @since 0.3.0.3
  */
 public static int binarySearch(short[] pasArray, short psValue)
 {
   return java.util.Arrays.binarySearch(pasArray, psValue);
 }
 /**
  * The binarySearch() routine is based on java.util.Arrays.binarySearch().
  *
  * @param paiArray the array of integers to be searched
  * @param piValue the value of integer to be searched in the array of integers
  * @return index of the searched value if it is in the array of integers
  * @since 0.3.0.3
  */
 public static int binarySearch(int[] paiArray, int piValue)
 {
   return java.util.Arrays.binarySearch(paiArray, piValue);
 }
 /**
  * The binarySearch() routine is based on java.util.Arrays.binarySearch().
  *
  * @param patArray the array of bytes to be searched
  * @param ptValue the value of byte to be searched in the array of bytes
  * @return index of the searched value if it is in the array of bytes
  * @since 0.3.0.3
  */
 public static int binarySearch(byte[] patArray, byte ptValue)
 {
   return java.util.Arrays.binarySearch(patArray, ptValue);
 }
 /**
  * The binarySearch() routine is based on java.util.Arrays.binarySearch().
  *
  * @param pacArray the array of characters to be searched
  * @param pcValue the value of character to be searched in the array of characters
  * @return index of the searched value if it is in the array of characters
  * @since 0.3.0.3
  */
 public static int binarySearch(char[] pacArray, char pcValue)
 {
   return java.util.Arrays.binarySearch(pacArray, pcValue);
 }
 /**
  * The binarySearch() routine is based on java.util.Arrays.binarySearch().
  *
  * @param paoArray the array of objects to be searched
  * @param poValue the value of object to be searched in the array of objects
  * @return index of the searched value if it is in the array of objects
  * @throws ClassCastException if the type of the searched value is not match the type of the array
  * @since 0.3.0.3
  */
 public static int binarySearch(Object[] paoArray, Object poValue)
 {
   return java.util.Arrays.binarySearch(paoArray, poValue);
 }
 /**
  * The binarySearch() routine is based on java.util.Arrays.binarySearch().
  *
  * @param paoArray the array of objects to be searched
  * @param poValue the value of object to be searched in the array of objects
  * @param poComparator the comparator to decide the order of the array
  * @return index of the searched value if it is in the array of objects
  * @throws ClassCastException if the type of the searched value is not match the type of the array
  * @since 0.3.0.3
  */
 public static int binarySearch(Object[] paoArray, Object poValue, Comparator poComparator)
 {
   return java.util.Arrays.binarySearch(paoArray, poValue, poComparator);
 }
 /*
  * ----
  * Misc
  * ----
  */
 /**
  * Returns source code revision information.
  *
  * @return revision string
  * @since 0.3.0.2
  */
 public static String getMARFSourceCodeRevision()
 {
   return "$Revision: 1.38 $";
 }

} // EOF

 </source>
   
  
 
  

Concatenate Java arrays

   <source lang="java">
  

/*

* Convenience methods for working with Java arrays.
* Copyright (C) 2005 Stephen Ostermiller
* http://ostermiller.org/contact.pl?regarding=Java+Utilities
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* See COPYING.TXT for details.
*/

import java.io.IOException; import java.lang.reflect.Array; /**

* Convenience methods for working with Java arrays.
* More information about this class is available from .
*
* @author Stephen Ostermiller http://ostermiller.org/contact.pl?regarding=Java+Utilities
* @since ostermillerutils 1.06.00
*/

public final class ArrayHelper {

 /**
  * Concatenates the given arrays into a single long array.
  * The returned array will be of the common super type of the
  * two given arrays.

*

* For example it can be called like this:
*

   * String[] arr = (String[])ArrayHelper.cat(new String[]{"one","two"}, new String[]{"three","four"});
   * 

  *
  * @param arr1 first array
  * @param arr2 second array
  * @return an array whose length is the sum of the given array"s lengths and contains all the elements in the given arrays.
  * @since ostermillerutils 1.06.00
  */
 public static Object[] cat(Object[] arr1, Object[] arr2){
   // Use reflection to find the super class of both arrays
   Class<?> commonSuperClass = Object.class;
   boolean foundcommonSuperClass=false;
   for (Class<?> c1 = arr1.getClass().getComponentType(); !foundcommonSuperClass && !c1.equals(Object.class); c1 = c1.getSuperclass()){
     for (Class<?> c2 = arr2.getClass().getComponentType(); !foundcommonSuperClass && !c2.equals(Object.class); c2 = c2.getSuperclass()){
       if (c2.equals(c1)){
         foundcommonSuperClass = true;
         commonSuperClass = c1;
       }
     }
   }
   // Create a new array of the correct type
   Object[] result = (Object[])Array.newInstance(commonSuperClass, arr1.length + arr2.length);
   // Copy the two arrays into the large array
   System.arraycopy(arr1, 0, result, 0, arr1.length);
   System.arraycopy(arr2, 0, result, arr1.length, arr2.length);
   return result;
 }

 /**
  * Tests two arrays to see if the arrays are equal.
  * Two arrays will be equal only if they are the same length
  * and contain objects that are equal in the same order.
  *
  * @param arr1 first array
  * @param arr2 second array
  * @return true iff two arguments are equal
  * @since ostermillerutils 1.06.00
  */
 public static boolean equal(Object[] arr1, Object[] arr2){
   if (arr1 == null && arr2 == null) return true;
   if (arr1 == null || arr2 == null) return false;
   if (arr1.length != arr2.length) return false;
   for (int i=0; i<arr1.length; i++){
     if (!equalObjects(arr1[i], arr2[i])) return false;
   }
   return true;
 }
 /**
  * Tests if the two objects are equal
  *
  * @param o1 first object
  * @param o2 second object
  * @since ostermillerutils 1.06.00
  */
 private static boolean equalObjects(Object o1, Object o2){
   if (o1 == null && o2 == null) return true;
   if (o1 == null || o2 == null) return false;
   return o1.equals(o2);
 }

}

 </source>
   
  
 
  

Copies the given array and adds the given element at the end of the new array.(boolean value type)

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

* <p>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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Copies the given array and adds the given element at the end of the new array.

  *

*

The new array contains the same elements of the input * array plus the given element in the last position. The component type of * the new array is the same as that of the input array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add(null, true)          = [true]
   * ArrayUtils.add([true], false)       = [true, false]
   * ArrayUtils.add([true, false], true) = [true, false, true]
   * 

  * 
  * @param array  the array to copy and add the element to, may be null
  * @param element  the object to add at the last index of the new array
  * @return A new array containing the existing elements plus the new element
  * @since 2.1
  */
 public static boolean[] add(boolean[] array, boolean element) {
     boolean[] newArray = (boolean[])copyArrayGrow1(array, Boolean.TYPE);
     newArray[newArray.length - 1] = element;
     return newArray;
 }
 
 
 /**
  * Returns a copy of the given array of size 1 greater than the argument. 
  * The last value of the array is left to the default value.
  * 
  * @param array The array to copy, must not be null.
  * @param newArrayComponentType If array is null, create a 
  * size 1 array of this type.
  * @return A new copy of the array of size 1 greater than the input.
  */    
 private static Object copyArrayGrow1(Object array, Class newArrayComponentType) {
     if (array != null) {
         int arrayLength = Array.getLength(array);
         Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
         System.arraycopy(array, 0, newArray, 0, arrayLength);
         return newArray;
     }
     return Array.newInstance(newArrayComponentType, 1);
 }

}

 </source>
   
  
 
  

Copies the given array and adds the given element at the end of the new array.(byte value type)

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Copies the given array and adds the given element at the end of the new array.

  *

*

The new array contains the same elements of the input * array plus the given element in the last position. The component type of * the new array is the same as that of the input array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add(null, 0)   = [0]
   * ArrayUtils.add([1], 0)    = [1, 0]
   * ArrayUtils.add([1, 0], 1) = [1, 0, 1]
   * 

  * 
  * @param array  the array to copy and add the element to, may be null
  * @param element  the object to add at the last index of the new array
  * @return A new array containing the existing elements plus the new element
  * @since 2.1
  */
 public static byte[] add(byte[] array, byte element) {
     byte[] newArray = (byte[])copyArrayGrow1(array, Byte.TYPE);
     newArray[newArray.length - 1] = element;
     return newArray;
 }
 
 /**
  * Returns a copy of the given array of size 1 greater than the argument. 
  * The last value of the array is left to the default value.
  * 
  * @param array The array to copy, must not be null.
  * @param newArrayComponentType If array is null, create a 
  * size 1 array of this type.
  * @return A new copy of the array of size 1 greater than the input.
  */    
 private static Object copyArrayGrow1(Object array, Class newArrayComponentType) {
     if (array != null) {
         int arrayLength = Array.getLength(array);
         Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
         System.arraycopy(array, 0, newArray, 0, arrayLength);
         return newArray;
     }
     return Array.newInstance(newArrayComponentType, 1);
 }

}

 </source>
   
  
 
  

Copies the given array and adds the given element at the end of the new array. (char type value)

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Copies the given array and adds the given element at the end of the new array.

  *

*

The new array contains the same elements of the input * array plus the given element in the last position. The component type of * the new array is the same as that of the input array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add(null, "0")       = ["0"]
   * ArrayUtils.add(["1"], "0")      = ["1", "0"]
   * ArrayUtils.add(["1", "0"], "1") = ["1", "0", "1"]
   * 

  * 
  * @param array  the array to copy and add the element to, may be null
  * @param element  the object to add at the last index of the new array
  * @return A new array containing the existing elements plus the new element
  * @since 2.1
  */
 public static char[] add(char[] array, char element) {
     char[] newArray = (char[])copyArrayGrow1(array, Character.TYPE);
     newArray[newArray.length - 1] = element;
     return newArray;
 }

 /**
  * Returns a copy of the given array of size 1 greater than the argument. 
  * The last value of the array is left to the default value.
  * 
  * @param array The array to copy, must not be null.
  * @param newArrayComponentType If array is null, create a 
  * size 1 array of this type.
  * @return A new copy of the array of size 1 greater than the input.
  */    
 private static Object copyArrayGrow1(Object array, Class newArrayComponentType) {
     if (array != null) {
         int arrayLength = Array.getLength(array);
         Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
         System.arraycopy(array, 0, newArray, 0, arrayLength);
         return newArray;
     }
     return Array.newInstance(newArrayComponentType, 1);
 }

}

 </source>
   
  
 
  

Copies the given array and adds the given element at the end of the new array.(double type value)

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Copies the given array and adds the given element at the end of the new array.

  *

*

The new array contains the same elements of the input * array plus the given element in the last position. The component type of * the new array is the same as that of the input array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add(null, 0)   = [0]
   * ArrayUtils.add([1], 0)    = [1, 0]
   * ArrayUtils.add([1, 0], 1) = [1, 0, 1]
   * 

  * 
  * @param array  the array to copy and add the element to, may be null
  * @param element  the object to add at the last index of the new array
  * @return A new array containing the existing elements plus the new element
  * @since 2.1
  */
 public static double[] add(double[] array, double element) {
     double[] newArray = (double[])copyArrayGrow1(array, Double.TYPE);
     newArray[newArray.length - 1] = element;
     return newArray;
 }
 
 /**
  * Returns a copy of the given array of size 1 greater than the argument. 
  * The last value of the array is left to the default value.
  * 
  * @param array The array to copy, must not be null.
  * @param newArrayComponentType If array is null, create a 
  * size 1 array of this type.
  * @return A new copy of the array of size 1 greater than the input.
  */    
 private static Object copyArrayGrow1(Object array, Class newArrayComponentType) {
     if (array != null) {
         int arrayLength = Array.getLength(array);
         Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
         System.arraycopy(array, 0, newArray, 0, arrayLength);
         return newArray;
     }
     return Array.newInstance(newArrayComponentType, 1);
 }

}

 </source>
   
  
 
  

Copies the given array and adds the given element at the end of the new array. (float type value)

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Copies the given array and adds the given element at the end of the new array.

  *

*

The new array contains the same elements of the input * array plus the given element in the last position. The component type of * the new array is the same as that of the input array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add(null, 0)   = [0]
   * ArrayUtils.add([1], 0)    = [1, 0]
   * ArrayUtils.add([1, 0], 1) = [1, 0, 1]
   * 

  * 
  * @param array  the array to copy and add the element to, may be null
  * @param element  the object to add at the last index of the new array
  * @return A new array containing the existing elements plus the new element
  * @since 2.1
  */
 public static float[] add(float[] array, float element) {
     float[] newArray = (float[])copyArrayGrow1(array, Float.TYPE);
     newArray[newArray.length - 1] = element;
     return newArray;
 }
 
 
 /**
  * Returns a copy of the given array of size 1 greater than the argument. 
  * The last value of the array is left to the default value.
  * 
  * @param array The array to copy, must not be null.
  * @param newArrayComponentType If array is null, create a 
  * size 1 array of this type.
  * @return A new copy of the array of size 1 greater than the input.
  */    
 private static Object copyArrayGrow1(Object array, Class newArrayComponentType) {
     if (array != null) {
         int arrayLength = Array.getLength(array);
         Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
         System.arraycopy(array, 0, newArray, 0, arrayLength);
         return newArray;
     }
     return Array.newInstance(newArrayComponentType, 1);
 }

}

 </source>
   
  
 
  

Copies the given array and adds the given element at the end of the new array.(int value type)

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Copies the given array and adds the given element at the end of the new array.

  *

*

The new array contains the same elements of the input * array plus the given element in the last position. The component type of * the new array is the same as that of the input array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add(null, 0)   = [0]
   * ArrayUtils.add([1], 0)    = [1, 0]
   * ArrayUtils.add([1, 0], 1) = [1, 0, 1]
   * 

  * 
  * @param array  the array to copy and add the element to, may be null
  * @param element  the object to add at the last index of the new array
  * @return A new array containing the existing elements plus the new element
  * @since 2.1
  */
 public static int[] add(int[] array, int element) {
     int[] newArray = (int[])copyArrayGrow1(array, Integer.TYPE);
     newArray[newArray.length - 1] = element;
     return newArray;
 }
 
 
 /**
  * Returns a copy of the given array of size 1 greater than the argument. 
  * The last value of the array is left to the default value.
  * 
  * @param array The array to copy, must not be null.
  * @param newArrayComponentType If array is null, create a 
  * size 1 array of this type.
  * @return A new copy of the array of size 1 greater than the input.
  */    
 private static Object copyArrayGrow1(Object array, Class newArrayComponentType) {
     if (array != null) {
         int arrayLength = Array.getLength(array);
         Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
         System.arraycopy(array, 0, newArray, 0, arrayLength);
         return newArray;
     }
     return Array.newInstance(newArrayComponentType, 1);
 }

}

 </source>
   
  
 
  

Copies the given array and adds the given element at the end of the new array. (long value type)

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Copies the given array and adds the given element at the end of the new array.

  *

*

The new array contains the same elements of the input * array plus the given element in the last position. The component type of * the new array is the same as that of the input array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add(null, 0)   = [0]
   * ArrayUtils.add([1], 0)    = [1, 0]
   * ArrayUtils.add([1, 0], 1) = [1, 0, 1]
   * 

  * 
  * @param array  the array to copy and add the element to, may be null
  * @param element  the object to add at the last index of the new array
  * @return A new array containing the existing elements plus the new element
  * @since 2.1
  */
 public static long[] add(long[] array, long element) {
     long[] newArray = (long[])copyArrayGrow1(array, Long.TYPE);
     newArray[newArray.length - 1] = element;
     return newArray;
 }
 
 /**
  * Returns a copy of the given array of size 1 greater than the argument. 
  * The last value of the array is left to the default value.
  * 
  * @param array The array to copy, must not be null.
  * @param newArrayComponentType If array is null, create a 
  * size 1 array of this type.
  * @return A new copy of the array of size 1 greater than the input.
  */    
 private static Object copyArrayGrow1(Object array, Class newArrayComponentType) {
     if (array != null) {
         int arrayLength = Array.getLength(array);
         Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
         System.arraycopy(array, 0, newArray, 0, arrayLength);
         return newArray;
     }
     return Array.newInstance(newArrayComponentType, 1);
 }

}

 </source>
   
  
 
  

Copies the given array and adds the given element at the end of the new array. (object value type)

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Copies the given array and adds the given element at the end of the new array.

  *

*

The new array contains the same elements of the input * array plus the given element in the last position. The component type of * the new array is the same as that of the input array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add(null, null)      = [null]
   * ArrayUtils.add(null, "a")       = ["a"]
   * ArrayUtils.add(["a"], null)     = ["a", null]
   * ArrayUtils.add(["a"], "b")      = ["a", "b"]
   * ArrayUtils.add(["a", "b"], "c") = ["a", "b", "c"]
   * 

  * 
  * @param array  the array to "add" the element to, may be null
  * @param element  the object to add
  * @return A new array containing the existing elements plus the new element
  * @since 2.1
  */
 public static Object[] add(Object[] array, Object element) {
     Class type = array != null ? array.getClass() : (element != null ? element.getClass() : Object.class);
     Object[] newArray = (Object[]) copyArrayGrow1(array, type);
     newArray[newArray.length - 1] = element;
     return newArray;
 }
 
 
 /**
  * Returns a copy of the given array of size 1 greater than the argument. 
  * The last value of the array is left to the default value.
  * 
  * @param array The array to copy, must not be null.
  * @param newArrayComponentType If array is null, create a 
  * size 1 array of this type.
  * @return A new copy of the array of size 1 greater than the input.
  */    
 private static Object copyArrayGrow1(Object array, Class newArrayComponentType) {
     if (array != null) {
         int arrayLength = Array.getLength(array);
         Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
         System.arraycopy(array, 0, newArray, 0, arrayLength);
         return newArray;
     }
     return Array.newInstance(newArrayComponentType, 1);
 }

}

 </source>
   
  
 
  

Copies the given array and adds the given element at the end of the new array.(short type array)

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Copies the given array and adds the given element at the end of the new array.

  *

*

The new array contains the same elements of the input * array plus the given element in the last position. The component type of * the new array is the same as that of the input array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add(null, 0)   = [0]
   * ArrayUtils.add([1], 0)    = [1, 0]
   * ArrayUtils.add([1, 0], 1) = [1, 0, 1]
   * 

  * 
  * @param array  the array to copy and add the element to, may be null
  * @param element  the object to add at the last index of the new array
  * @return A new array containing the existing elements plus the new element
  * @since 2.1
  */
 public static short[] add(short[] array, short element) {
     short[] newArray = (short[])copyArrayGrow1(array, Short.TYPE);
     newArray[newArray.length - 1] = element;
     return newArray;
 }
 
 /**
  * Returns a copy of the given array of size 1 greater than the argument. 
  * The last value of the array is left to the default value.
  * 
  * @param array The array to copy, must not be null.
  * @param newArrayComponentType If array is null, create a 
  * size 1 array of this type.
  * @return A new copy of the array of size 1 greater than the input.
  */    
 private static Object copyArrayGrow1(Object array, Class newArrayComponentType) {
     if (array != null) {
         int arrayLength = Array.getLength(array);
         Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
         System.arraycopy(array, 0, newArray, 0, arrayLength);
         return newArray;
     }
     return Array.newInstance(newArrayComponentType, 1);
 }

}

 </source>
   
  
 
  

Inserts the specified element at the specified position in the array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Inserts the specified element at the specified position in the array. * Shifts the element currently at that position (if any) and any subsequent * elements to the right (adds one to their indices).

  *

*

This method returns a new array with the same elements of the input * array plus the given element on the specified position. The component * type of the returned array is always the same as that of the input * array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add(null, 0, null)      = [null]
   * ArrayUtils.add(null, 0, "a")       = ["a"]
   * ArrayUtils.add(["a"], 1, null)     = ["a", null]
   * ArrayUtils.add(["a"], 1, "b")      = ["a", "b"]
   * ArrayUtils.add(["a", "b"], 3, "c") = ["a", "b", "c"]
   * 

  * 
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @return A new array containing the existing elements and the new element
  * @throws IndexOutOfBoundsException if the index is out of range 
  * (index < 0 || index > array.length).
  */
 public static Object[] add(Object[] array, int index, Object element) {
     Class clss = null;
     if (array != null) {
         clss = array.getClass().getComponentType();
     } else if (element != null) {
         clss = element.getClass();
     } else {
         return new Object[]{null};
     }
     return (Object[]) add(array, index, element, clss);
 }
 

 /**
  * Underlying implementation of add(array, index, element) methods. 
  * The last parameter is the class, which may not equal element.getClass 
  * for primitives.
  *
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @param clss the type of the element being added
  * @return A new array containing the existing elements and the new element
  */
 private static Object add(Object array, int index, Object element, Class clss) {
     if (array == null) {
         if (index != 0) {
             throw new IndexOutOfBoundsException("Index: " + index + ", Length: 0");
         }
         Object joinedArray = Array.newInstance(clss, 1);
         Array.set(joinedArray, 0, element);
         return joinedArray;
     }
     int length = Array.getLength(array);
     if (index > length || index < 0) {
         throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
     }
     Object result = Array.newInstance(clss, length + 1);
     System.arraycopy(array, 0, result, 0, index);
     Array.set(result, index, element);
     if (index < length) {
         System.arraycopy(array, index, result, index + 1, length - index);
     }
     return result;
 }

}

 </source>
   
  
 
  

Inserts the specified element at the specified position in the boolean-type-value array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Inserts the specified element at the specified position in the array. * Shifts the element currently at that position (if any) and any subsequent * elements to the right (adds one to their indices).

  *

*

This method returns a new array with the same elements of the input * array plus the given element on the specified position. The component * type of the returned array is always the same as that of the input * array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add(null, 0, true)          = [true]
   * ArrayUtils.add([true], 0, false)       = [false, true]
   * ArrayUtils.add([false], 1, true)       = [false, true]
   * ArrayUtils.add([true, false], 1, true) = [true, true, false]
   * 

  * 
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @return A new array containing the existing elements and the new element
  * @throws IndexOutOfBoundsException if the index is out of range 
  * (index < 0 || index > array.length).
  */
 public static boolean[] add(boolean[] array, int index, boolean element) {
     return (boolean[]) add(array, index, element, Boolean.TYPE);
 }

 /**
  * Underlying implementation of add(array, index, element) methods. 
  * The last parameter is the class, which may not equal element.getClass 
  * for primitives.
  *
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @param clss the type of the element being added
  * @return A new array containing the existing elements and the new element
  */
 private static Object add(Object array, int index, Object element, Class clss) {
     if (array == null) {
         if (index != 0) {
             throw new IndexOutOfBoundsException("Index: " + index + ", Length: 0");
         }
         Object joinedArray = Array.newInstance(clss, 1);
         Array.set(joinedArray, 0, element);
         return joinedArray;
     }
     int length = Array.getLength(array);
     if (index > length || index < 0) {
         throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
     }
     Object result = Array.newInstance(clss, length + 1);
     System.arraycopy(array, 0, result, 0, index);
     Array.set(result, index, element);
     if (index < length) {
         System.arraycopy(array, index, result, index + 1, length - index);
     }
     return result;
 }

}

 </source>
   
  
 
  

Inserts the specified element at the specified position in the byte-type-value array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Inserts the specified element at the specified position in the array. * Shifts the element currently at that position (if any) and any subsequent * elements to the right (adds one to their indices).

  *

*

This method returns a new array with the same elements of the input * array plus the given element on the specified position. The component * type of the returned array is always the same as that of the input * array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add([1], 0, 2)         = [2, 1]
   * ArrayUtils.add([2, 6], 2, 3)      = [2, 6, 3]
   * ArrayUtils.add([2, 6], 0, 1)      = [1, 2, 6]
   * ArrayUtils.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
   * 

  * 
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @return A new array containing the existing elements and the new element
  * @throws IndexOutOfBoundsException if the index is out of range 
  * (index < 0 || index > array.length).
  */
 public static byte[] add(byte[] array, int index, byte element) {
     return (byte[]) add(array, index, new Byte(element), Byte.TYPE);
 }
 
 /**
  * Underlying implementation of add(array, index, element) methods. 
  * The last parameter is the class, which may not equal element.getClass 
  * for primitives.
  *
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @param clss the type of the element being added
  * @return A new array containing the existing elements and the new element
  */
 private static Object add(Object array, int index, Object element, Class clss) {
     if (array == null) {
         if (index != 0) {
             throw new IndexOutOfBoundsException("Index: " + index + ", Length: 0");
         }
         Object joinedArray = Array.newInstance(clss, 1);
         Array.set(joinedArray, 0, element);
         return joinedArray;
     }
     int length = Array.getLength(array);
     if (index > length || index < 0) {
         throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
     }
     Object result = Array.newInstance(clss, length + 1);
     System.arraycopy(array, 0, result, 0, index);
     Array.set(result, index, element);
     if (index < length) {
         System.arraycopy(array, index, result, index + 1, length - index);
     }
     return result;
 }

}

 </source>
   
  
 
  

Inserts the specified element at the specified position in the char-type-value array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Inserts the specified element at the specified position in the array. * Shifts the element currently at that position (if any) and any subsequent * elements to the right (adds one to their indices).

  *

*

This method returns a new array with the same elements of the input * array plus the given element on the specified position. The component * type of the returned array is always the same as that of the input * array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add(null, 0, "a")            = ["a"]
   * ArrayUtils.add(["a"], 0, "b")           = ["b", "a"]
   * ArrayUtils.add(["a", "b"], 0, "c")      = ["c", "a", "b"]
   * ArrayUtils.add(["a", "b"], 1, "k")      = ["a", "k", "b"]
   * ArrayUtils.add(["a", "b", "c"], 1, "t") = ["a", "t", "b", "c"]
   * 

  * 
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @return A new array containing the existing elements and the new element
  * @throws IndexOutOfBoundsException if the index is out of range 
  * (index < 0 || index > array.length).
  */
 public static char[] add(char[] array, int index, char element) {
     return (char[]) add(array, index, new Character(element), Character.TYPE);
 }
 
 /**
  * Underlying implementation of add(array, index, element) methods. 
  * The last parameter is the class, which may not equal element.getClass 
  * for primitives.
  *
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @param clss the type of the element being added
  * @return A new array containing the existing elements and the new element
  */
 private static Object add(Object array, int index, Object element, Class clss) {
     if (array == null) {
         if (index != 0) {
             throw new IndexOutOfBoundsException("Index: " + index + ", Length: 0");
         }
         Object joinedArray = Array.newInstance(clss, 1);
         Array.set(joinedArray, 0, element);
         return joinedArray;
     }
     int length = Array.getLength(array);
     if (index > length || index < 0) {
         throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
     }
     Object result = Array.newInstance(clss, length + 1);
     System.arraycopy(array, 0, result, 0, index);
     Array.set(result, index, element);
     if (index < length) {
         System.arraycopy(array, index, result, index + 1, length - index);
     }
     return result;
 }

}

 </source>
   
  
 
  

Inserts the specified element at the specified position in the double-type-value array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Inserts the specified element at the specified position in the array. * Shifts the element currently at that position (if any) and any subsequent * elements to the right (adds one to their indices).

  *

*

This method returns a new array with the same elements of the input * array plus the given element on the specified position. The component * type of the returned array is always the same as that of the input * array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add([1.1], 0, 2.2)              = [2.2, 1.1]
   * ArrayUtils.add([2.3, 6.4], 2, 10.5)        = [2.3, 6.4, 10.5]
   * ArrayUtils.add([2.6, 6.7], 0, -4.8)        = [-4.8, 2.6, 6.7]
   * ArrayUtils.add([2.9, 6.0, 0.3], 2, 1.0)    = [2.9, 6.0, 1.0, 0.3]
   * 

  * 
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @return A new array containing the existing elements and the new element
  * @throws IndexOutOfBoundsException if the index is out of range 
  * (index < 0 || index > array.length).
  */
 public static double[] add(double[] array, int index, double element) {
     return (double[]) add(array, index, new Double(element), Double.TYPE);
 }
 
 /**
  * Underlying implementation of add(array, index, element) methods. 
  * The last parameter is the class, which may not equal element.getClass 
  * for primitives.
  *
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @param clss the type of the element being added
  * @return A new array containing the existing elements and the new element
  */
 private static Object add(Object array, int index, Object element, Class clss) {
     if (array == null) {
         if (index != 0) {
             throw new IndexOutOfBoundsException("Index: " + index + ", Length: 0");
         }
         Object joinedArray = Array.newInstance(clss, 1);
         Array.set(joinedArray, 0, element);
         return joinedArray;
     }
     int length = Array.getLength(array);
     if (index > length || index < 0) {
         throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
     }
     Object result = Array.newInstance(clss, length + 1);
     System.arraycopy(array, 0, result, 0, index);
     Array.set(result, index, element);
     if (index < length) {
         System.arraycopy(array, index, result, index + 1, length - index);
     }
     return result;
 }

}

 </source>
   
  
 
  

Inserts the specified element at the specified position in the float-value-type array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Inserts the specified element at the specified position in the array. * Shifts the element currently at that position (if any) and any subsequent * elements to the right (adds one to their indices).

  *

*

This method returns a new array with the same elements of the input * array plus the given element on the specified position. The component * type of the returned array is always the same as that of the input * array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add([1.1f], 0, 2.2f)               = [2.2f, 1.1f]
   * ArrayUtils.add([2.3f, 6.4f], 2, 10.5f)        = [2.3f, 6.4f, 10.5f]
   * ArrayUtils.add([2.6f, 6.7f], 0, -4.8f)        = [-4.8f, 2.6f, 6.7f]
   * ArrayUtils.add([2.9f, 6.0f, 0.3f], 2, 1.0f)   = [2.9f, 6.0f, 1.0f, 0.3f]
   * 

  * 
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @return A new array containing the existing elements and the new element
  * @throws IndexOutOfBoundsException if the index is out of range 
  * (index < 0 || index > array.length).
  */
 public static float[] add(float[] array, int index, float element) {
     return (float[]) add(array, index, new Float(element), Float.TYPE);
 }
 
 /**
  * Underlying implementation of add(array, index, element) methods. 
  * The last parameter is the class, which may not equal element.getClass 
  * for primitives.
  *
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @param clss the type of the element being added
  * @return A new array containing the existing elements and the new element
  */
 private static Object add(Object array, int index, Object element, Class clss) {
     if (array == null) {
         if (index != 0) {
             throw new IndexOutOfBoundsException("Index: " + index + ", Length: 0");
         }
         Object joinedArray = Array.newInstance(clss, 1);
         Array.set(joinedArray, 0, element);
         return joinedArray;
     }
     int length = Array.getLength(array);
     if (index > length || index < 0) {
         throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
     }
     Object result = Array.newInstance(clss, length + 1);
     System.arraycopy(array, 0, result, 0, index);
     Array.set(result, index, element);
     if (index < length) {
         System.arraycopy(array, index, result, index + 1, length - index);
     }
     return result;
 }

}

 </source>
   
  
 
  

Inserts the specified element at the specified position in the int-type-value array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Inserts the specified element at the specified position in the array. * Shifts the element currently at that position (if any) and any subsequent * elements to the right (adds one to their indices).

  *

*

This method returns a new array with the same elements of the input * array plus the given element on the specified position. The component * type of the returned array is always the same as that of the input * array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add([1], 0, 2)         = [2, 1]
   * ArrayUtils.add([2, 6], 2, 10)     = [2, 6, 10]
   * ArrayUtils.add([2, 6], 0, -4)     = [-4, 2, 6]
   * ArrayUtils.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
   * 

  * 
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @return A new array containing the existing elements and the new element
  * @throws IndexOutOfBoundsException if the index is out of range 
  * (index < 0 || index > array.length).
  */
 public static int[] add(int[] array, int index, int element) {
     return (int[]) add(array, index, new Integer(element), Integer.TYPE);
 }

 /**
  * Underlying implementation of add(array, index, element) methods. 
  * The last parameter is the class, which may not equal element.getClass 
  * for primitives.
  *
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @param clss the type of the element being added
  * @return A new array containing the existing elements and the new element
  */
 private static Object add(Object array, int index, Object element, Class clss) {
     if (array == null) {
         if (index != 0) {
             throw new IndexOutOfBoundsException("Index: " + index + ", Length: 0");
         }
         Object joinedArray = Array.newInstance(clss, 1);
         Array.set(joinedArray, 0, element);
         return joinedArray;
     }
     int length = Array.getLength(array);
     if (index > length || index < 0) {
         throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
     }
     Object result = Array.newInstance(clss, length + 1);
     System.arraycopy(array, 0, result, 0, index);
     Array.set(result, index, element);
     if (index < length) {
         System.arraycopy(array, index, result, index + 1, length - index);
     }
     return result;
 }

}

 </source>
   
  
 
  

Inserts the specified element at the specified position in the long-type-value array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Inserts the specified element at the specified position in the array. * Shifts the element currently at that position (if any) and any subsequent * elements to the right (adds one to their indices).

  *

*

This method returns a new array with the same elements of the input * array plus the given element on the specified position. The component * type of the returned array is always the same as that of the input * array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add([1L], 0, 2L)           = [2L, 1L]
   * ArrayUtils.add([2L, 6L], 2, 10L)      = [2L, 6L, 10L]
   * ArrayUtils.add([2L, 6L], 0, -4L)      = [-4L, 2L, 6L]
   * ArrayUtils.add([2L, 6L, 3L], 2, 1L)   = [2L, 6L, 1L, 3L]
   * 

  * 
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @return A new array containing the existing elements and the new element
  * @throws IndexOutOfBoundsException if the index is out of range 
  * (index < 0 || index > array.length).
  */
 public static long[] add(long[] array, int index, long element) {
     return (long[]) add(array, index, new Long(element), Long.TYPE);
 }
 
 
 /**
  * Underlying implementation of add(array, index, element) methods. 
  * The last parameter is the class, which may not equal element.getClass 
  * for primitives.
  *
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @param clss the type of the element being added
  * @return A new array containing the existing elements and the new element
  */
 private static Object add(Object array, int index, Object element, Class clss) {
     if (array == null) {
         if (index != 0) {
             throw new IndexOutOfBoundsException("Index: " + index + ", Length: 0");
         }
         Object joinedArray = Array.newInstance(clss, 1);
         Array.set(joinedArray, 0, element);
         return joinedArray;
     }
     int length = Array.getLength(array);
     if (index > length || index < 0) {
         throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
     }
     Object result = Array.newInstance(clss, length + 1);
     System.arraycopy(array, 0, result, 0, index);
     Array.set(result, index, element);
     if (index < length) {
         System.arraycopy(array, index, result, index + 1, length - index);
     }
     return result;
 }

}

 </source>
   
  
 
  

Inserts the specified element at the specified position in the short-value-type array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Inserts the specified element at the specified position in the array. * Shifts the element currently at that position (if any) and any subsequent * elements to the right (adds one to their indices).

  *

*

This method returns a new array with the same elements of the input * array plus the given element on the specified position. The component * type of the returned array is always the same as that of the input * array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add([1], 0, 2)         = [2, 1]
   * ArrayUtils.add([2, 6], 2, 10)     = [2, 6, 10]
   * ArrayUtils.add([2, 6], 0, -4)     = [-4, 2, 6]
   * ArrayUtils.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
   * 

  * 
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @return A new array containing the existing elements and the new element
  * @throws IndexOutOfBoundsException if the index is out of range 
  * (index < 0 || index > array.length).
  */
 public static short[] add(short[] array, int index, short element) {
     return (short[]) add(array, index, new Short(element), Short.TYPE);
 }
 

 /**
  * Underlying implementation of add(array, index, element) methods. 
  * The last parameter is the class, which may not equal element.getClass 
  * for primitives.
  *
  * @param array  the array to add the element to, may be null
  * @param index  the position of the new object
  * @param element  the object to add
  * @param clss the type of the element being added
  * @return A new array containing the existing elements and the new element
  */
 private static Object add(Object array, int index, Object element, Class clss) {
     if (array == null) {
         if (index != 0) {
             throw new IndexOutOfBoundsException("Index: " + index + ", Length: 0");
         }
         Object joinedArray = Array.newInstance(clss, 1);
         Array.set(joinedArray, 0, element);
         return joinedArray;
     }
     int length = Array.getLength(array);
     if (index > length || index < 0) {
         throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
     }
     Object result = Array.newInstance(clss, length + 1);
     System.arraycopy(array, 0, result, 0, index);
     Array.set(result, index, element);
     if (index < length) {
         System.arraycopy(array, index, result, index + 1, length - index);
     }
     return result;
 }

}

 </source>
   
  
 
  

Insert value to array

   <source lang="java">
  

/*

* dbXML - Native XML Database
* Copyright (C) 1999-2004  The dbXML Group, L.L.C.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*
* $Id: Array.java,v 1.2 2004/02/12 00:17:58 bradford Exp $
*/

/**

* Array utility methods
*/

public final class Array {

  private Array() {
  }
  public static Object[] insertArrayObject(Object[] vals, Object val, int idx) {
     Object[] newVals = new Object[vals.length + 1];
     if ( idx > 0 )
        System.arraycopy(vals, 0, newVals, 0, idx);
     newVals[idx] = val;
     if ( idx < vals.length )
        System.arraycopy(vals, idx, newVals, idx + 1, vals.length - idx);
     return newVals;
  }
  public static Object[] deleteArrayObject(Object[] vals, int idx) {
     Object[] newVals = new Object[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[] insertArrayLong(long[] vals, long val, int idx) {
     long[] newVals = new long[vals.length + 1];
     if ( idx > 0 )
        System.arraycopy(vals, 0, newVals, 0, idx);
     newVals[idx] = val;
     if ( idx < vals.length )
        System.arraycopy(vals, idx, newVals, idx + 1, vals.length - idx);
     return newVals;
  }
  public static long[] deleteArrayLong(long[] vals, 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 int[] insertArrayInt(int[] vals, int val, int idx) {
     int[] newVals = new int[vals.length + 1];
     if ( idx > 0 )
        System.arraycopy(vals, 0, newVals, 0, idx);
     newVals[idx] = val;
     if ( idx < vals.length )
        System.arraycopy(vals, idx, newVals, idx + 1, vals.length - idx);
     return newVals;
  }
  public static int[] deleteArrayInt(int[] vals, int idx) {
     int[] newVals = new int[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 short[] insertArrayShort(short[] vals, short val, int idx) {
     short[] newVals = new short[vals.length + 1];
     if ( idx > 0 )
        System.arraycopy(vals, 0, newVals, 0, idx);
     newVals[idx] = val;
     if ( idx < vals.length )
        System.arraycopy(vals, idx, newVals, idx + 1, vals.length - idx);
     return newVals;
  }
  public static short[] deleteArrayShort(short[] vals, int idx) {
     short[] newVals = new short[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;
  }

}

 </source>
   
  
 
  

Removes the element at the specified position from the specified array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).

  *

*

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.

  *

*

If the input array is null, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.

  *

*

   * ArrayUtils.remove([1], 0)         = []
   * ArrayUtils.remove([2, 6], 0)      = [6]
   * ArrayUtils.remove([2, 6], 1)      = [2]
   * ArrayUtils.remove([2, 6, 3], 1)   = [2, 3]
   * 

  * 
  * @param array  the array to remove the element from, may not be null
  * @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 null.
  * @since 2.1
  */
 public static short[] remove(short[] array, int index) {
     return (short[]) remove((Object) array, index);
 }
 /**

*

Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).

  *

*

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.

  *

*

If the input array is null, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.

  * 
  * @param array  the array to remove the element from, may not be null
  * @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 null.
  * @since 2.1
  */
 private static Object remove(Object array, 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 result;
 }
 /**

*

Finds the index of the given value in the array starting at the given index.

  *

*

This method returns {@link #INDEX_NOT_FOUND} (-1) for a null input array.

  *

*

A negative startIndex is treated as zero. A startIndex larger than the array * length will return {@link #INDEX_NOT_FOUND} (-1).

  * 
  * @param array  the array to search through for the object, may be null
  * @param valueToFind  the value to find
  * @param startIndex  the index to start searching at
  * @return the index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int indexOf(short[] array, short valueToFind) {
     if (array == null) {
         return -1;
     }
     for (int i = 0; i < array.length; i++) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return -1;
 }
 /**

*

Returns the length of the specified array. * This method can deal with Object arrays and with primitive arrays.

  *

*

If the input array is null, 0 is returned.

  *

*

   * ArrayUtils.getLength(null)            = 0
   * ArrayUtils.getLength([])              = 0
   * ArrayUtils.getLength([null])          = 1
   * ArrayUtils.getLength([true, false])   = 2
   * ArrayUtils.getLength([1, 2, 3])       = 3
   * ArrayUtils.getLength(["a", "b", "c"]) = 3
   * 

  *
  * @param array  the array to retrieve the length from, may be null
  * @return The length of the array, or 0 if the array is null
  * @throws IllegalArgumentException if the object arguement is not an array.
  * @since 2.1
  */
 public static int getLength(Object array) {
     if (array == null) {
         return 0;
     }
     return Array.getLength(array);
 }
 /**

*

Shallow clones an array returning a typecast result and handling * null.

  *

*

The objects in the array are not cloned, thus there is no special * handling for multi-dimensional arrays.

  * 

*

This method returns null for a null input array.

  * 
  * @param array  the array to shallow clone, may be null
  * @return the cloned array, null if null input
  */
 public static short[] clone(short[] array) {
     if (array == null) {
         return null;
     }
     return (short[]) array.clone();
 }

}

 </source>
   
  
 
  

Removes the element at the specified position from the specified long type array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).

  *

*

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.

  *

*

If the input array is null, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.

  *

*

   * ArrayUtils.remove([1], 0)         = []
   * ArrayUtils.remove([2, 6], 0)      = [6]
   * ArrayUtils.remove([2, 6], 1)      = [2]
   * ArrayUtils.remove([2, 6, 3], 1)   = [2, 3]
   * 

  * 
  * @param array  the array to remove the element from, may not be null
  * @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 null.
  * @since 2.1
  */
 public static long[] remove(long[] array, int index) {
     return (long[]) remove((Object) array, index);
 }
 
 /**

*

Removes the first occurrence of the specified element from the * specified array. All subsequent elements are shifted to the left * (substracts one from their indices). If the array doesn"t contains * such an element, no elements are removed from the array.

  *

*

This method returns a new array with the same elements of the input * array except the first occurrence of the specified element. The component * type of the returned array is always the same as that of the input * array.

  *

*

   * ArrayUtils.removeElement(null, 1)      = null
   * ArrayUtils.removeElement([], 1)        = []
   * ArrayUtils.removeElement([1], 2)       = [1]
   * ArrayUtils.removeElement([1, 3], 1)    = [3]
   * ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1]
   * 

  * 
  * @param array  the array to remove the element from, may be null
  * @param element  the element to be removed
  * @return A new array containing the existing elements except the first
  *         occurrence of the specified element.
  * @since 2.1
  */
 public static long[] removeElement(long[] array, long element) {
     int index = indexOf(array, element);
     if (index == -1) {
         return clone(array);
     } 
     return remove(array, index);
 }
 /**

*

Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).

  *

*

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.

  *

*

If the input array is null, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.

  * 
  * @param array  the array to remove the element from, may not be null
  * @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 null.
  * @since 2.1
  */
 private static Object remove(Object array, 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 result;
 }
 /**

*

Finds the index of the given value in the array starting at the given index.

  *

*

This method returns {@link #INDEX_NOT_FOUND} (-1) for a null input array.

  *

*

A negative startIndex is treated as zero. A startIndex larger than the array * length will return {@link #INDEX_NOT_FOUND} (-1).

  * 
  * @param array  the array to search through for the object, may be null
  * @param valueToFind  the value to find
  * @param startIndex  the index to start searching at
  * @return the index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int indexOf(long[] array, long valueToFind) {
     if (array == null) {
         return -1;
     }
     for (int i = 0; i < array.length; i++) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return -1;
 }
 /**

*

Returns the length of the specified array. * This method can deal with Object arrays and with primitive arrays.

  *

*

If the input array is null, 0 is returned.

  *

*

   * ArrayUtils.getLength(null)            = 0
   * ArrayUtils.getLength([])              = 0
   * ArrayUtils.getLength([null])          = 1
   * ArrayUtils.getLength([true, false])   = 2
   * ArrayUtils.getLength([1, 2, 3])       = 3
   * ArrayUtils.getLength(["a", "b", "c"]) = 3
   * 

  *
  * @param array  the array to retrieve the length from, may be null
  * @return The length of the array, or 0 if the array is null
  * @throws IllegalArgumentException if the object arguement is not an array.
  * @since 2.1
  */
 public static int getLength(Object array) {
     if (array == null) {
         return 0;
     }
     return Array.getLength(array);
 }
 /**

*

Shallow clones an array returning a typecast result and handling * null.

  *

*

The objects in the array are not cloned, thus there is no special * handling for multi-dimensional arrays.

  * 

*

This method returns null for a null input array.

  * 
  * @param array  the array to shallow clone, may be null
  * @return the cloned array, null if null input
  */
 public static long[] clone(long[] array) {
     if (array == null) {
         return null;
     }
     return (long[]) array.clone();
 }

}

 </source>
   
  
 
  

Removes the first occurrence of the specified element from the specified array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Removes the first occurrence of the specified element from the * specified array. All subsequent elements are shifted to the left * (substracts one from their indices). If the array doesn"t contains * such an element, no elements are removed from the array.

  *

*

This method returns a new array with the same elements of the input * array except the first occurrence of the specified element. The component * type of the returned array is always the same as that of the input * array.

  *

*

   * ArrayUtils.removeElement(null, 1)      = null
   * ArrayUtils.removeElement([], 1)        = []
   * ArrayUtils.removeElement([1], 2)       = [1]
   * ArrayUtils.removeElement([1, 3], 1)    = [3]
   * ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1]
   * 

  * 
  * @param array  the array to remove the element from, may be null
  * @param element  the element to be removed
  * @return A new array containing the existing elements except the first
  *         occurrence of the specified element.
  * @since 2.1
  */
 public static short[] removeElement(short[] array, short element) {
     int index = indexOf(array, element);
     if (index == -1) {
         return clone(array);
     } 
     return remove(array, index);
 }
 /**

*

Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).

  *

*

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.

  *

*

If the input array is null, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.

  *

*

   * ArrayUtils.remove([1], 0)         = []
   * ArrayUtils.remove([2, 6], 0)      = [6]
   * ArrayUtils.remove([2, 6], 1)      = [2]
   * ArrayUtils.remove([2, 6, 3], 1)   = [2, 3]
   * 

  * 
  * @param array  the array to remove the element from, may not be null
  * @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 null.
  * @since 2.1
  */
 public static short[] remove(short[] array, int index) {
     return (short[]) remove((Object) array, index);
 }
 /**

*

Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).

  *

*

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.

  *

*

If the input array is null, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.

  * 
  * @param array  the array to remove the element from, may not be null
  * @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 null.
  * @since 2.1
  */
 private static Object remove(Object array, 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 result;
 }
 /**

*

Finds the index of the given value in the array starting at the given index.

  *

*

This method returns {@link #INDEX_NOT_FOUND} (-1) for a null input array.

  *

*

A negative startIndex is treated as zero. A startIndex larger than the array * length will return {@link #INDEX_NOT_FOUND} (-1).

  * 
  * @param array  the array to search through for the object, may be null
  * @param valueToFind  the value to find
  * @param startIndex  the index to start searching at
  * @return the index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int indexOf(short[] array, short valueToFind) {
     if (array == null) {
         return -1;
     }
     for (int i = 0; i < array.length; i++) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return -1;
 }
 /**

*

Returns the length of the specified array. * This method can deal with Object arrays and with primitive arrays.

  *

*

If the input array is null, 0 is returned.

  *

*

   * ArrayUtils.getLength(null)            = 0
   * ArrayUtils.getLength([])              = 0
   * ArrayUtils.getLength([null])          = 1
   * ArrayUtils.getLength([true, false])   = 2
   * ArrayUtils.getLength([1, 2, 3])       = 3
   * ArrayUtils.getLength(["a", "b", "c"]) = 3
   * 

  *
  * @param array  the array to retrieve the length from, may be null
  * @return The length of the array, or 0 if the array is null
  * @throws IllegalArgumentException if the object arguement is not an array.
  * @since 2.1
  */
 public static int getLength(Object array) {
     if (array == null) {
         return 0;
     }
     return Array.getLength(array);
 }
 /**

*

Shallow clones an array returning a typecast result and handling * null.

  *

*

The objects in the array are not cloned, thus there is no special * handling for multi-dimensional arrays.

  * 

*

This method returns null for a null input array.

  * 
  * @param array  the array to shallow clone, may be null
  * @return the cloned array, null if null input
  */
 public static short[] clone(short[] array) {
     if (array == null) {
         return null;
     }
     return (short[]) array.clone();
 }

}

 </source>
   
  
 
  

Removes the first occurrence of the specified element from the specified long value array.

   <source lang="java">
  

/* Copyright 2004 The Apache Software Foundation

*
*   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.
*/

import java.lang.reflect.Array;

/**

*

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 Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).

  *

*

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.

  *

*

If the input array is null, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.

  *

*

   * ArrayUtils.remove([1], 0)         = []
   * ArrayUtils.remove([2, 6], 0)      = [6]
   * ArrayUtils.remove([2, 6], 1)      = [2]
   * ArrayUtils.remove([2, 6, 3], 1)   = [2, 3]
   * 

  * 
  * @param array  the array to remove the element from, may not be null
  * @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 null.
  * @since 2.1
  */
 public static long[] remove(long[] array, int index) {
     return (long[]) remove((Object) array, index);
 }
 
 /**

*

Removes the first occurrence of the specified element from the * specified array. All subsequent elements are shifted to the left * (substracts one from their indices). If the array doesn"t contains * such an element, no elements are removed from the array.

  *

*

This method returns a new array with the same elements of the input * array except the first occurrence of the specified element. The component * type of the returned array is always the same as that of the input * array.

  *

*

   * ArrayUtils.removeElement(null, 1)      = null
   * ArrayUtils.removeElement([], 1)        = []
   * ArrayUtils.removeElement([1], 2)       = [1]
   * ArrayUtils.removeElement([1, 3], 1)    = [3]
   * ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1]
   * 

  * 
  * @param array  the array to remove the element from, may be null
  * @param element  the element to be removed
  * @return A new array containing the existing elements except the first
  *         occurrence of the specified element.
  * @since 2.1
  */
 public static long[] removeElement(long[] array, long element) {
     int index = indexOf(array, element);
     if (index == -1) {
         return clone(array);
     } 
     return remove(array, index);
 }
 /**

*

Removes the element at the specified position from the specified array. * All subsequent elements are shifted to the left (substracts one from * their indices).

  *

*

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.

  *

*

If the input array is null, an IndexOutOfBoundsException * will be thrown, because in that case no valid index can be specified.

  * 
  * @param array  the array to remove the element from, may not be null
  * @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 null.
  * @since 2.1
  */
 private static Object remove(Object array, 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 result;
 }
 /**

*

Finds the index of the given value in the array starting at the given index.

  *

*

This method returns {@link #INDEX_NOT_FOUND} (-1) for a null input array.

  *

*

A negative startIndex is treated as zero. A startIndex larger than the array * length will return {@link #INDEX_NOT_FOUND} (-1).

  * 
  * @param array  the array to search through for the object, may be null
  * @param valueToFind  the value to find
  * @param startIndex  the index to start searching at
  * @return the index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int indexOf(long[] array, long valueToFind) {
     if (array == null) {
         return -1;
     }
     for (int i = 0; i < array.length; i++) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return -1;
 }
 /**

*

Returns the length of the specified array. * This method can deal with Object arrays and with primitive arrays.

  *

*

If the input array is null, 0 is returned.

  *

*

   * ArrayUtils.getLength(null)            = 0
   * ArrayUtils.getLength([])              = 0
   * ArrayUtils.getLength([null])          = 1
   * ArrayUtils.getLength([true, false])   = 2
   * ArrayUtils.getLength([1, 2, 3])       = 3
   * ArrayUtils.getLength(["a", "b", "c"]) = 3
   * 

  *
  * @param array  the array to retrieve the length from, may be null
  * @return The length of the array, or 0 if the array is null
  * @throws IllegalArgumentException if the object arguement is not an array.
  * @since 2.1
  */
 public static int getLength(Object array) {
     if (array == null) {
         return 0;
     }
     return Array.getLength(array);
 }
 /**

*

Shallow clones an array returning a typecast result and handling * null.

  *

*

The objects in the array are not cloned, thus there is no special * handling for multi-dimensional arrays.

  * 

*

This method returns null for a null input array.

  * 
  * @param array  the array to shallow clone, may be null
  * @return the cloned array, null if null input
  */
 public static long[] clone(long[] array) {
     if (array == null) {
         return null;
     }
     return (long[]) array.clone();
 }

}

 </source>