Java/Collections Data Structure/Array Sort Search

Check if object 1 contains object 2

   <source lang="java">
 

/*

* Copyright (c) 2002-2003 by OpenSymphony
* All rights reserved.
*/

import java.lang.reflect.Array; import java.util.Collection; import java.util.Map;

/**

* ContainUtil will check if object 1 contains object 2.
* Object 1 may be an Object, array, Collection, or a Map
*
* @author Matt Baldree (matt@smallleap.ru)
* @version $Revision: 2737 $
*/

public class ContainUtil {

 /**
    * Determine if obj2 exists in obj1.
    *

* * * * * * * * * * * * * * * * * * * * * * * * *

Type Of obj1	Comparison type
null	*	always return false
Map	Map containsKey(obj2)
Collection	Collection contains(obj2)
Array	there"s an array element (e) where e.equals(obj2)
Object	obj1.equals(obj2)

    *
    *
    * @param obj1
    * @param obj2
    * @return
    */
   public static boolean contains(Object obj1, Object obj2) {
       if ((obj1 == null) || (obj2 == null)) {
           //log.debug("obj1 or obj2 are null.");
           return false;
       }
       if (obj1 instanceof Map) {
           if (((Map) obj1).containsKey(obj2)) {
               //log.debug("obj1 is a map and contains obj2");
               return true;
           }
       } else if (obj1 instanceof Collection) {
           if (((Collection) obj1).contains(obj2)) {
               //log.debug("obj1 is a collection and contains obj2");
               return true;
           }
       } else if (obj1.getClass().isArray()) {
           for (int i = 0; i < Array.getLength(obj1); i++) {
               Object value = null;
               value = Array.get(obj1, i);
               if (value.equals(obj2)) {
                   //log.debug("obj1 is an array and contains obj2");
                   return true;
               }
           }
       } else if (obj1.equals(obj2)) {
           //log.debug("obj1 is an object and equals obj2");
           return true;
       }
       //log.debug("obj1 does not contain obj2: " + obj1 + ", " + obj2);
       return false;
   }

} //////////////// package com.opensymphony.webwork.util; import java.util.ArrayList; import java.util.LinkedHashSet; import java.util.List; import java.util.Set; import junit.framework.TestCase; import com.opensymphony.webwork.util.ContainUtil; public class ContainUtilTest extends TestCase {

 public void testNull() throws Exception {
   assertFalse(ContainUtil.contains(null, null));
   assertFalse(ContainUtil.contains(new Object(), null));
   assertFalse(ContainUtil.contains(null, new Object()));
 }
 
 public void testSimpleList() throws Exception {
   List l = new ArrayList();
   l.add("one");
   l.add("two");
   
   assertFalse(ContainUtil.contains(l, "three"));
   assertTrue(ContainUtil.contains(l, "one"));
   assertTrue(ContainUtil.contains(l, "two"));
 }
 
 public void testSimpleSet() throws Exception {
   Set s = new LinkedHashSet();
   s.add("one");
   s.add("two");
   
   assertFalse(ContainUtil.contains(s, "thre"));
   assertTrue(ContainUtil.contains(s, "one"));
   assertTrue(ContainUtil.contains(s, "two"));
 }
 
 public void testComplexList() throws Exception {
   List l = new ArrayList();
   l.add(new MyObject("tm_jee", Integer.valueOf("20")));
   l.add(new MyObject("jenny", Integer.valueOf("22")));
   
   assertFalse(ContainUtil.contains(l, new MyObject("paul", Integer.valueOf("50"))));
   assertFalse(ContainUtil.contains(l, new MyObject("tm_jee", Integer.valueOf("44"))));
   assertTrue(ContainUtil.contains(l, new MyObject("tm_jee", Integer.valueOf("20"))));
   assertTrue(ContainUtil.contains(l, new MyObject("jenny", Integer.valueOf("22"))));
 }
 
 public void testComplexMap() throws Exception {
   Set s = new LinkedHashSet();
   s.add(new MyObject("tm_jee", Integer.valueOf("20")));
   s.add(new MyObject("jenny", Integer.valueOf("22")));
   
   assertFalse(ContainUtil.contains(s, new MyObject("paul", Integer.valueOf("50"))));
   assertFalse(ContainUtil.contains(s, new MyObject("tm_jee", Integer.valueOf("44"))));
   assertTrue(ContainUtil.contains(s, new MyObject("tm_jee", Integer.valueOf("20"))));
   assertTrue(ContainUtil.contains(s, new MyObject("jenny", Integer.valueOf("22"))));
 }
 
 public void testObject() throws Exception {
   assertFalse(ContainUtil.contains("aaa", "bbb"));
   assertFalse(ContainUtil.contains(new MyObject("tm_jee", Integer.valueOf("22")), new MyObject("tmjee", Integer.valueOf("22"))));
   assertTrue(ContainUtil.contains("apple", "apple"));
   assertTrue(ContainUtil.contains(new MyObject("tm_jee", Integer.valueOf("22")), new MyObject("tm_jee", Integer.valueOf("22"))));
 }

 public static class MyObject {
   private String name;
   private Integer age;
   
   public MyObject(String name, Integer age) {
     this.name = name;
     this.age = age;
   }
   
   public int hashCode() {
     return this.name.hashCode();
   }
   
   public boolean equals(Object obj) {
     if (obj == null) { return false; }
     if (! (obj instanceof MyObject)) { return false; }
     MyObject tmp = (MyObject) obj;
     if (
         tmp.name.equals(this.name) &&
         tmp.age.equals(this.age)
       ) {
       return true;
     }
     return false;
       
   }
 }

}

 </source>
   
  
 
  

Find items in an array

   <source lang="java">
    

import org.apache.rumons.lang.ArrayUtils; public class Main {

 public static void main(String[] args) {
   String[] colours = { "Red", "Orange", "Yellow", "Green", "Blue", "Violet", "Orange", "Blue" };
   boolean contains = ArrayUtils.contains(colours, "Blue");
   System.out.println("Contains Blue? " + contains);
   int indexOfYellow = ArrayUtils.indexOf(colours, "Yellow");
   System.out.println("indexOfYellow = " + indexOfYellow);
   int indexOfOrange = ArrayUtils.indexOf(colours, "Orange");
   System.out.println("indexOfOrange = " + indexOfOrange);
   int lastIndexOfOrange = ArrayUtils.lastIndexOf(colours, "Orange");
   System.out.println("lastIndexOfOrange = " + lastIndexOfOrange);
 }

}

 </source>
   
  
 
  

Finds the index of the given object 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 {

 /**

*

Finds the index of the given object in the array.

  *

*

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

  * 
  * @param array  the array to search through for the object, may be null
  * @param objectToFind  the object to find, may be null
  * @return the index of the object within the array, 
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int indexOf(Object[] array, Object objectToFind) {
     return indexOf(array, objectToFind, 0);
 }
 /**

*

Finds the index of the given object 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 objectToFind  the object to find, may be null
  * @param startIndex  the index to start searching at
  * @return the index of the object within the array starting at the index,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int indexOf(Object[] array, Object objectToFind, int startIndex) {
     if (array == null) {
         return -1;
     }
     if (startIndex < 0) {
         startIndex = 0;
     }
     if (objectToFind == null) {
         for (int i = startIndex; i < array.length; i++) {
             if (array[i] == null) {
                 return i;
             }
         }
     } else {
         for (int i = startIndex; i < array.length; i++) {
             if (objectToFind.equals(array[i])) {
                 return i;
             }
         }
     }
     return -1;
 }

}

 </source>
   
  
 
  

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

   <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 {

 /**

*

Finds the index of the given object 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 objectToFind  the object to find, may be null
  * @param startIndex  the index to start searching at
  * @return the index of the object within the array starting at the index,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int indexOf(Object[] array, Object objectToFind, int startIndex) {
     if (array == null) {
         return -1;
     }
     if (startIndex < 0) {
         startIndex = 0;
     }
     if (objectToFind == null) {
         for (int i = startIndex; i < array.length; i++) {
             if (array[i] == null) {
                 return i;
             }
         }
     } else {
         for (int i = startIndex; i < array.length; i++) {
             if (objectToFind.equals(array[i])) {
                 return i;
             }
         }
     }
     return -1;
 }

}

 </source>
   
  
 
  

Finds the last index of the given object in the array starting at the given index.

   <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 {

 /**

*

Finds the last index of the given object in the array starting at the given index.

  *

*

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

  *

*

A negative startIndex will return {@link #INDEX_NOT_FOUND} (-1). A startIndex larger than * the array length will search from the end of the array.

  * 
  * @param array  the array to traverse for looking for the object, may be null
  * @param objectToFind  the object to find, may be null
  * @param startIndex  the start index to travers backwards from
  * @return the last index of the object within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(Object[] array, Object objectToFind, int startIndex) {
     if (array == null) {
         return -1;
     }
     if (startIndex < 0) {
         return -1;
     } else if (startIndex >= array.length) {
         startIndex = array.length - 1;
     }
     if (objectToFind == null) {
         for (int i = startIndex; i >= 0; i--) {
             if (array[i] == null) {
                 return i;
             }
         }
     } else {
         for (int i = startIndex; i >= 0; i--) {
             if (objectToFind.equals(array[i])) {
                 return i;
             }
         }
     }
     return -1;
 }

}

 </source>
   
  
 
  

Finds the last index of the given object within 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 {

 /**

*

Finds the last index of the given object within the array.

  *

*

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

  * 
  * @param array  the array to travers backwords looking for the object, may be null
  * @param objectToFind  the object to find, may be null
  * @return the last index of the object within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(Object[] array, Object objectToFind) {
     return lastIndexOf(array, objectToFind, Integer.MAX_VALUE);
 }
 /**

*

Finds the last index of the given object in the array starting at the given index.

  *

*

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

  *

*

A negative startIndex will return {@link #INDEX_NOT_FOUND} (-1). A startIndex larger than * the array length will search from the end of the array.

  * 
  * @param array  the array to traverse for looking for the object, may be null
  * @param objectToFind  the object to find, may be null
  * @param startIndex  the start index to travers backwards from
  * @return the last index of the object within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(Object[] array, Object objectToFind, int startIndex) {
     if (array == null) {
         return -1;
     }
     if (startIndex < 0) {
         return -1;
     } else if (startIndex >= array.length) {
         startIndex = array.length - 1;
     }
     if (objectToFind == null) {
         for (int i = startIndex; i >= 0; i--) {
             if (array[i] == null) {
                 return i;
             }
         }
     } else {
         for (int i = startIndex; i >= 0; i--) {
             if (objectToFind.equals(array[i])) {
                 return i;
             }
         }
     }
     return -1;
 }

}

 </source>
   
  
 
  

Get index of 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 {

 // long IndexOf
 //-----------------------------------------------------------------------
 /**

*

Finds the index of the given value in the array.

  *

*

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

  * 
  * @param array  the array to search through for the object, may be null
  * @param valueToFind  the value to find
  * @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) {
     return indexOf(array, valueToFind, 0);
 }
 /**

*

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, int startIndex) {
     if (array == null) {
         return -1;
     }
     if (startIndex < 0) {
         startIndex = 0;
     }
     for (int i = startIndex; i < array.length; i++) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return -1;
 }
 /**

*

Finds the last index of the given value within the array.

  *

*

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

  * 
  * @param array  the array to travers backwords looking for the object, may be null
  * @param valueToFind  the object to find
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(long[] array, long valueToFind) {
     return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
 }
 /**

*

Finds the last 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 will return {@link #INDEX_NOT_FOUND} (-1). A startIndex larger than the * array length will search from the end of the array.

  * 
  * @param array  the array to traverse for looking for the object, may be null
  * @param valueToFind  the value to find
  * @param startIndex  the start index to travers backwards from
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(long[] array, long valueToFind, int startIndex) {
     if (array == null) {
         return -1;
     }
     if (startIndex < 0) {
         return -1;
     } else if (startIndex >= array.length) {
         startIndex = array.length - 1;
     }
     for (int i = startIndex; i >= 0; i--) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return -1;
 }
 /**

*

Checks if the value is in the given array.

  *

*

The method returns false if a null array is passed in.

  * 
  * @param array  the array to search through
  * @param valueToFind  the value to find
  * @return true if the array contains the object
  */
 public static boolean contains(long[] array, long valueToFind) {
     return indexOf(array, valueToFind) != -1;
 }

}

 </source>
   
  
 
  

