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