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 <T> T[] remove(T[] array, T value) {
1328                    if (isEmpty(array)) {
1329                            return array;
1330                    }
1331    
1332                    List<T> list = new ArrayList<>();
1333    
1334                    for (int i = 0; i < array.length; i++) {
1335                            if (value != array[i]) {
1336                                    list.add(array[i]);
1337                            }
1338                    }
1339    
1340                    if (array.length == list.size()) {
1341                            return array;
1342                    }
1343    
1344                    Class<?> arrayClass = array.getClass();
1345    
1346                    return list.toArray(
1347                            (T[])Array.newInstance(arrayClass.getComponentType(), list.size()));
1348            }
1349    
1350            public static String[] removeByPrefix(String[] array, String prefix) {
1351                    List<String> list = new ArrayList<>();
1352    
1353                    for (String s : array) {
1354                            if (!s.startsWith(prefix)) {
1355                                    list.add(s);
1356                            }
1357                    }
1358    
1359                    return list.toArray(new String[list.size()]);
1360            }
1361    
1362            public static void replace(
1363                    String[] values, String oldValue, String newValue) {
1364    
1365                    for (int i = 0; i < values.length; i++) {
1366                            if (values[i].equals(oldValue)) {
1367                                    values[i] = newValue;
1368                            }
1369                    }
1370            }
1371    
1372            public static void reverse(boolean[] array) {
1373                    for (int left = 0, right = array.length - 1; left < right;
1374                            left++, right--) {
1375    
1376                            boolean value = array[left];
1377    
1378                            array[left] = array[right];
1379                            array[right] = value;
1380                    }
1381            }
1382    
1383            public static void reverse(char[] array) {
1384                    for (int left = 0, right = array.length - 1; left < right;
1385                            left++, right--) {
1386    
1387                            char value = array[left];
1388    
1389                            array[left] = array[right];
1390                            array[right] = value;
1391                    }
1392            }
1393    
1394            public static void reverse(double[] array) {
1395                    for (int left = 0, right = array.length - 1; left < right;
1396                            left++, right--) {
1397    
1398                            double value = array[left];
1399    
1400                            array[left] = array[right];
1401                            array[right] = value;
1402                    }
1403            }
1404    
1405            public static void reverse(int[] array) {
1406                    for (int left = 0, right = array.length - 1; left < right;
1407                            left++, right--) {
1408    
1409                            int value = array[left];
1410    
1411                            array[left] = array[right];
1412                            array[right] = value;
1413                    }
1414            }
1415    
1416            public static void reverse(long[] array) {
1417                    for (int left = 0, right = array.length - 1; left < right;
1418                            left++, right--) {
1419    
1420                            long value = array[left];
1421    
1422                            array[left] = array[right];
1423                            array[right] = value;
1424                    }
1425            }
1426    
1427            public static void reverse(short[] array) {
1428                    for (int left = 0, right = array.length - 1; left < right;
1429                            left++, right--) {
1430    
1431                            short value = array[left];
1432    
1433                            array[left] = array[right];
1434                            array[right] = value;
1435                    }
1436            }
1437    
1438            public static <T> void reverse(T[] array) {
1439                    for (int left = 0, right = array.length - 1; left < right;
1440                            left++, right--) {
1441    
1442                            T value = array[left];
1443    
1444                            array[left] = array[right];
1445                            array[right] = value;
1446                    }
1447            }
1448    
1449            public static boolean[] subset(boolean[] array, int start, int end) {
1450                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1451                            return array;
1452                    }
1453    
1454                    boolean[] newArray = new boolean[end - start];
1455    
1456                    System.arraycopy(array, start, newArray, 0, end - start);
1457    
1458                    return newArray;
1459            }
1460    
1461            public static byte[] subset(byte[] array, int start, int end) {
1462                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1463                            return array;
1464                    }
1465    
1466                    byte[] newArray = new byte[end - start];
1467    
1468                    System.arraycopy(array, start, newArray, 0, end - start);
1469    
1470                    return newArray;
1471            }
1472    
1473            public static char[] subset(char[] array, int start, int end) {
1474                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1475                            return array;
1476                    }
1477    
1478                    char[] newArray = new char[end - start];
1479    
1480                    System.arraycopy(array, start, newArray, 0, end - start);
1481    
1482                    return newArray;
1483            }
1484    
1485            public static double[] subset(double[] array, int start, int end) {
1486                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1487                            return array;
1488                    }
1489    
1490                    double[] newArray = new double[end - start];
1491    
1492                    System.arraycopy(array, start, newArray, 0, end - start);
1493    
1494                    return newArray;
1495            }
1496    
1497            public static float[] subset(float[] array, int start, int end) {
1498                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1499                            return array;
1500                    }
1501    
1502                    float[] newArray = new float[end - start];
1503    
1504                    System.arraycopy(array, start, newArray, 0, end - start);
1505    
1506                    return newArray;
1507            }
1508    
1509            public static int[] subset(int[] array, int start, int end) {
1510                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1511                            return array;
1512                    }
1513    
1514                    int[] newArray = new int[end - start];
1515    
1516                    System.arraycopy(array, start, newArray, 0, end - start);
1517    
1518                    return newArray;
1519            }
1520    
1521            public static long[] subset(long[] array, int start, int end) {
1522                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1523                            return array;
1524                    }
1525    
1526                    long[] newArray = new long[end - start];
1527    
1528                    System.arraycopy(array, start, newArray, 0, end - start);
1529    
1530                    return newArray;
1531            }
1532    
1533            public static short[] subset(short[] array, int start, int end) {
1534                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1535                            return array;
1536                    }
1537    
1538                    short[] newArray = new short[end - start];
1539    
1540                    System.arraycopy(array, start, newArray, 0, end - start);
1541    
1542                    return newArray;
1543            }
1544    
1545            public static <T> T[] subset(T[] array, int start, int end) {
1546                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1547                            return array;
1548                    }
1549    
1550                    Class<?> arrayClass = array.getClass();
1551    
1552                    T[] newArray = (T[])Array.newInstance(
1553                            arrayClass.getComponentType(), end - start);
1554    
1555                    System.arraycopy(array, start, newArray, 0, end - start);
1556    
1557                    return newArray;
1558            }
1559    
1560            public static Boolean[] toArray(boolean[] array) {
1561                    Boolean[] newArray = new Boolean[array.length];
1562    
1563                    for (int i = 0; i < array.length; i++) {
1564                            newArray[i] = Boolean.valueOf(array[i]);
1565                    }
1566    
1567                    return newArray;
1568            }
1569    
1570            public static boolean[] toArray(Boolean[] array) {
1571                    boolean[] newArray = new boolean[array.length];
1572    
1573                    for (int i = 0; i < array.length; i++) {
1574                            newArray[i] = array[i].booleanValue();
1575                    }
1576    
1577                    return newArray;
1578            }
1579    
1580            public static Byte[] toArray(byte[] array) {
1581                    Byte[] newArray = new Byte[array.length];
1582    
1583                    for (int i = 0; i < array.length; i++) {
1584                            newArray[i] = Byte.valueOf(array[i]);
1585                    }
1586    
1587                    return newArray;
1588            }
1589    
1590            public static byte[] toArray(Byte[] array) {
1591                    byte[] newArray = new byte[array.length];
1592    
1593                    for (int i = 0; i < array.length; i++) {
1594                            newArray[i] = array[i].byteValue();
1595                    }
1596    
1597                    return newArray;
1598            }
1599    
1600            public static Character[] toArray(char[] array) {
1601                    Character[] newArray = new Character[array.length];
1602    
1603                    for (int i = 0; i < array.length; i++) {
1604                            newArray[i] = Character.valueOf(array[i]);
1605                    }
1606    
1607                    return newArray;
1608            }
1609    
1610            public static char[] toArray(Character[] array) {
1611                    char[] newArray = new char[array.length];
1612    
1613                    for (int i = 0; i < array.length; i++) {
1614                            newArray[i] = array[i].charValue();
1615                    }
1616    
1617                    return newArray;
1618            }
1619    
1620            public static Double[] toArray(double[] array) {
1621                    Double[] newArray = new Double[array.length];
1622    
1623                    for (int i = 0; i < array.length; i++) {
1624                            newArray[i] = Double.valueOf(array[i]);
1625                    }
1626    
1627                    return newArray;
1628            }
1629    
1630            public static double[] toArray(Double[] array) {
1631                    double[] newArray = new double[array.length];
1632    
1633                    for (int i = 0; i < array.length; i++) {
1634                            newArray[i] = array[i].doubleValue();
1635                    }
1636    
1637                    return newArray;
1638            }
1639    
1640            public static Float[] toArray(float[] array) {
1641                    Float[] newArray = new Float[array.length];
1642    
1643                    for (int i = 0; i < array.length; i++) {
1644                            newArray[i] = Float.valueOf(array[i]);
1645                    }
1646    
1647                    return newArray;
1648            }
1649    
1650            public static float[] toArray(Float[] array) {
1651                    float[] newArray = new float[array.length];
1652    
1653                    for (int i = 0; i < array.length; i++) {
1654                            newArray[i] = array[i].floatValue();
1655                    }
1656    
1657                    return newArray;
1658            }
1659    
1660            public static Integer[] toArray(int[] array) {
1661                    Integer[] newArray = new Integer[array.length];
1662    
1663                    for (int i = 0; i < array.length; i++) {
1664                            newArray[i] = Integer.valueOf(array[i]);
1665                    }
1666    
1667                    return newArray;
1668            }
1669    
1670            public static int[] toArray(Integer[] array) {
1671                    int[] newArray = new int[array.length];
1672    
1673                    for (int i = 0; i < array.length; i++) {
1674                            newArray[i] = array[i].intValue();
1675                    }
1676    
1677                    return newArray;
1678            }
1679    
1680            public static Long[] toArray(long[] array) {
1681                    Long[] newArray = new Long[array.length];
1682    
1683                    for (int i = 0; i < array.length; i++) {
1684                            newArray[i] = Long.valueOf(array[i]);
1685                    }
1686    
1687                    return newArray;
1688            }
1689    
1690            public static long[] toArray(Long[] array) {
1691                    long[] newArray = new long[array.length];
1692    
1693                    for (int i = 0; i < array.length; i++) {
1694                            newArray[i] = array[i].longValue();
1695                    }
1696    
1697                    return newArray;
1698            }
1699    
1700            public static Short[] toArray(short[] array) {
1701                    Short[] newArray = new Short[array.length];
1702    
1703                    for (int i = 0; i < array.length; i++) {
1704                            newArray[i] = Short.valueOf(array[i]);
1705                    }
1706    
1707                    return newArray;
1708            }
1709    
1710            public static short[] toArray(Short[] array) {
1711                    short[] newArray = new short[array.length];
1712    
1713                    for (int i = 0; i < array.length; i++) {
1714                            newArray[i] = array[i].shortValue();
1715                    }
1716    
1717                    return newArray;
1718            }
1719    
1720            public static String[] toArray(String[] array) {
1721                    String[] newArray = new String[array.length];
1722    
1723                    for (int i = 0; i < array.length; i++) {
1724                            newArray[i] = array[i].toString();
1725                    }
1726    
1727                    return newArray;
1728            }
1729    
1730            public static <T, A> A[] toArray(T[] list, Accessor<T, A> accessor) {
1731                    A[] aArray = (A[])Array.newInstance(
1732                            accessor.getAttributeClass(), list.length);
1733    
1734                    for (int i = 0; i < list.length; i++) {
1735                            aArray[i] = accessor.get(list[i]);
1736                    }
1737    
1738                    return aArray;
1739            }
1740    
1741            public static double[] toDoubleArray(
1742                    Collection<? extends Number> collection) {
1743    
1744                    double[] newArray = new double[collection.size()];
1745    
1746                    if (collection instanceof List) {
1747                            List<Number> list = (List<Number>)collection;
1748    
1749                            for (int i = 0; i < list.size(); i++) {
1750                                    Number value = list.get(i);
1751    
1752                                    newArray[i] = value.doubleValue();
1753                            }
1754                    }
1755                    else {
1756                            int i = 0;
1757    
1758                            Iterator<? extends Number> iterator = collection.iterator();
1759    
1760                            while (iterator.hasNext()) {
1761                                    Number value = iterator.next();
1762    
1763                                    newArray[i++] = value.doubleValue();
1764                            }
1765                    }
1766    
1767                    return newArray;
1768            }
1769    
1770            public static float[] toFloatArray(
1771                    Collection<? extends Number> collection) {
1772    
1773                    float[] newArray = new float[collection.size()];
1774    
1775                    if (collection instanceof List) {
1776                            List<Number> list = (List<Number>)collection;
1777    
1778                            for (int i = 0; i < list.size(); i++) {
1779                                    Number value = list.get(i);
1780    
1781                                    newArray[i] = value.floatValue();
1782                            }
1783                    }
1784                    else {
1785                            int i = 0;
1786    
1787                            Iterator<? extends Number> iterator = collection.iterator();
1788    
1789                            while (iterator.hasNext()) {
1790                                    Number value = iterator.next();
1791    
1792                                    newArray[i++] = value.floatValue();
1793                            }
1794                    }
1795    
1796                    return newArray;
1797            }
1798    
1799            public static int[] toIntArray(Collection<? extends Number> collection) {
1800                    int[] newArray = new int[collection.size()];
1801    
1802                    if (collection instanceof List) {
1803                            List<Number> list = (List<Number>)collection;
1804    
1805                            for (int i = 0; i < list.size(); i++) {
1806                                    Number value = list.get(i);
1807    
1808                                    newArray[i] = value.intValue();
1809                            }
1810                    }
1811                    else {
1812                            int i = 0;
1813    
1814                            Iterator<? extends Number> iterator = collection.iterator();
1815    
1816                            while (iterator.hasNext()) {
1817                                    Number value = iterator.next();
1818    
1819                                    newArray[i++] = value.intValue();
1820                            }
1821                    }
1822    
1823                    return newArray;
1824            }
1825    
1826            public static long[] toLongArray(Collection<? extends Number> collection) {
1827                    long[] newArray = new long[collection.size()];
1828    
1829                    if (collection instanceof List) {
1830                            List<Number> list = (List<Number>)collection;
1831    
1832                            for (int i = 0; i < list.size(); i++) {
1833                                    Number value = list.get(i);
1834    
1835                                    newArray[i] = value.longValue();
1836                            }
1837                    }
1838                    else {
1839                            int i = 0;
1840    
1841                            Iterator<? extends Number> iterator = collection.iterator();
1842    
1843                            while (iterator.hasNext()) {
1844                                    Number value = iterator.next();
1845    
1846                                    newArray[i++] = value.longValue();
1847                            }
1848                    }
1849    
1850                    return newArray;
1851            }
1852    
1853            public static Long[] toLongArray(int[] array) {
1854                    Long[] newArray = new Long[array.length];
1855    
1856                    for (int i = 0; i < array.length; i++) {
1857                            newArray[i] = (long)array[i];
1858                    }
1859    
1860                    return newArray;
1861            }
1862    
1863            public static Long[] toLongArray(long[] array) {
1864                    Long[] newArray = new Long[array.length];
1865    
1866                    for (int i = 0; i < array.length; i++) {
1867                            newArray[i] = array[i];
1868                    }
1869    
1870                    return newArray;
1871            }
1872    
1873            public static Long[] toLongArray(Object[] array) {
1874                    Long[] newArray = new Long[array.length];
1875    
1876                    for (int i = 0; i < array.length; i++) {
1877                            newArray[i] = (Long)array[i];
1878                    }
1879    
1880                    return newArray;
1881            }
1882    
1883            public static short[] toShortArray(Collection<Short> collection) {
1884                    short[] newArray = new short[collection.size()];
1885    
1886                    if (collection instanceof List) {
1887                            List<Short> list = (List<Short>)collection;
1888    
1889                            for (int i = 0; i < list.size(); i++) {
1890                                    Short value = list.get(i);
1891    
1892                                    newArray[i] = value.shortValue();
1893                            }
1894                    }
1895                    else {
1896                            int i = 0;
1897    
1898                            Iterator<Short> iterator = collection.iterator();
1899    
1900                            while (iterator.hasNext()) {
1901                                    Short value = iterator.next();
1902    
1903                                    newArray[i++] = value.shortValue();
1904                            }
1905                    }
1906    
1907                    return newArray;
1908            }
1909    
1910            /**
1911             * @see ListUtil#toString(List, String)
1912             */
1913            public static String toString(Object[] array, String param) {
1914                    return toString(array, param, StringPool.COMMA);
1915            }
1916    
1917            /**
1918             * @see ListUtil#toString(List, String, String)
1919             */
1920            public static String toString(
1921                    Object[] array, String param, String delimiter) {
1922    
1923                    return toString(array, param, delimiter, null);
1924            }
1925    
1926            public static String toString(
1927                    Object[] array, String param, String delimiter, Locale locale) {
1928    
1929                    if (isEmpty(array)) {
1930                            return StringPool.BLANK;
1931                    }
1932    
1933                    StringBundler sb = new StringBundler(2 * array.length - 1);
1934    
1935                    for (int i = 0; i < array.length; i++) {
1936                            Object bean = array[i];
1937    
1938                            Object value = BeanPropertiesUtil.getObject(bean, param);
1939    
1940                            if (value != null) {
1941                                    if (locale != null) {
1942                                            sb.append(LanguageUtil.get(locale, value.toString()));
1943                                    }
1944                                    else {
1945                                            sb.append(value);
1946                                    }
1947                            }
1948    
1949                            if ((i + 1) != array.length) {
1950                                    sb.append(delimiter);
1951                            }
1952                    }
1953    
1954                    return sb.toString();
1955            }
1956    
1957            /**
1958             * @see ListUtil#toString(List, Accessor)
1959             */
1960            public static <T, A> String toString(T[] list, Accessor<T, A> accessor) {
1961                    return toString(list, accessor, StringPool.COMMA);
1962            }
1963    
1964            /**
1965             * @see ListUtil#toString(List, Accessor, String)
1966             */
1967            public static <T, A> String toString(
1968                    T[] list, Accessor<T, A> accessor, String delimiter) {
1969    
1970                    return toString(list, accessor, delimiter, null);
1971            }
1972    
1973            public static <T, A> String toString(
1974                    T[] list, Accessor<T, A> accessor, String delimiter, Locale locale) {
1975    
1976                    if (isEmpty(list)) {
1977                            return StringPool.BLANK;
1978                    }
1979    
1980                    StringBundler sb = new StringBundler(2 * list.length - 1);
1981    
1982                    for (int i = 0; i < list.length; i++) {
1983                            T bean = list[i];
1984    
1985                            A attribute = accessor.get(bean);
1986    
1987                            if (attribute != null) {
1988                                    if (locale != null) {
1989                                            sb.append(LanguageUtil.get(locale, attribute.toString()));
1990                                    }
1991                                    else {
1992                                            sb.append(attribute);
1993                                    }
1994                            }
1995    
1996                            if ((i + 1) != list.length) {
1997                                    sb.append(delimiter);
1998                            }
1999                    }
2000    
2001                    return sb.toString();
2002            }
2003    
2004            public static String[] toStringArray(boolean[] array) {
2005                    String[] newArray = new String[array.length];
2006    
2007                    for (int i = 0; i < array.length; i++) {
2008                            newArray[i] = String.valueOf(array[i]);
2009                    }
2010    
2011                    return newArray;
2012            }
2013    
2014            public static String[] toStringArray(byte[] array) {
2015                    String[] newArray = new String[array.length];
2016    
2017                    for (int i = 0; i < array.length; i++) {
2018                            newArray[i] = String.valueOf(array[i]);
2019                    }
2020    
2021                    return newArray;
2022            }
2023    
2024            public static String[] toStringArray(char[] array) {
2025                    String[] newArray = new String[array.length];
2026    
2027                    for (int i = 0; i < array.length; i++) {
2028                            newArray[i] = String.valueOf(array[i]);
2029                    }
2030    
2031                    return newArray;
2032            }
2033    
2034            public static String[] toStringArray(Collection<String> collection) {
2035                    String[] newArray = new String[collection.size()];
2036    
2037                    if (collection instanceof List) {
2038                            List<String> list = (List<String>)collection;
2039    
2040                            for (int i = 0; i < list.size(); i++) {
2041                                    String value = list.get(i);
2042    
2043                                    newArray[i] = String.valueOf(value);
2044                            }
2045                    }
2046                    else {
2047                            int i = 0;
2048    
2049                            Iterator<String> iterator = collection.iterator();
2050    
2051                            while (iterator.hasNext()) {
2052                                    String value = iterator.next();
2053    
2054                                    newArray[i++] = String.valueOf(value);
2055                            }
2056                    }
2057    
2058                    return newArray;
2059            }
2060    
2061            public static String[] toStringArray(Date[] array, DateFormat dateFormat) {
2062                    String[] newArray = new String[array.length];
2063    
2064                    for (int i = 0; i < array.length; i++) {
2065                            newArray[i] = dateFormat.format(array[i]);
2066                    }
2067    
2068                    return newArray;
2069            }
2070    
2071            public static String[] toStringArray(double[] array) {
2072                    String[] newArray = new String[array.length];
2073    
2074                    for (int i = 0; i < array.length; i++) {
2075                            newArray[i] = String.valueOf(array[i]);
2076                    }
2077    
2078                    return newArray;
2079            }
2080    
2081            public static String[] toStringArray(float[] array) {
2082                    String[] newArray = new String[array.length];
2083    
2084                    for (int i = 0; i < array.length; i++) {
2085                            newArray[i] = String.valueOf(array[i]);
2086                    }
2087    
2088                    return newArray;
2089            }
2090    
2091            public static String[] toStringArray(int[] array) {
2092                    String[] newArray = new String[array.length];
2093    
2094                    for (int i = 0; i < array.length; i++) {
2095                            newArray[i] = String.valueOf(array[i]);
2096                    }
2097    
2098                    return newArray;
2099            }
2100    
2101            public static String[] toStringArray(JSONArray array) {
2102                    String[] newArray = new String[array.length()];
2103    
2104                    for (int i = 0; i < array.length(); i++) {
2105                            newArray[i] = array.getString(i);
2106                    }
2107    
2108                    return newArray;
2109            }
2110    
2111            public static String[] toStringArray(long[] array) {
2112                    String[] newArray = new String[array.length];
2113    
2114                    for (int i = 0; i < array.length; i++) {
2115                            newArray[i] = String.valueOf(array[i]);
2116                    }
2117    
2118                    return newArray;
2119            }
2120    
2121            public static String[] toStringArray(Object[] array) {
2122                    String[] newArray = new String[array.length];
2123    
2124                    for (int i = 0; i < array.length; i++) {
2125                            newArray[i] = String.valueOf(array[i]);
2126                    }
2127    
2128                    return newArray;
2129            }
2130    
2131            public static String[] toStringArray(short[] array) {
2132                    String[] newArray = new String[array.length];
2133    
2134                    for (int i = 0; i < array.length; i++) {
2135                            newArray[i] = String.valueOf(array[i]);
2136                    }
2137    
2138                    return newArray;
2139            }
2140    
2141            public static byte[] unique(byte[] array) {
2142                    Set<Byte> set = new LinkedHashSet<>();
2143    
2144                    for (int i = 0; i < array.length; i++) {
2145                            set.add(array[i]);
2146                    }
2147    
2148                    return toArray(set.toArray(new Byte[set.size()]));
2149            }
2150    
2151            public static double[] unique(double[] array) {
2152                    Set<Double> set = new LinkedHashSet<>();
2153    
2154                    for (int i = 0; i < array.length; i++) {
2155                            set.add(array[i]);
2156                    }
2157    
2158                    return toArray(set.toArray(new Double[set.size()]));
2159            }
2160    
2161            public static float[] unique(float[] array) {
2162                    Set<Float> set = new LinkedHashSet<>();
2163    
2164                    for (int i = 0; i < array.length; i++) {
2165                            set.add(array[i]);
2166                    }
2167    
2168                    return toArray(set.toArray(new Float[set.size()]));
2169            }
2170    
2171            public static int[] unique(int[] array) {
2172                    Set<Integer> set = new LinkedHashSet<>();
2173    
2174                    for (int i = 0; i < array.length; i++) {
2175                            set.add(array[i]);
2176                    }
2177    
2178                    return toArray(set.toArray(new Integer[set.size()]));
2179            }
2180    
2181            public static long[] unique(long[] array) {
2182                    Set<Long> set = new LinkedHashSet<>();
2183    
2184                    for (int i = 0; i < array.length; i++) {
2185                            set.add(array[i]);
2186                    }
2187    
2188                    return toArray(set.toArray(new Long[set.size()]));
2189            }
2190    
2191            public static short[] unique(short[] array) {
2192                    Set<Short> set = new LinkedHashSet<>();
2193    
2194                    for (int i = 0; i < array.length; i++) {
2195                            set.add(array[i]);
2196                    }
2197    
2198                    return toArray(set.toArray(new Short[set.size()]));
2199            }
2200    
2201            public static String[] unique(String[] array) {
2202                    Set<String> set = new LinkedHashSet<>();
2203    
2204                    for (int i = 0; i < array.length; i++) {
2205                            set.add(array[i]);
2206                    }
2207    
2208                    return toArray(set.toArray(new String[set.size()]));
2209            }
2210    
2211    }