Get the element index and last index in a float 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 {

 /**
  * The index value when an element is not found in a list or array: -1.
  * This value is returned by methods in this class and can also be used in comparisons with values returned by
  * various method from {@link java.util.List}.
  */
 public static final int INDEX_NOT_FOUND = -1;
 // float IndexOf
 //-----------------------------------------------------------------------
 /**

*

Finds the index of the given value in the array.

  *

*

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

  * 
  * @param array  the array to search through for the object, may be null
  * @param valueToFind  the value to find
  * @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(float[] array, float valueToFind) {
     return indexOf(array, valueToFind, 0);
 }
 /**

*

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(float[] array, float valueToFind, int startIndex) {
     if (isEmpty(array)) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         startIndex = 0;
     }
     for (int i = startIndex; i < array.length; i++) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
   /**

*

Finds the last index of the given value within the array.

    *

*

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

    * 
    * @param array  the array to travers backwords looking for the object, may be null
    * @param valueToFind  the object to find
    * @return the last index of the value within the array,
    *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
    */
   public static int lastIndexOf(float[] array, float valueToFind) {
       return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
   }
   /**

*

Finds the last 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 will return {@link #INDEX_NOT_FOUND} (-1). A startIndex larger than the * array length will search from the end of the array.

    * 
    * @param array  the array to traverse for looking for the object, may be null
    * @param valueToFind  the value to find
    * @param startIndex  the start index to travers backwards from
    * @return the last index of the value within the array,
    *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
    */
   public static int lastIndexOf(float[] array, float valueToFind, int startIndex) {
       if (isEmpty(array)) {
           return INDEX_NOT_FOUND;
       }
       if (startIndex < 0) {
           return INDEX_NOT_FOUND;
       } else if (startIndex >= array.length) {
           startIndex = array.length - 1;
       }
       for (int i = startIndex; i >= 0; i--) {
           if (valueToFind == array[i]) {
               return i;
           }
       }
       return INDEX_NOT_FOUND;
   }
   /**

*

Checks if the value is in the given array.

    *

*

The method returns false if a null array is passed in.

    * 
    * @param array  the array to search through
    * @param valueToFind  the value to find
    * @return true if the array contains the object
    */
   public static boolean contains(float[] array, float valueToFind) {
       return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
   }

 /**

*

Checks if an array of primitive doubles is empty or null.

  *
  * @param array  the array to test
  * @return true if the array is empty or null
  * @since 2.1
  */
 public static boolean isEmpty(float[] array) {
     if (array == null || array.length == 0) {
         return true;
     }
     return false;
 }

}

 </source>
   
  
 
  

Get the element index or last index among a boolean 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 {

 /**
  * The index value when an element is not found in a list or array: -1.
  * This value is returned by methods in this class and can also be used in comparisons with values returned by
  * various method from {@link java.util.List}.
  */
 public static final int INDEX_NOT_FOUND = -1;
 // boolean IndexOf
 //-----------------------------------------------------------------------
 /**

*

Finds the index of the given value in the array.

  *

*

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

  * 
  * @param array  the array to search through for the object, may be null
  * @param valueToFind  the value to find
  * @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(boolean[] array, boolean valueToFind) {
     return indexOf(array, valueToFind, 0);
 }
 /**

*

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(boolean[] array, boolean valueToFind, int startIndex) {
     if (isEmpty(array)) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         startIndex = 0;
     }
     for (int i = startIndex; i < array.length; i++) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
 /**

*

Finds the last index of the given value within the array.

  *

*

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

  * 
  * @param array  the array to travers backwords looking for the object, may be null
  * @param valueToFind  the object to find
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(boolean[] array, boolean valueToFind) {
     return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
 }
 /**

*

Finds the last 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 will return {@link #INDEX_NOT_FOUND} (-1). A startIndex larger than * the array length will search from the end of the array.

  * 
  * @param array  the array to traverse for looking for the object, may be null
  * @param valueToFind  the value to find
  * @param startIndex  the start index to travers backwards from
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(boolean[] array, boolean valueToFind, int startIndex) {
     if (isEmpty(array)) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         return INDEX_NOT_FOUND;
     } else if (startIndex >= array.length) {
         startIndex = array.length - 1;
     }
     for (int i = startIndex; i >= 0; i--) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
 /**

*

Checks if the value is in the given array.

  *

*

The method returns false if a null array is passed in.

  * 
  * @param array  the array to search through
  * @param valueToFind  the value to find
  * @return true if the array contains the object
  */
 public static boolean contains(boolean[] array, boolean valueToFind) {
     return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
 }

 /**

*

Checks if an array of primitive doubles is empty or null.

  *
  * @param array  the array to test
  * @return true if the array is empty or null
  * @since 2.1
  */
 public static boolean isEmpty(boolean[] array) {
     if (array == null || array.length == 0) {
         return true;
     }
     return false;
 }

}

 </source>
   
  
 
  

Get the index and last index of a 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 {

 /**
  * The index value when an element is not found in a list or array: -1.
  * This value is returned by methods in this class and can also be used in comparisons with values returned by
  * various method from {@link java.util.List}.
  */
 public static final int INDEX_NOT_FOUND = -1;

 // char IndexOf
 //-----------------------------------------------------------------------
 /**

*

Finds the index of the given value in the array.

  *

*

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

  * 
  * @param array  the array to search through for the object, may be null
  * @param valueToFind  the value to find
  * @return the index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  * @since 2.1
  */
 public static int indexOf(char[] array, char valueToFind) {
     return indexOf(array, valueToFind, 0);
 }
 /**

*

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
  * @since 2.1
  */
 public static int indexOf(char[] array, char valueToFind, int startIndex) {
     if (array == null) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         startIndex = 0;
     }
     for (int i = startIndex; i < array.length; i++) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
 /**

*

Finds the last index of the given value within the array.

  *

*

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

  * 
  * @param array  the array to travers backwords looking for the object, may be null
  * @param valueToFind  the object to find
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  * @since 2.1
  */
 public static int lastIndexOf(char[] array, char valueToFind) {
     return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
 }
 /**

*

Finds the last 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 will return {@link #INDEX_NOT_FOUND} (-1). A startIndex larger than the * array length will search from the end of the array.

  * 
  * @param array  the array to traverse for looking for the object, may be null
  * @param valueToFind  the value to find
  * @param startIndex  the start index to travers backwards from
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  * @since 2.1
  */
 public static int lastIndexOf(char[] array, char valueToFind, int startIndex) {
     if (array == null) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         return INDEX_NOT_FOUND;
     } else if (startIndex >= array.length) {
         startIndex = array.length - 1;
     }
     for (int i = startIndex; i >= 0; i--) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
 /**

*

Checks if the value is in the given array.

  *

*

The method returns false if a null array is passed in.

  * 
  * @param array  the array to search through
  * @param valueToFind  the value to find
  * @return true if the array contains the object
  * @since 2.1
  */
 public static boolean contains(char[] array, char valueToFind) {
     return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
 }

}

 </source>
   
  
 
  

Get the index and last index of a 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 {

 /**
  * The index value when an element is not found in a list or array: -1.
  * This value is returned by methods in this class and can also be used in comparisons with values returned by
  * various method from {@link java.util.List}.
  */
 public static final int INDEX_NOT_FOUND = -1;

 // double IndexOf
 //-----------------------------------------------------------------------
 /**

*

Finds the index of the given value in the array.

  *

*

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

  * 
  * @param array  the array to search through for the object, may be null
  * @param valueToFind  the value to find
  * @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(double[] array, double valueToFind) {
     return indexOf(array, valueToFind, 0);
 }
 /**

*

Finds the index of the given value within a given tolerance in the array. * This method will return the index of the first value which falls between the region * defined by valueToFind - tolerance and valueToFind + tolerance.

  *

*

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

  * 
  * @param array  the array to search through for the object, may be null
  * @param valueToFind  the value to find
  * @param tolerance tolerance of the search
  * @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(double[] array, double valueToFind, double tolerance) {
     return indexOf(array, valueToFind, 0, tolerance);
 }
 /**

*

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(double[] array, double valueToFind, int startIndex) {
     if (isEmpty(array)) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         startIndex = 0;
     }
     for (int i = startIndex; i < array.length; i++) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
 /**

*

Finds the index of the given value in the array starting at the given index. * This method will return the index of the first value which falls between the region * defined by valueToFind - tolerance and valueToFind + tolerance.

  *

*

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
  * @param tolerance tolerance of the search
  * @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(double[] array, double valueToFind, int startIndex, double tolerance) {
     if (isEmpty(array)) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         startIndex = 0;
     }
     double min = valueToFind - tolerance;
     double max = valueToFind + tolerance;
     for (int i = startIndex; i < array.length; i++) {
         if (array[i] >= min && array[i] <= max) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
 /**

*

Finds the last index of the given value within the array.

  *

*

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

  * 
  * @param array  the array to travers backwords looking for the object, may be null
  * @param valueToFind  the object to find
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(double[] array, double valueToFind) {
     return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
 }
 /**

*

Finds the last index of the given value within a given tolerance in the array. * This method will return the index of the last value which falls between the region * defined by valueToFind - tolerance and valueToFind + tolerance.

  *

*

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

  * 
  * @param array  the array to search through for the object, may be null
  * @param valueToFind  the value to find
  * @param tolerance tolerance of the search
  * @return the index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(double[] array, double valueToFind, double tolerance) {
     return lastIndexOf(array, valueToFind, Integer.MAX_VALUE, tolerance);
 }
 /**

*

Finds the last 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 will return {@link #INDEX_NOT_FOUND} (-1). A startIndex larger than the * array length will search from the end of the array.

  * 
  * @param array  the array to traverse for looking for the object, may be null
  * @param valueToFind  the value to find
  * @param startIndex  the start index to travers backwards from
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(double[] array, double valueToFind, int startIndex) {
     if (isEmpty(array)) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         return INDEX_NOT_FOUND;
     } else if (startIndex >= array.length) {
         startIndex = array.length - 1;
     }
     for (int i = startIndex; i >= 0; i--) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
 /**

*

Finds the last index of the given value in the array starting at the given index. * This method will return the index of the last value which falls between the region * defined by valueToFind - tolerance and valueToFind + tolerance.

  *

*

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

  *

*

A negative startIndex will return {@link #INDEX_NOT_FOUND} (-1). A startIndex larger than the * array length will search from the end of the array.

  * 
  * @param array  the array to traverse for looking for the object, may be null
  * @param valueToFind  the value to find
  * @param startIndex  the start index to travers backwards from
  * @param tolerance  search for value within plus/minus this amount
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(double[] array, double valueToFind, int startIndex, double tolerance) {
     if (isEmpty(array)) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         return INDEX_NOT_FOUND;
     } else if (startIndex >= array.length) {
         startIndex = array.length - 1;
     }
     double min = valueToFind - tolerance;
     double max = valueToFind + tolerance;
     for (int i = startIndex; i >= 0; i--) {
         if (array[i] >= min && array[i] <= max) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
 /**

*

Checks if the value is in the given array.

  *

*

The method returns false if a null array is passed in.

  * 
  * @param array  the array to search through
  * @param valueToFind  the value to find
  * @return true if the array contains the object
  */
 public static boolean contains(double[] array, double valueToFind) {
     return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
 }
 /**

*

Checks if a value falling within the given tolerance is in the * given array. If the array contains a value within the inclusive range * defined by (value - tolerance) to (value + tolerance).

  *

*

The method returns false if a null array * is passed in.

  *
  * @param array  the array to search
  * @param valueToFind  the value to find
  * @param tolerance  the array contains the tolerance of the search
  * @return true if value falling within tolerance is in array
  */
 public static boolean contains(double[] array, double valueToFind, double tolerance) {
     return indexOf(array, valueToFind, 0, tolerance) != INDEX_NOT_FOUND;
 }

 /**

*

Checks if an array of primitive doubles is empty or null.

  *
  * @param array  the array to test
  * @return true if the array is empty or null
  * @since 2.1
  */
 public static boolean isEmpty(double[] array) {
     if (array == null || array.length == 0) {
         return true;
     }
     return false;
 }

}

 </source>
   
  
 
  

