001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portal.kernel.util;
016    
017    import com.liferay.portal.kernel.json.JSONArray;
018    
019    import java.lang.reflect.Array;
020    
021    import java.text.DateFormat;
022    
023    import java.util.ArrayList;
024    import java.util.Comparator;
025    import java.util.Date;
026    import java.util.List;
027    import java.util.Set;
028    import java.util.TreeSet;
029    
030    /**
031     * @author Brian Wing Shun Chan
032     */
033    public class ArrayUtil {
034    
035            public static boolean[] append(boolean[]... arrays) {
036                    int length = 0;
037    
038                    for (boolean[] array : arrays) {
039                            length += array.length;
040                    }
041    
042                    boolean[] newArray = new boolean[length];
043    
044                    int previousLength = 0;
045    
046                    for (boolean[] array : arrays) {
047                            System.arraycopy(array, 0, newArray, previousLength, array.length);
048    
049                            previousLength += array.length;
050                    }
051    
052                    return newArray;
053            }
054    
055            public static boolean[] append(boolean[] array, boolean value) {
056                    boolean[] newArray = new boolean[array.length + 1];
057    
058                    System.arraycopy(array, 0, newArray, 0, array.length);
059    
060                    newArray[newArray.length - 1] = value;
061    
062                    return newArray;
063            }
064    
065            public static byte[] append(byte[]... arrays) {
066                    int length = 0;
067    
068                    for (byte[] array : arrays) {
069                            length += array.length;
070                    }
071    
072                    byte[] newArray = new byte[length];
073    
074                    int previousLength = 0;
075    
076                    for (byte[] array : arrays) {
077                            System.arraycopy(array, 0, newArray, previousLength, array.length);
078    
079                            previousLength += array.length;
080                    }
081    
082                    return newArray;
083            }
084    
085            public static byte[] append(byte[] array, byte value) {
086                    byte[] newArray = new byte[array.length + 1];
087    
088                    System.arraycopy(array, 0, newArray, 0, array.length);
089    
090                    newArray[newArray.length - 1] = value;
091    
092                    return newArray;
093            }
094    
095            public static char[] append(char[]... arrays) {
096                    int length = 0;
097    
098                    for (char[] array : arrays) {
099                            length += array.length;
100                    }
101    
102                    char[] newArray = new char[length];
103    
104                    int previousLength = 0;
105    
106                    for (char[] array : arrays) {
107                            System.arraycopy(array, 0, newArray, previousLength, array.length);
108    
109                            previousLength += array.length;
110                    }
111    
112                    return newArray;
113            }
114    
115            public static char[] append(char[] array, char value) {
116                    char[] newArray = new char[array.length + 1];
117    
118                    System.arraycopy(array, 0, newArray, 0, array.length);
119    
120                    newArray[newArray.length - 1] = value;
121    
122                    return newArray;
123            }
124    
125            public static double[] append(double[]... arrays) {
126                    int length = 0;
127    
128                    for (double[] array : arrays) {
129                            length += array.length;
130                    }
131    
132                    double[] newArray = new double[length];
133    
134                    int previousLength = 0;
135    
136                    for (double[] array : arrays) {
137                            System.arraycopy(array, 0, newArray, previousLength, array.length);
138    
139                            previousLength += array.length;
140                    }
141    
142                    return newArray;
143            }
144    
145            public static double[] append(double[] array, double value) {
146                    double[] newArray = new double[array.length + 1];
147    
148                    System.arraycopy(array, 0, newArray, 0, array.length);
149    
150                    newArray[newArray.length - 1] = value;
151    
152                    return newArray;
153            }
154    
155            public static float[] append(float[]... arrays) {
156                    int length = 0;
157    
158                    for (float[] array : arrays) {
159                            length += array.length;
160                    }
161    
162                    float[] newArray = new float[length];
163    
164                    int previousLength = 0;
165    
166                    for (float[] array : arrays) {
167                            System.arraycopy(array, 0, newArray, previousLength, array.length);
168    
169                            previousLength += array.length;
170                    }
171    
172                    return newArray;
173            }
174    
175            public static float[] append(float[] array, float value) {
176                    float[] newArray = new float[array.length + 1];
177    
178                    System.arraycopy(array, 0, newArray, 0, array.length);
179    
180                    newArray[newArray.length - 1] = value;
181    
182                    return newArray;
183            }
184    
185            public static int[] append(int[]... arrays) {
186                    int length = 0;
187    
188                    for (int[] array : arrays) {
189                            length += array.length;
190                    }
191    
192                    int[] newArray = new int[length];
193    
194                    int previousLength = 0;
195    
196                    for (int[] array : arrays) {
197                            System.arraycopy(array, 0, newArray, previousLength, array.length);
198    
199                            previousLength += array.length;
200                    }
201    
202                    return newArray;
203            }
204    
205            public static int[] append(int[] array, int value) {
206                    int[] newArray = new int[array.length + 1];
207    
208                    System.arraycopy(array, 0, newArray, 0, array.length);
209    
210                    newArray[newArray.length - 1] = value;
211    
212                    return newArray;
213            }
214    
215            public static long[] append(long[]... arrays) {
216                    int length = 0;
217    
218                    for (long[] array : arrays) {
219                            length += array.length;
220                    }
221    
222                    long[] newArray = new long[length];
223    
224                    int previousLength = 0;
225    
226                    for (long[] array : arrays) {
227                            System.arraycopy(array, 0, newArray, previousLength, array.length);
228    
229                            previousLength += array.length;
230                    }
231    
232                    return newArray;
233            }
234    
235            public static long[] append(long[] array, long value) {
236                    long[] newArray = new long[array.length + 1];
237    
238                    System.arraycopy(array, 0, newArray, 0, array.length);
239    
240                    newArray[newArray.length - 1] = value;
241    
242                    return newArray;
243            }
244    
245            public static short[] append(short[]... arrays) {
246                    int length = 0;
247    
248                    for (short[] array : arrays) {
249                            length += array.length;
250                    }
251    
252                    short[] newArray = new short[length];
253    
254                    int previousLength = 0;
255    
256                    for (short[] array : arrays) {
257                            System.arraycopy(array, 0, newArray, previousLength, array.length);
258    
259                            previousLength += array.length;
260                    }
261    
262                    return newArray;
263            }
264    
265            public static short[] append(short[] array, short value) {
266                    short[] newArray = new short[array.length + 1];
267    
268                    System.arraycopy(array, 0, newArray, 0, array.length);
269    
270                    newArray[newArray.length - 1] = value;
271    
272                    return newArray;
273            }
274    
275            public static <T> T[] append(T[]... arrays) {
276                    int length = 0;
277    
278                    for (T[] array : arrays) {
279                            length += array.length;
280                    }
281    
282                    Class<?> arraysClass = arrays.getClass();
283    
284                    T[] newArray = (T[])Array.newInstance(
285                            arraysClass.getComponentType(), length);
286    
287                    int previousLength = 0;
288    
289                    for (T[] array : arrays) {
290                            System.arraycopy(array, 0, newArray, previousLength, array.length);
291    
292                            previousLength += array.length;
293                    }
294    
295                    return newArray;
296            }
297    
298            public static <T> T[] append(T[] array, T value) {
299                    Class<?> arrayClass = array.getClass();
300    
301                    T[] newArray = (T[])Array.newInstance(
302                            arrayClass.getComponentType(), array.length + 1);
303    
304                    System.arraycopy(array, 0, newArray, 0, array.length);
305    
306                    newArray[array.length] = value;
307    
308                    return newArray;
309            }
310    
311            public static <T> T[] append(T[] array1, T[] array2) {
312                    Class<?> array1Class = array1.getClass();
313    
314                    T[] newArray = (T[])Array.newInstance(
315                            array1Class.getComponentType(), array1.length + array2.length);
316    
317                    System.arraycopy(array1, 0, newArray, 0, array1.length);
318    
319                    System.arraycopy(array2, 0, newArray, array1.length, array2.length);
320    
321                    return newArray;
322            }
323    
324            public static <T> T[][] append(T[][] array1, T[] value) {
325                    Class<?> array1Class = array1.getClass();
326    
327                    T[][] newArray = (T[][])Array.newInstance(
328                            array1Class.getComponentType(), array1.length + 1);
329    
330                    System.arraycopy(array1, 0, newArray, 0, array1.length);
331    
332                    newArray[array1.length] = value;
333    
334                    return newArray;
335            }
336    
337            public static <T> T[][] append(T[][] array1, T[][] array2) {
338                    Class<?> array1Class = array1.getClass();
339    
340                    T[][] newArray = (T[][])Array.newInstance(
341                            array1Class.getComponentType(), array1.length + array2.length);
342    
343                    System.arraycopy(array1, 0, newArray, 0, array1.length);
344                    System.arraycopy(array2, 0, newArray, array1.length, array2.length);
345    
346                    return newArray;
347            }
348    
349            public static boolean[] clone(boolean[] array) {
350                    boolean[] newArray = new boolean[array.length];
351    
352                    System.arraycopy(array, 0, newArray, 0, array.length);
353    
354                    return newArray;
355            }
356    
357            public static byte[] clone(byte[] array) {
358                    byte[] newArray = new byte[array.length];
359    
360                    System.arraycopy(array, 0, newArray, 0, array.length);
361    
362                    return newArray;
363            }
364    
365            public static char[] clone(char[] array) {
366                    char[] newArray = new char[array.length];
367    
368                    System.arraycopy(array, 0, newArray, 0, array.length);
369    
370                    return newArray;
371            }
372    
373            public static double[] clone(double[] array) {
374                    double[] newArray = new double[array.length];
375    
376                    System.arraycopy(array, 0, newArray, 0, array.length);
377    
378                    return newArray;
379            }
380    
381            public static float[] clone(float[] array) {
382                    float[] newArray = new float[array.length];
383    
384                    System.arraycopy(array, 0, newArray, 0, array.length);
385    
386                    return newArray;
387            }
388    
389            public static int[] clone(int[] array) {
390                    int[] newArray = new int[array.length];
391    
392                    System.arraycopy(array, 0, newArray, 0, array.length);
393    
394                    return newArray;
395            }
396    
397            public static long[] clone(long[] array) {
398                    long[] newArray = new long[array.length];
399    
400                    System.arraycopy(array, 0, newArray, 0, array.length);
401    
402                    return newArray;
403            }
404    
405            public static short[] clone(short[] array) {
406                    short[] newArray = new short[array.length];
407    
408                    System.arraycopy(array, 0, newArray, 0, array.length);
409    
410                    return newArray;
411            }
412    
413            public static <T> T[] clone(T[] array) {
414                    Class<?> arrayClass = array.getClass();
415    
416                    T[] newArray = (T[])Array.newInstance(
417                            arrayClass.getComponentType(), array.length);
418    
419                    System.arraycopy(array, 0, newArray, 0, array.length);
420    
421                    return newArray;
422            }
423    
424            public static <T> T[][] clone(T[][] array) {
425                    Class<?> arrayClass = array.getClass();
426    
427                    T[][] newArray = (T[][])Array.newInstance(
428                            arrayClass.getComponentType(), array.length);
429    
430                    System.arraycopy(array, 0, newArray, 0, array.length);
431    
432                    return newArray;
433            }
434    
435            public static void combine(
436                    Object[] array1, Object[] array2, Object[] combinedArray) {
437    
438                    System.arraycopy(array1, 0, combinedArray, 0, array1.length);
439    
440                    System.arraycopy(
441                            array2, 0, combinedArray, array1.length, array2.length);
442            }
443    
444            public static boolean contains(boolean[] array, boolean value) {
445                    if ((array == null) || (array.length == 0)) {
446                            return false;
447                    }
448    
449                    for (int i = 0; i < array.length; i++) {
450                            if (value == array[i]) {
451                                    return true;
452                            }
453                    }
454    
455                    return false;
456            }
457    
458            public static boolean contains(byte[] array, byte value) {
459                    if ((array == null) || (array.length == 0)) {
460                            return false;
461                    }
462    
463                    for (int i = 0; i < array.length; i++) {
464                            if (value == array[i]) {
465                                    return true;
466                            }
467                    }
468    
469                    return false;
470            }
471    
472            public static boolean contains(char[] array, char value) {
473                    if ((array == null) || (array.length == 0)) {
474                            return false;
475                    }
476    
477                    for (int i = 0; i < array.length; i++) {
478                            if (value == array[i]) {
479                                    return true;
480                            }
481                    }
482    
483                    return false;
484            }
485    
486            public static boolean contains(double[] array, double value) {
487                    if ((array == null) || (array.length == 0)) {
488                            return false;
489                    }
490    
491                    for (int i = 0; i < array.length; i++) {
492                            if (value == array[i]) {
493                                    return true;
494                            }
495                    }
496    
497                    return false;
498            }
499    
500            public static boolean contains(float[] array, float value) {
501                    if ((array == null) || (array.length == 0)) {
502                            return false;
503                    }
504    
505                    for (int i = 0; i < array.length; i++) {
506                            if (value == array[i]) {
507                                    return true;
508                            }
509                    }
510    
511                    return false;
512            }
513    
514            public static boolean contains(int[] array, int value) {
515                    if ((array == null) || (array.length == 0)) {
516                            return false;
517                    }
518    
519                    for (int i = 0; i < array.length; i++) {
520                            if (value == array[i]) {
521                                    return true;
522                            }
523                    }
524    
525                    return false;
526            }
527    
528            public static boolean contains(long[] array, long value) {
529                    if ((array == null) || (array.length == 0)) {
530                            return false;
531                    }
532    
533                    for (int i = 0; i < array.length; i++) {
534                            if (value == array[i]) {
535                                    return true;
536                            }
537                    }
538    
539                    return false;
540            }
541    
542            public static boolean contains(Object[] array, Object value) {
543                    if ((array == null) || (array.length == 0) || (value == null)) {
544                            return false;
545                    }
546    
547                    for (int i = 0; i < array.length; i++) {
548                            if (value.equals(array[i])) {
549                                    return true;
550                            }
551                    }
552    
553                    return false;
554            }
555    
556            public static boolean contains(short[] array, short value) {
557                    if ((array == null) || (array.length == 0)) {
558                            return false;
559                    }
560    
561                    for (int i = 0; i < array.length; i++) {
562                            if (value == array[i]) {
563                                    return true;
564                            }
565                    }
566    
567                    return false;
568            }
569    
570            public static String[] distinct(String[] array) {
571                    return distinct(array, null);
572            }
573    
574            public static String[] distinct(
575                    String[] array, Comparator<String> comparator) {
576    
577                    if ((array == null) || (array.length == 0)) {
578                            return array;
579                    }
580    
581                    Set<String> set = null;
582    
583                    if (comparator == null) {
584                            set = new TreeSet<String>();
585                    }
586                    else {
587                            set = new TreeSet<String>(comparator);
588                    }
589    
590                    for (int i = 0; i < array.length; i++) {
591                            String s = array[i];
592    
593                            if (!set.contains(s)) {
594                                    set.add(s);
595                            }
596                    }
597    
598                    return set.toArray(new String[set.size()]);
599            }
600    
601            public static int getLength(Object[] array) {
602                    if (array == null) {
603                            return 0;
604                    }
605                    else {
606                            return array.length;
607                    }
608            }
609    
610            public static Object getValue(Object[] array, int pos) {
611                    if ((array == null) || (array.length <= pos)) {
612                            return null;
613                    }
614                    else {
615                            return array[pos];
616                    }
617            }
618    
619            public static boolean[] remove(boolean[] array, boolean value) {
620                    List<Boolean> list = new ArrayList<Boolean>();
621    
622                    for (int i = 0; i < array.length; i++) {
623                            if (value != array[i]) {
624                                    list.add(new Boolean(array[i]));
625                            }
626                    }
627    
628                    return toArray(list.toArray(new Boolean[list.size()]));
629            }
630    
631            public static byte[] remove(byte[] array, byte value) {
632                    List<Byte> list = new ArrayList<Byte>();
633    
634                    for (int i = 0; i < array.length; i++) {
635                            if (value != array[i]) {
636                                    list.add(new Byte(array[i]));
637                            }
638                    }
639    
640                    return toArray(list.toArray(new Byte[list.size()]));
641            }
642    
643            public static char[] remove(char[] array, char value) {
644                    List<Character> list = new ArrayList<Character>();
645    
646                    for (int i = 0; i < array.length; i++) {
647                            if (value != array[i]) {
648                                    list.add(new Character(array[i]));
649                            }
650                    }
651    
652                    return toArray(list.toArray(new Character[list.size()]));
653            }
654    
655            public static double[] remove(double[] array, double value) {
656                    List<Double> list = new ArrayList<Double>();
657    
658                    for (int i = 0; i < array.length; i++) {
659                            if (value != array[i]) {
660                                    list.add(new Double(array[i]));
661                            }
662                    }
663    
664                    return toArray(list.toArray(new Double[list.size()]));
665            }
666    
667            public static int[] remove(int[] array, int value) {
668                    List<Integer> list = new ArrayList<Integer>();
669    
670                    for (int i = 0; i < array.length; i++) {
671                            if (value != array[i]) {
672                                    list.add(new Integer(array[i]));
673                            }
674                    }
675    
676                    return toArray(list.toArray(new Integer[list.size()]));
677            }
678    
679            public static long[] remove(long[] array, long value) {
680                    List<Long> list = new ArrayList<Long>();
681    
682                    for (int i = 0; i < array.length; i++) {
683                            if (value != array[i]) {
684                                    list.add(new Long(array[i]));
685                            }
686                    }
687    
688                    return toArray(list.toArray(new Long[list.size()]));
689            }
690    
691            public static short[] remove(short[] array, short value) {
692                    List<Short> list = new ArrayList<Short>();
693    
694                    for (int i = 0; i < array.length; i++) {
695                            if (value != array[i]) {
696                                    list.add(new Short(array[i]));
697                            }
698                    }
699    
700                    return toArray(list.toArray(new Short[list.size()]));
701            }
702    
703            public static String[] remove(String[] array, String value) {
704                    List<String> list = new ArrayList<String>();
705    
706                    for (String s : array) {
707                            if (!s.equals(value)) {
708                                    list.add(s);
709                            }
710                    }
711    
712                    return list.toArray(new String[list.size()]);
713            }
714    
715            public static String[] removeByPrefix(String[] array, String prefix) {
716                    List<String> list = new ArrayList<String>();
717    
718                    for (String s : array) {
719                            if (!s.startsWith(prefix)) {
720                                    list.add(s);
721                            }
722                    }
723    
724                    return list.toArray(new String[list.size()]);
725            }
726    
727            public static void reverse(String[] array) {
728                    for (int left = 0, right = array.length - 1; left < right;
729                                    left++, right--) {
730    
731                            String value = array[left];
732    
733                            array[left] = array[right];
734                            array[right] = value;
735                    }
736            }
737    
738            public static boolean[] subset(boolean[] array, int start, int end) {
739                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
740                            return array;
741                    }
742    
743                    boolean[] newArray = new boolean[end - start];
744    
745                    System.arraycopy(array, start, newArray, 0, end - start);
746    
747                    return newArray;
748            }
749    
750            public static byte[] subset(byte[] array, int start, int end) {
751                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
752                            return array;
753                    }
754    
755                    byte[] newArray = new byte[end - start];
756    
757                    System.arraycopy(array, start, newArray, 0, end - start);
758    
759                    return newArray;
760            }
761    
762            public static char[] subset(char[] array, int start, int end) {
763                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
764                            return array;
765                    }
766    
767                    char[] newArray = new char[end - start];
768    
769                    System.arraycopy(array, start, newArray, 0, end - start);
770    
771                    return newArray;
772            }
773    
774            public static double[] subset(double[] array, int start, int end) {
775                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
776                            return array;
777                    }
778    
779                    double[] newArray = new double[end - start];
780    
781                    System.arraycopy(array, start, newArray, 0, end - start);
782    
783                    return newArray;
784            }
785    
786            public static float[] subset(float[] array, int start, int end) {
787                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
788                            return array;
789                    }
790    
791                    float[] newArray = new float[end - start];
792    
793                    System.arraycopy(array, start, newArray, 0, end - start);
794    
795                    return newArray;
796            }
797    
798            public static int[] subset(int[] array, int start, int end) {
799                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
800                            return array;
801                    }
802    
803                    int[] newArray = new int[end - start];
804    
805                    System.arraycopy(array, start, newArray, 0, end - start);
806    
807                    return newArray;
808            }
809    
810            public static long[] subset(long[] array, int start, int end) {
811                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
812                            return array;
813                    }
814    
815                    long[] newArray = new long[end - start];
816    
817                    System.arraycopy(array, start, newArray, 0, end - start);
818    
819                    return newArray;
820            }
821    
822            public static short[] subset(short[] array, int start, int end) {
823                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
824                            return array;
825                    }
826    
827                    short[] newArray = new short[end - start];
828    
829                    System.arraycopy(array, start, newArray, 0, end - start);
830    
831                    return newArray;
832            }
833    
834            public static <T> T[] subset(T[] array, int start, int end) {
835                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
836                            return array;
837                    }
838    
839                    Class<?> arrayClass = array.getClass();
840    
841                    T[] newArray = (T[])Array.newInstance(
842                            arrayClass.getComponentType(), end - start);
843    
844                    System.arraycopy(array, start, newArray, 0, end - start);
845    
846                    return newArray;
847            }
848    
849            public static Boolean[] toArray(boolean[] array) {
850                    Boolean[] newArray = new Boolean[array.length];
851    
852                    for (int i = 0; i < array.length; i++) {
853                            newArray[i] = Boolean.valueOf(array[i]);
854                    }
855    
856                    return newArray;
857            }
858    
859            public static boolean[] toArray(Boolean[] array) {
860                    boolean[] newArray = new boolean[array.length];
861    
862                    for (int i = 0; i < array.length; i++) {
863                            newArray[i] = array[i].booleanValue();
864                    }
865    
866                    return newArray;
867            }
868    
869            public static Byte[] toArray(byte[] array) {
870                    Byte[] newArray = new Byte[array.length];
871    
872                    for (int i = 0; i < array.length; i++) {
873                            newArray[i] = Byte.valueOf(array[i]);
874                    }
875    
876                    return newArray;
877            }
878    
879            public static byte[] toArray(Byte[] array) {
880                    byte[] newArray = new byte[array.length];
881    
882                    for (int i = 0; i < array.length; i++) {
883                            newArray[i] = array[i].byteValue();
884                    }
885    
886                    return newArray;
887            }
888    
889            public static Character[] toArray(char[] array) {
890                    Character[] newArray = new Character[array.length];
891    
892                    for (int i = 0; i < array.length; i++) {
893                            newArray[i] = Character.valueOf(array[i]);
894                    }
895    
896                    return newArray;
897            }
898    
899            public static char[] toArray(Character[] array) {
900                    char[] newArray = new char[array.length];
901    
902                    for (int i = 0; i < array.length; i++) {
903                            newArray[i] = array[i].charValue();
904                    }
905    
906                    return newArray;
907            }
908    
909            public static Double[] toArray(double[] array) {
910                    Double[] newArray = new Double[array.length];
911    
912                    for (int i = 0; i < array.length; i++) {
913                            newArray[i] = new Double(array[i]);
914                    }
915    
916                    return newArray;
917            }
918    
919            public static double[] toArray(Double[] array) {
920                    double[] newArray = new double[array.length];
921    
922                    for (int i = 0; i < array.length; i++) {
923                            newArray[i] = array[i].doubleValue();
924                    }
925    
926                    return newArray;
927            }
928    
929            public static Float[] toArray(float[] array) {
930                    Float[] newArray = new Float[array.length];
931    
932                    for (int i = 0; i < array.length; i++) {
933                            newArray[i] = new Float(array[i]);
934                    }
935    
936                    return newArray;
937            }
938    
939            public static float[] toArray(Float[] array) {
940                    float[] newArray = new float[array.length];
941    
942                    for (int i = 0; i < array.length; i++) {
943                            newArray[i] = array[i].floatValue();
944                    }
945    
946                    return newArray;
947            }
948    
949            public static Integer[] toArray(int[] array) {
950                    Integer[] newArray = new Integer[array.length];
951    
952                    for (int i = 0; i < array.length; i++) {
953                            newArray[i] = new Integer(array[i]);
954                    }
955    
956                    return newArray;
957            }
958    
959            public static int[] toArray(Integer[] array) {
960                    int[] newArray = new int[array.length];
961    
962                    for (int i = 0; i < array.length; i++) {
963                            newArray[i] = array[i].intValue();
964                    }
965    
966                    return newArray;
967            }
968    
969            public static Long[] toArray(long[] array) {
970                    Long[] newArray = new Long[array.length];
971    
972                    for (int i = 0; i < array.length; i++) {
973                            newArray[i] = new Long(array[i]);
974                    }
975    
976                    return newArray;
977            }
978    
979            public static long[] toArray(Long[] array) {
980                    long[] newArray = new long[array.length];
981    
982                    for (int i = 0; i < array.length; i++) {
983                            newArray[i] = array[i].longValue();
984                    }
985    
986                    return newArray;
987            }
988    
989            public static Short[] toArray(short[] array) {
990                    Short[] newArray = new Short[array.length];
991    
992                    for (int i = 0; i < array.length; i++) {
993                            newArray[i] = new Short(array[i]);
994                    }
995    
996                    return newArray;
997            }
998    
999            public static short[] toArray(Short[] array) {
1000                    short[] newArray = new short[array.length];
1001    
1002                    for (int i = 0; i < array.length; i++) {
1003                            newArray[i] = array[i].shortValue();
1004                    }
1005    
1006                    return newArray;
1007            }
1008    
1009            public static Long[] toLongArray(Object[] array) {
1010                    Long[] newArray = new Long[array.length];
1011    
1012                    for (int i = 0; i < array.length; i++) {
1013                            newArray[i] = (Long)array[i];
1014                    }
1015    
1016                    return newArray;
1017            }
1018    
1019            public static String[] toStringArray(boolean[] array) {
1020                    String[] newArray = new String[array.length];
1021    
1022                    for (int i = 0; i < array.length; i++) {
1023                            newArray[i] = String.valueOf(array[i]);
1024                    }
1025    
1026                    return newArray;
1027            }
1028    
1029            public static String[] toStringArray(byte[] array) {
1030                    String[] newArray = new String[array.length];
1031    
1032                    for (int i = 0; i < array.length; i++) {
1033                            newArray[i] = String.valueOf(array[i]);
1034                    }
1035    
1036                    return newArray;
1037            }
1038    
1039            public static String[] toStringArray(char[] array) {
1040                    String[] newArray = new String[array.length];
1041    
1042                    for (int i = 0; i < array.length; i++) {
1043                            newArray[i] = String.valueOf(array[i]);
1044                    }
1045    
1046                    return newArray;
1047            }
1048    
1049            public static String[] toStringArray(Date[] array, DateFormat df) {
1050                    String[] newArray = new String[array.length];
1051    
1052                    for (int i = 0; i < array.length; i++) {
1053                            newArray[i] = df.format(array[i]);
1054                    }
1055    
1056                    return newArray;
1057            }
1058    
1059            public static String[] toStringArray(double[] array) {
1060                    String[] newArray = new String[array.length];
1061    
1062                    for (int i = 0; i < array.length; i++) {
1063                            newArray[i] = String.valueOf(array[i]);
1064                    }
1065    
1066                    return newArray;
1067            }
1068    
1069            public static String[] toStringArray(float[] array) {
1070                    String[] newArray = new String[array.length];
1071    
1072                    for (int i = 0; i < array.length; i++) {
1073                            newArray[i] = String.valueOf(array[i]);
1074                    }
1075    
1076                    return newArray;
1077            }
1078    
1079            public static String[] toStringArray(int[] array) {
1080                    String[] newArray = new String[array.length];
1081    
1082                    for (int i = 0; i < array.length; i++) {
1083                            newArray[i] = String.valueOf(array[i]);
1084                    }
1085    
1086                    return newArray;
1087            }
1088    
1089            public static String[] toStringArray(JSONArray array) {
1090                    String[] newArray = new String[array.length()];
1091    
1092                    for (int i = 0; i < array.length(); i++) {
1093                            newArray[i] = array.getString(i);
1094                    }
1095    
1096                    return newArray;
1097            }
1098    
1099            public static String[] toStringArray(long[] array) {
1100                    String[] newArray = new String[array.length];
1101    
1102                    for (int i = 0; i < array.length; i++) {
1103                            newArray[i] = String.valueOf(array[i]);
1104                    }
1105    
1106                    return newArray;
1107            }
1108    
1109            public static String[] toStringArray(Object[] array) {
1110                    String[] newArray = new String[array.length];
1111    
1112                    for (int i = 0; i < array.length; i++) {
1113                            newArray[i] = String.valueOf(array[i]);
1114                    }
1115    
1116                    return newArray;
1117            }
1118    
1119            public static String[] toStringArray(short[] array) {
1120                    String[] newArray = new String[array.length];
1121    
1122                    for (int i = 0; i < array.length; i++) {
1123                            newArray[i] = String.valueOf(array[i]);
1124                    }
1125    
1126                    return newArray;
1127            }
1128    
1129    }