001    /**
002     * Copyright (c) 2000-2013 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.bean.BeanPropertiesUtil;
018    import com.liferay.portal.kernel.json.JSONArray;
019    import com.liferay.portal.kernel.language.LanguageUtil;
020    
021    import java.lang.reflect.Array;
022    
023    import java.text.DateFormat;
024    
025    import java.util.ArrayList;
026    import java.util.Arrays;
027    import java.util.Collection;
028    import java.util.Comparator;
029    import java.util.Date;
030    import java.util.Iterator;
031    import java.util.List;
032    import java.util.Locale;
033    import java.util.Set;
034    import java.util.TreeSet;
035    
036    /**
037     * @author Brian Wing Shun Chan
038     */
039    public class ArrayUtil {
040    
041            public static boolean[] append(boolean[]... arrays) {
042                    int length = 0;
043    
044                    for (boolean[] array : arrays) {
045                            length += array.length;
046                    }
047    
048                    boolean[] newArray = new boolean[length];
049    
050                    int previousLength = 0;
051    
052                    for (boolean[] array : arrays) {
053                            System.arraycopy(array, 0, newArray, previousLength, array.length);
054    
055                            previousLength += array.length;
056                    }
057    
058                    return newArray;
059            }
060    
061            public static boolean[] append(boolean[] array, boolean value) {
062                    boolean[] newArray = new boolean[array.length + 1];
063    
064                    System.arraycopy(array, 0, newArray, 0, array.length);
065    
066                    newArray[newArray.length - 1] = value;
067    
068                    return newArray;
069            }
070    
071            public static byte[] append(byte[]... arrays) {
072                    int length = 0;
073    
074                    for (byte[] array : arrays) {
075                            length += array.length;
076                    }
077    
078                    byte[] newArray = new byte[length];
079    
080                    int previousLength = 0;
081    
082                    for (byte[] array : arrays) {
083                            System.arraycopy(array, 0, newArray, previousLength, array.length);
084    
085                            previousLength += array.length;
086                    }
087    
088                    return newArray;
089            }
090    
091            public static byte[] append(byte[] array, byte value) {
092                    byte[] newArray = new byte[array.length + 1];
093    
094                    System.arraycopy(array, 0, newArray, 0, array.length);
095    
096                    newArray[newArray.length - 1] = value;
097    
098                    return newArray;
099            }
100    
101            public static char[] append(char[]... arrays) {
102                    int length = 0;
103    
104                    for (char[] array : arrays) {
105                            length += array.length;
106                    }
107    
108                    char[] newArray = new char[length];
109    
110                    int previousLength = 0;
111    
112                    for (char[] array : arrays) {
113                            System.arraycopy(array, 0, newArray, previousLength, array.length);
114    
115                            previousLength += array.length;
116                    }
117    
118                    return newArray;
119            }
120    
121            public static char[] append(char[] array, char value) {
122                    char[] newArray = new char[array.length + 1];
123    
124                    System.arraycopy(array, 0, newArray, 0, array.length);
125    
126                    newArray[newArray.length - 1] = value;
127    
128                    return newArray;
129            }
130    
131            public static double[] append(double[]... arrays) {
132                    int length = 0;
133    
134                    for (double[] array : arrays) {
135                            length += array.length;
136                    }
137    
138                    double[] newArray = new double[length];
139    
140                    int previousLength = 0;
141    
142                    for (double[] array : arrays) {
143                            System.arraycopy(array, 0, newArray, previousLength, array.length);
144    
145                            previousLength += array.length;
146                    }
147    
148                    return newArray;
149            }
150    
151            public static double[] append(double[] array, double value) {
152                    double[] newArray = new double[array.length + 1];
153    
154                    System.arraycopy(array, 0, newArray, 0, array.length);
155    
156                    newArray[newArray.length - 1] = value;
157    
158                    return newArray;
159            }
160    
161            public static float[] append(float[]... arrays) {
162                    int length = 0;
163    
164                    for (float[] array : arrays) {
165                            length += array.length;
166                    }
167    
168                    float[] newArray = new float[length];
169    
170                    int previousLength = 0;
171    
172                    for (float[] array : arrays) {
173                            System.arraycopy(array, 0, newArray, previousLength, array.length);
174    
175                            previousLength += array.length;
176                    }
177    
178                    return newArray;
179            }
180    
181            public static float[] append(float[] array, float value) {
182                    float[] newArray = new float[array.length + 1];
183    
184                    System.arraycopy(array, 0, newArray, 0, array.length);
185    
186                    newArray[newArray.length - 1] = value;
187    
188                    return newArray;
189            }
190    
191            public static int[] append(int[]... arrays) {
192                    int length = 0;
193    
194                    for (int[] array : arrays) {
195                            length += array.length;
196                    }
197    
198                    int[] newArray = new int[length];
199    
200                    int previousLength = 0;
201    
202                    for (int[] array : arrays) {
203                            System.arraycopy(array, 0, newArray, previousLength, array.length);
204    
205                            previousLength += array.length;
206                    }
207    
208                    return newArray;
209            }
210    
211            public static int[] append(int[] array, int value) {
212                    int[] newArray = new int[array.length + 1];
213    
214                    System.arraycopy(array, 0, newArray, 0, array.length);
215    
216                    newArray[newArray.length - 1] = value;
217    
218                    return newArray;
219            }
220    
221            public static long[] append(long[]... arrays) {
222                    int length = 0;
223    
224                    for (long[] array : arrays) {
225                            length += array.length;
226                    }
227    
228                    long[] newArray = new long[length];
229    
230                    int previousLength = 0;
231    
232                    for (long[] array : arrays) {
233                            System.arraycopy(array, 0, newArray, previousLength, array.length);
234    
235                            previousLength += array.length;
236                    }
237    
238                    return newArray;
239            }
240    
241            public static long[] append(long[] array, long value) {
242                    long[] newArray = new long[array.length + 1];
243    
244                    System.arraycopy(array, 0, newArray, 0, array.length);
245    
246                    newArray[newArray.length - 1] = value;
247    
248                    return newArray;
249            }
250    
251            public static short[] append(short[]... arrays) {
252                    int length = 0;
253    
254                    for (short[] array : arrays) {
255                            length += array.length;
256                    }
257    
258                    short[] newArray = new short[length];
259    
260                    int previousLength = 0;
261    
262                    for (short[] array : arrays) {
263                            System.arraycopy(array, 0, newArray, previousLength, array.length);
264    
265                            previousLength += array.length;
266                    }
267    
268                    return newArray;
269            }
270    
271            public static short[] append(short[] array, short value) {
272                    short[] newArray = new short[array.length + 1];
273    
274                    System.arraycopy(array, 0, newArray, 0, array.length);
275    
276                    newArray[newArray.length - 1] = value;
277    
278                    return newArray;
279            }
280    
281            public static <T> T[] append(T[]... arrays) {
282                    int length = 0;
283    
284                    for (T[] array : arrays) {
285                            length += array.length;
286                    }
287    
288                    Class<?> arraysClass = arrays[0].getClass();
289    
290                    T[] newArray = (T[])Array.newInstance(
291                            arraysClass.getComponentType(), length);
292    
293                    int previousLength = 0;
294    
295                    for (T[] array : arrays) {
296                            System.arraycopy(array, 0, newArray, previousLength, array.length);
297    
298                            previousLength += array.length;
299                    }
300    
301                    return newArray;
302            }
303    
304            public static <T> T[] append(T[] array, T value) {
305                    Class<?> arrayClass = array.getClass();
306    
307                    T[] newArray = (T[])Array.newInstance(
308                            arrayClass.getComponentType(), array.length + 1);
309    
310                    System.arraycopy(array, 0, newArray, 0, array.length);
311    
312                    newArray[array.length] = value;
313    
314                    return newArray;
315            }
316    
317            public static <T> T[] append(T[] array1, T[] array2) {
318                    Class<?> array1Class = array1.getClass();
319    
320                    T[] newArray = (T[])Array.newInstance(
321                            array1Class.getComponentType(), array1.length + array2.length);
322    
323                    System.arraycopy(array1, 0, newArray, 0, array1.length);
324    
325                    System.arraycopy(array2, 0, newArray, array1.length, array2.length);
326    
327                    return newArray;
328            }
329    
330            public static <T> T[][] append(T[][] array1, T[] value) {
331                    Class<?> array1Class = array1.getClass();
332    
333                    T[][] newArray = (T[][])Array.newInstance(
334                            array1Class.getComponentType(), array1.length + 1);
335    
336                    System.arraycopy(array1, 0, newArray, 0, array1.length);
337    
338                    newArray[array1.length] = value;
339    
340                    return newArray;
341            }
342    
343            public static <T> T[][] append(T[][] array1, T[][] array2) {
344                    Class<?> array1Class = array1.getClass();
345    
346                    T[][] newArray = (T[][])Array.newInstance(
347                            array1Class.getComponentType(), array1.length + array2.length);
348    
349                    System.arraycopy(array1, 0, newArray, 0, array1.length);
350                    System.arraycopy(array2, 0, newArray, array1.length, array2.length);
351    
352                    return newArray;
353            }
354    
355            public static boolean[] clone(boolean[] array) {
356                    boolean[] newArray = new boolean[array.length];
357    
358                    System.arraycopy(array, 0, newArray, 0, array.length);
359    
360                    return newArray;
361            }
362    
363            public static boolean[] clone(boolean[] array, int from, int to) {
364                    boolean[] newArray = new boolean[to - from];
365    
366                    System.arraycopy(
367                            array, from, newArray, 0,
368                            Math.min(array.length - from, newArray.length));
369    
370                    return newArray;
371            }
372    
373            public static byte[] clone(byte[] array) {
374                    byte[] newArray = new byte[array.length];
375    
376                    System.arraycopy(array, 0, newArray, 0, array.length);
377    
378                    return newArray;
379            }
380    
381            public static byte[] clone(byte[] array, int from, int to) {
382                    byte[] newArray = new byte[to - from];
383    
384                    System.arraycopy(
385                            array, from, newArray, 0,
386                            Math.min(array.length - from, newArray.length));
387    
388                    return newArray;
389            }
390    
391            public static char[] clone(char[] array) {
392                    char[] newArray = new char[array.length];
393    
394                    System.arraycopy(array, 0, newArray, 0, array.length);
395    
396                    return newArray;
397            }
398    
399            public static char[] clone(char[] array, int from, int to) {
400                    char[] newArray = new char[to - from];
401    
402                    System.arraycopy(
403                            array, from, newArray, 0,
404                            Math.min(array.length - from, newArray.length));
405    
406                    return newArray;
407            }
408    
409            public static double[] clone(double[] array) {
410                    double[] newArray = new double[array.length];
411    
412                    System.arraycopy(array, 0, newArray, 0, array.length);
413    
414                    return newArray;
415            }
416    
417            public static double[] clone(double[] array, int from, int to) {
418                    double[] newArray = new double[to - from];
419    
420                    System.arraycopy(
421                            array, from, newArray, 0,
422                            Math.min(array.length - from, newArray.length));
423    
424                    return newArray;
425            }
426    
427            public static float[] clone(float[] array) {
428                    float[] newArray = new float[array.length];
429    
430                    System.arraycopy(array, 0, newArray, 0, array.length);
431    
432                    return newArray;
433            }
434    
435            public static float[] clone(float[] array, int from, int to) {
436                    float[] newArray = new float[to - from];
437    
438                    System.arraycopy(
439                            array, from, newArray, 0,
440                            Math.min(array.length - from, newArray.length));
441    
442                    return newArray;
443            }
444    
445            public static int[] clone(int[] array) {
446                    int[] newArray = new int[array.length];
447    
448                    System.arraycopy(array, 0, newArray, 0, array.length);
449    
450                    return newArray;
451            }
452    
453            public static int[] clone(int[] array, int from, int to) {
454                    int[] newArray = new int[to - from];
455    
456                    System.arraycopy(
457                            array, from, newArray, 0,
458                            Math.min(array.length - from, newArray.length));
459    
460                    return newArray;
461            }
462    
463            public static long[] clone(long[] array) {
464                    long[] newArray = new long[array.length];
465    
466                    System.arraycopy(array, 0, newArray, 0, array.length);
467    
468                    return newArray;
469            }
470    
471            public static long[] clone(long[] array, int from, int to) {
472                    long[] newArray = new long[to - from];
473    
474                    System.arraycopy(
475                            array, from, newArray, 0,
476                            Math.min(array.length - from, newArray.length));
477    
478                    return newArray;
479            }
480    
481            public static short[] clone(short[] array) {
482                    short[] newArray = new short[array.length];
483    
484                    System.arraycopy(array, 0, newArray, 0, array.length);
485    
486                    return newArray;
487            }
488    
489            public static short[] clone(short[] array, int from, int to) {
490                    short[] newArray = new short[to - from];
491    
492                    System.arraycopy(
493                            array, from, newArray, 0,
494                            Math.min(array.length - from, newArray.length));
495    
496                    return newArray;
497            }
498    
499            public static <T> T[] clone(T[] array) {
500                    Class<?> arrayClass = array.getClass();
501    
502                    T[] newArray = (T[])Array.newInstance(
503                            arrayClass.getComponentType(), array.length);
504    
505                    System.arraycopy(array, 0, newArray, 0, array.length);
506    
507                    return newArray;
508            }
509    
510            public static <T> T[] clone(T[] array, int from, int to) {
511                    Class<?> arrayClass = array.getClass();
512    
513                    T[] newArray = (T[])Array.newInstance(
514                            arrayClass.getComponentType(), to - from);
515    
516                    System.arraycopy(
517                            array, from, newArray, 0,
518                            Math.min(array.length - from, newArray.length));
519    
520                    return newArray;
521            }
522    
523            public static <T> T[][] clone(T[][] array) {
524                    Class<?> arrayClass = array.getClass();
525    
526                    T[][] newArray = (T[][])Array.newInstance(
527                            arrayClass.getComponentType(), array.length);
528    
529                    System.arraycopy(array, 0, newArray, 0, array.length);
530    
531                    return newArray;
532            }
533    
534            public static <T> T[][] clone(T[][] array, int from, int to) {
535                    Class<?> arrayClass = array.getClass();
536    
537                    T[][] newArray = (T[][])Array.newInstance(
538                            arrayClass.getComponentType(), to - from);
539    
540                    System.arraycopy(
541                            array, from, newArray, 0,
542                            Math.min(array.length - from, newArray.length));
543    
544                    return newArray;
545            }
546    
547            public static void combine(
548                    Object[] array1, Object[] array2, Object[] combinedArray) {
549    
550                    System.arraycopy(array1, 0, combinedArray, 0, array1.length);
551    
552                    System.arraycopy(
553                            array2, 0, combinedArray, array1.length, array2.length);
554            }
555    
556            public static boolean contains(boolean[] array, boolean 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 boolean contains(byte[] array, byte value) {
571                    if ((array == null) || (array.length == 0)) {
572                            return false;
573                    }
574    
575                    for (int i = 0; i < array.length; i++) {
576                            if (value == array[i]) {
577                                    return true;
578                            }
579                    }
580    
581                    return false;
582            }
583    
584            public static boolean contains(char[] array, char value) {
585                    if ((array == null) || (array.length == 0)) {
586                            return false;
587                    }
588    
589                    for (int i = 0; i < array.length; i++) {
590                            if (value == array[i]) {
591                                    return true;
592                            }
593                    }
594    
595                    return false;
596            }
597    
598            public static boolean contains(double[] array, double value) {
599                    if ((array == null) || (array.length == 0)) {
600                            return false;
601                    }
602    
603                    for (int i = 0; i < array.length; i++) {
604                            if (value == array[i]) {
605                                    return true;
606                            }
607                    }
608    
609                    return false;
610            }
611    
612            public static boolean contains(float[] array, float value) {
613                    if ((array == null) || (array.length == 0)) {
614                            return false;
615                    }
616    
617                    for (int i = 0; i < array.length; i++) {
618                            if (value == array[i]) {
619                                    return true;
620                            }
621                    }
622    
623                    return false;
624            }
625    
626            public static boolean contains(int[] array, int value) {
627                    if ((array == null) || (array.length == 0)) {
628                            return false;
629                    }
630    
631                    for (int i = 0; i < array.length; i++) {
632                            if (value == array[i]) {
633                                    return true;
634                            }
635                    }
636    
637                    return false;
638            }
639    
640            public static boolean contains(long[] array, long value) {
641                    if ((array == null) || (array.length == 0)) {
642                            return false;
643                    }
644    
645                    for (int i = 0; i < array.length; i++) {
646                            if (value == array[i]) {
647                                    return true;
648                            }
649                    }
650    
651                    return false;
652            }
653    
654            public static boolean contains(Object[] array, Object value) {
655                    if ((array == null) || (array.length == 0) || (value == null)) {
656                            return false;
657                    }
658    
659                    for (int i = 0; i < array.length; i++) {
660                            if (value.equals(array[i])) {
661                                    return true;
662                            }
663                    }
664    
665                    return false;
666            }
667    
668            public static boolean contains(short[] array, short value) {
669                    if ((array == null) || (array.length == 0)) {
670                            return false;
671                    }
672    
673                    for (int i = 0; i < array.length; i++) {
674                            if (value == array[i]) {
675                                    return true;
676                            }
677                    }
678    
679                    return false;
680            }
681    
682            public static boolean containsAll(boolean[] array1, boolean[] array2) {
683                    if ((array1 == null) || (array1.length == 0) ||
684                            (array2 == null) || (array2.length == 0)) {
685    
686                            return false;
687                    }
688    
689                    for (int i = 0; i < array2.length; i++) {
690                            if (!contains(array1, array2[i])) {
691                                    return false;
692                            }
693                    }
694    
695                    return true;
696            }
697    
698            public static boolean containsAll(byte[] array1, byte[] array2) {
699                    if ((array1 == null) || (array1.length == 0) ||
700                            (array2 == null) || (array2.length == 0)) {
701    
702                            return false;
703                    }
704    
705                    for (int i = 0; i < array2.length; i++) {
706                            if (!contains(array1, array2[i])) {
707                                    return false;
708                            }
709                    }
710    
711                    return true;
712            }
713    
714            public static boolean containsAll(char[] array1, char[] array2) {
715                    if ((array1 == null) || (array1.length == 0) ||
716                            (array2 == null) || (array2.length == 0)) {
717    
718                            return false;
719                    }
720    
721                    for (int i = 0; i < array2.length; i++) {
722                            if (!contains(array1, array2[i])) {
723                                    return false;
724                            }
725                    }
726    
727                    return true;
728            }
729    
730            public static boolean containsAll(double[] array1, double[] array2) {
731                    if ((array1 == null) || (array1.length == 0) ||
732                            (array2 == null) || (array2.length == 0)) {
733    
734                            return false;
735                    }
736    
737                    for (int i = 0; i < array2.length; i++) {
738                            if (!contains(array1, array2[i])) {
739                                    return false;
740                            }
741                    }
742    
743                    return true;
744            }
745    
746            public static boolean containsAll(float[] array1, float[] array2) {
747                    if ((array1 == null) || (array1.length == 0) ||
748                            (array2 == null) || (array2.length == 0)) {
749    
750                            return false;
751                    }
752    
753                    for (int i = 0; i < array2.length; i++) {
754                            if (!contains(array1, array2[i])) {
755                                    return false;
756                            }
757                    }
758    
759                    return true;
760            }
761    
762            public static boolean containsAll(int[] array1, int[] array2) {
763                    if ((array1 == null) || (array1.length == 0) ||
764                            (array2 == null) || (array2.length == 0)) {
765    
766                            return false;
767                    }
768    
769                    for (int i = 0; i < array2.length; i++) {
770                            if (!contains(array1, array2[i])) {
771                                    return false;
772                            }
773                    }
774    
775                    return true;
776            }
777    
778            public static boolean containsAll(long[] array1, long[] array2) {
779                    if ((array1 == null) || (array1.length == 0) ||
780                            (array2 == null) || (array2.length == 0)) {
781    
782                            return false;
783                    }
784    
785                    for (int i = 0; i < array2.length; i++) {
786                            if (!contains(array1, array2[i])) {
787                                    return false;
788                            }
789                    }
790    
791                    return true;
792            }
793    
794            public static boolean containsAll(Object[] array1, Object[] array2) {
795                    if ((array1 == null) || (array1.length == 0) ||
796                            (array2 == null) || (array2.length == 0)) {
797    
798                            return false;
799                    }
800    
801                    for (int i = 0; i < array2.length; i++) {
802                            if (!contains(array1, array2[i])) {
803                                    return false;
804                            }
805                    }
806    
807                    return true;
808            }
809    
810            public static boolean containsAll(short[] array1, short[] array2) {
811                    if ((array1 == null) || (array1.length == 0) ||
812                            (array2 == null) || (array2.length == 0)) {
813    
814                            return false;
815                    }
816    
817                    for (int i = 0; i < array2.length; i++) {
818                            if (!contains(array1, array2[i])) {
819                                    return false;
820                            }
821                    }
822    
823                    return true;
824            }
825    
826            public static String[] distinct(String[] array) {
827                    return distinct(array, null);
828            }
829    
830            public static String[] distinct(
831                    String[] array, Comparator<String> comparator) {
832    
833                    if ((array == null) || (array.length == 0)) {
834                            return array;
835                    }
836    
837                    Set<String> set = null;
838    
839                    if (comparator == null) {
840                            set = new TreeSet<String>();
841                    }
842                    else {
843                            set = new TreeSet<String>(comparator);
844                    }
845    
846                    for (int i = 0; i < array.length; i++) {
847                            String s = array[i];
848    
849                            if (!set.contains(s)) {
850                                    set.add(s);
851                            }
852                    }
853    
854                    return set.toArray(new String[set.size()]);
855            }
856    
857            public static boolean[] filter(
858                    boolean[] array, PredicateFilter<Boolean> predicateFilter) {
859    
860                    if ((array == null) || (array.length == 0)) {
861                            return array;
862                    }
863    
864                    List<Boolean> filteredList = new ArrayList<Boolean>();
865    
866                    for (boolean b : array) {
867                            if (predicateFilter.filter(b)) {
868                                    filteredList.add(b);
869                            }
870                    }
871    
872                    return toArray(filteredList.toArray(new Boolean[filteredList.size()]));
873            }
874    
875            public static byte[] filter(
876                    byte[] array, PredicateFilter<Byte> predicateFilter) {
877    
878                    if ((array == null) || (array.length == 0)) {
879                            return array;
880                    }
881    
882                    List<Byte> filteredList = new ArrayList<Byte>();
883    
884                    for (byte b : array) {
885                            if (predicateFilter.filter(b)) {
886                                    filteredList.add(b);
887                            }
888                    }
889    
890                    return toArray(filteredList.toArray(new Byte[filteredList.size()]));
891            }
892    
893            public static char[] filter(
894                    char[] array, PredicateFilter<Character> predicateFilter) {
895    
896                    if ((array == null) || (array.length == 0)) {
897                            return array;
898                    }
899    
900                    List<Character> filteredList = new ArrayList<Character>();
901    
902                    for (char c : array) {
903                            if (predicateFilter.filter(c)) {
904                                    filteredList.add(c);
905                            }
906                    }
907    
908                    return toArray(
909                            filteredList.toArray(new Character[filteredList.size()]));
910            }
911    
912            public static double[] filter(
913                    double[] array, PredicateFilter<Double> predicateFilter) {
914    
915                    if ((array == null) || (array.length == 0)) {
916                            return array;
917                    }
918    
919                    List<Double> filteredList = new ArrayList<Double>();
920    
921                    for (double d : array) {
922                            if (predicateFilter.filter(d)) {
923                                    filteredList.add(d);
924                            }
925                    }
926    
927                    return toArray(filteredList.toArray(new Double[filteredList.size()]));
928            }
929    
930            public static float[] filter(
931                    float[] array, PredicateFilter<Float> predicateFilter) {
932    
933                    if ((array == null) || (array.length == 0)) {
934                            return array;
935                    }
936    
937                    List<Float> filteredList = new ArrayList<Float>();
938    
939                    for (float f : array) {
940                            if (predicateFilter.filter(f)) {
941                                    filteredList.add(f);
942                            }
943                    }
944    
945                    return toArray(filteredList.toArray(new Float[filteredList.size()]));
946            }
947    
948            public static int[] filter(
949                    int[] array, PredicateFilter<Integer> predicateFilter) {
950    
951                    if ((array == null) || (array.length == 0)) {
952                            return array;
953                    }
954    
955                    List<Integer> filteredList = new ArrayList<Integer>();
956    
957                    for (int i : array) {
958                            if (predicateFilter.filter(i)) {
959                                    filteredList.add(i);
960                            }
961                    }
962    
963                    return toArray(filteredList.toArray(new Integer[filteredList.size()]));
964            }
965    
966            public static long[] filter(
967                    long[] array, PredicateFilter<Long> predicateFilter) {
968    
969                    if ((array == null) ||(array.length == 0)) {
970                            return array;
971                    }
972    
973                    List<Long> filteredList = new ArrayList<Long>();
974    
975                    for (long l : array) {
976                            if (predicateFilter.filter(l)) {
977                                    filteredList.add(l);
978                            }
979                    }
980    
981                    return toArray(filteredList.toArray(new Long[filteredList.size()]));
982            }
983    
984            public static short[] filter(
985                    short[] array, PredicateFilter<Short> predicateFilter) {
986    
987                    if ((array == null) || (array.length == 0)) {
988                            return array;
989                    }
990    
991                    List<Short> filteredList = new ArrayList<Short>();
992    
993                    for (short s : array) {
994                            if (predicateFilter.filter(s)) {
995                                    filteredList.add(s);
996                            }
997                    }
998    
999                    return toArray(filteredList.toArray(new Short[filteredList.size()]));
1000            }
1001    
1002            public static <T> T[] filter(
1003                    T[] array, PredicateFilter<T> filterPredicate) {
1004    
1005                    if ((array == null) || (array.length == 0)) {
1006                            return array;
1007                    }
1008    
1009                    List<T> filteredList = new ArrayList<T>();
1010    
1011                    for (T t : array) {
1012                            if (filterPredicate.filter(t)) {
1013                                    filteredList.add(t);
1014                            }
1015                    }
1016    
1017                    Object[] filteredArray = filteredList.toArray();
1018    
1019                    return (T[])Arrays.copyOf(
1020                            filteredArray, filteredArray.length, array.getClass());
1021            }
1022    
1023            public static int getLength(Object[] array) {
1024                    if (array == null) {
1025                            return 0;
1026                    }
1027                    else {
1028                            return array.length;
1029                    }
1030            }
1031    
1032            public static Object getValue(Object[] array, int pos) {
1033                    if ((array == null) || (array.length <= pos)) {
1034                            return null;
1035                    }
1036                    else {
1037                            return array[pos];
1038                    }
1039            }
1040    
1041            public static boolean isEmpty(boolean[] array) {
1042                    if ((array == null) || (array.length == 0)) {
1043                            return true;
1044                    }
1045    
1046                    return false;
1047            }
1048    
1049            public static boolean isEmpty(byte[] array) {
1050                    if ((array == null) || (array.length == 0)) {
1051                            return true;
1052                    }
1053    
1054                    return false;
1055            }
1056    
1057            public static boolean isEmpty(char[] array) {
1058                    if ((array == null) || (array.length == 0)) {
1059                            return true;
1060                    }
1061    
1062                    return false;
1063            }
1064    
1065            public static boolean isEmpty(double[] array) {
1066                    if ((array == null) || (array.length == 0)) {
1067                            return true;
1068                    }
1069    
1070                    return false;
1071            }
1072    
1073            public static boolean isEmpty(float[] array) {
1074                    if ((array == null) || (array.length == 0)) {
1075                            return true;
1076                    }
1077    
1078                    return false;
1079            }
1080    
1081            public static boolean isEmpty(int[] array) {
1082                    if ((array == null) || (array.length == 0)) {
1083                            return true;
1084                    }
1085    
1086                    return false;
1087            }
1088    
1089            public static boolean isEmpty(long[] array) {
1090                    if ((array == null) || (array.length == 0)) {
1091                            return true;
1092                    }
1093    
1094                    return false;
1095            }
1096    
1097            public static boolean isEmpty(Object[] array) {
1098                    if ((array == null) || (array.length == 0)) {
1099                            return true;
1100                    }
1101    
1102                    return false;
1103            }
1104    
1105            public static boolean isEmpty(short[] array) {
1106                    if ((array == null) || (array.length == 0)) {
1107                            return true;
1108                    }
1109    
1110                    return false;
1111            }
1112    
1113            public static boolean[] remove(boolean[] array, boolean value) {
1114                    List<Boolean> list = new ArrayList<Boolean>();
1115    
1116                    for (int i = 0; i < array.length; i++) {
1117                            if (value != array[i]) {
1118                                    list.add(new Boolean(array[i]));
1119                            }
1120                    }
1121    
1122                    return toArray(list.toArray(new Boolean[list.size()]));
1123            }
1124    
1125            public static byte[] remove(byte[] array, byte value) {
1126                    List<Byte> list = new ArrayList<Byte>();
1127    
1128                    for (int i = 0; i < array.length; i++) {
1129                            if (value != array[i]) {
1130                                    list.add(new Byte(array[i]));
1131                            }
1132                    }
1133    
1134                    return toArray(list.toArray(new Byte[list.size()]));
1135            }
1136    
1137            public static char[] remove(char[] array, char value) {
1138                    List<Character> list = new ArrayList<Character>();
1139    
1140                    for (int i = 0; i < array.length; i++) {
1141                            if (value != array[i]) {
1142                                    list.add(new Character(array[i]));
1143                            }
1144                    }
1145    
1146                    return toArray(list.toArray(new Character[list.size()]));
1147            }
1148    
1149            public static double[] remove(double[] array, double value) {
1150                    List<Double> list = new ArrayList<Double>();
1151    
1152                    for (int i = 0; i < array.length; i++) {
1153                            if (value != array[i]) {
1154                                    list.add(new Double(array[i]));
1155                            }
1156                    }
1157    
1158                    return toArray(list.toArray(new Double[list.size()]));
1159            }
1160    
1161            public static int[] remove(int[] array, int value) {
1162                    List<Integer> list = new ArrayList<Integer>();
1163    
1164                    for (int i = 0; i < array.length; i++) {
1165                            if (value != array[i]) {
1166                                    list.add(new Integer(array[i]));
1167                            }
1168                    }
1169    
1170                    return toArray(list.toArray(new Integer[list.size()]));
1171            }
1172    
1173            public static long[] remove(long[] array, long value) {
1174                    List<Long> list = new ArrayList<Long>();
1175    
1176                    for (int i = 0; i < array.length; i++) {
1177                            if (value != array[i]) {
1178                                    list.add(new Long(array[i]));
1179                            }
1180                    }
1181    
1182                    return toArray(list.toArray(new Long[list.size()]));
1183            }
1184    
1185            public static short[] remove(short[] array, short value) {
1186                    List<Short> list = new ArrayList<Short>();
1187    
1188                    for (int i = 0; i < array.length; i++) {
1189                            if (value != array[i]) {
1190                                    list.add(new Short(array[i]));
1191                            }
1192                    }
1193    
1194                    return toArray(list.toArray(new Short[list.size()]));
1195            }
1196    
1197            public static String[] remove(String[] array, String value) {
1198                    List<String> list = new ArrayList<String>();
1199    
1200                    for (String s : array) {
1201                            if (!s.equals(value)) {
1202                                    list.add(s);
1203                            }
1204                    }
1205    
1206                    return list.toArray(new String[list.size()]);
1207            }
1208    
1209            public static String[] removeByPrefix(String[] array, String prefix) {
1210                    List<String> list = new ArrayList<String>();
1211    
1212                    for (String s : array) {
1213                            if (!s.startsWith(prefix)) {
1214                                    list.add(s);
1215                            }
1216                    }
1217    
1218                    return list.toArray(new String[list.size()]);
1219            }
1220    
1221            public static void reverse(boolean[] array) {
1222                    for (int left = 0, right = array.length - 1; left < right;
1223                                    left++, right--) {
1224    
1225                            boolean value = array[left];
1226    
1227                            array[left] = array[right];
1228                            array[right] = value;
1229                    }
1230            }
1231    
1232            public static void reverse(char[] array) {
1233                    for (int left = 0, right = array.length - 1; left < right;
1234                                    left++, right--) {
1235    
1236                            char value = array[left];
1237    
1238                            array[left] = array[right];
1239                            array[right] = value;
1240                    }
1241            }
1242    
1243            public static void reverse(double[] array) {
1244                    for (int left = 0, right = array.length - 1; left < right;
1245                                    left++, right--) {
1246    
1247                            double value = array[left];
1248    
1249                            array[left] = array[right];
1250                            array[right] = value;
1251                    }
1252            }
1253    
1254            public static void reverse(int[] array) {
1255                    for (int left = 0, right = array.length - 1; left < right;
1256                                    left++, right--) {
1257    
1258                            int value = array[left];
1259    
1260                            array[left] = array[right];
1261                            array[right] = value;
1262                    }
1263            }
1264    
1265            public static void reverse(long[] array) {
1266                    for (int left = 0, right = array.length - 1; left < right;
1267                                    left++, right--) {
1268    
1269                            long value = array[left];
1270    
1271                            array[left] = array[right];
1272                            array[right] = value;
1273                    }
1274            }
1275    
1276            public static void reverse(short[] array) {
1277                    for (int left = 0, right = array.length - 1; left < right;
1278                                    left++, right--) {
1279    
1280                            short value = array[left];
1281    
1282                            array[left] = array[right];
1283                            array[right] = value;
1284                    }
1285            }
1286    
1287            public static void reverse(String[] array) {
1288                    for (int left = 0, right = array.length - 1; left < right;
1289                                    left++, right--) {
1290    
1291                            String value = array[left];
1292    
1293                            array[left] = array[right];
1294                            array[right] = value;
1295                    }
1296            }
1297    
1298            public static boolean[] subset(boolean[] array, int start, int end) {
1299                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1300                            return array;
1301                    }
1302    
1303                    boolean[] newArray = new boolean[end - start];
1304    
1305                    System.arraycopy(array, start, newArray, 0, end - start);
1306    
1307                    return newArray;
1308            }
1309    
1310            public static byte[] subset(byte[] array, int start, int end) {
1311                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1312                            return array;
1313                    }
1314    
1315                    byte[] newArray = new byte[end - start];
1316    
1317                    System.arraycopy(array, start, newArray, 0, end - start);
1318    
1319                    return newArray;
1320            }
1321    
1322            public static char[] subset(char[] array, int start, int end) {
1323                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1324                            return array;
1325                    }
1326    
1327                    char[] newArray = new char[end - start];
1328    
1329                    System.arraycopy(array, start, newArray, 0, end - start);
1330    
1331                    return newArray;
1332            }
1333    
1334            public static double[] subset(double[] array, int start, int end) {
1335                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1336                            return array;
1337                    }
1338    
1339                    double[] newArray = new double[end - start];
1340    
1341                    System.arraycopy(array, start, newArray, 0, end - start);
1342    
1343                    return newArray;
1344            }
1345    
1346            public static float[] subset(float[] array, int start, int end) {
1347                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1348                            return array;
1349                    }
1350    
1351                    float[] newArray = new float[end - start];
1352    
1353                    System.arraycopy(array, start, newArray, 0, end - start);
1354    
1355                    return newArray;
1356            }
1357    
1358            public static int[] subset(int[] array, int start, int end) {
1359                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1360                            return array;
1361                    }
1362    
1363                    int[] newArray = new int[end - start];
1364    
1365                    System.arraycopy(array, start, newArray, 0, end - start);
1366    
1367                    return newArray;
1368            }
1369    
1370            public static long[] subset(long[] array, int start, int end) {
1371                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1372                            return array;
1373                    }
1374    
1375                    long[] newArray = new long[end - start];
1376    
1377                    System.arraycopy(array, start, newArray, 0, end - start);
1378    
1379                    return newArray;
1380            }
1381    
1382            public static short[] subset(short[] array, int start, int end) {
1383                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1384                            return array;
1385                    }
1386    
1387                    short[] newArray = new short[end - start];
1388    
1389                    System.arraycopy(array, start, newArray, 0, end - start);
1390    
1391                    return newArray;
1392            }
1393    
1394            public static <T> T[] subset(T[] array, int start, int end) {
1395                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1396                            return array;
1397                    }
1398    
1399                    Class<?> arrayClass = array.getClass();
1400    
1401                    T[] newArray = (T[])Array.newInstance(
1402                            arrayClass.getComponentType(), end - start);
1403    
1404                    System.arraycopy(array, start, newArray, 0, end - start);
1405    
1406                    return newArray;
1407            }
1408    
1409            public static Boolean[] toArray(boolean[] array) {
1410                    Boolean[] newArray = new Boolean[array.length];
1411    
1412                    for (int i = 0; i < array.length; i++) {
1413                            newArray[i] = Boolean.valueOf(array[i]);
1414                    }
1415    
1416                    return newArray;
1417            }
1418    
1419            public static boolean[] toArray(Boolean[] array) {
1420                    boolean[] newArray = new boolean[array.length];
1421    
1422                    for (int i = 0; i < array.length; i++) {
1423                            newArray[i] = array[i].booleanValue();
1424                    }
1425    
1426                    return newArray;
1427            }
1428    
1429            public static Byte[] toArray(byte[] array) {
1430                    Byte[] newArray = new Byte[array.length];
1431    
1432                    for (int i = 0; i < array.length; i++) {
1433                            newArray[i] = Byte.valueOf(array[i]);
1434                    }
1435    
1436                    return newArray;
1437            }
1438    
1439            public static byte[] toArray(Byte[] array) {
1440                    byte[] newArray = new byte[array.length];
1441    
1442                    for (int i = 0; i < array.length; i++) {
1443                            newArray[i] = array[i].byteValue();
1444                    }
1445    
1446                    return newArray;
1447            }
1448    
1449            public static Character[] toArray(char[] array) {
1450                    Character[] newArray = new Character[array.length];
1451    
1452                    for (int i = 0; i < array.length; i++) {
1453                            newArray[i] = Character.valueOf(array[i]);
1454                    }
1455    
1456                    return newArray;
1457            }
1458    
1459            public static char[] toArray(Character[] array) {
1460                    char[] newArray = new char[array.length];
1461    
1462                    for (int i = 0; i < array.length; i++) {
1463                            newArray[i] = array[i].charValue();
1464                    }
1465    
1466                    return newArray;
1467            }
1468    
1469            public static Double[] toArray(double[] array) {
1470                    Double[] newArray = new Double[array.length];
1471    
1472                    for (int i = 0; i < array.length; i++) {
1473                            newArray[i] = new Double(array[i]);
1474                    }
1475    
1476                    return newArray;
1477            }
1478    
1479            public static double[] toArray(Double[] array) {
1480                    double[] newArray = new double[array.length];
1481    
1482                    for (int i = 0; i < array.length; i++) {
1483                            newArray[i] = array[i].doubleValue();
1484                    }
1485    
1486                    return newArray;
1487            }
1488    
1489            public static Float[] toArray(float[] array) {
1490                    Float[] newArray = new Float[array.length];
1491    
1492                    for (int i = 0; i < array.length; i++) {
1493                            newArray[i] = new Float(array[i]);
1494                    }
1495    
1496                    return newArray;
1497            }
1498    
1499            public static float[] toArray(Float[] array) {
1500                    float[] newArray = new float[array.length];
1501    
1502                    for (int i = 0; i < array.length; i++) {
1503                            newArray[i] = array[i].floatValue();
1504                    }
1505    
1506                    return newArray;
1507            }
1508    
1509            public static Integer[] toArray(int[] array) {
1510                    Integer[] newArray = new Integer[array.length];
1511    
1512                    for (int i = 0; i < array.length; i++) {
1513                            newArray[i] = new Integer(array[i]);
1514                    }
1515    
1516                    return newArray;
1517            }
1518    
1519            public static int[] toArray(Integer[] array) {
1520                    int[] newArray = new int[array.length];
1521    
1522                    for (int i = 0; i < array.length; i++) {
1523                            newArray[i] = array[i].intValue();
1524                    }
1525    
1526                    return newArray;
1527            }
1528    
1529            public static Long[] toArray(long[] array) {
1530                    Long[] newArray = new Long[array.length];
1531    
1532                    for (int i = 0; i < array.length; i++) {
1533                            newArray[i] = new Long(array[i]);
1534                    }
1535    
1536                    return newArray;
1537            }
1538    
1539            public static long[] toArray(Long[] array) {
1540                    long[] newArray = new long[array.length];
1541    
1542                    for (int i = 0; i < array.length; i++) {
1543                            newArray[i] = array[i].longValue();
1544                    }
1545    
1546                    return newArray;
1547            }
1548    
1549            public static Short[] toArray(short[] array) {
1550                    Short[] newArray = new Short[array.length];
1551    
1552                    for (int i = 0; i < array.length; i++) {
1553                            newArray[i] = new Short(array[i]);
1554                    }
1555    
1556                    return newArray;
1557            }
1558    
1559            public static short[] toArray(Short[] array) {
1560                    short[] newArray = new short[array.length];
1561    
1562                    for (int i = 0; i < array.length; i++) {
1563                            newArray[i] = array[i].shortValue();
1564                    }
1565    
1566                    return newArray;
1567            }
1568    
1569            public static double[] toDoubleArray(Collection<Double> collection) {
1570                    double[] newArray = new double[collection.size()];
1571    
1572                    if (collection instanceof List) {
1573                            List<Double> list = (List<Double>)collection;
1574    
1575                            for (int i = 0; i < list.size(); i++) {
1576                                    Double value = list.get(i);
1577    
1578                                    newArray[i] = value.doubleValue();
1579                            }
1580                    }
1581                    else {
1582                            int i = 0;
1583    
1584                            Iterator<Double> iterator = collection.iterator();
1585    
1586                            while (iterator.hasNext()) {
1587                                    Double value = iterator.next();
1588    
1589                                    newArray[i++] = value.doubleValue();
1590                            }
1591                    }
1592    
1593                    return newArray;
1594            }
1595    
1596            public static float[] toFloatArray(Collection<Float> collection) {
1597                    float[] newArray = new float[collection.size()];
1598    
1599                    if (collection instanceof List) {
1600                            List<Float> list = (List<Float>)collection;
1601    
1602                            for (int i = 0; i < list.size(); i++) {
1603                                    Float value = list.get(i);
1604    
1605                                    newArray[i] = value.floatValue();
1606                            }
1607                    }
1608                    else {
1609                            int i = 0;
1610    
1611                            Iterator<Float> iterator = collection.iterator();
1612    
1613                            while (iterator.hasNext()) {
1614                                    Float value = iterator.next();
1615    
1616                                    newArray[i++] = value.floatValue();
1617                            }
1618                    }
1619    
1620                    return newArray;
1621            }
1622    
1623            public static int[] toIntArray(Collection<Integer> collection) {
1624                    int[] newArray = new int[collection.size()];
1625    
1626                    if (collection instanceof List) {
1627                            List<Integer> list = (List<Integer>)collection;
1628    
1629                            for (int i = 0; i < list.size(); i++) {
1630                                    Integer value = list.get(i);
1631    
1632                                    newArray[i] = value.intValue();
1633                            }
1634                    }
1635                    else {
1636                            int i = 0;
1637    
1638                            Iterator<Integer> iterator = collection.iterator();
1639    
1640                            while (iterator.hasNext()) {
1641                                    Integer value = iterator.next();
1642    
1643                                    newArray[i++] = value.intValue();
1644                            }
1645                    }
1646    
1647                    return newArray;
1648            }
1649    
1650            public static long[] toLongArray(Collection<Long> collection) {
1651                    long[] newArray = new long[collection.size()];
1652    
1653                    if (collection instanceof List) {
1654                            List<Long> list = (List<Long>)collection;
1655    
1656                            for (int i = 0; i < list.size(); i++) {
1657                                    Long value = list.get(i);
1658    
1659                                    newArray[i] = value.longValue();
1660                            }
1661                    }
1662                    else {
1663                            int i = 0;
1664    
1665                            Iterator<Long> iterator = collection.iterator();
1666    
1667                            while (iterator.hasNext()) {
1668                                    Long value = iterator.next();
1669    
1670                                    newArray[i++] = value.longValue();
1671                            }
1672                    }
1673    
1674                    return newArray;
1675            }
1676    
1677            public static Long[] toLongArray(Object[] array) {
1678                    Long[] newArray = new Long[array.length];
1679    
1680                    for (int i = 0; i < array.length; i++) {
1681                            newArray[i] = (Long)array[i];
1682                    }
1683    
1684                    return newArray;
1685            }
1686    
1687            public static short[] toShortArray(Collection<Short> collection) {
1688                    short[] newArray = new short[collection.size()];
1689    
1690                    if (collection instanceof List) {
1691                            List<Short> list = (List<Short>)collection;
1692    
1693                            for (int i = 0; i < list.size(); i++) {
1694                                    Short value = list.get(i);
1695    
1696                                    newArray[i] = value.shortValue();
1697                            }
1698                    }
1699                    else {
1700                            int i = 0;
1701    
1702                            Iterator<Short> iterator = collection.iterator();
1703    
1704                            while (iterator.hasNext()) {
1705                                    Short value = iterator.next();
1706    
1707                                    newArray[i++] = value.shortValue();
1708                            }
1709                    }
1710    
1711                    return newArray;
1712            }
1713    
1714            /**
1715             * @see ListUtil#toString(List, String)
1716             */
1717            public static String toString(Object[] array, String param) {
1718                    return toString(array, param, StringPool.COMMA);
1719            }
1720    
1721            /**
1722             * @see ListUtil#toString(List, String, String)
1723             */
1724            public static String toString(
1725                    Object[] array, String param, String delimiter) {
1726    
1727                    return toString(array, param, delimiter, null);
1728            }
1729    
1730            public static String toString(
1731                    Object[] array, String param, String delimiter, Locale locale) {
1732    
1733                    if ((array == null) || (array.length == 0)) {
1734                            return StringPool.BLANK;
1735                    }
1736    
1737                    StringBundler sb = new StringBundler(2 * array.length - 1);
1738    
1739                    for (int i = 0; i < array.length; i++) {
1740                            Object bean = array[i];
1741    
1742                            Object value = BeanPropertiesUtil.getObject(bean, param);
1743    
1744                            if (value != null) {
1745                                    if (locale != null) {
1746                                            sb.append(LanguageUtil.get(locale, value.toString()));
1747                                    }
1748                                    else {
1749                                            sb.append(value);
1750                                    }
1751                            }
1752    
1753                            if ((i + 1) != array.length) {
1754                                    sb.append(delimiter);
1755                            }
1756                    }
1757    
1758                    return sb.toString();
1759            }
1760    
1761            /**
1762             * @see ListUtil#toString(List, Accessor)
1763             */
1764            public static <T, V> String toString(T[] list, Accessor<T, V> accessor) {
1765                    return toString(list, accessor, StringPool.COMMA);
1766            }
1767    
1768            /**
1769             * @see ListUtil#toString(List, Accessor, String)
1770             */
1771            public static <T, V> String toString(
1772                    T[] list, Accessor<T, V> accessor, String delimiter) {
1773    
1774                    return toString(list, accessor, delimiter, null);
1775            }
1776    
1777            public static <T, V> String toString(
1778                    T[] list, Accessor<T, V> accessor, String delimiter, Locale locale) {
1779    
1780                    if ((list == null) || (list.length == 0)) {
1781                            return StringPool.BLANK;
1782                    }
1783    
1784                    StringBundler sb = new StringBundler(2 * list.length - 1);
1785    
1786                    for (int i = 0; i < list.length; i++) {
1787                            T bean = list[i];
1788    
1789                            V value = accessor.get(bean);
1790    
1791                            if (value != null) {
1792                                    if (locale != null) {
1793                                            sb.append(LanguageUtil.get(locale, value.toString()));
1794                                    }
1795                                    else {
1796                                            sb.append(value);
1797                                    }
1798                            }
1799    
1800                            if ((i + 1) != list.length) {
1801                                    sb.append(delimiter);
1802                            }
1803                    }
1804    
1805                    return sb.toString();
1806            }
1807    
1808            public static String[] toStringArray(boolean[] array) {
1809                    String[] newArray = new String[array.length];
1810    
1811                    for (int i = 0; i < array.length; i++) {
1812                            newArray[i] = String.valueOf(array[i]);
1813                    }
1814    
1815                    return newArray;
1816            }
1817    
1818            public static String[] toStringArray(byte[] array) {
1819                    String[] newArray = new String[array.length];
1820    
1821                    for (int i = 0; i < array.length; i++) {
1822                            newArray[i] = String.valueOf(array[i]);
1823                    }
1824    
1825                    return newArray;
1826            }
1827    
1828            public static String[] toStringArray(char[] array) {
1829                    String[] newArray = new String[array.length];
1830    
1831                    for (int i = 0; i < array.length; i++) {
1832                            newArray[i] = String.valueOf(array[i]);
1833                    }
1834    
1835                    return newArray;
1836            }
1837    
1838            public static String[] toStringArray(Date[] array, DateFormat dateFormat) {
1839                    String[] newArray = new String[array.length];
1840    
1841                    for (int i = 0; i < array.length; i++) {
1842                            newArray[i] = dateFormat.format(array[i]);
1843                    }
1844    
1845                    return newArray;
1846            }
1847    
1848            public static String[] toStringArray(double[] array) {
1849                    String[] newArray = new String[array.length];
1850    
1851                    for (int i = 0; i < array.length; i++) {
1852                            newArray[i] = String.valueOf(array[i]);
1853                    }
1854    
1855                    return newArray;
1856            }
1857    
1858            public static String[] toStringArray(float[] array) {
1859                    String[] newArray = new String[array.length];
1860    
1861                    for (int i = 0; i < array.length; i++) {
1862                            newArray[i] = String.valueOf(array[i]);
1863                    }
1864    
1865                    return newArray;
1866            }
1867    
1868            public static String[] toStringArray(int[] array) {
1869                    String[] newArray = new String[array.length];
1870    
1871                    for (int i = 0; i < array.length; i++) {
1872                            newArray[i] = String.valueOf(array[i]);
1873                    }
1874    
1875                    return newArray;
1876            }
1877    
1878            public static String[] toStringArray(JSONArray array) {
1879                    String[] newArray = new String[array.length()];
1880    
1881                    for (int i = 0; i < array.length(); i++) {
1882                            newArray[i] = array.getString(i);
1883                    }
1884    
1885                    return newArray;
1886            }
1887    
1888            public static String[] toStringArray(long[] array) {
1889                    String[] newArray = new String[array.length];
1890    
1891                    for (int i = 0; i < array.length; i++) {
1892                            newArray[i] = String.valueOf(array[i]);
1893                    }
1894    
1895                    return newArray;
1896            }
1897    
1898            public static String[] toStringArray(Object[] array) {
1899                    String[] newArray = new String[array.length];
1900    
1901                    for (int i = 0; i < array.length; i++) {
1902                            newArray[i] = String.valueOf(array[i]);
1903                    }
1904    
1905                    return newArray;
1906            }
1907    
1908            public static String[] toStringArray(short[] array) {
1909                    String[] newArray = new String[array.length];
1910    
1911                    for (int i = 0; i < array.length; i++) {
1912                            newArray[i] = String.valueOf(array[i]);
1913                    }
1914    
1915                    return newArray;
1916            }
1917    
1918            public static byte[] unique(byte[] array) {
1919                    List<Byte> list = new UniqueList<Byte>();
1920    
1921                    for (int i = 0; i < array.length; i++) {
1922                            list.add(array[i]);
1923                    }
1924    
1925                    return toArray(list.toArray(new Byte[list.size()]));
1926            }
1927    
1928            public static double[] unique(double[] array) {
1929                    List<Double> list = new UniqueList<Double>();
1930    
1931                    for (int i = 0; i < array.length; i++) {
1932                            list.add(array[i]);
1933                    }
1934    
1935                    return toArray(list.toArray(new Double[list.size()]));
1936            }
1937    
1938            public static float[] unique(float[] array) {
1939                    List<Float> list = new UniqueList<Float>();
1940    
1941                    for (int i = 0; i < array.length; i++) {
1942                            list.add(array[i]);
1943                    }
1944    
1945                    return toArray(list.toArray(new Float[list.size()]));
1946            }
1947    
1948            public static int[] unique(int[] array) {
1949                    List<Integer> list = new UniqueList<Integer>();
1950    
1951                    for (int i = 0; i < array.length; i++) {
1952                            list.add(array[i]);
1953                    }
1954    
1955                    return toArray(list.toArray(new Integer[list.size()]));
1956            }
1957    
1958            public static long[] unique(long[] array) {
1959                    List<Long> list = new UniqueList<Long>();
1960    
1961                    for (int i = 0; i < array.length; i++) {
1962                            list.add(array[i]);
1963                    }
1964    
1965                    return toArray(list.toArray(new Long[list.size()]));
1966            }
1967    
1968            public static short[] unique(short[] array) {
1969                    List<Short> list = new UniqueList<Short>();
1970    
1971                    for (int i = 0; i < array.length; i++) {
1972                            list.add(array[i]);
1973                    }
1974    
1975                    return toArray(list.toArray(new Short[list.size()]));
1976            }
1977    
1978    }