Get the index and last index of an 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 {

 /**
  * The index value when an element is not found in a list or array: -1.
  * This value is returned by methods in this class and can also be used in comparisons with values returned by
  * various method from {@link java.util.List}.
  */
 public static final int INDEX_NOT_FOUND = -1;
 // int IndexOf
 //-----------------------------------------------------------------------
 /**

*

Finds the index of the given value in the array.

  *

*

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

  * 
  * @param array  the array to search through for the object, may be null
  * @param valueToFind  the value to find
  * @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(int[] array, int valueToFind) {
     return indexOf(array, valueToFind, 0);
 }
 /**

*

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(int[] array, int valueToFind, int startIndex) {
     if (array == null) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         startIndex = 0;
     }
     for (int i = startIndex; i < array.length; i++) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
 /**

*

Finds the last index of the given value within the array.

  *

*

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

  * 
  * @param array  the array to travers backwords looking for the object, may be null
  * @param valueToFind  the object to find
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(int[] array, int valueToFind) {
     return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
 }
 /**

*

Finds the last 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 will return {@link #INDEX_NOT_FOUND} (-1). A startIndex larger than the * array length will search from the end of the array.

  * 
  * @param array  the array to traverse for looking for the object, may be null
  * @param valueToFind  the value to find
  * @param startIndex  the start index to travers backwards from
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(int[] array, int valueToFind, int startIndex) {
     if (array == null) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         return INDEX_NOT_FOUND;
     } else if (startIndex >= array.length) {
         startIndex = array.length - 1;
     }
     for (int i = startIndex; i >= 0; i--) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
 /**

*

Checks if the value is in the given array.

  *

*

The method returns false if a null array is passed in.

  * 
  * @param array  the array to search through
  * @param valueToFind  the value to find
  * @return true if the array contains the object
  */
 public static boolean contains(int[] array, int valueToFind) {
     return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
 }

}

 </source>
   
  
 
  

Get the index and last index of a short 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 {

 /**
  * The index value when an element is not found in a list or array: -1.
  * This value is returned by methods in this class and can also be used in comparisons with values returned by
  * various method from {@link java.util.List}.
  */
 public static final int INDEX_NOT_FOUND = -1;

 // short IndexOf
 //-----------------------------------------------------------------------
 /**

*

Finds the index of the given value in the array.

  *

*

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

  * 
  * @param array  the array to search through for the object, may be null
  * @param valueToFind  the value to find
  * @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) {
     return indexOf(array, valueToFind, 0);
 }
 /**

*

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, int startIndex) {
     if (array == null) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         startIndex = 0;
     }
     for (int i = startIndex; i < array.length; i++) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
 /**

*

Finds the last index of the given value within the array.

  *

*

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

  * 
  * @param array  the array to travers backwords looking for the object, may be null
  * @param valueToFind  the object to find
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(short[] array, short valueToFind) {
     return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
 }
 /**

*

Finds the last 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 will return {@link #INDEX_NOT_FOUND} (-1). A startIndex larger than the * array length will search from the end of the array.

  * 
  * @param array  the array to traverse for looking for the object, may be null
  * @param valueToFind  the value to find
  * @param startIndex  the start index to travers backwards from
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(short[] array, short valueToFind, int startIndex) {
     if (array == null) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         return INDEX_NOT_FOUND;
     } else if (startIndex >= array.length) {
         startIndex = array.length - 1;
     }
     for (int i = startIndex; i >= 0; i--) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
 /**

*

Checks if the value is in the given array.

  *

*

The method returns false if a null array is passed in.

  * 
  * @param array  the array to search through
  * @param valueToFind  the value to find
  * @return true if the array contains the object
  */
 public static boolean contains(short[] array, short valueToFind) {
     return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
 }

}

 </source>
   
  
 
  

Get the index and last index of 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 {

 /**
  * The index value when an element is not found in a list or array: -1.
  * This value is returned by methods in this class and can also be used in comparisons with values returned by
  * various method from {@link java.util.List}.
  */
 public static final int INDEX_NOT_FOUND = -1;

 // byte IndexOf
 //-----------------------------------------------------------------------
 /**

*

Finds the index of the given value in the array.

  *

*

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

  * 
  * @param array  the array to search through for the object, may be null
  * @param valueToFind  the value to find
  * @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(byte[] array, byte valueToFind) {
     return indexOf(array, valueToFind, 0);
 }
 /**

*

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(byte[] array, byte valueToFind, int startIndex) {
     if (array == null) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         startIndex = 0;
     }
     for (int i = startIndex; i < array.length; i++) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
 /**

*

Finds the last index of the given value within the array.

  *

*

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

  * 
  * @param array  the array to travers backwords looking for the object, may be null
  * @param valueToFind  the object to find
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(byte[] array, byte valueToFind) {
     return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
 }
 /**

*

Finds the last 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 will return {@link #INDEX_NOT_FOUND} (-1). A startIndex larger than the * array length will search from the end of the array.

  * 
  * @param array  the array to traverse for looking for the object, may be null
  * @param valueToFind  the value to find
  * @param startIndex  the start index to travers backwards from
  * @return the last index of the value within the array,
  *  {@link #INDEX_NOT_FOUND} (-1) if not found or null array input
  */
 public static int lastIndexOf(byte[] array, byte valueToFind, int startIndex) {
     if (array == null) {
         return INDEX_NOT_FOUND;
     }
     if (startIndex < 0) {
         return INDEX_NOT_FOUND;
     } else if (startIndex >= array.length) {
         startIndex = array.length - 1;
     }
     for (int i = startIndex; i >= 0; i--) {
         if (valueToFind == array[i]) {
             return i;
         }
     }
     return INDEX_NOT_FOUND;
 }
 /**

*

Checks if the value is in the given array.

  *

*

The method returns false if a null array is passed in.

  * 
  * @param array  the array to search through
  * @param valueToFind  the value to find
  * @return true if the array contains the object
  */
 public static boolean contains(byte[] array, byte valueToFind) {
     return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
 }

}

 </source>
   
  
 
  

How to sort an array

   <source lang="java">
    

import java.util.Arrays; public class Main {

 public static void main(String[] args) {
   int[] intArray = new int[] { 4, 5, 9, 0, 3, 5, 6, 2 };
   Arrays.sort(intArray);
   for (int i = 0; i < intArray.length; i++)
     System.out.println(intArray[i]);
   String[] stringArray = new String[] { "D", "E", "A", "C", "B" };
   Arrays.sort(stringArray);
   for (int i = 0; i < stringArray.length; i++)
     System.out.println(stringArray[i]);
 }

} /*0 2 3 4 5 5 6 9 A B C D E

• /

 </source>
   
  
 
  

If array contains given element

   <source lang="java">
  

/*

* Copyright (c) 2003 - 2007 OpenSubsystems s.r.o. Slovak Republic. All rights reserved.
* 
* Project: OpenSubsystems
* 
* $Id: ArrayUtils.java,v 1.9 2007/01/23 06:00:30 bastafidli Exp $
* 
* 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; version 2 of the License. 
* 
* 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 
*/

/**

* Collection of useful utilities to work with arrays. 
* 
* @version $Id: ArrayUtils.java,v 1.9 2007/01/23 06:00:30 bastafidli Exp $
* @author Peter Satury
* @code.reviewer Miro Halas
* @code.reviewed 1.5 2005/07/29 07:36:24 bastafidli
*/

public final class ArrayUtils {

  /** 
   * Private constructor since this class cannot be instantiated
   */
  private ArrayUtils(
  )
  {
     // Do nothing
  }
  
  // Public methods ///////////////////////////////////////////////////////////
  /**
   * Method to exclude 2 arrays of ints so that the result contains all elements
   * from the first array, which are not in the second array.
   *  
   * @param arrBase - base array to exclude from 
   * @param arrExclude - array to exclude from the first one
   * @return int[] - array which contains all elements from the first array 
   *                 which are not in the second array or null
   */
  public static int[] exclude(
     int[] arrBase, 
     int[] arrExclude
  )
  {
     int[] arrReturn = null;
     if ((arrBase != null) && (arrBase.length > 0) && (arrExclude != null)
        && (arrExclude.length > 0))
     {
        int[] arrHelp;
        int   iCount1;
        int   iHelp;
        int   iLength = 0;
        
        arrHelp = new int[arrBase.length];
        for (iCount1 = 0; iCount1 < arrBase.length; iCount1++)
        {
           iHelp = arrBase[iCount1];
           if (ArrayUtils.contains(arrExclude, iHelp) == -1)
           {
              // If the element is not part of the second array then it should
              // be included in the result
              arrHelp[iLength++] = iHelp;
           }
        }
        
        // Shrink the array
        // TODO: Performance: Replace this with System.arraycopy
        arrReturn = new int[iLength];
        for (int iCount = 0; iCount < iLength; iCount++)
        {
           arrReturn[iCount] = arrHelp[iCount];
        }
     }
     else
     {
        arrReturn = arrBase;
     }
     
     return arrReturn;
  }
  
  /**
   * Test if specified array contains given element and if it does, find 
   * its position.
   * 
   * @param source - array to search, can be null
   * @param iTarget - element to find
   * @return int - -1 if it doesn"t exist there otherwise its position
   */
  public static int contains(
     int[] source,
     int   iTarget
  )
  {
     int iReturn = -1;
     
     if ((source != null) && (source.length > 0))
     {   
        int iIndex;
        
        for (iIndex = 0; iIndex < source.length; iIndex++)
        {
           if (source[iIndex] == iTarget)
           {
              iReturn = iIndex;
              break;
           }
        }
     }
     
     return iReturn;
  }
  /**
   * Sum all elements in the array.
   * 
   * @param source - array to sum elements of
   * @return long - sum of the elements in the array
   */
  public static long sum(
     int[] source
  )
  {
     int iReturn = 0;
     
     if ((source != null) && (source.length > 0))
     {   
        int iIndex;
        
        for (iIndex = 0; iIndex < source.length; iIndex++)
        {
           iReturn += source[iIndex];
        }
     }
     
     return iReturn;
  }

}

 </source>
   
  
 
  

Inserting an Element into a Sorted Array

   <source lang="java">
    

import java.util.Arrays; public class Main {

 public static void main(String[] argv) {
   String[] oldArray = new String[] { "a", "b", "c", "d" };
   int index = Arrays.binarySearch(oldArray, "e");
   if (index < 0) {
     int insertIndex = -index - 1;
     String[] newArray = new String[oldArray.length + 1];
     System.arraycopy(oldArray, 0, newArray, 0, insertIndex);
     System.arraycopy(oldArray, insertIndex, newArray, insertIndex + 1,
         oldArray.length - insertIndex);
     newArray[insertIndex] = "e";
     oldArray = newArray;
   }
 }

}

 </source>
   
  
 
  

Produces a new array containing the elements between the start and end indices.

   <source lang="java">
   

