commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From scolebou...@apache.org
Subject cvs commit: jakarta-commons/lang/src/test/org/apache/commons/lang ArrayUtilsTest.java
Date Sun, 24 Nov 2002 16:50:38 GMT
scolebourne    2002/11/24 08:50:38

  Modified:    lang/src/java/org/apache/commons/lang ArrayUtils.java
               lang/src/test/org/apache/commons/lang ArrayUtilsTest.java
  Log:
  Add reverse to ArrayUtils
  
  Revision  Changes    Path
  1.6       +210 -1    jakarta-commons/lang/src/java/org/apache/commons/lang/ArrayUtils.java
  
  Index: ArrayUtils.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/ArrayUtils.java,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- ArrayUtils.java	16 Nov 2002 12:56:43 -0000	1.5
  +++ ArrayUtils.java	24 Nov 2002 16:50:38 -0000	1.6
  @@ -679,4 +679,213 @@
           return array1.getClass().getName().equals(array2.getClass().getName());
       }
       
  +    /** 
  +     * Reverses the order of the given array.
  +     * <p>
  +     * There is no special handling for multi-dimensional arrays.
  +     * <p>
  +     * The method does nothing if <code>null</code> is passed in.
  +     * 
  +     * @param array  the array to reverse
  +     */
  +    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++;
  +        }
  +    }
  +
  +    /**
  +     * Reverses the order of the given array.
  +     * <p>
  +     * The method does nothing if <code>null</code> is passed in.
  +     * 
  +     * @param array  the array to reverse
  +     */
  +    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++;
  +        }
  +    }
  +
  +    /**
  +     * Reverses the order of the given array.
  +     * <p>
  +     * The method does nothing if <code>null</code> is passed in.
  +     * 
  +     * @param array  the array to reverse
  +     */
  +    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++;
  +        }
  +    }
  +
  +    /**
  +     * Reverses the order of the given array.
  +     * <p>
  +     * There is no special handling for multi-dimensional arrays.
  +     * 
  +     * @param array  the array to reverse
  +     */
  +    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++;
  +        }
  +    }
  +
  +    /**
  +     * Reverses the order of the given array.
  +     * <p>
  +     * The method does nothing if <code>null</code> is passed in.
  +     * 
  +     * @param array  the array to reverse
  +     */
  +    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++;
  +        }
  +    }
  +
  +    /**
  +     * Reverses the order of the given array.
  +     * <p>
  +     * The method does nothing if <code>null</code> is passed in.
  +     * 
  +     * @param array  the array to reverse
  +     */
  +    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++;
  +        }
  +    }
  +
  +    /**
  +     * Reverses the order of the given array.
  +     * <p>
  +     * The method does nothing if <code>null</code> is passed in.
  +     * 
  +     * @param array  the array to reverse
  +     */
  +    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++;
  +        }
  +    }
  +
  +    /**
  +     * Reverses the order of the given array.
  +     * <p>
  +     * The method does nothing if <code>null</code> is passed in.
  +     * 
  +     * @param array  the array to reverse
  +     */
  +    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++;
  +        }
  +    }
  +
  +    /**
  +     * Reverses the order of the given array.
  +     * <p>
  +     * The method does nothing if <code>null</code> is passed in.
  +     * 
  +     * @param array  the array to reverse
  +     */
  +    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++;
  +        }
  +    }
  +
   }
  
  
  
  1.3       +122 -1    jakarta-commons/lang/src/test/org/apache/commons/lang/ArrayUtilsTest.java
  
  Index: ArrayUtilsTest.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/lang/src/test/org/apache/commons/lang/ArrayUtilsTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- ArrayUtilsTest.java	16 Nov 2002 12:56:44 -0000	1.2
  +++ ArrayUtilsTest.java	24 Nov 2002 16:50:38 -0000	1.3
  @@ -517,4 +517,125 @@
           assertEquals(false, ArrayUtils.isSameType(new String[0][0], new String[0]));
       }
       
  +    //-----------------------------------------------------------------------
  +    public void testReverse() {
  +        StringBuffer str1 = new StringBuffer("pick");
  +        String str2 = "a";
  +        String[] str3 = new String[] {"stick"};
  +        String str4 = "up";
  +        
  +        Object[] array = new Object[] {str1, str2, str3};
  +        ArrayUtils.reverse(array);
  +        assertEquals(array[0], str3);
  +        assertEquals(array[1], str2);
  +        assertEquals(array[2], str1);
  +        
  +        array = new Object[] {str1, str2, str3, str4};
  +        ArrayUtils.reverse(array);
  +        assertEquals(array[0], str4);
  +        assertEquals(array[1], str3);
  +        assertEquals(array[2], str2);
  +        assertEquals(array[3], str1);
  +
  +        array = null;
  +        ArrayUtils.reverse(array);
  +        assertEquals(null, array);
  +    }
  +
  +    public void testReverseLong() {
  +        long[] array = new long[] {1L, 2L, 3L};
  +        ArrayUtils.reverse(array);
  +        assertEquals(array[0], 3L);
  +        assertEquals(array[1], 2L);
  +        assertEquals(array[2], 1L);
  +
  +        array = null;
  +        ArrayUtils.reverse(array);
  +        assertEquals(null, array);
  +    }
  +    
  +    public void testReverseInt() {
  +        int[] array = new int[] {1, 2, 3};
  +        ArrayUtils.reverse(array);
  +        assertEquals(array[0], 3);
  +        assertEquals(array[1], 2);
  +        assertEquals(array[2], 1);
  +
  +        array = null;
  +        ArrayUtils.reverse(array);
  +        assertEquals(null, array);
  +    }
  +    
  +    public void testReverseShort() {
  +        short[] array = new short[] {1, 2, 3};
  +        ArrayUtils.reverse(array);
  +        assertEquals(array[0], 3);
  +        assertEquals(array[1], 2);
  +        assertEquals(array[2], 1);
  +
  +        array = null;
  +        ArrayUtils.reverse(array);
  +        assertEquals(null, array);
  +    }
  +    
  +    public void testReverseChar() {
  +        char[] array = new char[] {'a', 'f', 'C'};
  +        ArrayUtils.reverse(array);
  +        assertEquals(array[0], 'C');
  +        assertEquals(array[1], 'f');
  +        assertEquals(array[2], 'a');
  +
  +        array = null;
  +        ArrayUtils.reverse(array);
  +        assertEquals(null, array);
  +    }
  +    
  +    public void testReverseByte() {
  +        byte[] array = new byte[] {2, 3, 4};
  +        ArrayUtils.reverse(array);
  +        assertEquals(array[0], 4);
  +        assertEquals(array[1], 3);
  +        assertEquals(array[2], 2);
  +
  +        array = null;
  +        ArrayUtils.reverse(array);
  +        assertEquals(null, array);
  +    }
  +    
  +    public void testReverseDouble() {
  +        double[] array = new double[] {0.3d, 0.4d, 0.5d};
  +        ArrayUtils.reverse(array);
  +        assertEquals(array[0], 0.5d, 0.0d);
  +        assertEquals(array[1], 0.4d, 0.0d);
  +        assertEquals(array[2], 0.3d, 0.0d);
  +
  +        array = null;
  +        ArrayUtils.reverse(array);
  +        assertEquals(null, array);
  +    }
  +    
  +    public void testReverseFloat() {
  +        float[] array = new float[] {0.3f, 0.4f, 0.5f};
  +        ArrayUtils.reverse(array);
  +        assertEquals(array[0], 0.5f, 0.0f);
  +        assertEquals(array[1], 0.4f, 0.0f);
  +        assertEquals(array[2], 0.3f, 0.0f);
  +
  +        array = null;
  +        ArrayUtils.reverse(array);
  +        assertEquals(null, array);
  +    }
  +    
  +    public void testReverseBoolean() {
  +        boolean[] array = new boolean[] {false, false, true};
  +        ArrayUtils.reverse(array);
  +        assertEquals(array[0], true);
  +        assertEquals(array[1], false);
  +        assertEquals(array[2], false);
  +
  +        array = null;
  +        ArrayUtils.reverse(array);
  +        assertEquals(null, array);
  +    }
  +    
   }
  
  
  

--
To unsubscribe, e-mail:   <mailto:commons-dev-unsubscribe@jakarta.apache.org>
For additional commands, e-mail: <mailto:commons-dev-help@jakarta.apache.org>


Mime
View raw message