Arrays

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

marf.util
Class Arrays

java.lang.Object
  marf.util.Arrays

public class Arrays
extends java.lang.Object
extends java.lang.Object

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.41 2008/02/16 20:58:06 mokhov Exp $

Since:: 0.3.0.1
Version:: $Revision: 1.41 $
Author:: Serguei Mokhov, Shuxin Fan
See Also:: Arrays, System.arraycopy(Object, int, Object, int, int)

Constructor Summary
`protected`	`Arrays()` The protected default constructor is provided to allow making extension of this class if developers desire to do so.

Method Summary
`static java.lang.String`	`arrayToCSV(boolean[] pabData)` Converts array of booleans to a single comma-separated String.
`static java.lang.String`	`arrayToCSV(byte[] patData)` Converts array of bytes to a single comma-separated String.
`static java.lang.String`	`arrayToCSV(char[] pacData)` Converts array of characters to a single comma-separated String.
`static java.lang.String`	`arrayToCSV(double[] padData)` Converts array of doubles to a single comma-separated String.
`static java.lang.String`	`arrayToCSV(float[] pafData)` Converts array of floats to a single comma-separated String.
`static java.lang.String`	`arrayToCSV(int[] paiData)` Converts array of integers to a single comma-separated String.
`static java.lang.String`	`arrayToCSV(long[] palData)` Converts array of longs to a single comma-separated String.
`static java.lang.String`	`arrayToCSV(java.lang.Object[] paoData)` Converts array of Objects to a single comma-separated String.
`static java.lang.String`	`arrayToCSV(java.lang.String[] pastrData)` Converts array of Strings to a single comma-separated String.
`static java.lang.String`	`arrayToDelimitedString(boolean[] pabData, java.lang.String pstrDelimeter)` Converts array of booleans to a single string separated by the specified delimiter.
`static java.lang.String`	`arrayToDelimitedString(byte[] patData, java.lang.String pstrDelimeter)` Converts array of bytes to a single string separated by the specified delimiter.
`static java.lang.String`	`arrayToDelimitedString(char[] pacData, java.lang.String pstrDelimiter)` Converts array of characters to a single string separated by the specified delimiter.
`static java.lang.String`	`arrayToDelimitedString(double[] padData, java.lang.String pstrDelimeter)` Converts array of doubles to a single string separated by the specified delimiter.
`static java.lang.String`	`arrayToDelimitedString(float[] pafData, java.lang.String pstrDelimeter)` Converts array of floats to a single string separated by the specified delimiter.
`static java.lang.String`	`arrayToDelimitedString(int[] paiData, java.lang.String pstrDelimeter)` Converts array of integers to a single string separated by the specified delimiter.
`static java.lang.String`	`arrayToDelimitedString(long[] palData, java.lang.String pstrDelimeter)` Converts array of longs to a single string separated by the specified delimiter.
`static java.lang.String`	`arrayToDelimitedString(java.lang.Object[] paoData, java.lang.String pstrDelimeter)` Converts array of Objects to a single string separated by the specified delimiter.
`static java.lang.String`	`arrayToDelimitedString(java.lang.String[] pastrData, java.lang.String pstrDelimeter)` Converts array of Strings to a single string separated by the specified delimiter.
`static java.lang.String`	`arrayToString(boolean[] pabData)` Converts array of booleans to a single space-separated String.
`static java.lang.String`	`arrayToString(byte[] patData)` Converts array of bytes to a single space-separated String.
`static java.lang.String`	`arrayToString(char[] pacData)` Converts array of characters to a single space-separated String.
`static java.lang.String`	`arrayToString(double[] padData)` Converts array of doubles to a single space-separated String.
`static java.lang.String`	`arrayToString(float[] pafData)` Converts array of floats to a single space-separated String.
`static java.lang.String`	`arrayToString(int[] paiData)` Converts array of integers to a single space-separated String.
`static java.lang.String`	`arrayToString(long[] palData)` Converts array of longs to a single space-separated String.
`static java.lang.String`	`arrayToString(java.lang.Object[] paoData)` Converts array of Objects to a single space-separated String.
`static java.lang.String`	`arrayToString(java.lang.String[] pastrData)` Converts array of Strings to a single space-separated String.
`static java.util.Vector`	`arrayToVector(byte[] patData)` Converts array of bytes to Vector.
`static java.util.Vector`	`arrayToVector(char[] pacData)` Converts array of characters to Vector.
`static java.util.Vector`	`arrayToVector(double[] padData)` Converts array of doubles to Vector.
`static java.util.Vector`	`arrayToVector(float[] pafData)` Converts array of floats to Vector.
`static java.util.Vector`	`arrayToVector(int[] paiData)` Converts array of ints to Vector.
`static java.util.Vector`	`arrayToVector(long[] palData)` Converts array of longs to Vector.
`static java.util.Vector`	`arrayToVector(java.lang.Object[] paoData)` Converts array of Objects to Vector.
`static java.util.Vector`	`arrayToVector(short[] pasData)` Converts array of shorts to Vector.
`static java.util.Vector`	`arrayToVector(java.lang.String[] pastrData)` Converts array of Strings to Vector.
`static java.util.List`	`asList(java.lang.Object[] paoObjects)` Provides an array-of-objects-to-List bridge.
`static int`	`binarySearch(byte[] patArray, byte ptValue)` The `binarySearch()` routine is based on `java.util.Arrays.binarySearch()`.
`static int`	`binarySearch(char[] pacArray, char pcValue)` The `binarySearch()` routine is based on `java.util.Arrays.binarySearch()`.
`static int`	`binarySearch(double[] padArray, double pdValue)` The `binarySearch()` routine is based on `java.util.Arrays.binarySearch()`.
`static int`	`binarySearch(float[] pafArray, float pfValue)` The `binarySearch()` routine is based on `java.util.Arrays.binarySearch()`.
`static int`	`binarySearch(int[] paiArray, int piValue)` The `binarySearch()` routine is based on `java.util.Arrays.binarySearch()`.
`static int`	`binarySearch(java.lang.Object[] paoArray, java.lang.Object poValue)` The `binarySearch()` routine is based on `java.util.Arrays.binarySearch()`.
`static int`	`binarySearch(java.lang.Object[] paoArray, java.lang.Object poValue, java.util.Comparator poComparator)` The `binarySearch()` routine is based on `java.util.Arrays.binarySearch()`.
`static int`	`binarySearch(short[] pasArray, short psValue)` The `binarySearch()` routine is based on `java.util.Arrays.binarySearch()`.
`static boolean[]`	`concatenate(boolean[] pabLHS, boolean[] pabRHS)` Concatenates two arrays of booleans and returns a newly allocated array of the concatenated pieces.
`static byte[]`	`concatenate(byte[] patLHS, byte[] patRHS)` Concatenates two arrays of bytes and returns a newly allocated array of the concatenated pieces.
`static char[]`	`concatenate(char[] pacLHS, char[] pacRHS)` Concatenates two arrays of characters and returns a newly allocated array of the concatenated pieces.
`static double[]`	`concatenate(double[] padLHS, double[] padRHS)` Concatenates two arrays of doubles and returns a newly allocated array of the concatenated pieces.
`static float[]`	`concatenate(float[] pafLHS, float[] pafRHS)` Concatenates two arrays of floats and returns a newly allocated array of the concatenated pieces.
`static int[]`	`concatenate(int[] paiLHS, int[] paiRHS)` Concatenates two arrays of integers and returns a newly allocated array of the concatenated pieces.
`static long[]`	`concatenate(long[] palLHS, long[] palRHS)` Concatenates two arrays of longs and returns a newly allocated array of the concatenated pieces.
`static java.lang.Object[]`	`concatenate(java.lang.Object[] paoLHS, java.lang.Object[] paoRHS)` Concatenates two arrays of objects and returns a newly allocated array of the concatenated pieces.
`static short[]`	`concatenate(short[] pasLHS, short[] pasRHS)` Concatenates two arrays of shorts and returns a newly allocated array of the concatenated pieces.
`static java.lang.String[]`	`concatenate(java.lang.String[] pastrLHS, java.lang.String[] pastrRHS)` Concatenates two arrays of Strings and returns a newly allocated array of the concatenated pieces.
`static void`	`copy(boolean[] pabDestination, boolean[] pabSource, int piHowMany)` Copies N boolean elements from source to destination.
`static void`	`copy(boolean[] pabDestination, int piStartIndex, boolean[] pabSource)` Copies source to destination starting at certain index in the destination.
`static void`	`copy(boolean[] pabDestination, int piStartIndex, boolean[] pabSource, int piHowMany)` Copies N boolean elements from source to destination starting at certain index in the destination.
`static void`	`copy(boolean[] pabDestination, int piDestinationStartIndex, boolean[] pabSource, int piSourceStartIndex, int piHowMany)` Copies N boolean elements from source to destination starting at certain index in the destination.
`static void`	`copy(byte[] patDestination, byte[] patSource, int piHowMany)` Copies N byte elements from source to destination.
`static void`	`copy(byte[] patDestination, char[] pacSource)` Copy-conversion method that copies all character elements from an array of characters into array of bytes.
`static void`	`copy(byte[] patDestination, char[] pacSource, int piHowMany)` Copy-conversion method that copies N character elements from an array of characters into array of bytes.
`static void`	`copy(byte[] patDestination, double[] padSource)` Copy-conversion method that copies all double elements from an array of doubles into array of bytes.
`static void`	`copy(byte[] patDestination, double[] padSource, int piHowMany)` Copy-conversion method that copies N double elements from an array of doubles into array of bytes.
`static void`	`copy(byte[] patDestination, float[] pafSource)` Copy-conversion method that copies all float elements from an array of floats into array of characters.
`static void`	`copy(byte[] patDestination, float[] pafSource, int piHowMany)` Copy-conversion method that copies N float elements from an array of floats into array of bytes.
`static void`	`copy(byte[] patDestination, int[] paiSource)` Copy-conversion method that copies all int elements from an array of ints into array of bytes.
`static void`	`copy(byte[] patDestination, int[] paiSource, int piHowMany)` Copy-conversion method that copies N int elements from an array of ints into array of bytes.
`static void`	`copy(byte[] patDestination, int piStartIndex, byte[] patSource)` Copies source to destination starting at certain index in the destination.
`static void`	`copy(byte[] patDestination, int piStartIndex, byte[] patSource, int piHowMany)` Copies N byte elements from source to destination starting at certain index in the destination.
`static void`	`copy(byte[] patDestination, int piDestinationStartIndex, byte[] patSource, int piSourceStartIndex, int piHowMany)` Copies N byte elements from source to destination starting at certain index in the destination.
`static void`	`copy(byte[] patDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N character elements from an array of characters into array of bytes.
`static void`	`copy(byte[] patDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N double elements from an array of doubles into array of bytes.
`static void`	`copy(byte[] patDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N float elements from an array of floats into array of bytes.
`static void`	`copy(byte[] patDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N int elements from an array of ints into array of bytes.
`static void`	`copy(byte[] patDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N short elements from an array of shorts into array of bytes.
`static void`	`copy(byte[] patDestination, int piDestinationFrom, java.lang.String[] pastrSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N String elements from an array of Strings into array of bytes.
`static void`	`copy(byte[] patDestination, short[] pasSource)` Copy-conversion method that copies all short elements from an array of shorts into array of bytes.
`static void`	`copy(byte[] patDestination, short[] pasSource, int piHowMany)` Copy-conversion method that copies N short elements from an array of shorts into array of bytes.
`static void`	`copy(byte[] patDestination, java.lang.String[] pastrSource)` Copy-conversion method that copies all String elements from an array of Strings into array of bytes.
`static void`	`copy(byte[] patDestination, java.lang.String[] pastrSource, int piHowMany)` Copy-conversion method that copies N String elements from an array of Strings into array of bytes.
`static void`	`copy(char[] pacDestination, byte[] patSource)` Copy-conversion method that copies all byte elements from an array of bytes into array of bytes.
`static void`	`copy(char[] pacDestination, byte[] patSource, int piHowMany)` Copy-conversion method that copies N byte elements from an array of bytes into array of characters.
`static void`	`copy(char[] pacDestination, char[] pacSource, int piHowMany)` Copies N character elements from source to destination.
`static void`	`copy(char[] pacDestination, double[] padSource)` Copy-conversion method that copies all double elements from an array of doubles into array of characters.
`static void`	`copy(char[] pacDestination, double[] padSource, int piHowMany)` Copy-conversion method that copies N double elements from an array of doubles into array of characters.
`static void`	`copy(char[] pacDestination, float[] pafSource)` Copy-conversion method that copies all float elements from an array of floats into array of characters.
`static void`	`copy(char[] pacDestination, float[] pafSource, int piHowMany)` Copy-conversion method that copies N float elements from an array of floats into array of characters.
`static void`	`copy(char[] pacDestination, int[] paiSource)` Copy-conversion method that copies all int elements from an array of ints into array of characters.
`static void`	`copy(char[] pacDestination, int[] paiSource, int piHowMany)` Copy-conversion method that copies N int elements from an array of ints into array of characters.
`static void`	`copy(char[] pacDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N byte elements from an array of bytes into array of characters.
`static void`	`copy(char[] pacDestination, int piStartIndex, char[] pacSource)` Copies source to destination starting at certain index in the destination.
`static void`	`copy(char[] pacDestination, int piStartIndex, char[] pacSource, int piHowMany)` Copies N character elements from source to destination starting at certain index in the destination.
`static void`	`copy(char[] pacDestination, int piDestinationStartIndex, char[] pacSource, int piSourceStartIndex, int piHowMany)` Copies N character elements from source to destination starting at certain index in the destination.
`static void`	`copy(char[] pacDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N double elements from an array of doubles into array of characters.
`static void`	`copy(char[] pacDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N float elements from an array of floats into array of characters.
`static void`	`copy(char[] pacDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N int elements from an array of ints into array of characters.
`static void`	`copy(char[] pacDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N short elements from an array of shorts into array of characters.
`static void`	`copy(char[] pacDestination, short[] pasSource)` Copy-conversion method that copies all short elements from an array of shorts into array of characters.
`static void`	`copy(char[] pacDestination, short[] pasSource, int piHowMany)` Copy-conversion method that copies N short elements from an array of shorts into array of characters.
`static void`	`copy(double[] padDestination, byte[] patSource)` Copy-conversion method that copies all byte elements from an array of bytes into array of doubles.
`static void`	`copy(double[] padDestination, byte[] patSource, int piHowMany)` Copy-conversion method that copies N byte elements from an array of bytes into array of doubles.
`static void`	`copy(double[] padDestination, char[] pacSource)` Copy-conversion method that copies all character elements from an array of characters into array of doubles.
`static void`	`copy(double[] padDestination, char[] pacSource, int piHowMany)` Copy-conversion method that copies N character elements from an array of characters into array of doubles.
`static void`	`copy(double[] padDestination, double[] padSource, int piHowMany)` Copies N double elements from source to destination.
`static void`	`copy(double[] padDestination, float[] pafSource)` Copy-conversion method that copies all float elements from an array of floats into array of doubles.
`static void`	`copy(double[] padDestination, float[] pafSource, int piHowMany)` Copy-conversion method that copies N float elements from an array of floats into array of doubles.
`static void`	`copy(double[] padDestination, int[] paiSource)` Copy-conversion method that copies all int elements from an array of ints into array of doubles.
`static void`	`copy(double[] padDestination, int[] paiSource, int piHowMany)` Copy-conversion method that copies N int elements from an array of ints into array of doubles.
`static void`	`copy(double[] padDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N byte elements from an array of bytes into array of doubles.
`static void`	`copy(double[] padDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N character elements from an array of characters into array of doubles.
`static void`	`copy(double[] padDestination, int piStartIndex, double[] padSource)` Copies source to destination starting at certain index in the destination.
`static void`	`copy(double[] padDestination, int piStartIndex, double[] padSource, int piHowMany)` Copies N double elements from source to destination starting at certain index in the destination.
`static void`	`copy(double[] padDestination, int piDestinationStartIndex, double[] padSource, int piSourceStartIndex, int piHowMany)` Copies N double elements from source to destination starting at certain index in the destination.
`static void`	`copy(double[] padDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N float elements from an array of floats into array of doubles.
`static void`	`copy(double[] padDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N int elements from an array of ints into array of doubles.
`static void`	`copy(double[] padDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N short elements from an array of shorts into array of doubles.
`static void`	`copy(double[] padDestination, int piDestinationFrom, java.lang.String[] pastrSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N String elements from an array of Strings into array of doubles.
`static void`	`copy(double[] padDestination, short[] pasSource)` Copy-conversion method that copies all short elements from an array of shorts into array of doubles.
`static void`	`copy(double[] padDestination, short[] pasSource, int piHowMany)` Copy-conversion method that copies N short elements from an array of shorts into array of doubles.
`static void`	`copy(double[] padDestination, java.lang.String[] pastrSource)` Copy-conversion method that copies all String elements from an array of Strings into array of doubles.
`static void`	`copy(double[] padDestination, java.lang.String[] pastrSource, int piHowMany)` Copy-conversion method that copies N String elements from an array of Strings into array of doubles.
`static void`	`copy(float[] pafDestination, byte[] patSource)` Copy-conversion method that copies all byte elements from an array of bytes into array of floats.
`static void`	`copy(float[] pafDestination, byte[] patSource, int piHowMany)` Copy-conversion method that copies N byte elements from an array of bytes into array of floats.
`static void`	`copy(float[] pafDestination, char[] pacSource)` Copy-conversion method that copies all character elements from an array of characters into array of floats.
`static void`	`copy(float[] pafDestination, char[] pacSource, int piHowMany)` Copy-conversion method that copies N character elements from an array of characters into array of floats.
`static void`	`copy(float[] pafDestination, double[] padSource)` Copy-conversion method that copies all double elements from an array of doubles into array of floats.
`static void`	`copy(float[] pafDestination, double[] padSource, int piHowMany)` Copy-conversion method that copies N double elements from an array of doubles into array of floats.
`static void`	`copy(float[] pafDestination, float[] pafSource, int piHowMany)` Copies N float elements from source to destination.
`static void`	`copy(float[] pafDestination, int[] paiSource)` Copy-conversion method that copies all int elements from an array of ints into array of floats.
`static void`	`copy(float[] pafDestination, int[] paiSource, int piHowMany)` Copy-conversion method that copies N int elements from an array of ints into array of floats.
`static void`	`copy(float[] pafDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N byte elements from an array of bytes into array of floats.
`static void`	`copy(float[] pafDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N character elements from an array of characters into array of floats.
`static void`	`copy(float[] pafDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N double elements from an array of doubles into array of floats.
`static void`	`copy(float[] pafDestination, int piStartIndex, float[] pafSource)` Copies source to destination starting at certain index in the destination.
`static void`	`copy(float[] pafDestination, int piStartIndex, float[] pafSource, int piHowMany)` Copies N float elements from source to destination starting at certain index in the destination.
`static void`	`copy(float[] pafDestination, int piDestinationStartIndex, float[] pafSource, int piSourceStartIndex, int piHowMany)` Copies N float elements from source to destination starting at certain index in the destination.
`static void`	`copy(float[] pafDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N int elements from an array of ints into array of floats.
`static void`	`copy(float[] pafDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N short elements from an array of shorts into array of floats.
`static void`	`copy(float[] pafDestination, int piDestinationFrom, java.lang.String[] pastrSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N String elements from an array of Strings into array of floats.
`static void`	`copy(float[] pafDestination, short[] pasSource)` Copy-conversion method that copies all short elements from an array of shorts into array of floats.
`static void`	`copy(float[] pafDestination, short[] pasSource, int piHowMany)` Copy-conversion method that copies N short elements from an array of shorts into array of floats.
`static void`	`copy(float[] pafDestination, java.lang.String[] pastrSource)` Copy-conversion method that copies all String elements from an array of Strings into array of floats.
`static void`	`copy(float[] pafDestination, java.lang.String[] pastrSource, int piHowMany)` Copy-conversion method that copies N String elements from an array of Strings into array of floats.
`static void`	`copy(int[] paiDestination, byte[] patSource)` Copy-conversion method that copies all byte elements from an array of bytes into array of integers.
`static void`	`copy(int[] paiDestination, byte[] patSource, int piHowMany)` Copy-conversion method that copies N byte elements from an array of bytes into array of integers.
`static void`	`copy(int[] paiDestination, char[] pacSource)` Copy-conversion method that copies all character elements from an array of characters into array of integers.
`static void`	`copy(int[] paiDestination, char[] pacSource, int piHowMany)` Copy-conversion method that copies N character elements from an array of characters into array of integers.
`static void`	`copy(int[] paiDestination, double[] padSource)` Copy-conversion method that copies all double elements from an array of doubles into array of ints.
`static void`	`copy(int[] paiDestination, double[] padSource, int piHowMany)` Copy-conversion method that copies N double elements from an array of doubles into array of integers.
`static void`	`copy(int[] paiDestination, float[] pafSource)` Copy-conversion method that copies all float elements from an array of floats into array of integers.
`static void`	`copy(int[] paiDestination, float[] pafSource, int piHowMany)` Copy-conversion method that copies N float elements from an array of floats into array of integers.
`static void`	`copy(int[] paiDestination, int[] paiSource, int piHowMany)` Copies N int elements from source to destination.
`static void`	`copy(int[] paiDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N byte elements from an array of bytes into array of integers.
`static void`	`copy(int[] paiDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N character elements from an array of characters into array of integers.
`static void`	`copy(int[] paiDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N double elements from an array of doubles into array of integers.
`static void`	`copy(int[] paiDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N float elements from an array of floats into array of integers.
`static void`	`copy(int[] paiDestination, int piStartIndex, int[] paiSource)` Copies source to destination starting at certain index in the destination.
`static void`	`copy(int[] paiDestination, int piStartIndex, int[] paiSource, int piHowMany)` Copies N integer elements from source to destination starting at certain index in the destination.
`static void`	`copy(int[] paiDestination, int piDestinationStartIndex, int[] paiSource, int piSourceStartIndex, int piHowMany)` Copies N integer elements from source to destination starting at certain index in the destination.
`static void`	`copy(int[] paiDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N short elements from an array of shorts into array of integers.
`static void`	`copy(int[] paiDestination, int piDestinationFrom, java.lang.String[] pastrSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N String elements from an array of Strings into array of integers.
`static void`	`copy(int[] paiDestination, short[] pasSource)` Copy-conversion method that copies all short elements from an array of shorts into array of integers.
`static void`	`copy(int[] paiDestination, short[] pasSource, int piHowMany)` Copy-conversion method that copies N short elements from an array of shorts into array of integers.
`static void`	`copy(int[] paiDestination, java.lang.String[] pastrSource)` Copy-conversion method that copies all String elements from an array of Strings into array of integers.
`static void`	`copy(int[] paiDestination, java.lang.String[] pastrSource, int piHowMany)` Copy-conversion method that copies N String elements from an array of Strings into array of integers.
`static void`	`copy(long[] palDestination, byte[] patSource)` Copy-conversion method that copies all byte elements from an array of bytes into array of longs.
`static void`	`copy(long[] palDestination, byte[] patSource, int piHowMany)` Copy-conversion method that copies N byte elements from an array of bytes into array of longs.
`static void`	`copy(long[] palDestination, char[] pacSource)` Copy-conversion method that copies all character elements from an array of characters into array of longs.
`static void`	`copy(long[] palDestination, char[] pacSource, int piHowMany)` Copy-conversion method that copies N character elements from an array of characters into array of longs.
`static void`	`copy(long[] palDestination, double[] padSource)` Copy-conversion method that copies all double elements from an array of doubles into array of longs.
`static void`	`copy(long[] palDestination, double[] padSource, int piHowMany)` Copy-conversion method that copies N double elements from an array of doubles into array of longs.
`static void`	`copy(long[] palDestination, float[] pafSource)` Copy-conversion method that copies all float elements from an array of floats into array of longs.
`static void`	`copy(long[] palDestination, float[] pafSource, int piHowMany)` Copy-conversion method that copies N float elements from an array of floats into array of longs.
`static void`	`copy(long[] palDestination, int[] paiSource)` Copy-conversion method that copies all int elements from an array of ints into array of longs.
`static void`	`copy(long[] palDestination, int[] paiSource, int piHowMany)` Copy-conversion method that copies N int elements from an array of ints into array of longs.
`static void`	`copy(long[] palDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N byte elements from an array of bytes into array of longs.
`static void`	`copy(long[] palDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N character elements from an array of characters into array of longs.
`static void`	`copy(long[] palDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N double elements from an array of doubles into array of longs.
`static void`	`copy(long[] palDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N float elements from an array of floats into array of longs.
`static void`	`copy(long[] palDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N int elements from an array of ints into array of longs.
`static void`	`copy(long[] palDestination, int piStartIndex, long[] palSource)` Copies source to destination starting at certain index in the destination.
`static void`	`copy(long[] palDestination, int piStartIndex, long[] palSource, int piHowMany)` Copies N long elements from source to destination starting at certain index in the destination.
`static void`	`copy(long[] palDestination, int piDestinationStartIndex, long[] palSource, int piSourceStartIndex, int piHowMany)` Copies N long elements from source to destination starting at certain index in the destination.
`static void`	`copy(long[] palDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N short elements from an array of shorts into array of longs.
`static void`	`copy(long[] palDestination, int piDestinationFrom, java.lang.String[] pastrSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N String elements from an array of Strings into array of longs.
`static void`	`copy(long[] palDestination, long[] palSource, int piHowMany)` Copies N long elements from source to destination.
`static void`	`copy(long[] palDestination, short[] pasSource)` Copy-conversion method that copies all short elements from an array of shorts into array of longs.
`static void`	`copy(long[] palDestination, short[] pasSource, int piHowMany)` Copy-conversion method that copies N short elements from an array of shorts into array of longs.
`static void`	`copy(long[] palDestination, java.lang.String[] pastrSource)` Copy-conversion method that copies all String elements from an array of Strings into array of longs.
`static void`	`copy(long[] palDestination, java.lang.String[] pastrSource, int piHowMany)` Copy-conversion method that copies N String elements from an array of Strings into array of longs.
`static void`	`copy(java.lang.Object[] paoDestination, int piStartIndex, java.lang.Object[] paoSource)` Generic `copy()` routine is based on `System.arraycopy()` for Object arrays.
`static void`	`copy(java.lang.Object[] paoDestination, int piStartIndex, java.lang.Object[] paoSource, int piHowMany)` Generic `copy()` routine is based on `System.arraycopy()` for Object arrays.
`static void`	`copy(java.lang.Object[] paoDestination, int piDestinationStartIndex, java.lang.Object[] paoSource, int piSourceStartIndex, int piHowMany)` Generic `copy()` routine is based on `System.arraycopy()` for Object arrays.
`static void`	`copy(java.lang.Object[] paoDestination, java.lang.Object[] paoSource, int piHowMany)` Generic `copy()` routine is based on `System.arraycopy()` for Object arrays.
`static void`	`copy(java.lang.Object poDestination, int piStartIndex, java.lang.Object poSource, int piHowMany)` Generic `copy()` routine is based on `System.arraycopy()`.
`static void`	`copy(java.lang.Object poDestination, int piDestinationStartIndex, java.lang.Object poSource, int piSourceStartIndex, int piHowMany)` Generic `copy()` routine is based on `System.arraycopy()`.
`static void`	`copy(java.lang.Object poDestination, java.lang.Object poSource, int piHowMany)` Generic `copy()` routine is based on `System.arraycopy()`.
`static void`	`copy(short[] pasDestination, byte[] patSource)` Copy-conversion method that copies all byte elements from an array of bytes into array of shorts.
`static void`	`copy(short[] pasDestination, byte[] patSource, int piHowMany)` Copy-conversion method that copies N byte elements from an array of bytes into array of shorts.
`static void`	`copy(short[] pasDestination, char[] pacSource)` Copy-conversion method that copies all character elements from an array of characters into array of shorts.
`static void`	`copy(short[] pasDestination, char[] pacSource, int piHowMany)` Copy-conversion method that copies N character elements from an array of characters into array of shorts.
`static void`	`copy(short[] pasDestination, double[] padSource)` Copy-conversion method that copies all double elements from an array of doubles into array of shorts.
`static void`	`copy(short[] pasDestination, double[] padSource, int piHowMany)` Copy-conversion method that copies N double elements from an array of doubles into array of shorts.
`static void`	`copy(short[] pasDestination, float[] pafSource)` Copy-conversion method that copies all float elements from an array of floats into array of shorts.
`static void`	`copy(short[] pasDestination, float[] pafSource, int piHowMany)` Copy-conversion method that copies N float elements from an array of floats into array of shorts.
`static void`	`copy(short[] pasDestination, int[] paiSource)` Copy-conversion method that copies all int elements from an array of ints into array of shorts.
`static void`	`copy(short[] pasDestination, int[] paiSource, int piHowMany)` Copy-conversion method that copies N int elements from an array of ints into array of shorts.
`static void`	`copy(short[] pasDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N byte elements from an array of bytes into array of shorts.
`static void`	`copy(short[] pasDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N character elements from an array of characters into array of shorts.
`static void`	`copy(short[] pasDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N double elements from an array of doubles into array of shorts.
`static void`	`copy(short[] pasDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N float elements from an array of floats into array of shorts.
`static void`	`copy(short[] pasDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N int elements from an array of ints into array of shorts.
`static void`	`copy(short[] pasDestination, int piStartIndex, short[] pasSource)` Copies source to destination starting at certain index in the destination.
`static void`	`copy(short[] pasDestination, int piStartIndex, short[] pasSource, int piHowMany)` Copies N short elements from source to destination starting at certain index in the destination.
`static void`	`copy(short[] pasDestination, int piDestinationStartIndex, short[] pasSource, int piSourceStartIndex, int piHowMany)` Copies N short elements from source to destination starting at certain index in the destination.
`static void`	`copy(short[] pasDestination, int piDestinationFrom, java.lang.String[] pastrSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N String elements from an array of Strings into array of shorts.
`static void`	`copy(short[] pasDestination, short[] pasSource, int piHowMany)` Copies N short elements from source to destination.
`static void`	`copy(short[] pasDestination, java.lang.String[] pastrSource)` Copy-conversion method that copies all String elements from an array of Strings into array of shorts.
`static void`	`copy(short[] pasDestination, java.lang.String[] pastrSource, int piHowMany)` Copy-conversion method that copies N String elements from an array of Strings into array of shorts.
`static void`	`copy(java.lang.String[] pstrDestination, byte[] patSource)` Copy-conversion method that copies all byte elements from an array of ints into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, byte[] patSource, int piHowMany)` Copy-conversion method that copies N byte elements from an array of bytes into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, char[] pacSource)` Copy-conversion method that copies all char elements from an array of chars into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, char[] pacSource, int piHowMany)` Copy-conversion method that copies N char elements from an array of chars into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, double[] padSource)` Copy-conversion method that copies all double elements from an array of doubles into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, double[] padSource, int piHowMany)` Copy-conversion method that copies N double elements from an array of doubles into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, float[] pafSource)` Copy-conversion method that copies all float elements from an array of floats into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, float[] pafSource, int piHowMany)` Copy-conversion method that copies N float elements from an array of floats into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, int[] paiSource)` Copy-conversion method that copies all int elements from an array of ints into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, int[] paiSource, int piHowMany)` Copy-conversion method that copies N int elements from an array of ints into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, int piDestinationFrom, byte[] patSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N byte elements from an array of bytes into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, int piDestinationFrom, char[] pacSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N char elements from an array of chars into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, int piDestinationFrom, double[] padSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N double elements from an array of doubles into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, int piDestinationFrom, float[] pafSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N float elements from an array of floats into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, int piDestinationFrom, int[] paiSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N int elements from an array of ints into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, int piDestinationFrom, long[] palSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N long elements from an array of longs into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, int piDestinationFrom, short[] pasSource, int piSourceFrom, int piHowMany)` General copy-conversion method that copies N short elements from an array of shorts into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, long[] palSource)` Copy-conversion method that copies all long elements from an array of longs into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, long[] palSource, int piHowMany)` Copy-conversion method that copies N long elements from an array of longs into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, short[] pasSource)` Copy-conversion method that copies all short elements from an array of shorts into array of Strings.
`static void`	`copy(java.lang.String[] pstrDestination, short[] patSource, int piHowMany)` Copy-conversion method that copies N short elements from an array of shorts into array of Strings.
`static boolean`	`equals(boolean[] pabArray1, boolean[] pabArray2)` The `equals()` routine is based on `java.util.Arrays.equals()`.
`static boolean`	`equals(byte[] patArray1, byte[] patArray2)` The `equals()` routine is based on `java.util.Arrays.equals()`.
`static boolean`	`equals(char[] pacArray1, char[] pacArray2)` The `equals()` routine is based on `java.util.Arrays.equals()`.
`static boolean`	`equals(double[] padArray1, double[] padArray2)` The `equals()` routine is based on `java.util.Arrays.equals()`.
`static boolean`	`equals(float[] pafArray1, float[] pafArray2)` The `equals()` routine is based on `java.util.Arrays.equals()`.
`static boolean`	`equals(int[] paiArray1, int[] paiArray2)` The `equals()` routine is based on `java.util.Arrays.equals()`.
`static boolean`	`equals(long[] palArray1, long[] palArray2)` The `equals()` routine is based on `java.util.Arrays.equals()`.
`static boolean`	`equals(java.lang.Object[] paoArray1, java.lang.Object[] paoArray2)` The `equals()` routine is based on `java.util.Arrays.equals()`.
`static boolean`	`equals(short[] pasArray1, short[] pasArray2)` The `equals()` routine is based on `java.util.Arrays.equals()`.
`static void`	`fill(boolean[] pabArray, boolean pbValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(boolean[] pabArray, int piFromIndex, int piToIndex, boolean pbValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(byte[] patArray, byte ptValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(byte[] patArray, int piFromIndex, int piToIndex, byte ptValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(char[] pacArray, char pcValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(char[] pacArray, int piFromIndex, int piToIndex, char pcValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(double[] padArray, double pdValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(double[] padArray, int piFromIndex, int piToIndex, double pdValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(float[] pafArray, float pfValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(float[] pafArray, int piFromIndex, int piToIndex, float pfValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(int[] paiArray, int piValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(int[] paiArray, int piFromIndex, int piToIndex, int piValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(long[] palArray, int piFromIndex, int piToIndex, long plValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(long[] palArray, long plValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(java.lang.Object[] paoArray, int piFromIndex, int piToIndex, java.lang.Object paValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(java.lang.Object[] paoArray, java.lang.Object poValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(short[] pasArray, int piFromIndex, int piToIndex, short psValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fill(short[] pasArray, short psValue)` The `fill()` is based on `java.util.Arrays.fill()`.
`static void`	`fillRandom(double[] padArray)` Sets all elements of the parameter at pseudo-random order.
`static java.lang.String`	`getMARFSourceCodeRevision()` Returns source code revision information.
`static void`	`sort(byte[] patArrayToSort)` A wrapper of java.util.Arrays.sort(byte[]).
`static void`	`sort(char[] pacArrayToSort)` A wrapper of java.util.Arrays.sort(char[]).
`static void`	`sort(double[] padArrayToSort)` A wrapper of java.util.Arrays.sort(double[]).
`static void`	`sort(float[] pafArrayToSort)` A wrapper of java.util.Arrays.sort(float[]).
`static void`	`sort(int[] paiArrayToSort)` A wrapper of java.util.Arrays.sort(int[]).
`static void`	`sort(long[] palArrayToSort)` A wrapper of java.util.Arrays.sort(double[]).
`static void`	`sort(java.lang.Object[] paoArrayToSort)` A wrapper of java.util.Arrays.sort(object []).
`static void`	`sort(java.lang.Object[] paoArrayToSort, java.util.Comparator poComparator)` A wrapper of java.util.Arrays.sort(Object[], Comparator).
`static void`	`sort(short[] pasArrayToSort)` A wrapper of java.util.Arrays.sort(short[]).

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

Arrays

protected 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.

Method Detail

copy

public static void copy(java.lang.Object poDestination,
                        int piDestinationStartIndex,
                        java.lang.Object poSource,
                        int piSourceStartIndex,
                        int piHowMany)

Generic copy() routine is based on System.arraycopy().

Parameters:: poDestination - destination array of copy; piDestinationStartIndex - where in the destination array start placing the values; poSource - source of elements; piSourceStartIndex - where in the source array start copying the values from; piHowMany - how many elements should be copied from the source to destination

copy

public static void copy(java.lang.Object[] paoDestination,
                        int piDestinationStartIndex,
                        java.lang.Object[] paoSource,
                        int piSourceStartIndex,
                        int piHowMany)

Generic copy() routine is based on System.arraycopy() for Object arrays.

Parameters:: paoDestination - destination array of objects to copy to; piDestinationStartIndex - where in the destination array start placing the values; paoSource - source of Object elements; piSourceStartIndex - where in the source array start copying the values from; piHowMany - how many elements should be copied from the source to destination

copy

public static void copy(boolean[] pabDestination,
                        int piDestinationStartIndex,
                        boolean[] pabSource,
                        int piSourceStartIndex,
                        int piHowMany)

Copies N boolean elements from source to destination starting at certain index in the destination. A wrapper call to System.arraycopy().

Parameters:: pabDestination - array to copy to; piDestinationStartIndex - starting index in the destination to start copying to; pabSource - array of booleans to copy from; piSourceStartIndex - starting index in the source to start copying from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(byte[] patDestination,
                        int piDestinationStartIndex,
                        byte[] patSource,
                        int piSourceStartIndex,
                        int piHowMany)

Copies N byte elements from source to destination starting at certain index in the destination. A wrapper call to System.arraycopy().

Parameters:: patDestination - array to copy to; piDestinationStartIndex - starting index in the destination to start copying to; patSource - array of bytes to copy from; piSourceStartIndex - starting index in the source to start copying from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(char[] pacDestination,
                        int piDestinationStartIndex,
                        char[] pacSource,
                        int piSourceStartIndex,
                        int piHowMany)

Copies N character elements from source to destination starting at certain index in the destination. A wrapper call to System.arraycopy().

Parameters:: pacDestination - array to copy to; piDestinationStartIndex - starting index in the destination to start copying to; pacSource - array of characters to copy from; piSourceStartIndex - starting index in the source to start copying from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(int[] paiDestination,
                        int piDestinationStartIndex,
                        int[] paiSource,
                        int piSourceStartIndex,
                        int piHowMany)

Copies N integer elements from source to destination starting at certain index in the destination. A wrapper call to System.arraycopy().

Parameters:: paiDestination - array to copy to; piDestinationStartIndex - starting index in the destination to start copying to; paiSource - array of integers to copy from; piSourceStartIndex - starting index in the source to start copying from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(short[] pasDestination,
                        int piDestinationStartIndex,
                        short[] pasSource,
                        int piSourceStartIndex,
                        int piHowMany)

Copies N short elements from source to destination starting at certain index in the destination. A wrapper call to System.arraycopy().

Parameters:: pasDestination - array to copy to; piDestinationStartIndex - starting index in the destination to start copying to; pasSource - array of shorts to copy from; piSourceStartIndex - starting index in the source to start copying from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(long[] palDestination,
                        int piDestinationStartIndex,
                        long[] palSource,
                        int piSourceStartIndex,
                        int piHowMany)

Copies N long elements from source to destination starting at certain index in the destination. A wrapper call to System.arraycopy().

Parameters:: palDestination - array to copy to; piDestinationStartIndex - starting index in the destination to start copying to; palSource - array of longs to copy from; piSourceStartIndex - starting index in the source to start copying from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(float[] pafDestination,
                        int piDestinationStartIndex,
                        float[] pafSource,
                        int piSourceStartIndex,
                        int piHowMany)

Copies N float elements from source to destination starting at certain index in the destination. A wrapper call to System.arraycopy().

Parameters:: pafDestination - array to copy to; piDestinationStartIndex - starting index in the destination to start copying to; pafSource - array of float to copy from; piSourceStartIndex - starting index in the source to start copying from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(double[] padDestination,
                        int piDestinationStartIndex,
                        double[] padSource,
                        int piSourceStartIndex,
                        int piHowMany)

Copies N double elements from source to destination starting at certain index in the destination. A wrapper call to System.arraycopy().

Parameters:: padDestination - array to copy to; piDestinationStartIndex - starting index in the destination to start copying to; padSource - array of doubles to copy from; piSourceStartIndex - starting index in the source to start copying from; piHowMany - N; the number of elements to copy from the source to the destination
Throws:: java.lang.ArrayIndexOutOfBoundsException - if one of the indices is out of range

copy

public static void copy(java.lang.Object poDestination,
                        int piStartIndex,
                        java.lang.Object poSource,
                        int piHowMany)

Generic copy() routine is based on System.arraycopy().

Parameters:: poDestination - destination array of copy; piStartIndex - where in the destination array start placing the values; poSource - source of elements; piHowMany - how many elements should be copied from the source to destination

copy

public static void copy(java.lang.Object[] paoDestination,
                        int piStartIndex,
                        java.lang.Object[] paoSource,
                        int piHowMany)

Generic copy() routine is based on System.arraycopy() for Object arrays.

Parameters:: paoDestination - destination array of objects to copy to; piStartIndex - where in the destination array start placing the values; paoSource - source of Object elements; piHowMany - how many elements should be copied from the source to destination

copy

public static void copy(char[] pacDestination,
                        int piStartIndex,
                        char[] pacSource,
                        int piHowMany)

Copies N character elements from source to destination starting at certain index in the destination.

Parameters:: pacDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; pacSource - array of characters to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(boolean[] pabDestination,
                        int piStartIndex,
                        boolean[] pabSource,
                        int piHowMany)

Copies N boolean elements from source to destination starting at certain index in the destination.

Parameters:: pabDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; pabSource - array of booleans to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(byte[] patDestination,
                        int piStartIndex,
                        byte[] patSource,
                        int piHowMany)

Copies N byte elements from source to destination starting at certain index in the destination.

Parameters:: patDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; patSource - array of bytes to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(int[] paiDestination,
                        int piStartIndex,
                        int[] paiSource,
                        int piHowMany)

Copies N integer elements from source to destination starting at certain index in the destination.

Parameters:: paiDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; paiSource - array of integers to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(short[] pasDestination,
                        int piStartIndex,
                        short[] pasSource,
                        int piHowMany)

Copies N short elements from source to destination starting at certain index in the destination.

Parameters:: pasDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; pasSource - array of shorts to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(long[] palDestination,
                        int piStartIndex,
                        long[] palSource,
                        int piHowMany)

Copies N long elements from source to destination starting at certain index in the destination.

Parameters:: palDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; palSource - array of longs to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(float[] pafDestination,
                        int piStartIndex,
                        float[] pafSource,
                        int piHowMany)

Copies N float elements from source to destination starting at certain index in the destination.

Parameters:: pafDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; pafSource - array of floats to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(double[] padDestination,
                        int piStartIndex,
                        double[] padSource,
                        int piHowMany)

Copies N double elements from source to destination starting at certain index in the destination.

Parameters:: padDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; padSource - array of doubles to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(java.lang.Object[] paoDestination,
                        int piStartIndex,
                        java.lang.Object[] paoSource)

Generic copy() routine is based on System.arraycopy() for Object arrays.

Parameters:: paoDestination - destination array of objects to copy to; piStartIndex - starting index in the destination to start copying to; paoSource - source of object elements

copy

public static void copy(boolean[] pabDestination,
                        int piStartIndex,
                        boolean[] pabSource)

Copies source to destination starting at certain index in the destination.

Parameters:: pabDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; pabSource - array of booleans to copy from

copy

public static void copy(byte[] patDestination,
                        int piStartIndex,
                        byte[] patSource)

Copies source to destination starting at certain index in the destination.

Parameters:: patDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; patSource - array of bytes to copy from

copy

public static void copy(char[] pacDestination,
                        int piStartIndex,
                        char[] pacSource)

Copies source to destination starting at certain index in the destination.

Parameters:: pacDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; pacSource - array of characters to copy from

copy

public static void copy(int[] paiDestination,
                        int piStartIndex,
                        int[] paiSource)

Copies source to destination starting at certain index in the destination.

Parameters:: paiDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; paiSource - array of integers to copy from

copy

public static void copy(short[] pasDestination,
                        int piStartIndex,
                        short[] pasSource)

Copies source to destination starting at certain index in the destination.

Parameters:: pasDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; pasSource - array of shorts to copy from

copy

public static void copy(long[] palDestination,
                        int piStartIndex,
                        long[] palSource)

Copies source to destination starting at certain index in the destination.

Parameters:: palDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; palSource - array of longs to copy from

copy

public static void copy(float[] pafDestination,
                        int piStartIndex,
                        float[] pafSource)

Copies source to destination starting at certain index in the destination.

Parameters:: pafDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; pafSource - array of floats to copy from

copy

public static void copy(double[] padDestination,
                        int piStartIndex,
                        double[] padSource)

Copies source to destination starting at certain index in the destination.

Parameters:: padDestination - array to copy to; piStartIndex - starting index in the destination to start copying to; padSource - array of doubles to copy from

copy

public static void copy(java.lang.Object poDestination,
                        java.lang.Object poSource,
                        int piHowMany)

Generic copy() routine is based on System.arraycopy().

Parameters:: poDestination - destination array of copy; poSource - source of elements; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(java.lang.Object[] paoDestination,
                        java.lang.Object[] paoSource,
                        int piHowMany)

Generic copy() routine is based on System.arraycopy() for Object arrays.

Parameters:: paoDestination - array to copy to; paoSource - source of object elements; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(char[] pacDestination,
                        char[] pacSource,
                        int piHowMany)

Copies N character elements from source to destination.

Parameters:: pacDestination - array to copy to; pacSource - array of characters to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(boolean[] pabDestination,
                        boolean[] pabSource,
                        int piHowMany)

Copies N boolean elements from source to destination.

Parameters:: pabDestination - array to copy to; pabSource - array of boolean to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(byte[] patDestination,
                        byte[] patSource,
                        int piHowMany)

Copies N byte elements from source to destination.

Parameters:: patDestination - array to copy to; patSource - array of bytes to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(short[] pasDestination,
                        short[] pasSource,
                        int piHowMany)

Copies N short elements from source to destination.

Parameters:: pasDestination - array to copy to; pasSource - array of shorts to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(long[] palDestination,
                        long[] palSource,
                        int piHowMany)

Copies N long elements from source to destination.

Parameters:: palDestination - array to copy to; palSource - array of longs to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(float[] pafDestination,
                        float[] pafSource,
                        int piHowMany)

Copies N float elements from source to destination.

Parameters:: pafDestination - array to copy to; pafSource - array of floats to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(double[] padDestination,
                        double[] padSource,
                        int piHowMany)

Copies N double elements from source to destination.

Parameters:: padDestination - array to copy to; padSource - array of doubles to copy from; piHowMany - N; the number of elements to copy from the source to the destination

copy

public static void copy(int[] paiDestination,
                        int[] paiSource,
                        int piHowMany)

Copies N int elements from source to destination.

Parameters:: paiDestination - array to copy to; paiSource - array of ints to copy from; piHowMany - N; the number of elements to copy from the source to the destination

concatenate

public static java.lang.Object[] concatenate(java.lang.Object[] paoLHS,
                                             java.lang.Object[] paoRHS)

Concatenates two arrays of objects and returns a newly allocated array of the concatenated pieces.

Parameters:: paoLHS - first array piece; paoRHS - second array piece
Returns:: new combined array
Since:: 0.3.0.4

concatenate

public static java.lang.String[] concatenate(java.lang.String[] pastrLHS,
                                             java.lang.String[] pastrRHS)

Concatenates two arrays of Strings and returns a newly allocated array of the concatenated pieces.

Parameters:: pastrLHS - first array piece; pastrRHS - second array piece
Returns:: new combined array
Since:: 0.3.0.4

concatenate

public static double[] concatenate(double[] padLHS,
                                   double[] padRHS)

Concatenates two arrays of doubles and returns a newly allocated array of the concatenated pieces.

Parameters:: padLHS - first array piece; padRHS - second array piece
Returns:: new combined array
Since:: 0.3.0.4

concatenate

public static boolean[] concatenate(boolean[] pabLHS,
                                    boolean[] pabRHS)

Concatenates two arrays of booleans and returns a newly allocated array of the concatenated pieces.

Parameters:: pabLHS - first array piece; pabRHS - second array piece
Returns:: new combined array
Since:: 0.3.0.4

concatenate

public static byte[] concatenate(byte[] patLHS,
                                 byte[] patRHS)

Concatenates two arrays of bytes and returns a newly allocated array of the concatenated pieces.

Parameters:: patLHS - first array piece; patRHS - second array piece
Returns:: new combined array
Since:: 0.3.0.4

concatenate

public static char[] concatenate(char[] pacLHS,
                                 char[] pacRHS)

Concatenates two arrays of characters and returns a newly allocated array of the concatenated pieces.

Parameters:: pacLHS - first array piece; pacRHS - second array piece
Returns:: new combined array
Since:: 0.3.0.4

concatenate

public static int[] concatenate(int[] paiLHS,
                                int[] paiRHS)

Concatenates two arrays of integers and returns a newly allocated array of the concatenated pieces.

Parameters:: paiLHS - first array piece; paiRHS - second array piece
Returns:: new combined array
Since:: 0.3.0.4

concatenate

public static short[] concatenate(short[] pasLHS,
                                  short[] pasRHS)

Concatenates two arrays of shorts and returns a newly allocated array of the concatenated pieces.

Parameters:: pasLHS - first array piece; pasRHS - second array piece
Returns:: new combined array
Since:: 0.3.0.4

concatenate

public static float[] concatenate(float[] pafLHS,
                                  float[] pafRHS)

Concatenates two arrays of floats and returns a newly allocated array of the concatenated pieces.

Parameters:: pafLHS - first array piece; pafRHS - second array piece
Returns:: new combined array
Since:: 0.3.0.4

concatenate

public static long[] concatenate(long[] palLHS,
                                 long[] palRHS)

Concatenates two arrays of longs and returns a newly allocated array of the concatenated pieces.

Parameters:: palLHS - first array piece; palRHS - second array piece
Returns:: new combined array
Since:: 0.3.0.4

equals

public static boolean equals(boolean[] pabArray1,
                             boolean[] pabArray2)

The equals() routine is based on java.util.Arrays.equals().

Parameters:: pabArray1 - the first array of booleans to be compared for equality; pabArray2 - the second array of booleans to be compared for equality
Returns:: a boolean value true if the two arrays are equal

equals

public static boolean equals(byte[] patArray1,
                             byte[] patArray2)

The equals() routine is based on java.util.Arrays.equals().

Parameters:: patArray1 - the first array of bytes to be compared for equality; patArray2 - the second array of bytes to be compared for equality
Returns:: a boolean value true if the two arrays are equal

equals

public static boolean equals(char[] pacArray1,
                             char[] pacArray2)

The equals() routine is based on java.util.Arrays.equals().

Parameters:: pacArray1 - the first array of characters to be compared for equality; pacArray2 - the second array of characters to be compared for equality
Returns:: a boolean value true if the two arrays are equal

equals

public static boolean equals(double[] padArray1,
                             double[] padArray2)

The equals() routine is based on java.util.Arrays.equals().

Parameters:: padArray1 - the first array of doubles to be compared for equality; padArray2 - the second array of doubles to be compared for equality
Returns:: a boolean value true if the two arrays are equal

equals

public static boolean equals(float[] pafArray1,
                             float[] pafArray2)

The equals() routine is based on java.util.Arrays.equals().

Parameters:: pafArray1 - the first array of floats to be compared for equality; pafArray2 - the second array of floats to be compared for equality
Returns:: a boolean value true if the two arrays are equal

equals

public static boolean equals(int[] paiArray1,
                             int[] paiArray2)

The equals() routine is based on java.util.Arrays.equals().

Parameters:: paiArray1 - the first array of integers to be compared for equality; paiArray2 - the second array of integers to be compared for equality
Returns:: a boolean value true if the two arrays are equal

equals

public static boolean equals(long[] palArray1,
                             long[] palArray2)

The equals() routine is based on java.util.Arrays.equals().

Parameters:: palArray1 - the first array of longs to be compared for equality; palArray2 - the second array of longs to be compared for equality
Returns:: a boolean value true if the two arrays are equal

equals

public static boolean equals(java.lang.Object[] paoArray1,
                             java.lang.Object[] paoArray2)

The equals() routine is based on java.util.Arrays.equals().

Parameters:: paoArray1 - the first array of Objects to be compared for equality; paoArray2 - the second array of Objects to be compared for equality
Returns:: a boolean value true if the two arrays are equal

equals

public static boolean equals(short[] pasArray1,
                             short[] pasArray2)

The equals() routine is based on java.util.Arrays.equals().

Parameters:: pasArray1 - the first array of shorts to be compared for equality; pasArray2 - the second array of shorts to be compared for equality
Returns:: a boolean value true if the two arrays are equal