import java.lang.reflect.Array; /*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 // Subarrays
 //-----------------------------------------------------------------------
 /**

*

Produces a new array containing the elements between * the start and end indices.

  *

*

The start index is inclusive, the end index exclusive. * Null array input produces null output.

  *

*

The component type of the subarray is always the same as * that of the input array. Thus, if the input is an array of type * Date, the following usage is envisaged:

  *

*

   * Date[] someDates = (Date[])ArrayUtils.subarray(allDates, 2, 5);
   * 

  *
  * @param array  the array
  * @param startIndexInclusive  the starting index. Undervalue (<0)
  *      is promoted to 0, overvalue (>array.length) results
  *      in an empty array.
  * @param endIndexExclusive  elements up to endIndex-1 are present in the
  *      returned subarray. Undervalue (< startIndex) produces
  *      empty array, overvalue (>array.length) is demoted to
  *      array length.
  * @return a new array containing the elements between
  *      the start and end indices.
  * @since 2.1
  */
 public static Object[] subarray(Object[] array, int startIndexInclusive, int endIndexExclusive) {
     if (array == null) {
         return null;
     }
     if (startIndexInclusive < 0) {
         startIndexInclusive = 0;
     }
     if (endIndexExclusive > array.length) {
         endIndexExclusive = array.length;
     }
     int newSize = endIndexExclusive - startIndexInclusive;
     Class type = array.getClass().getComponentType();
     if (newSize <= 0) {
         return (Object[]) Array.newInstance(type, 0);
     }
     Object[] subarray = (Object[]) Array.newInstance(type, newSize);
     System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
     return subarray;
 }

}

 </source>
   
  
 
  

Produces a new boolean array containing the elements between the start and end indices.

   <source lang="java">
   

import java.lang.reflect.Array; /*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Produces a new boolean array containing the elements * between the start and end indices.

  *

*

The start index is inclusive, the end index exclusive. * Null array input produces null output.

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

}

 </source>
   
  
 
  

Produces a new byte array containing the elements between the start and end indices.

   <source lang="java">
   

import java.lang.reflect.Array; /*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Produces a new byte array containing the elements * between the start and end indices.

  *

*

The start index is inclusive, the end index exclusive. * Null array input produces null output.

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

}

 </source>
   
  
 
  

Produces a new char array containing the elements between the start and end indices.

   <source lang="java">
   

import java.lang.reflect.Array; /*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Produces a new char array containing the elements * between the start and end indices.

  *

*

The start index is inclusive, the end index exclusive. * Null array input produces null output.

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

}

 </source>
   
  
 
  

Produces a new double array containing the elements between the start and end indices.

   <source lang="java">
   

import java.lang.reflect.Array; /*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Produces a new double array containing the elements * between the start and end indices.

  *

*

The start index is inclusive, the end index exclusive. * Null array input produces null output.

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

}

 </source>
   
  
 
  

Produces a new float array containing the elements between the start and end indices.

   <source lang="java">
   

import java.lang.reflect.Array; /*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Produces a new float array containing the elements * between the start and end indices.

  *

*

The start index is inclusive, the end index exclusive. * Null array input produces null output.

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

}

 </source>
   
  
 
  

Produces a new int array containing the elements between the start and end indices.

   <source lang="java">
   

import java.lang.reflect.Array; /*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Produces a new int array containing the elements * between the start and end indices.

  *

*

The start index is inclusive, the end index exclusive. * Null array input produces null output.

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

}

 </source>
   
  
 
  

Produces a new long array containing the elements between the start and end indices.

   <source lang="java">
   

import java.lang.reflect.Array; /*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Produces a new long array containing the elements * between the start and end indices.

  *

*

The start index is inclusive, the end index exclusive. * Null array input produces null output.

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

}

 </source>
   
  
 
  

Produces a new short array containing the elements between the start and end indices.

   <source lang="java">
   

import java.lang.reflect.Array; /*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Produces a new short array containing the elements * between the start and end indices.

  *

*

The start index is inclusive, the end index exclusive. * Null array input produces null output.

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

}

 </source>
   
  
 
  

Quicksort implementation for sorting arrays

   <source lang="java">

/*

* Copyright (c) 1998 - 2005 Versant Corporation
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Versant Corporation - initial API and implementation
*/

import java.util.ruparator; /**

* Quicksort implementation for sorting arrays. Unlike the merge sort in
* java.utils.Collections this one does not create any objects. There are
* two implementations, one for arrays of Comparable"s and another that
* uses a comparator.
*/

public class Quicksort {

   private Quicksort() {
   }
   /**
    * Sort the first size entries in a.
    */
   public static void quicksort(Object[] a, int size) {
       quicksort(a, 0, size - 1);
   }
   /**
    * Sort the entries in a between left and right inclusive.
    */
   public static void quicksort(Object[] a, int left, int right) {
       int size = right - left + 1;
       switch (size) {
           case 0:
           case 1:
               break;
           case 2:
               if (compare(a[left], a[right]) > 0) swap(a, left, right);
               break;
           case 3:
               if (compare(a[left], a[right - 1]) > 0) swap(a, left, right - 1);
               if (compare(a[left], a[right]) > 0) swap(a, left, right);
               if (compare(a[left + 1], a[right]) > 0) swap(a, left + 1, right);
               break;
           default:
               int median = median(a, left, right);
               int partition = partition(a, left, right, median);
               quicksort(a, left, partition - 1);
               quicksort(a, partition + 1, right);
       }
   }
   private static int compare(Object a, Object b) {
       if (a == null) {
           return b == null ? 0 : -1;
       } else if (b == null) {
           return +1;
       } else {
           return ((Comparable)a).rupareTo(b);
       }
   }
   private static void swap(Object[] a, int left, int right) {
       Object t = a[left];
       a[left] = a[right];
       a[right] = t;
   }
   private static int median(Object[] a, int left, int right) {
       int center = (left + right) / 2;
       if (compare(a[left], a[center]) > 0) swap(a, left, center);
       if (compare(a[left], a[right]) > 0) swap(a, left, right);
       if (compare(a[center], a[right]) > 0) swap(a, center, right);
       swap(a, center, right - 1);
       return right - 1;
   }
   private static int partition(Object[] a, int left, int right, int pivotIndex) {
       int leftIndex = left;
       int rightIndex = right - 1;
       while (true) {
           while (compare(a[++leftIndex], a[pivotIndex]) < 0);
           while (compare(a[--rightIndex], a[pivotIndex]) > 0);
           if (leftIndex >= rightIndex) {
               break; // pointers cross so partition done
           } else {
               swap(a, leftIndex, rightIndex);
           }
       }
       swap(a, leftIndex, right - 1);         // restore pivot
       return leftIndex;                 // return pivot location
   }
   /**
    * Sort the first size entries in a.
    */
   public static void quicksort(Object[] a, int size, Comparator c) {
       quicksort(a, 0, size - 1, c);
   }
   /**
    * Sort the entries in a between left and right inclusive.
    */
   public static void quicksort(Object[] a, int left, int right, Comparator c) {
       int size = right - left + 1;
       switch (size) {
           case 0:
           case 1:
               break;
           case 2:
               if (c.rupare(a[left], a[right]) > 0) swap(a, left, right);
               break;
           case 3:
               if (c.rupare(a[left], a[right - 1]) > 0) swap(a, left, right - 1);
               if (c.rupare(a[left], a[right]) > 0) swap(a, left, right);
               if (c.rupare(a[left + 1], a[right]) > 0) swap(a, left + 1, right);
               break;
           default:
               int median = median(a, left, right, c);
               int partition = partition(a, left, right, median, c);
               quicksort(a, left, partition - 1, c);
               quicksort(a, partition + 1, right, c);
       }
   }
   private static int median(Object[] a, int left, int right, Comparator c) {
       int center = (left + right) / 2;
       if (c.rupare(a[left], a[center]) > 0) swap(a, left, center);
       if (c.rupare(a[left], a[right]) > 0) swap(a, left, right);
       if (c.rupare(a[center], a[right]) > 0) swap(a, center, right);
       swap(a, center, right - 1);
       return right - 1;
   }
   private static int partition(Object[] a, int left, int right,
           int pivotIndex, Comparator c) {
       int leftIndex = left;
       int rightIndex = right - 1;
       while (true) {
           while (c.rupare(a[++leftIndex], a[pivotIndex]) < 0);
           while (c.rupare(a[--rightIndex], a[pivotIndex]) > 0);
           if (leftIndex >= rightIndex) {
               break; // pointers cross so partition done
           } else {
               swap(a, leftIndex, rightIndex);
           }
       }
       swap(a, leftIndex, right - 1);         // restore pivot
       return leftIndex;                 // return pivot location
   }

}

 </source>
   
  
 
  

Returns the index in the source array where the first occurrence of the specified byte pattern is found

   <source lang="java">
  

/**********************************************************************************

*
* Copyright (c) 2003, 2004 The Regents of the University of Michigan, Trustees of Indiana University,
*                  Board of Trustees of the Leland Stanford, Jr., University, and The MIT Corporation
*
* Licensed under the Educational Community License Version 1.0 (the "License");
* By obtaining, using and/or copying this Original Work, you agree that you have read,
* understand, and will comply with the terms and conditions of the Educational Community License.
* You may obtain a copy of the License at:
*
*      http://cvs.sakaiproject.org/licenses/license_1_0.html
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**********************************************************************************/

/**

* Byte utilities
*/

public class ByteUtils {

 /**
  * Returns the index in the source array where the first occurrence of the
  * specified byte pattern is found
  * 
  * @param source
  *          Byte array to examine
  * @param match
  *          Byte array to locate in source
  * @return Index of the first matching character (-1 if no match)
  */
 public static int indexOf(byte[] source, byte[] match) {
   for (int i = 0; i < source.length; i++) {
     if (startsWith(source, i, match)) {
       return i;
     }
   }
   return -1;
 }
 /**
  * Returns the index in the source array where the last occurrence of the
  * specified text (a String, converted to a byte array) is found
  * 
  * @param source
  *          Byte array to examine
  * @param matchString
  *          String to locate in source
  * @return Index of the first matching character (-1 if no match)
  */
 public static int lastIndexOf(byte[] source, String matchString) {
   return lastIndexOf(source, matchString.getBytes());
 }
 /**
  * Returns the index in the source array where the last occurrence of the
  * specified byte pattern is found
  * 
  * @param source
  *          Byte array to examine
  * @param match
  *          Byte array to locate in source
  * @return Index of the last matching character (-1 if no match)
  */
 public static int lastIndexOf(byte[] source, byte[] match) {
   if (source.length < match.length) {
     return -1;
   }
   for (int i = (source.length - match.length); i >= 0; i--) {
     if (startsWith(source, i, match)) {
       return i;
     }
   }
   return -1;
 }
 /**
  * Does this byte array begin with match array content?
  * 
  * @param source
  *          Byte array to examine
  * @param match
  *          Byte array to locate in source
  * @return true If the starting bytes are equal
  */
 public static boolean startsWith(byte[] source, byte[] match) {
   return startsWith(source, 0, match);
 }
 /**
  * Does this byte array begin with match array content?
  * 
  * @param source
  *          Byte array to examine
  * @param offset
  *          An offset into the source array
  * @param match
  *          Byte array to locate in source
  * @return true If the starting bytes are equal
  */
 public static boolean startsWith(byte[] source, int offset, byte[] match) {
   if (match.length > (source.length - offset)) {
     return false;
   }
   for (int i = 0; i < match.length; i++) {
     if (source[offset + i] != match[i]) {
       return false;
     }
   }
   return true;
 }
 /**
  * Does the source array equal the match array?
  * 
  * @param source
  *          Byte array to examine
  * @param offset
  *          An offset into the source array
  * @param match
  *          Byte array to locate in source
  * @return true If the two arrays are equal
  */
 public static boolean equals(byte[] source, byte[] match) {
   if (match.length != source.length) {
     return false;
   }
   return startsWith(source, 0, match);
 }
 /**
  * Copies bytes from the source byte array to the destination array
  * 
  * @param source
  *          The source array
  * @param srcBegin
  *          Index of the first source byte to copy
  * @param srcEnd
  *          Index after the last source byte to copy
  * @param destination
  *          The destination array
  * @param dstBegin
  *          The starting offset in the destination array
  */
 public static void getBytes(byte[] source, int srcBegin, int srcEnd, byte[] destination,
     int dstBegin) {
   System.arraycopy(source, srcBegin, destination, dstBegin, srcEnd - srcBegin);
 }
 /**
  * Return a new byte array containing a sub-portion of the source array
  * 
  * @param srcBegin
  *          The beginning index (inclusive)
  * @param srcEnd
  *          The ending index (exclusive)
  * @return The new, populated byte array
  */
 public static byte[] subbytes(byte[] source, int srcBegin, int srcEnd) {
   byte destination[];
   destination = new byte[srcEnd - srcBegin];
   getBytes(source, srcBegin, srcEnd, destination, 0);
   return destination;
 }
 /**
  * Return a new byte array containing a sub-portion of the source array
  * 
  * @param srcBegin
  *          The beginning index (inclusive)
  * @return The new, populated byte array
  */
 public static byte[] subbytes(byte[] source, int srcBegin) {
   return subbytes(source, srcBegin, source.length);
 }

}

 </source>
   
  
 
  

