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