001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
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                    else {
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    
459            public static boolean contains(byte[] array, byte value) {
460                    if ((array == null) || (array.length == 0)) {
461                            return false;
462                    }
463                    else {
464                            for (int i = 0; i < array.length; i++) {
465                                    if (value == array[i]) {
466                                            return true;
467                                    }
468                            }
469    
470                            return false;
471                    }
472            }
473    
474            public static boolean contains(char[] array, char value) {
475                    if ((array == null) || (array.length == 0)) {
476                            return false;
477                    }
478                    else {
479                            for (int i = 0; i < array.length; i++) {
480                                    if (value == array[i]) {
481                                            return true;
482                                    }
483                            }
484    
485                            return false;
486                    }
487            }
488    
489            public static boolean contains(double[] array, double value) {
490                    if ((array == null) || (array.length == 0)) {
491                            return false;
492                    }
493                    else {
494                            for (int i = 0; i < array.length; i++) {
495                                    if (value == array[i]) {
496                                            return true;
497                                    }
498                            }
499    
500                            return false;
501                    }
502            }
503    
504            public static boolean contains(float[] array, float value) {
505                    if ((array == null) || (array.length == 0)) {
506                            return false;
507                    }
508                    else {
509                            for (int i = 0; i < array.length; i++) {
510                                    if (value == array[i]) {
511                                            return true;
512                                    }
513                            }
514    
515                            return false;
516                    }
517            }
518    
519            public static boolean contains(int[] array, int value) {
520                    if ((array == null) || (array.length == 0)) {
521                            return false;
522                    }
523                    else {
524                            for (int i = 0; i < array.length; i++) {
525                                    if (value == array[i]) {
526                                            return true;
527                                    }
528                            }
529    
530                            return false;
531                    }
532            }
533    
534            public static boolean contains(long[] array, long value) {
535                    if ((array == null) || (array.length == 0)) {
536                            return false;
537                    }
538                    else {
539                            for (int i = 0; i < array.length; i++) {
540                                    if (value == array[i]) {
541                                            return true;
542                                    }
543                            }
544    
545                            return false;
546                    }
547            }
548    
549            public static boolean contains(Object[] array, Object value) {
550                    if ((array == null) || (array.length == 0) || (value == null)) {
551                            return false;
552                    }
553                    else {
554                            for (int i = 0; i < array.length; i++) {
555                                    if (value.equals(array[i])) {
556                                            return true;
557                                    }
558                            }
559    
560                            return false;
561                    }
562            }
563    
564            public static boolean contains(short[] array, short value) {
565                    if ((array == null) || (array.length == 0)) {
566                            return false;
567                    }
568                    else {
569                            for (int i = 0; i < array.length; i++) {
570                                    if (value == array[i]) {
571                                            return true;
572                                    }
573                            }
574    
575                            return false;
576                    }
577            }
578    
579            public static String[] distinct(String[] array) {
580                    return distinct(array, null);
581            }
582    
583            public static String[] distinct(
584                    String[] array, Comparator<String> comparator) {
585    
586                    if ((array == null) || (array.length == 0)) {
587                            return array;
588                    }
589    
590                    Set<String> set = null;
591    
592                    if (comparator == null) {
593                            set = new TreeSet<String>();
594                    }
595                    else {
596                            set = new TreeSet<String>(comparator);
597                    }
598    
599                    for (int i = 0; i < array.length; i++) {
600                            String s = array[i];
601    
602                            if (!set.contains(s)) {
603                                    set.add(s);
604                            }
605                    }
606    
607                    return set.toArray(new String[set.size()]);
608            }
609    
610            public static int getLength(Object[] array) {
611                    if (array == null) {
612                            return 0;
613                    }
614                    else {
615                            return array.length;
616                    }
617            }
618    
619            public static Object getValue(Object[] array, int pos) {
620                    if ((array == null) || (array.length <= pos)) {
621                            return null;
622                    }
623                    else {
624                            return array[pos];
625                    }
626            }
627    
628            public static boolean[] remove(boolean[] array, boolean value) {
629                    List<Boolean> list = new ArrayList<Boolean>();
630    
631                    for (int i = 0; i < array.length; i++) {
632                            if (value != array[i]) {
633                                    list.add(new Boolean(array[i]));
634                            }
635                    }
636    
637                    return toArray(list.toArray(new Boolean[list.size()]));
638            }
639    
640            public static byte[] remove(byte[] array, byte value) {
641                    List<Byte> list = new ArrayList<Byte>();
642    
643                    for (int i = 0; i < array.length; i++) {
644                            if (value != array[i]) {
645                                    list.add(new Byte(array[i]));
646                            }
647                    }
648    
649                    return toArray(list.toArray(new Byte[list.size()]));
650            }
651    
652            public static char[] remove(char[] array, char value) {
653                    List<Character> list = new ArrayList<Character>();
654    
655                    for (int i = 0; i < array.length; i++) {
656                            if (value != array[i]) {
657                                    list.add(new Character(array[i]));
658                            }
659                    }
660    
661                    return toArray(list.toArray(new Character[list.size()]));
662            }
663    
664            public static double[] remove(double[] array, double value) {
665                    List<Double> list = new ArrayList<Double>();
666    
667                    for (int i = 0; i < array.length; i++) {
668                            if (value != array[i]) {
669                                    list.add(new Double(array[i]));
670                            }
671                    }
672    
673                    return toArray(list.toArray(new Double[list.size()]));
674            }
675    
676            public static int[] remove(int[] array, int value) {
677                    List<Integer> list = new ArrayList<Integer>();
678    
679                    for (int i = 0; i < array.length; i++) {
680                            if (value != array[i]) {
681                                    list.add(new Integer(array[i]));
682                            }
683                    }
684    
685                    return toArray(list.toArray(new Integer[list.size()]));
686            }
687    
688            public static long[] remove(long[] array, long value) {
689                    List<Long> list = new ArrayList<Long>();
690    
691                    for (int i = 0; i < array.length; i++) {
692                            if (value != array[i]) {
693                                    list.add(new Long(array[i]));
694                            }
695                    }
696    
697                    return toArray(list.toArray(new Long[list.size()]));
698            }
699    
700            public static short[] remove(short[] array, short value) {
701                    List<Short> list = new ArrayList<Short>();
702    
703                    for (int i = 0; i < array.length; i++) {
704                            if (value != array[i]) {
705                                    list.add(new Short(array[i]));
706                            }
707                    }
708    
709                    return toArray(list.toArray(new Short[list.size()]));
710            }
711    
712            public static String[] remove(String[] array, String value) {
713                    List<String> list = new ArrayList<String>();
714    
715                    for (String s : array) {
716                            if (!s.equals(value)) {
717                                    list.add(s);
718                            }
719                    }
720    
721                    return list.toArray(new String[list.size()]);
722            }
723    
724            public static String[] removeByPrefix(String[] array, String prefix) {
725                    List<String> list = new ArrayList<String>();
726    
727                    for (String s : array) {
728                            if (!s.startsWith(prefix)) {
729                                    list.add(s);
730                            }
731                    }
732    
733                    return list.toArray(new String[list.size()]);
734            }
735    
736            public static void reverse(String[] array) {
737                    for (int left = 0, right = array.length - 1; left < right;
738                                    left++, right--) {
739    
740                            String value = array[left];
741    
742                            array[left] = array[right];
743                            array[right] = value;
744                    }
745            }
746    
747            public static boolean[] subset(boolean[] array, int start, int end) {
748                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
749                            return array;
750                    }
751    
752                    boolean[] newArray = new boolean[end - start];
753    
754                    System.arraycopy(array, start, newArray, 0, end - start);
755    
756                    return newArray;
757            }
758    
759            public static byte[] subset(byte[] array, int start, int end) {
760                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
761                            return array;
762                    }
763    
764                    byte[] newArray = new byte[end - start];
765    
766                    System.arraycopy(array, start, newArray, 0, end - start);
767    
768                    return newArray;
769            }
770    
771            public static char[] subset(char[] array, int start, int end) {
772                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
773                            return array;
774                    }
775    
776                    char[] newArray = new char[end - start];
777    
778                    System.arraycopy(array, start, newArray, 0, end - start);
779    
780                    return newArray;
781            }
782    
783            public static double[] subset(double[] array, int start, int end) {
784                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
785                            return array;
786                    }
787    
788                    double[] newArray = new double[end - start];
789    
790                    System.arraycopy(array, start, newArray, 0, end - start);
791    
792                    return newArray;
793            }
794    
795            public static float[] subset(float[] array, int start, int end) {
796                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
797                            return array;
798                    }
799    
800                    float[] newArray = new float[end - start];
801    
802                    System.arraycopy(array, start, newArray, 0, end - start);
803    
804                    return newArray;
805            }
806    
807            public static int[] subset(int[] array, int start, int end) {
808                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
809                            return array;
810                    }
811    
812                    int[] newArray = new int[end - start];
813    
814                    System.arraycopy(array, start, newArray, 0, end - start);
815    
816                    return newArray;
817            }
818    
819            public static long[] subset(long[] array, int start, int end) {
820                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
821                            return array;
822                    }
823    
824                    long[] newArray = new long[end - start];
825    
826                    System.arraycopy(array, start, newArray, 0, end - start);
827    
828                    return newArray;
829            }
830    
831            public static short[] subset(short[] array, int start, int end) {
832                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
833                            return array;
834                    }
835    
836                    short[] newArray = new short[end - start];
837    
838                    System.arraycopy(array, start, newArray, 0, end - start);
839    
840                    return newArray;
841            }
842    
843            public static <T> T[] subset(T[] array, int start, int end) {
844                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
845                            return array;
846                    }
847    
848                    Class<?> arrayClass = array.getClass();
849    
850                    T[] newArray = (T[])Array.newInstance(
851                            arrayClass.getComponentType(), end - start);
852    
853                    System.arraycopy(array, start, newArray, 0, end - start);
854    
855                    return newArray;
856            }
857    
858            public static Boolean[] toArray(boolean[] array) {
859                    Boolean[] newArray = new Boolean[array.length];
860    
861                    for (int i = 0; i < array.length; i++) {
862                            newArray[i] = Boolean.valueOf(array[i]);
863                    }
864    
865                    return newArray;
866            }
867    
868            public static boolean[] toArray(Boolean[] array) {
869                    boolean[] newArray = new boolean[array.length];
870    
871                    for (int i = 0; i < array.length; i++) {
872                            newArray[i] = array[i].booleanValue();
873                    }
874    
875                    return newArray;
876            }
877    
878            public static Byte[] toArray(byte[] array) {
879                    Byte[] newArray = new Byte[array.length];
880    
881                    for (int i = 0; i < array.length; i++) {
882                            newArray[i] = Byte.valueOf(array[i]);
883                    }
884    
885                    return newArray;
886            }
887    
888            public static byte[] toArray(Byte[] array) {
889                    byte[] newArray = new byte[array.length];
890    
891                    for (int i = 0; i < array.length; i++) {
892                            newArray[i] = array[i].byteValue();
893                    }
894    
895                    return newArray;
896            }
897    
898            public static Character[] toArray(char[] array) {
899                    Character[] newArray = new Character[array.length];
900    
901                    for (int i = 0; i < array.length; i++) {
902                            newArray[i] = Character.valueOf(array[i]);
903                    }
904    
905                    return newArray;
906            }
907    
908            public static char[] toArray(Character[] array) {
909                    char[] newArray = new char[array.length];
910    
911                    for (int i = 0; i < array.length; i++) {
912                            newArray[i] = array[i].charValue();
913                    }
914    
915                    return newArray;
916            }
917    
918            public static Double[] toArray(double[] array) {
919                    Double[] newArray = new Double[array.length];
920    
921                    for (int i = 0; i < array.length; i++) {
922                            newArray[i] = new Double(array[i]);
923                    }
924    
925                    return newArray;
926            }
927    
928            public static double[] toArray(Double[] array) {
929                    double[] newArray = new double[array.length];
930    
931                    for (int i = 0; i < array.length; i++) {
932                            newArray[i] = array[i].doubleValue();
933                    }
934    
935                    return newArray;
936            }
937    
938            public static Float[] toArray(float[] array) {
939                    Float[] newArray = new Float[array.length];
940    
941                    for (int i = 0; i < array.length; i++) {
942                            newArray[i] = new Float(array[i]);
943                    }
944    
945                    return newArray;
946            }
947    
948            public static float[] toArray(Float[] array) {
949                    float[] newArray = new float[array.length];
950    
951                    for (int i = 0; i < array.length; i++) {
952                            newArray[i] = array[i].floatValue();
953                    }
954    
955                    return newArray;
956            }
957    
958            public static Integer[] toArray(int[] array) {
959                    Integer[] newArray = new Integer[array.length];
960    
961                    for (int i = 0; i < array.length; i++) {
962                            newArray[i] = new Integer(array[i]);
963                    }
964    
965                    return newArray;
966            }
967    
968            public static int[] toArray(Integer[] array) {
969                    int[] newArray = new int[array.length];
970    
971                    for (int i = 0; i < array.length; i++) {
972                            newArray[i] = array[i].intValue();
973                    }
974    
975                    return newArray;
976            }
977    
978            public static Long[] toArray(long[] array) {
979                    Long[] newArray = new Long[array.length];
980    
981                    for (int i = 0; i < array.length; i++) {
982                            newArray[i] = new Long(array[i]);
983                    }
984    
985                    return newArray;
986            }
987    
988            public static long[] toArray(Long[] array) {
989                    long[] newArray = new long[array.length];
990    
991                    for (int i = 0; i < array.length; i++) {
992                            newArray[i] = array[i].longValue();
993                    }
994    
995                    return newArray;
996            }
997    
998            public static Short[] toArray(short[] array) {
999                    Short[] newArray = new Short[array.length];
1000    
1001                    for (int i = 0; i < array.length; i++) {
1002                            newArray[i] = new Short(array[i]);
1003                    }
1004    
1005                    return newArray;
1006            }
1007    
1008            public static short[] toArray(Short[] array) {
1009                    short[] newArray = new short[array.length];
1010    
1011                    for (int i = 0; i < array.length; i++) {
1012                            newArray[i] = array[i].shortValue();
1013                    }
1014    
1015                    return newArray;
1016            }
1017    
1018            public static Long[] toLongArray(Object[] array) {
1019                    Long[] newArray = new Long[array.length];
1020    
1021                    for (int i = 0; i < array.length; i++) {
1022                            newArray[i] = (Long)array[i];
1023                    }
1024    
1025                    return newArray;
1026            }
1027    
1028            public static String[] toStringArray(boolean[] array) {
1029                    String[] newArray = new String[array.length];
1030    
1031                    for (int i = 0; i < array.length; i++) {
1032                            newArray[i] = String.valueOf(array[i]);
1033                    }
1034    
1035                    return newArray;
1036            }
1037    
1038            public static String[] toStringArray(byte[] array) {
1039                    String[] newArray = new String[array.length];
1040    
1041                    for (int i = 0; i < array.length; i++) {
1042                            newArray[i] = String.valueOf(array[i]);
1043                    }
1044    
1045                    return newArray;
1046            }
1047    
1048            public static String[] toStringArray(char[] array) {
1049                    String[] newArray = new String[array.length];
1050    
1051                    for (int i = 0; i < array.length; i++) {
1052                            newArray[i] = String.valueOf(array[i]);
1053                    }
1054    
1055                    return newArray;
1056            }
1057    
1058            public static String[] toStringArray(Date[] array, DateFormat df) {
1059                    String[] newArray = new String[array.length];
1060    
1061                    for (int i = 0; i < array.length; i++) {
1062                            newArray[i] = df.format(array[i]);
1063                    }
1064    
1065                    return newArray;
1066            }
1067    
1068            public static String[] toStringArray(double[] array) {
1069                    String[] newArray = new String[array.length];
1070    
1071                    for (int i = 0; i < array.length; i++) {
1072                            newArray[i] = String.valueOf(array[i]);
1073                    }
1074    
1075                    return newArray;
1076            }
1077    
1078            public static String[] toStringArray(float[] array) {
1079                    String[] newArray = new String[array.length];
1080    
1081                    for (int i = 0; i < array.length; i++) {
1082                            newArray[i] = String.valueOf(array[i]);
1083                    }
1084    
1085                    return newArray;
1086            }
1087    
1088            public static String[] toStringArray(int[] array) {
1089                    String[] newArray = new String[array.length];
1090    
1091                    for (int i = 0; i < array.length; i++) {
1092                            newArray[i] = String.valueOf(array[i]);
1093                    }
1094    
1095                    return newArray;
1096            }
1097    
1098            public static String[] toStringArray(JSONArray array) {
1099                    String[] newArray = new String[array.length()];
1100    
1101                    for (int i = 0; i < array.length(); i++) {
1102                            newArray[i] = array.getString(i);
1103                    }
1104    
1105                    return newArray;
1106            }
1107    
1108            public static String[] toStringArray(long[] array) {
1109                    String[] newArray = new String[array.length];
1110    
1111                    for (int i = 0; i < array.length; i++) {
1112                            newArray[i] = String.valueOf(array[i]);
1113                    }
1114    
1115                    return newArray;
1116            }
1117    
1118            public static String[] toStringArray(Object[] array) {
1119                    String[] newArray = new String[array.length];
1120    
1121                    for (int i = 0; i < array.length; i++) {
1122                            newArray[i] = String.valueOf(array[i]);
1123                    }
1124    
1125                    return newArray;
1126            }
1127    
1128            public static String[] toStringArray(short[] array) {
1129                    String[] newArray = new String[array.length];
1130    
1131                    for (int i = 0; i < array.length; i++) {
1132                            newArray[i] = String.valueOf(array[i]);
1133                    }
1134    
1135                    return newArray;
1136            }
1137    
1138    }