Returns the index in the source array where the first occurrence of the specified text (a String, converted to a byte array) is found

   <source lang="java">
  

/**********************************************************************************

*
* Copyright (c) 2003, 2004 The Regents of the University of Michigan, Trustees of Indiana University,
*                  Board of Trustees of the Leland Stanford, Jr., University, and The MIT Corporation
*
* Licensed under the Educational Community License Version 1.0 (the "License");
* By obtaining, using and/or copying this Original Work, you agree that you have read,
* understand, and will comply with the terms and conditions of the Educational Community License.
* You may obtain a copy of the License at:
*
*      http://cvs.sakaiproject.org/licenses/license_1_0.html
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**********************************************************************************/

/**

* Byte utilities
*/

public class ByteUtils {

 /**
  * Returns the index in the source array where the first occurrence of the
  * specified text (a String, converted to a byte array) is found
  * 
  * @param source
  *          Byte array to examine
  * @param matchString
  *          String to locate in source
  * @return Index of the first matching character (-1 if no match)
  */
 public static int indexOf(byte[] source, String matchString) {
   return indexOf(source, matchString.getBytes());
 }
 /**
  * Returns the index in the source array where the first occurrence of the
  * specified byte pattern is found
  * 
  * @param source
  *          Byte array to examine
  * @param match
  *          Byte array to locate in source
  * @return Index of the first matching character (-1 if no match)
  */
 public static int indexOf(byte[] source, byte[] match) {
   for (int i = 0; i < source.length; i++) {
     if (startsWith(source, i, match)) {
       return i;
     }
   }
   return -1;
 }
 /**
  * Returns the index in the source array where the last occurrence of the
  * specified text (a String, converted to a byte array) is found
  * 
  * @param source
  *          Byte array to examine
  * @param matchString
  *          String to locate in source
  * @return Index of the first matching character (-1 if no match)
  */
 public static int lastIndexOf(byte[] source, String matchString) {
   return lastIndexOf(source, matchString.getBytes());
 }
 /**
  * Returns the index in the source array where the last occurrence of the
  * specified byte pattern is found
  * 
  * @param source
  *          Byte array to examine
  * @param match
  *          Byte array to locate in source
  * @return Index of the last matching character (-1 if no match)
  */
 public static int lastIndexOf(byte[] source, byte[] match) {
   if (source.length < match.length) {
     return -1;
   }
   for (int i = (source.length - match.length); i >= 0; i--) {
     if (startsWith(source, i, match)) {
       return i;
     }
   }
   return -1;
 }
 /**
  * Does this byte array begin with match array content?
  * 
  * @param source
  *          Byte array to examine
  * @param match
  *          Byte array to locate in source
  * @return true If the starting bytes are equal
  */
 public static boolean startsWith(byte[] source, byte[] match) {
   return startsWith(source, 0, match);
 }
 /**
  * Does this byte array begin with match array content?
  * 
  * @param source
  *          Byte array to examine
  * @param offset
  *          An offset into the source array
  * @param match
  *          Byte array to locate in source
  * @return true If the starting bytes are equal
  */
 public static boolean startsWith(byte[] source, int offset, byte[] match) {
   if (match.length > (source.length - offset)) {
     return false;
   }
   for (int i = 0; i < match.length; i++) {
     if (source[offset + i] != match[i]) {
       return false;
     }
   }
   return true;
 }
 /**
  * Does the source array equal the match array?
  * 
  * @param source
  *          Byte array to examine
  * @param offset
  *          An offset into the source array
  * @param match
  *          Byte array to locate in source
  * @return true If the two arrays are equal
  */
 public static boolean equals(byte[] source, byte[] match) {
   if (match.length != source.length) {
     return false;
   }
   return startsWith(source, 0, match);
 }
 /**
  * Copies bytes from the source byte array to the destination array
  * 
  * @param source
  *          The source array
  * @param srcBegin
  *          Index of the first source byte to copy
  * @param srcEnd
  *          Index after the last source byte to copy
  * @param destination
  *          The destination array
  * @param dstBegin
  *          The starting offset in the destination array
  */
 public static void getBytes(byte[] source, int srcBegin, int srcEnd, byte[] destination,
     int dstBegin) {
   System.arraycopy(source, srcBegin, destination, dstBegin, srcEnd - srcBegin);
 }
 /**
  * Return a new byte array containing a sub-portion of the source array
  * 
  * @param srcBegin
  *          The beginning index (inclusive)
  * @param srcEnd
  *          The ending index (exclusive)
  * @return The new, populated byte array
  */
 public static byte[] subbytes(byte[] source, int srcBegin, int srcEnd) {
   byte destination[];
   destination = new byte[srcEnd - srcBegin];
   getBytes(source, srcBegin, srcEnd, destination, 0);
   return destination;
 }
 /**
  * Return a new byte array containing a sub-portion of the source array
  * 
  * @param srcBegin
  *          The beginning index (inclusive)
  * @return The new, populated byte array
  */
 public static byte[] subbytes(byte[] source, int srcBegin) {
   return subbytes(source, srcBegin, source.length);
 }
 /*
  * Test
  */
 public static void main(String[] args) throws Exception {
   byte byteText[];
   int index, last;
   byteText = "XXXXXXXXXX".getBytes();
   index = indexOf(byteText, "XXX");
   last = lastIndexOf(byteText, "XXX");
 }

}

 </source>
   
  
 
  

Returns the index in the source array where the last occurrence of the specified byte pattern is found

   <source lang="java">
  

/**********************************************************************************

*
* Copyright (c) 2003, 2004 The Regents of the University of Michigan, Trustees of Indiana University,
*                  Board of Trustees of the Leland Stanford, Jr., University, and The MIT Corporation
*
* Licensed under the Educational Community License Version 1.0 (the "License");
* By obtaining, using and/or copying this Original Work, you agree that you have read,
* understand, and will comply with the terms and conditions of the Educational Community License.
* You may obtain a copy of the License at:
*
*      http://cvs.sakaiproject.org/licenses/license_1_0.html
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**********************************************************************************/

/**

* Byte utilities
*/

public class ByteUtils {

 /**
  * Returns the index in the source array where the last occurrence of the
  * specified byte pattern is found
  * 
  * @param source
  *          Byte array to examine
  * @param match
  *          Byte array to locate in source
  * @return Index of the last matching character (-1 if no match)
  */
 public static int lastIndexOf(byte[] source, byte[] match) {
   if (source.length < match.length) {
     return -1;
   }
   for (int i = (source.length - match.length); i >= 0; i--) {
     if (startsWith(source, i, match)) {
       return i;
     }
   }
   return -1;
 }
 /**
  * Does this byte array begin with match array content?
  * 
  * @param source
  *          Byte array to examine
  * @param match
  *          Byte array to locate in source
  * @return true If the starting bytes are equal
  */
 public static boolean startsWith(byte[] source, byte[] match) {
   return startsWith(source, 0, match);
 }
 /**
  * Does this byte array begin with match array content?
  * 
  * @param source
  *          Byte array to examine
  * @param offset
  *          An offset into the source array
  * @param match
  *          Byte array to locate in source
  * @return true If the starting bytes are equal
  */
 public static boolean startsWith(byte[] source, int offset, byte[] match) {
   if (match.length > (source.length - offset)) {
     return false;
   }
   for (int i = 0; i < match.length; i++) {
     if (source[offset + i] != match[i]) {
       return false;
     }
   }
   return true;
 }
 /**
  * Does the source array equal the match array?
  * 
  * @param source
  *          Byte array to examine
  * @param offset
  *          An offset into the source array
  * @param match
  *          Byte array to locate in source
  * @return true If the two arrays are equal
  */
 public static boolean equals(byte[] source, byte[] match) {
   if (match.length != source.length) {
     return false;
   }
   return startsWith(source, 0, match);
 }
 /**
  * Copies bytes from the source byte array to the destination array
  * 
  * @param source
  *          The source array
  * @param srcBegin
  *          Index of the first source byte to copy
  * @param srcEnd
  *          Index after the last source byte to copy
  * @param destination
  *          The destination array
  * @param dstBegin
  *          The starting offset in the destination array
  */
 public static void getBytes(byte[] source, int srcBegin, int srcEnd, byte[] destination,
     int dstBegin) {
   System.arraycopy(source, srcBegin, destination, dstBegin, srcEnd - srcBegin);
 }
 /**
  * Return a new byte array containing a sub-portion of the source array
  * 
  * @param srcBegin
  *          The beginning index (inclusive)
  * @param srcEnd
  *          The ending index (exclusive)
  * @return The new, populated byte array
  */
 public static byte[] subbytes(byte[] source, int srcBegin, int srcEnd) {
   byte destination[];
   destination = new byte[srcEnd - srcBegin];
   getBytes(source, srcBegin, srcEnd, destination, 0);
   return destination;
 }
 /**
  * Return a new byte array containing a sub-portion of the source array
  * 
  * @param srcBegin
  *          The beginning index (inclusive)
  * @return The new, populated byte array
  */
 public static byte[] subbytes(byte[] source, int srcBegin) {
   return subbytes(source, srcBegin, source.length);
 }

}

 </source>
   
  
 
  

Returns the index in the source array where the last occurrence of the specified text (a String, converted to a byte array) is found

   <source lang="java">
  

/**********************************************************************************

*
* Copyright (c) 2003, 2004 The Regents of the University of Michigan, Trustees of Indiana University,
*                  Board of Trustees of the Leland Stanford, Jr., University, and The MIT Corporation
*
* Licensed under the Educational Community License Version 1.0 (the "License");
* By obtaining, using and/or copying this Original Work, you agree that you have read,
* understand, and will comply with the terms and conditions of the Educational Community License.
* You may obtain a copy of the License at:
*
*      http://cvs.sakaiproject.org/licenses/license_1_0.html
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**********************************************************************************/

/**

* Byte utilities
*/

public class ByteUtils {

 /**
  * Returns the index in the source array where the last occurrence of the
  * specified text (a String, converted to a byte array) is found
  * 
  * @param source
  *          Byte array to examine
  * @param matchString
  *          String to locate in source
  * @return Index of the first matching character (-1 if no match)
  */
 public static int lastIndexOf(byte[] source, String matchString) {
   return lastIndexOf(source, matchString.getBytes());
 }
 /**
  * Returns the index in the source array where the last occurrence of the
  * specified byte pattern is found
  * 
  * @param source
  *          Byte array to examine
  * @param match
  *          Byte array to locate in source
  * @return Index of the last matching character (-1 if no match)
  */
 public static int lastIndexOf(byte[] source, byte[] match) {
   if (source.length < match.length) {
     return -1;
   }
   for (int i = (source.length - match.length); i >= 0; i--) {
     if (startsWith(source, i, match)) {
       return i;
     }
   }
   return -1;
 }
 /**
  * Does this byte array begin with match array content?
  * 
  * @param source
  *          Byte array to examine
  * @param match
  *          Byte array to locate in source
  * @return true If the starting bytes are equal
  */
 public static boolean startsWith(byte[] source, byte[] match) {
   return startsWith(source, 0, match);
 }
 /**
  * Does this byte array begin with match array content?
  * 
  * @param source
  *          Byte array to examine
  * @param offset
  *          An offset into the source array
  * @param match
  *          Byte array to locate in source
  * @return true If the starting bytes are equal
  */
 public static boolean startsWith(byte[] source, int offset, byte[] match) {
   if (match.length > (source.length - offset)) {
     return false;
   }
   for (int i = 0; i < match.length; i++) {
     if (source[offset + i] != match[i]) {
       return false;
     }
   }
   return true;
 }
 /**
  * Does the source array equal the match array?
  * 
  * @param source
  *          Byte array to examine
  * @param offset
  *          An offset into the source array
  * @param match
  *          Byte array to locate in source
  * @return true If the two arrays are equal
  */
 public static boolean equals(byte[] source, byte[] match) {
   if (match.length != source.length) {
     return false;
   }
   return startsWith(source, 0, match);
 }
 /**
  * Copies bytes from the source byte array to the destination array
  * 
  * @param source
  *          The source array
  * @param srcBegin
  *          Index of the first source byte to copy
  * @param srcEnd
  *          Index after the last source byte to copy
  * @param destination
  *          The destination array
  * @param dstBegin
  *          The starting offset in the destination array
  */
 public static void getBytes(byte[] source, int srcBegin, int srcEnd, byte[] destination,
     int dstBegin) {
   System.arraycopy(source, srcBegin, destination, dstBegin, srcEnd - srcBegin);
 }
 /**
  * Return a new byte array containing a sub-portion of the source array
  * 
  * @param srcBegin
  *          The beginning index (inclusive)
  * @param srcEnd
  *          The ending index (exclusive)
  * @return The new, populated byte array
  */
 public static byte[] subbytes(byte[] source, int srcBegin, int srcEnd) {
   byte destination[];
   destination = new byte[srcEnd - srcBegin];
   getBytes(source, srcBegin, srcEnd, destination, 0);
   return destination;
 }
 /**
  * Return a new byte array containing a sub-portion of the source array
  * 
  * @param srcBegin
  *          The beginning index (inclusive)
  * @return The new, populated byte array
  */
 public static byte[] subbytes(byte[] source, int srcBegin) {
   return subbytes(source, srcBegin, source.length);
 }

}

 </source>
   
  
 
  

Returns the maximum value in a byte-type array.

   <source lang="java">
  

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
* 
*      http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

*

Provides extra functionality for Java Number classes.

*
* @author 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/

public class Main {

 /**

*

Returns the maximum value in an array.

  * 
  * @param array  an array, must not be null or empty
  * @return the minimum value in the array
  * @throws IllegalArgumentException if array is null
  * @throws IllegalArgumentException if array is empty
  */
 public static byte max(byte[] array) {
     // Validates input
     if (array == null) {
         throw new IllegalArgumentException("The Array must not be null");
     } else if (array.length == 0) {
         throw new IllegalArgumentException("Array cannot be empty.");
     }
 
     // Finds and returns max
     byte max = array[0];
     for (int i = 1; i < array.length; i++) {
         if (array[i] > max) {
             max = array[i];
         }
     }
 
     return max;
 }

}

 </source>
   
  
 
  

Returns the maximum value in a double-type array.

   <source lang="java">
  

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
* 
*      http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

*

Provides extra functionality for Java Number classes.

*
* @author 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/

public class Main {

 /**

*

Returns the maximum value in an array.

  * 
  * @param array  an array, must not be null or empty
  * @return the minimum value in the array
  * @throws IllegalArgumentException if array is null
  * @throws IllegalArgumentException if array is empty
  * @see IEEE754rUtils#max(double[]) IEEE754rUtils for a version of this method that handles NaN differently
  */
 public static double max(double[] array) {
     // Validates input
     if (array== null) {
         throw new IllegalArgumentException("The Array must not be null");
     } else if (array.length == 0) {
         throw new IllegalArgumentException("Array cannot be empty.");
     }
 
     // Finds and returns max
     double max = array[0];
     for (int j = 1; j < array.length; j++) {
         if (Double.isNaN(array[j])) {
             return Double.NaN;
         }
         if (array[j] > max) {
             max = array[j];
         }
     }
 
     return max;
 }

}

 </source>
   
  
 
  

Returns the maximum value in a float-type array.

   <source lang="java">
  

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
* 
*      http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

*

Provides extra functionality for Java Number classes.

*
* @author 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/

public class Main {

 /**

*

Returns the maximum value in an array.

  * 
  * @param array  an array, must not be null or empty
  * @return the minimum value in the array
  * @throws IllegalArgumentException if array is null
  * @throws IllegalArgumentException if array is empty
  * @see IEEE754rUtils#max(float[]) IEEE754rUtils for a version of this method that handles NaN differently
  */
 public static float max(float[] array) {
     // Validates input
     if (array == null) {
         throw new IllegalArgumentException("The Array must not be null");
     } else if (array.length == 0) {
         throw new IllegalArgumentException("Array cannot be empty.");
     }
     // Finds and returns max
     float max = array[0];
     for (int j = 1; j < array.length; j++) {
         if (Float.isNaN(array[j])) {
             return Float.NaN;
         }
         if (array[j] > max) {
             max = array[j];
         }
     }
     return max;
 }

}

 </source>
   
  
 
  

Returns the maximum value in a long-value array.

   <source lang="java">
  

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
* 
*      http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

*

Provides extra functionality for Java Number classes.

*
* @author 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/

public class Main {

 /**

*

Returns the maximum value in an array.

  * 
  * @param array  an array, must not be null or empty
  * @return the minimum value in the array
  * @throws IllegalArgumentException if array is null
  * @throws IllegalArgumentException if array is empty
  */
 public static long max(long[] array) {
     // Validates input
     if (array == null) {
         throw new IllegalArgumentException("The Array must not be null");
     } else if (array.length == 0) {
         throw new IllegalArgumentException("Array cannot be empty.");
     }
     // Finds and returns max
     long max = array[0];
     for (int j = 1; j < array.length; j++) {
         if (array[j] > max) {
             max = array[j];
         }
     }
     return max;
 }

}

 </source>
   
  
 
  

Returns the maximum value in an int-type array.

   <source lang="java">
  

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
* 
*      http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

*

Provides extra functionality for Java Number classes.

*
* @author 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/

public class Main {

 /**

*

Returns the maximum value in an array.

  * 
  * @param array  an array, must not be null or empty
  * @return the minimum value in the array
  * @throws IllegalArgumentException if array is null
  * @throws IllegalArgumentException if array is empty
  */
 public static int max(int[] array) {
     // Validates input
     if (array == null) {
         throw new IllegalArgumentException("The Array must not be null");
     } else if (array.length == 0) {
         throw new IllegalArgumentException("Array cannot be empty.");
     }
 
     // Finds and returns max
     int max = array[0];
     for (int j = 1; j < array.length; j++) {
         if (array[j] > max) {
             max = array[j];
         }
     }
 
     return max;
 }

}

 </source>
   
  
 
  

Returns the maximum value in a short-type array.

   <source lang="java">
  

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
* 
*      http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

*

Provides extra functionality for Java Number classes.

*
* @author 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/

public class Main {

 /**

*

Returns the maximum value in an array.

  * 
  * @param array  an array, must not be null or empty
  * @return the minimum value in the array
  * @throws IllegalArgumentException if array is null
  * @throws IllegalArgumentException if array is empty
  */
 public static short max(short[] array) {
     // Validates input
     if (array == null) {
         throw new IllegalArgumentException("The Array must not be null");
     } else if (array.length == 0) {
         throw new IllegalArgumentException("Array cannot be empty.");
     }
 
     // Finds and returns max
     short max = array[0];
     for (int i = 1; i < array.length; i++) {
         if (array[i] > max) {
             max = array[i];
         }
     }
 
     return max;
 }

}

 </source>
   
  
 
  

Returns the minimum value in a double-type array.

   <source lang="java">
  

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
* 
*      http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

*

Provides extra functionality for Java Number classes.

*
* @author 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/

public class Main {

 /**

*

Returns the minimum value in an array.

 * 
 * @param array  an array, must not be null or empty
 * @return the minimum value in the array
 * @throws IllegalArgumentException if array is null
 * @throws IllegalArgumentException if array is empty
 * @see IEEE754rUtils#min(double[]) IEEE754rUtils for a version of this method that handles NaN differently
 */
public static double min(double[] array) {
    // Validates input
    if (array == null) {
        throw new IllegalArgumentException("The Array must not be null");
    } else if (array.length == 0) {
        throw new IllegalArgumentException("Array cannot be empty.");
    }

    // Finds and returns min
    double min = array[0];
    for (int i = 1; i < array.length; i++) {
        if (Double.isNaN(array[i])) {
            return Double.NaN;
        }
        if (array[i] < min) {
            min = array[i];
        }
    }

    return min;
}

}

 </source>
   
  
 
  

Returns the minimum value in a float-value array.

   <source lang="java">
  

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
* 
*      http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

*

Provides extra functionality for Java Number classes.

*
* @author 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/

public class Main {

 /**

*

Returns the minimum value in an array.

  * 
  * @param array  an array, must not be null or empty
  * @return the minimum value in the array
  * @throws IllegalArgumentException if array is null
  * @throws IllegalArgumentException if array is empty
  * @see IEEE754rUtils#min(float[]) IEEE754rUtils for a version of this method that handles NaN differently
  */
 public static float min(float[] array) {
     // Validates input
     if (array == null) {
         throw new IllegalArgumentException("The Array must not be null");
     } else if (array.length == 0) {
         throw new IllegalArgumentException("Array cannot be empty.");
     }
 
     // Finds and returns min
     float min = array[0];
     for (int i = 1; i < array.length; i++) {
         if (Float.isNaN(array[i])) {
             return Float.NaN;
         }
         if (array[i] < min) {
             min = array[i];
         }
     }
 
     return min;
 }

}

 </source>
   
  
 
  

Returns the minimum value in an array.

   <source lang="java">
  

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
* 
*      http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

*

Provides extra functionality for Java Number classes.

*
* @author 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/

public class Main {

 /**

*

Returns the minimum value in an array.

  * 
  * @param array  an array, must not be null or empty
  * @return the minimum value in the array
  * @throws IllegalArgumentException if array is null
  * @throws IllegalArgumentException if array is empty
  */
 public static long min(long[] array) {
     // Validates input
     if (array == null) {
         throw new IllegalArgumentException("The Array must not be null");
     } else if (array.length == 0) {
         throw new IllegalArgumentException("Array cannot be empty.");
     }
 
     // Finds and returns min
     long min = array[0];
     for (int i = 1; i < array.length; i++) {
         if (array[i] < min) {
             min = array[i];
         }
     }
 
     return min;
 }

}

 </source>
   
  
 
  

Returns the minimum value in an int-type array.

   <source lang="java">
  

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
* 
*      http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

*

Provides extra functionality for Java Number classes.

*
* @author 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/

public class Main {

 /**

*

Returns the minimum value in an array.

  * 
  * @param array  an array, must not be null or empty
  * @return the minimum value in the array
  * @throws IllegalArgumentException if array is null
  * @throws IllegalArgumentException if array is empty
  */
 public static int min(int[] array) {
     // Validates input
     if (array == null) {
         throw new IllegalArgumentException("The Array must not be null");
     } else if (array.length == 0) {
         throw new IllegalArgumentException("Array cannot be empty.");
     }
 
     // Finds and returns min
     int min = array[0];
     for (int j = 1; j < array.length; j++) {
         if (array[j] < min) {
             min = array[j];
         }
     }
 
     return min;
 }

}

 </source>
   
  
 
  

Returns the minimum value in an short-type array.

   <source lang="java">
  

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
* 
*      http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

*

Provides extra functionality for Java Number classes.

*
* @author 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/

public class Main {

 /**

*

Returns the minimum value in an array.

  * 
  * @param array  an array, must not be null or empty
  * @return the minimum value in the array
  * @throws IllegalArgumentException if array is null
  * @throws IllegalArgumentException if array is empty
  */
 public static short min(short[] array) {
     // Validates input
     if (array == null) {
         throw new IllegalArgumentException("The Array must not be null");
     } else if (array.length == 0) {
         throw new IllegalArgumentException("Array cannot be empty.");
     }
 
     // Finds and returns min
     short min = array[0];
     for (int i = 1; i < array.length; i++) {
         if (array[i] < min) {
             min = array[i];
         }
     }
 
     return min;
 }

}

 </source>
   
  
 
  

Returns the minimum value in a short-type array.

   <source lang="java">
  

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
* 
*      http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

*

Provides extra functionality for Java Number classes.

*
* @author 
* @since 2.0
* @version $Id: NumberUtils.java 609475 2008-01-06 23:58:59Z bayard $
*/

public class Main {

 /**

*

Returns the minimum value in an array.

  * 
  * @param array  an array, must not be null or empty
  * @return the minimum value in the array
  * @throws IllegalArgumentException if array is null
  * @throws IllegalArgumentException if array is empty
  */
 public static byte min(byte[] array) {
     // Validates input
     if (array == null) {
         throw new IllegalArgumentException("The Array must not be null");
     } else if (array.length == 0) {
         throw new IllegalArgumentException("Array cannot be empty.");
     }
 
     // Finds and returns min
     byte min = array[0];
     for (int i = 1; i < array.length; i++) {
         if (array[i] < min) {
             min = array[i];
         }
     }
 
     return min;
 }

}

 </source>
   
  
 
  

Reverses the order of the given boolean type value array.

   <source lang="java">
   

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Reverses the order of the given array.

  * 

*

This method does nothing for a null input array.

  * 
  * @param array  the array to reverse, may be null
  */
 public static void reverse(boolean[] array) {
     if (array == null) {
         return;
     }
     int i = 0;
     int j = array.length - 1;
     boolean tmp;
     while (j > i) {
         tmp = array[j];
         array[j] = array[i];
         array[i] = tmp;
         j--;
         i++;
     }
 }

}

 </source>
   
  
 
  

Reverses the order of the given byte type array.

   <source lang="java">
   

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Reverses the order of the given array.

  * 

*

This method does nothing for a null input array.

  * 
  * @param array  the array to reverse, may be null
  */
 public static void reverse(byte[] array) {
     if (array == null) {
         return;
     }
     int i = 0;
     int j = array.length - 1;
     byte tmp;
     while (j > i) {
         tmp = array[j];
         array[j] = array[i];
         array[i] = tmp;
         j--;
         i++;
     }
 }

}

 </source>
   
  
 
  

Reverses the order of the given char type value array.

   <source lang="java">
   

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Reverses the order of the given array.

  * 

*

This method does nothing for a null input array.

  * 
  * @param array  the array to reverse, may be null
  */
 public static void reverse(char[] array) {
     if (array == null) {
         return;
     }
     int i = 0;
     int j = array.length - 1;
     char tmp;
     while (j > i) {
         tmp = array[j];
         array[j] = array[i];
         array[i] = tmp;
         j--;
         i++;
     }
 }

}

 </source>
   
  
 
  

Reverses the order of the given double value type array.

   <source lang="java">
   

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Reverses the order of the given array.

  * 

*

This method does nothing for a null input array.

  * 
  * @param array  the array to reverse, may be null
  */
 public static void reverse(double[] array) {
     if (array == null) {
         return;
     }
     int i = 0;
     int j = array.length - 1;
     double tmp;
     while (j > i) {
         tmp = array[j];
         array[j] = array[i];
         array[i] = tmp;
         j--;
         i++;
     }
 }

}

 </source>
   
  
 
  

Reverses the order of the given float type value array.

   <source lang="java">
   

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Reverses the order of the given array.

  * 

*

This method does nothing for a null input array.

  * 
  * @param array  the array to reverse, may be null
  */
 public static void reverse(float[] array) {
     if (array == null) {
         return;
     }
     int i = 0;
     int j = array.length - 1;
     float tmp;
     while (j > i) {
         tmp = array[j];
         array[j] = array[i];
         array[i] = tmp;
         j--;
         i++;
     }
 }

}

 </source>
   
  
 
  

Reverses the order of the given int type value array.

   <source lang="java">
   

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Reverses the order of the given array.

  * 

*

This method does nothing for a null input array.

  * 
  * @param array  the array to reverse, may be null
  */
 public static void reverse(int[] array) {
     if (array == null) {
         return;
     }
     int i = 0;
     int j = array.length - 1;
     int tmp;
     while (j > i) {
         tmp = array[j];
         array[j] = array[i];
         array[i] = tmp;
         j--;
         i++;
     }
 }

}

 </source>
   
  
 
  

Reverses the order of the given long type value array.

   <source lang="java">
   

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Reverses the order of the given array.

  * 

*

This method does nothing for a null input array.

  * 
  * @param array  the array to reverse, may be null
  */
 public static void reverse(long[] array) {
     if (array == null) {
         return;
     }
     int i = 0;
     int j = array.length - 1;
     long tmp;
     while (j > i) {
         tmp = array[j];
         array[j] = array[i];
         array[i] = tmp;
         j--;
         i++;
     }
 }

}

 </source>
   
  
 
  

Reverses the order of the given object array.

   <source lang="java">
   

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

public class Main {

 /** 

*

Reverses the order of the given array.

  *

*

There is no special handling for multi-dimensional arrays.

  *

*

This method does nothing for a null input array.

  * 
  * @param array  the array to reverse, may be null
  */
 public static void reverse(Object[] array) {
     if (array == null) {
         return;
     }
     int i = 0;
     int j = array.length - 1;
     Object tmp;
     while (j > i) {
         tmp = array[j];
         array[j] = array[i];
         array[i] = tmp;
         j--;
         i++;
     }
 }

}

 </source>
   
  
 
  

Reverses the order of the given short type value array.

   <source lang="java">
   

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

/**

* @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 {

 /**

*

Reverses the order of the given array.

  * 

*

This method does nothing for a null input array.

  * 
  * @param array  the array to reverse, may be null
  */
 public static void reverse(short[] array) {
     if (array == null) {
         return;
     }
     int i = 0;
     int j = array.length - 1;
     short tmp;
     while (j > i) {
         tmp = array[j];
         array[j] = array[i];
         array[i] = tmp;
         j--;
         i++;
     }
 }

}

 </source>
   
  
 
  

Search for an object in an array.

   <source lang="java">
  

/**********************************************************************************

* $URL: https://source.sakaiproject.org/svn/util/branches/sakai_2-5-4/util-util/util/src/java/org/sakaiproject/util/ArrayUtil.java $
* $Id: ArrayUtil.java 7914 2006-04-18 18:11:25Z ggolden@umich.edu $
***********************************************************************************
*
* Copyright (c) 2006 The Sakai Foundation.
* 
* Licensed under the Educational Community License, Version 1.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.opensource.org/licenses/ecl1.php
* 
* 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.
*
**********************************************************************************/

/**

*

* ArrayUtil collects together some Array utility methods. *

*/

public class ArrayUtil {

 /**
  * Search for an object in an array.
  * 
  * @param target
  *        The target array
  * @param search
  *        The object to search for.
  * @return true if search is "in" (equal to any object in) the target, false if not
  */
 public static boolean contains(Object[] target, Object search)
 {
   if ((target == null) || (search == null)) return false;
   if (target.length == 0) return false;
   try
   {
     for (int i = 0; i < target.length; i++)
     {
       if (search.equals(target[i])) return true;
     }
   }
   catch (Throwable e)
   {
     return false;
   }
   return false;
 }

}

 </source>
   
  
 
  

Search for a specified value of an array

   <source lang="java">
    

import java.util.Arrays; public class Main {

 public static void main(String[] args) {
   int items[] = { 5, 4, 6, 1, 8, 9, 6, 7, 3, 2 };
   Arrays.sort(items);
   int index = Arrays.binarySearch(items, 1);
   System.out.println("Search item found at: " + index);
 }

}

 </source>
   
  
 
  

Sort array utilities

   <source lang="java">
  

/*

* Copyright 2004, 2005, 2006 Odysseus Software GmbH
*
* 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.util.Arrays; import java.util.ruparator; import java.util.Iterator; import java.util.List; /**

* Utility class providing some useful static sort methods. The sort routines
* all return index permutations p such that data[p[0]],..,data[p[data.length-1]]
* is in sorted order. The data array itself is not modified.
* To actually rearrange the array elements, the inverse of p can be used to
* permute the array, such that data[0],..,data[data.length-1] is in sorted
* order. Use getIterator(p, data) to iterate in sorted order.
* A code example may show you what to do next:

*

 * String[] colors = { "red", "green", "blue" };
 * int[] p = SortUtils.sort(colors, new StringComparator());
 * // --> (colors[p[0]], colors[p[1]], colors[p[2]]) == ("blue","green","red")
 * Iterator iter = SortUtils.getIterator(p, colors)
 * // --> (iter.next(), iter.next(), iter.next()) == ("blue","green","red")
 * SortUtils.permute(SortUtils.inverse(p), colors, true);
 * // --> (colors[0], colors[1], colors[2]) == ("blue","green","red")
 * 

* Stable sorts (preserving order of equal elements) are supported.
* Sorting is done using quick-sort mith median of 3 (and insertion-sort
* for small ranges).
*
* @author Christoph Beck
*/

public class SortUtils {

 /**
  * Helper class used to perform quicksort.
  *
  * @author Christoph Beck
  */
 static final class QuickSorter {
   private static final int INSERTIONSORT_THRESHOLD = 7;
   private final Object[] data;
   QuickSorter(Object[] data) {
     this.data = data;
   }
   private int compare(Comparator cmp, boolean stable, int i, int j) {
     int result = cmp.rupare(data[i], data[j]);
     if (result == 0 && stable && i != j) {
       result = i < j ? -1 : 1;
     }
     return result;
   }
   private int med3(Comparator cmp, int a, int b, int c) {
       return  (compare(cmp, false, a, b) < 0 ?
           (compare(cmp, false, b, c) < 0 ? b : compare(cmp, false, a, c) < 0 ? c : a) :
           (compare(cmp, false, b, c) > 0 ? b : compare(cmp, false, a, c) < 0 ? c : a));
   }
   private int pivot(int[] indices, Comparator cmp, int lo, int hi) {
     return med3(cmp, indices[lo + 1], indices[(lo + hi) / 2], indices[hi - 1]);
   }
   private void swap(int[] indices, int i, int j) {
     int tmp = indices[i];
     indices[i] = indices[j];
     indices[j] = tmp;
   }
   private void insertionSort(int[] indices, Comparator cmp, boolean stable, int lo, int hi) {
     for (int i = lo; i <= hi; i++) {
           for (int j = i; j > lo && compare(cmp, stable, indices[j-1], indices[j]) > 0; j--) {
             swap(indices, j-1, j);
           }
         }
   }
   private void quickSort(int[] indices, Comparator cmp, boolean stable, int lo0, int hi0) {
     int pivot = pivot(indices, cmp, lo0, hi0);
     int lo = lo0, hi = hi0;
     while (lo <= hi) {
       while (lo < hi0 && compare(cmp, stable, pivot, indices[lo]) > 0)
         ++lo;
       while (hi > lo0 && compare(cmp, stable, pivot, indices[hi]) < 0)
         --hi;
       if (lo <= hi) {
         swap(indices, lo++, hi--);
       }
     }
     sort(indices, cmp, stable, lo0, hi);
     sort(indices, cmp, stable, lo, hi0);
   }
   void sort(int[] indices, Comparator cmp, boolean stable, int lo, int hi) {
     if (hi - lo < INSERTIONSORT_THRESHOLD) {
       insertionSort(indices, cmp, stable, lo, hi);
     } else {
       quickSort(indices, cmp, stable, lo, hi);
     }
   }
   void sort(int[] indices, Comparator cmp, boolean stable) {
     sort(indices, cmp, stable, 0, indices.length - 1);
   }
   int[] sort(Comparator cmp, boolean stable) {
     int[] indices = identity(data.length);
     sort(indices, cmp, stable);
     return indices;
   }
 }
 /**
  * Create identity permutation, that is {0, 1, ..., n}
  */
 public static int[] identity(int n) {
   int[] indices = new int[n];
   for (int i = 0; i < n; i++)
     indices[i] = i;
   return indices;
 }
 /**
  * Create reverse permutation, that is {n-1, .... 1, 0}
  */
 public static int[] reverse(int n) {
   int[] indices = new int[n];
   for (int i = 0; i < n; i++)
     indices[i] = n - i - 1;
   return indices;
 }
 /**
  * Compute inverse permutation
  */
 public static int[] inverse(int[] p) {
   int[] pi = new int[p.length];
   for (int i = 0; i < pi.length; i++)
     pi[p[i]] = i;
   return pi;
 }
 /**
  * Rearrange the specified data according to the specified permutation.
  * That is, the array is rearranged, such that
  * data_after[p[i]] == data_before[i].
  * @param data data to be permuted
  * @param p the permutation
  * @param clone if true, rearrange a clone instead of the original data;
  * @return the permuted array (which is the original reference if clone == false)
  */
 public static Object[] permute(int[] p, Object[] data, boolean clone) {
   Object[] permuted = null;
   if (clone) {
     permuted = (Object[])data.clone();
     for (int i = 0; i < data.length; i++)
       permuted[p[i]] = data[i];
   } else {
     // run thru cycles
     int i = 0;
     while (i < p.length) {
       if (p[i] < 0 || p[i] == i) // skip already handled and cycles of length 1
         ++i;
       else { // start a new cycle
         int j = p[i];
         Object save = data[i];
         while (p[j] >= 0) {
           Object tmp = data[j];
           data[j] = save;
           save = tmp;
           i = j;
           j = p[j];
           p[i] = -1;
         }
       }
     }
     permuted = data;
   }
   return permuted;
 }
 /**
  * Answer iterator, which iterates over specified data array according
  * to the specified permutation, that is
  * data[p[0]],..,data[p[data.length-1]]
  */
 public static Iterator getIterator(final int[] p, final Object[] data) {
   return new Iterator() {
     int pos = 0;
     public boolean hasNext() {
       return pos < data.length;
     }
     public Object next() {
       return data[p[pos++]];
     }
     public void remove() {
       throw new UnsupportedOperationException("Cannot remove from immutable iterator!");
     }
   };
 }
 /**
  * Answer iterator, which iterates over specified data list according
  * to the specified permutation, that is
  * data.get(p[0]),..,data.get(p[data.length-1])
  */
 public static Iterator getIterator(final int[] p, final List data) {
   return new Iterator() {
     int pos = 0;
     public boolean hasNext() {
       return pos < data.size();
     }
     public Object next() {
       return data.get(p[pos++]);
     }
     public void remove() {
       throw new UnsupportedOperationException("Cannot remove from immutable iterator!");
     }
   };
 }

// /** // * An improved heap builder. // * Assumes children of i at 2i and 2i+1 (requires i>0) // */ // private static void cheap(int[] indices, Object[] data, Comparator comparator, int i, int j) { // int k = (i << 1); // if (k > j) // return; // while (k < j) { // if (comparator.rupare(data[indices[k]], data[indices[k + 1]]) < 0) // k++; // k <<= 1; // } // if (k > j) // k >>= 1; // while (comparator.rupare(data[indices[k]], data[indices[i]]) < 0) // k >>= 1; // int t1 = indices[i], t2; // while (k > i) { // t2 = indices[k]; // indices[k] = t1; // k >>= 1; // t1 = indices[k]; // indices[k] = t2; // k >>= 1; // } // if (k == i) // indices[i] = t1; // } // // /** // * Do a (clever) heapsort. // * // * @param comparator Comparator object specifying the sort order. // */ // public static void cheapSort(int[] indices, Object[] data, Comparator comparator) { // int n = data.length; // if (n > 1) { // int i; // int m = 0; // for (i = 1; i < n; i++) // if (comparator.rupare(data[indices[i]], data[indices[m]]) < 0) // m = i; // if (m > 0) { // int t = indices[0]; // indices[0] = indices[m]; // indices[m] = t; // } // if (n > 2) { // for (i = n / 2; i > 1; i--) // cheap(indices, data, comparator, i, n - 1); // for (i = n - 1; i > 1; i--) { // cheap(indices, data, comparator, 1, i); // int t = indices[1]; // indices[1] = indices[i]; // indices[i] = t; // } // } // } // } // // /** // * Perform a cheapsort // */ // public static int[] cheapSort(Object[] data, Comparator comparator) { // int[] indices = identity(data.length); // cheapSort(indices, data, comparator); // return indices; // }

 /**
  * Do a sort on indices.
  * @param data data to be sorted
  * @param comparator comparator to use
  * @param stable do a stable sort iff true
  * @param indices into data (any permutation of 0,..data.length-1).
  */
 public static void sort(int[] indices, Object[] data, Comparator comparator, boolean stable) {
   new QuickSorter(data).sort(indices, comparator, stable);
 }
 /**
  * Do a sort on indices.
  * @param data data to be sorted
  * @param comparator comparator to use
  * @param stable do a stable sort iff true
  * @return permutation p such that data[p[0]],..,data[p[data.length-1]] is in sorted order
  */
 public static int[] sort(Object[] data, Comparator comparator, boolean stable) {
   int[] indices = identity(data.length);
   sort(indices, data, comparator, stable);
   return indices;
 }
 /**
  * Do an unstable sort.
  * @param data data to be sorted
  * @param comparator comparator to use
  * @return permutation p such that data[p[0]],..,data[p[data.length-1]] is in sorted order
  */
 public static int[] sort(Object[] data, Comparator comparator) {
   return sort(data, comparator, false);
 }
 /**
  * Do an unstable sort.
  * @param data data to be sorted
  * @param indices into data (permutation of 0,..data.length-1).
  */
 public static void sort(int[] indices, Object[] data, Comparator comparator) {
   sort(indices, data, comparator, false);
 }
 /**
  * Test method
  */
 public static void main(String[] args) {
   Comparator cmp = new Comparator() {
     public int compare(Object o1, Object o2) {
       return ((Comparable)o1).rupareTo(o2);
     }
   };
   int n = 1000000;
   if (args.length == 1)
     try {
       n = Integer.parseInt(args[0]);
     } catch (Exception e) {
       System.err.println(e);
     }
   System.out.println("Generating " + n + " random integers...");
   java.util.Random random = new java.util.Random();
   Integer[] data = new Integer[n];
   for (int i = 0; i < n; i++) {
     data[i] = new Integer(Math.abs(random.nextInt()));

// data[i] = new Integer(i);

   }
   int[] indices;
   long time;
   System.out.print("Arrays.sort...");
   time = System.currentTimeMillis();
   Integer[] clone = (Integer[])data.clone();
   Arrays.sort(clone, cmp);
   System.out.println(System.currentTimeMillis()-time  + "ms");
   System.out.print("quicksort...");
   indices = identity(n);
   time = System.currentTimeMillis();
   sort(indices, data, cmp, false);
   System.out.println(System.currentTimeMillis()-time  + "ms");
   for (int i = 1; i < n; i++)
     if (cmp.rupare(data[indices[i-1]], data[indices[i]]) > 0)
       System.err.println("proplem: quickSort at " + i);
   System.out.print("quicksort stable...");

// indices = identity(n);

   time = System.currentTimeMillis();
   sort(indices, data, cmp, true);
   System.out.println(System.currentTimeMillis()-time + "ms");
   for (int i = 1; i < n; i++) {
     int res = cmp.rupare(data[indices[i-1]], data[indices[i]]);
     if (res > 0)
       System.err.println("proplem: quickSort stable at " + i);
     if (res == 0 && indices[i-1] > indices[i])
       System.err.println("proplem: quickSort stable (not stable) at " + i);
   }

// System.out.print("cheapsort..."); // time = System.currentTimeMillis(); // indices = cheapSort(data, cmp); // System.out.println(System.currentTimeMillis()-time + "ms"); // for (int i = 1; i < n; i++) // if (cmp.rupare(data[indices[i-1]], data[indices[i]]) > 0) // System.err.println("proplem: cheapSort at " + i);

   System.out.print("permutate copy...");
   time = System.currentTimeMillis();
   Object[] data_copy = permute(inverse(indices), data, true);
   System.out.println(System.currentTimeMillis()-time + "ms");
   for (int i = 1; i < n; i++)
     if (cmp.rupare(data_copy[i-1], data_copy[i]) > 0)
       System.err.println("proplem: permute copy at " + i);
   System.out.print("permutate original...");
   time = System.currentTimeMillis();
   permute(inverse(indices), data, false);
   System.out.println(System.currentTimeMillis()-time + "ms");
   for (int i = 1; i < n; i++)
     if (cmp.rupare(data[i-1], data[i]) > 0)
       System.err.println("proplem: permute original at " + i);
 }

}

 </source>
   
  
 
  

Sort array values in descending order

   <source lang="java">
    

import java.util.Arrays; import java.util.Collections; public class Main {

 public static void main(String[] args) {
   Integer[] points = new Integer[5];
   points[0] = 4;
   points[1] = 3;
   points[2] = 0;
   points[3] = 4;
   points[4] = 4;
   Arrays.sort(points);
   System.out.println(Arrays.toString(points));
   Arrays.sort(points, Collections.reverseOrder());
   System.out.println(Arrays.toString(points));
 }

} /*[0, 3, 4, 4, 4] [4, 4, 4, 3, 0]

• /

 </source>
   
  
 
  

Sorting an Array

   <source lang="java">
    

import java.util.Arrays; import java.util.Collections; public class Main {

 public static void main(String[] argv) throws Exception {
   int[] intArray = new int[] { 4, 1, 3, -23 };
   Arrays.sort(intArray);
   // [-23, 1, 3, 4]
   String[] strArray = new String[] { "z", "a", "C" };
   Arrays.sort(strArray);
   // [C, a, z]
   // Case-insensitive sort
   Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
   // [a, C, z]
   // Reverse-order sort
   Arrays.sort(strArray, Collections.reverseOrder());
   // [z, a, C]
   // Case-insensitive reverse-order sort
   Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
   Collections.reverse(Arrays.asList(strArray));
   // [z, C, a]
 }

}

 </source>
   
  
 
  

Sorting an Array in Descending (Reverse) Order

   <source lang="java">
    

import java.util.Arrays; import java.util.Collections; public class Main {

   public static void main(String[] args) {
       Integer[] arrayToSort = new Integer[] {
           new Integer(5),
           new Integer(89),
           new Integer(16),
           new Integer(2)
       };
       
       Arrays.sort(arrayToSort, Collections.reverseOrder());
       
       for (Integer i : arrayToSort) {
           System.out.println(i.intValue());
       }
   }

} /*89 16 5 2

• /

 </source>
   
  
 
  

Sort in reverse order

   <source lang="java">
    

import java.util.Arrays; import java.util.Collections; public class Main {

 public static void main(String args[]) {
   String[] myArray = new String[] { "A", "a", "B" };
   Arrays.sort (myArray, Collections.reverseOrder());
   System.out.println(Arrays.toString(myArray));
 }

} //[a, B, A]

 </source>