001    /**
002     * Copyright (c) 2000-2012 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    
020    import java.lang.reflect.Array;
021    
022    import java.text.DateFormat;
023    
024    import java.util.ArrayList;
025    import java.util.Comparator;
026    import java.util.Date;
027    import java.util.List;
028    import java.util.Set;
029    import java.util.TreeSet;
030    
031    /**
032     * @author Brian Wing Shun Chan
033     */
034    public class ArrayUtil {
035    
036            public static boolean[] append(boolean[]... arrays) {
037                    int length = 0;
038    
039                    for (boolean[] array : arrays) {
040                            length += array.length;
041                    }
042    
043                    boolean[] newArray = new boolean[length];
044    
045                    int previousLength = 0;
046    
047                    for (boolean[] array : arrays) {
048                            System.arraycopy(array, 0, newArray, previousLength, array.length);
049    
050                            previousLength += array.length;
051                    }
052    
053                    return newArray;
054            }
055    
056            public static boolean[] append(boolean[] array, boolean value) {
057                    boolean[] newArray = new boolean[array.length + 1];
058    
059                    System.arraycopy(array, 0, newArray, 0, array.length);
060    
061                    newArray[newArray.length - 1] = value;
062    
063                    return newArray;
064            }
065    
066            public static byte[] append(byte[]... arrays) {
067                    int length = 0;
068    
069                    for (byte[] array : arrays) {
070                            length += array.length;
071                    }
072    
073                    byte[] newArray = new byte[length];
074    
075                    int previousLength = 0;
076    
077                    for (byte[] array : arrays) {
078                            System.arraycopy(array, 0, newArray, previousLength, array.length);
079    
080                            previousLength += array.length;
081                    }
082    
083                    return newArray;
084            }
085    
086            public static byte[] append(byte[] array, byte value) {
087                    byte[] newArray = new byte[array.length + 1];
088    
089                    System.arraycopy(array, 0, newArray, 0, array.length);
090    
091                    newArray[newArray.length - 1] = value;
092    
093                    return newArray;
094            }
095    
096            public static char[] append(char[]... arrays) {
097                    int length = 0;
098    
099                    for (char[] array : arrays) {
100                            length += array.length;
101                    }
102    
103                    char[] newArray = new char[length];
104    
105                    int previousLength = 0;
106    
107                    for (char[] array : arrays) {
108                            System.arraycopy(array, 0, newArray, previousLength, array.length);
109    
110                            previousLength += array.length;
111                    }
112    
113                    return newArray;
114            }
115    
116            public static char[] append(char[] array, char value) {
117                    char[] newArray = new char[array.length + 1];
118    
119                    System.arraycopy(array, 0, newArray, 0, array.length);
120    
121                    newArray[newArray.length - 1] = value;
122    
123                    return newArray;
124            }
125    
126            public static double[] append(double[]... arrays) {
127                    int length = 0;
128    
129                    for (double[] array : arrays) {
130                            length += array.length;
131                    }
132    
133                    double[] newArray = new double[length];
134    
135                    int previousLength = 0;
136    
137                    for (double[] array : arrays) {
138                            System.arraycopy(array, 0, newArray, previousLength, array.length);
139    
140                            previousLength += array.length;
141                    }
142    
143                    return newArray;
144            }
145    
146            public static double[] append(double[] array, double value) {
147                    double[] newArray = new double[array.length + 1];
148    
149                    System.arraycopy(array, 0, newArray, 0, array.length);
150    
151                    newArray[newArray.length - 1] = value;
152    
153                    return newArray;
154            }
155    
156            public static float[] append(float[]... arrays) {
157                    int length = 0;
158    
159                    for (float[] array : arrays) {
160                            length += array.length;
161                    }
162    
163                    float[] newArray = new float[length];
164    
165                    int previousLength = 0;
166    
167                    for (float[] array : arrays) {
168                            System.arraycopy(array, 0, newArray, previousLength, array.length);
169    
170                            previousLength += array.length;
171                    }
172    
173                    return newArray;
174            }
175    
176            public static float[] append(float[] array, float value) {
177                    float[] newArray = new float[array.length + 1];
178    
179                    System.arraycopy(array, 0, newArray, 0, array.length);
180    
181                    newArray[newArray.length - 1] = value;
182    
183                    return newArray;
184            }
185    
186            public static int[] append(int[]... arrays) {
187                    int length = 0;
188    
189                    for (int[] array : arrays) {
190                            length += array.length;
191                    }
192    
193                    int[] newArray = new int[length];
194    
195                    int previousLength = 0;
196    
197                    for (int[] array : arrays) {
198                            System.arraycopy(array, 0, newArray, previousLength, array.length);
199    
200                            previousLength += array.length;
201                    }
202    
203                    return newArray;
204            }
205    
206            public static int[] append(int[] array, int value) {
207                    int[] newArray = new int[array.length + 1];
208    
209                    System.arraycopy(array, 0, newArray, 0, array.length);
210    
211                    newArray[newArray.length - 1] = value;
212    
213                    return newArray;
214            }
215    
216            public static long[] append(long[]... arrays) {
217                    int length = 0;
218    
219                    for (long[] array : arrays) {
220                            length += array.length;
221                    }
222    
223                    long[] newArray = new long[length];
224    
225                    int previousLength = 0;
226    
227                    for (long[] array : arrays) {
228                            System.arraycopy(array, 0, newArray, previousLength, array.length);
229    
230                            previousLength += array.length;
231                    }
232    
233                    return newArray;
234            }
235    
236            public static long[] append(long[] array, long value) {
237                    long[] newArray = new long[array.length + 1];
238    
239                    System.arraycopy(array, 0, newArray, 0, array.length);
240    
241                    newArray[newArray.length - 1] = value;
242    
243                    return newArray;
244            }
245    
246            public static short[] append(short[]... arrays) {
247                    int length = 0;
248    
249                    for (short[] array : arrays) {
250                            length += array.length;
251                    }
252    
253                    short[] newArray = new short[length];
254    
255                    int previousLength = 0;
256    
257                    for (short[] array : arrays) {
258                            System.arraycopy(array, 0, newArray, previousLength, array.length);
259    
260                            previousLength += array.length;
261                    }
262    
263                    return newArray;
264            }
265    
266            public static short[] append(short[] array, short value) {
267                    short[] newArray = new short[array.length + 1];
268    
269                    System.arraycopy(array, 0, newArray, 0, array.length);
270    
271                    newArray[newArray.length - 1] = value;
272    
273                    return newArray;
274            }
275    
276            public static <T> T[] append(T[]... arrays) {
277                    int length = 0;
278    
279                    for (T[] array : arrays) {
280                            length += array.length;
281                    }
282    
283                    Class<?> arraysClass = arrays[0].getClass();
284    
285                    T[] newArray = (T[])Array.newInstance(
286                            arraysClass.getComponentType(), length);
287    
288                    int previousLength = 0;
289    
290                    for (T[] array : arrays) {
291                            System.arraycopy(array, 0, newArray, previousLength, array.length);
292    
293                            previousLength += array.length;
294                    }
295    
296                    return newArray;
297            }
298    
299            public static <T> T[] append(T[] array, T value) {
300                    Class<?> arrayClass = array.getClass();
301    
302                    T[] newArray = (T[])Array.newInstance(
303                            arrayClass.getComponentType(), array.length + 1);
304    
305                    System.arraycopy(array, 0, newArray, 0, array.length);
306    
307                    newArray[array.length] = value;
308    
309                    return newArray;
310            }
311    
312            public static <T> T[] append(T[] array1, T[] array2) {
313                    Class<?> array1Class = array1.getClass();
314    
315                    T[] newArray = (T[])Array.newInstance(
316                            array1Class.getComponentType(), array1.length + array2.length);
317    
318                    System.arraycopy(array1, 0, newArray, 0, array1.length);
319    
320                    System.arraycopy(array2, 0, newArray, array1.length, array2.length);
321    
322                    return newArray;
323            }
324    
325            public static <T> T[][] append(T[][] array1, T[] value) {
326                    Class<?> array1Class = array1.getClass();
327    
328                    T[][] newArray = (T[][])Array.newInstance(
329                            array1Class.getComponentType(), array1.length + 1);
330    
331                    System.arraycopy(array1, 0, newArray, 0, array1.length);
332    
333                    newArray[array1.length] = value;
334    
335                    return newArray;
336            }
337    
338            public static <T> T[][] append(T[][] array1, T[][] array2) {
339                    Class<?> array1Class = array1.getClass();
340    
341                    T[][] newArray = (T[][])Array.newInstance(
342                            array1Class.getComponentType(), array1.length + array2.length);
343    
344                    System.arraycopy(array1, 0, newArray, 0, array1.length);
345                    System.arraycopy(array2, 0, newArray, array1.length, array2.length);
346    
347                    return newArray;
348            }
349    
350            public static boolean[] clone(boolean[] array) {
351                    boolean[] newArray = new boolean[array.length];
352    
353                    System.arraycopy(array, 0, newArray, 0, array.length);
354    
355                    return newArray;
356            }
357    
358            public static boolean[] clone(boolean[] array, int from, int to) {
359                    boolean[] newArray = new boolean[to - from];
360    
361                    System.arraycopy(
362                            array, from, newArray, 0,
363                            Math.min(array.length - from, newArray.length));
364    
365                    return newArray;
366            }
367    
368            public static byte[] clone(byte[] array) {
369                    byte[] newArray = new byte[array.length];
370    
371                    System.arraycopy(array, 0, newArray, 0, array.length);
372    
373                    return newArray;
374            }
375    
376            public static byte[] clone(byte[] array, int from, int to) {
377                    byte[] newArray = new byte[to - from];
378    
379                    System.arraycopy(
380                            array, from, newArray, 0,
381                            Math.min(array.length - from, newArray.length));
382    
383                    return newArray;
384            }
385    
386            public static char[] clone(char[] array) {
387                    char[] newArray = new char[array.length];
388    
389                    System.arraycopy(array, 0, newArray, 0, array.length);
390    
391                    return newArray;
392            }
393    
394            public static char[] clone(char[] array, int from, int to) {
395                    char[] newArray = new char[to - from];
396    
397                    System.arraycopy(
398                            array, from, newArray, 0,
399                            Math.min(array.length - from, newArray.length));
400    
401                    return newArray;
402            }
403    
404            public static double[] clone(double[] array) {
405                    double[] newArray = new double[array.length];
406    
407                    System.arraycopy(array, 0, newArray, 0, array.length);
408    
409                    return newArray;
410            }
411    
412            public static double[] clone(double[] array, int from, int to) {
413                    double[] newArray = new double[to - from];
414    
415                    System.arraycopy(
416                            array, from, newArray, 0,
417                            Math.min(array.length - from, newArray.length));
418    
419                    return newArray;
420            }
421    
422            public static float[] clone(float[] array) {
423                    float[] newArray = new float[array.length];
424    
425                    System.arraycopy(array, 0, newArray, 0, array.length);
426    
427                    return newArray;
428            }
429    
430            public static float[] clone(float[] array, int from, int to) {
431                    float[] newArray = new float[to - from];
432    
433                    System.arraycopy(
434                            array, from, newArray, 0,
435                            Math.min(array.length - from, newArray.length));
436    
437                    return newArray;
438            }
439    
440            public static int[] clone(int[] array) {
441                    int[] newArray = new int[array.length];
442    
443                    System.arraycopy(array, 0, newArray, 0, array.length);
444    
445                    return newArray;
446            }
447    
448            public static int[] clone(int[] array, int from, int to) {
449                    int[] newArray = new int[to - from];
450    
451                    System.arraycopy(
452                            array, from, newArray, 0,
453                            Math.min(array.length - from, newArray.length));
454    
455                    return newArray;
456            }
457    
458            public static long[] clone(long[] array) {
459                    long[] newArray = new long[array.length];
460    
461                    System.arraycopy(array, 0, newArray, 0, array.length);
462    
463                    return newArray;
464            }
465    
466            public static long[] clone(long[] array, int from, int to) {
467                    long[] newArray = new long[to - from];
468    
469                    System.arraycopy(
470                            array, from, newArray, 0,
471                            Math.min(array.length - from, newArray.length));
472    
473                    return newArray;
474            }
475    
476            public static short[] clone(short[] array) {
477                    short[] newArray = new short[array.length];
478    
479                    System.arraycopy(array, 0, newArray, 0, array.length);
480    
481                    return newArray;
482            }
483    
484            public static short[] clone(short[] array, int from, int to) {
485                    short[] newArray = new short[to - from];
486    
487                    System.arraycopy(
488                            array, from, newArray, 0,
489                            Math.min(array.length - from, newArray.length));
490    
491                    return newArray;
492            }
493    
494            public static <T> T[] clone(T[] array) {
495                    Class<?> arrayClass = array.getClass();
496    
497                    T[] newArray = (T[])Array.newInstance(
498                            arrayClass.getComponentType(), array.length);
499    
500                    System.arraycopy(array, 0, newArray, 0, array.length);
501    
502                    return newArray;
503            }
504    
505            public static <T> T[] clone(T[] array, int from, int to) {
506                    Class<?> arrayClass = array.getClass();
507    
508                    T[] newArray = (T[])Array.newInstance(
509                            arrayClass.getComponentType(), to - from);
510    
511                    System.arraycopy(
512                            array, from, newArray, 0,
513                            Math.min(array.length - from, newArray.length));
514    
515                    return newArray;
516            }
517    
518            public static <T> T[][] clone(T[][] array) {
519                    Class<?> arrayClass = array.getClass();
520    
521                    T[][] newArray = (T[][])Array.newInstance(
522                            arrayClass.getComponentType(), array.length);
523    
524                    System.arraycopy(array, 0, newArray, 0, array.length);
525    
526                    return newArray;
527            }
528    
529            public static <T> T[][] clone(T[][] array, int from, int to) {
530                    Class<?> arrayClass = array.getClass();
531    
532                    T[][] newArray = (T[][])Array.newInstance(
533                            arrayClass.getComponentType(), to - from);
534    
535                    System.arraycopy(
536                            array, from, newArray, 0,
537                            Math.min(array.length - from, newArray.length));
538    
539                    return newArray;
540            }
541    
542            public static void combine(
543                    Object[] array1, Object[] array2, Object[] combinedArray) {
544    
545                    System.arraycopy(array1, 0, combinedArray, 0, array1.length);
546    
547                    System.arraycopy(
548                            array2, 0, combinedArray, array1.length, array2.length);
549            }
550    
551            public static boolean contains(boolean[] array, boolean value) {
552                    if ((array == null) || (array.length == 0)) {
553                            return false;
554                    }
555    
556                    for (int i = 0; i < array.length; i++) {
557                            if (value == array[i]) {
558                                    return true;
559                            }
560                    }
561    
562                    return false;
563            }
564    
565            public static boolean contains(byte[] array, byte value) {
566                    if ((array == null) || (array.length == 0)) {
567                            return false;
568                    }
569    
570                    for (int i = 0; i < array.length; i++) {
571                            if (value == array[i]) {
572                                    return true;
573                            }
574                    }
575    
576                    return false;
577            }
578    
579            public static boolean contains(char[] array, char value) {
580                    if ((array == null) || (array.length == 0)) {
581                            return false;
582                    }
583    
584                    for (int i = 0; i < array.length; i++) {
585                            if (value == array[i]) {
586                                    return true;
587                            }
588                    }
589    
590                    return false;
591            }
592    
593            public static boolean contains(double[] array, double value) {
594                    if ((array == null) || (array.length == 0)) {
595                            return false;
596                    }
597    
598                    for (int i = 0; i < array.length; i++) {
599                            if (value == array[i]) {
600                                    return true;
601                            }
602                    }
603    
604                    return false;
605            }
606    
607            public static boolean contains(float[] array, float value) {
608                    if ((array == null) || (array.length == 0)) {
609                            return false;
610                    }
611    
612                    for (int i = 0; i < array.length; i++) {
613                            if (value == array[i]) {
614                                    return true;
615                            }
616                    }
617    
618                    return false;
619            }
620    
621            public static boolean contains(int[] array, int value) {
622                    if ((array == null) || (array.length == 0)) {
623                            return false;
624                    }
625    
626                    for (int i = 0; i < array.length; i++) {
627                            if (value == array[i]) {
628                                    return true;
629                            }
630                    }
631    
632                    return false;
633            }
634    
635            public static boolean contains(long[] array, long value) {
636                    if ((array == null) || (array.length == 0)) {
637                            return false;
638                    }
639    
640                    for (int i = 0; i < array.length; i++) {
641                            if (value == array[i]) {
642                                    return true;
643                            }
644                    }
645    
646                    return false;
647            }
648    
649            public static boolean contains(Object[] array, Object value) {
650                    if ((array == null) || (array.length == 0) || (value == null)) {
651                            return false;
652                    }
653    
654                    for (int i = 0; i < array.length; i++) {
655                            if (value.equals(array[i])) {
656                                    return true;
657                            }
658                    }
659    
660                    return false;
661            }
662    
663            public static boolean contains(short[] array, short value) {
664                    if ((array == null) || (array.length == 0)) {
665                            return false;
666                    }
667    
668                    for (int i = 0; i < array.length; i++) {
669                            if (value == array[i]) {
670                                    return true;
671                            }
672                    }
673    
674                    return false;
675            }
676    
677            public static String[] distinct(String[] array) {
678                    return distinct(array, null);
679            }
680    
681            public static String[] distinct(
682                    String[] array, Comparator<String> comparator) {
683    
684                    if ((array == null) || (array.length == 0)) {
685                            return array;
686                    }
687    
688                    Set<String> set = null;
689    
690                    if (comparator == null) {
691                            set = new TreeSet<String>();
692                    }
693                    else {
694                            set = new TreeSet<String>(comparator);
695                    }
696    
697                    for (int i = 0; i < array.length; i++) {
698                            String s = array[i];
699    
700                            if (!set.contains(s)) {
701                                    set.add(s);
702                            }
703                    }
704    
705                    return set.toArray(new String[set.size()]);
706            }
707    
708            public static int getLength(Object[] array) {
709                    if (array == null) {
710                            return 0;
711                    }
712                    else {
713                            return array.length;
714                    }
715            }
716    
717            public static Object getValue(Object[] array, int pos) {
718                    if ((array == null) || (array.length <= pos)) {
719                            return null;
720                    }
721                    else {
722                            return array[pos];
723                    }
724            }
725    
726            public static boolean[] remove(boolean[] array, boolean value) {
727                    List<Boolean> list = new ArrayList<Boolean>();
728    
729                    for (int i = 0; i < array.length; i++) {
730                            if (value != array[i]) {
731                                    list.add(new Boolean(array[i]));
732                            }
733                    }
734    
735                    return toArray(list.toArray(new Boolean[list.size()]));
736            }
737    
738            public static byte[] remove(byte[] array, byte value) {
739                    List<Byte> list = new ArrayList<Byte>();
740    
741                    for (int i = 0; i < array.length; i++) {
742                            if (value != array[i]) {
743                                    list.add(new Byte(array[i]));
744                            }
745                    }
746    
747                    return toArray(list.toArray(new Byte[list.size()]));
748            }
749    
750            public static char[] remove(char[] array, char value) {
751                    List<Character> list = new ArrayList<Character>();
752    
753                    for (int i = 0; i < array.length; i++) {
754                            if (value != array[i]) {
755                                    list.add(new Character(array[i]));
756                            }
757                    }
758    
759                    return toArray(list.toArray(new Character[list.size()]));
760            }
761    
762            public static double[] remove(double[] array, double value) {
763                    List<Double> list = new ArrayList<Double>();
764    
765                    for (int i = 0; i < array.length; i++) {
766                            if (value != array[i]) {
767                                    list.add(new Double(array[i]));
768                            }
769                    }
770    
771                    return toArray(list.toArray(new Double[list.size()]));
772            }
773    
774            public static int[] remove(int[] array, int value) {
775                    List<Integer> list = new ArrayList<Integer>();
776    
777                    for (int i = 0; i < array.length; i++) {
778                            if (value != array[i]) {
779                                    list.add(new Integer(array[i]));
780                            }
781                    }
782    
783                    return toArray(list.toArray(new Integer[list.size()]));
784            }
785    
786            public static long[] remove(long[] array, long value) {
787                    List<Long> list = new ArrayList<Long>();
788    
789                    for (int i = 0; i < array.length; i++) {
790                            if (value != array[i]) {
791                                    list.add(new Long(array[i]));
792                            }
793                    }
794    
795                    return toArray(list.toArray(new Long[list.size()]));
796            }
797    
798            public static short[] remove(short[] array, short value) {
799                    List<Short> list = new ArrayList<Short>();
800    
801                    for (int i = 0; i < array.length; i++) {
802                            if (value != array[i]) {
803                                    list.add(new Short(array[i]));
804                            }
805                    }
806    
807                    return toArray(list.toArray(new Short[list.size()]));
808            }
809    
810            public static String[] remove(String[] array, String value) {
811                    List<String> list = new ArrayList<String>();
812    
813                    for (String s : array) {
814                            if (!s.equals(value)) {
815                                    list.add(s);
816                            }
817                    }
818    
819                    return list.toArray(new String[list.size()]);
820            }
821    
822            public static String[] removeByPrefix(String[] array, String prefix) {
823                    List<String> list = new ArrayList<String>();
824    
825                    for (String s : array) {
826                            if (!s.startsWith(prefix)) {
827                                    list.add(s);
828                            }
829                    }
830    
831                    return list.toArray(new String[list.size()]);
832            }
833    
834            public static void reverse(String[] array) {
835                    for (int left = 0, right = array.length - 1; left < right;
836                                    left++, right--) {
837    
838                            String value = array[left];
839    
840                            array[left] = array[right];
841                            array[right] = value;
842                    }
843            }
844    
845            public static boolean[] subset(boolean[] array, int start, int end) {
846                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
847                            return array;
848                    }
849    
850                    boolean[] newArray = new boolean[end - start];
851    
852                    System.arraycopy(array, start, newArray, 0, end - start);
853    
854                    return newArray;
855            }
856    
857            public static byte[] subset(byte[] array, int start, int end) {
858                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
859                            return array;
860                    }
861    
862                    byte[] newArray = new byte[end - start];
863    
864                    System.arraycopy(array, start, newArray, 0, end - start);
865    
866                    return newArray;
867            }
868    
869            public static char[] subset(char[] array, int start, int end) {
870                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
871                            return array;
872                    }
873    
874                    char[] newArray = new char[end - start];
875    
876                    System.arraycopy(array, start, newArray, 0, end - start);
877    
878                    return newArray;
879            }
880    
881            public static double[] subset(double[] array, int start, int end) {
882                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
883                            return array;
884                    }
885    
886                    double[] newArray = new double[end - start];
887    
888                    System.arraycopy(array, start, newArray, 0, end - start);
889    
890                    return newArray;
891            }
892    
893            public static float[] subset(float[] array, int start, int end) {
894                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
895                            return array;
896                    }
897    
898                    float[] newArray = new float[end - start];
899    
900                    System.arraycopy(array, start, newArray, 0, end - start);
901    
902                    return newArray;
903            }
904    
905            public static int[] subset(int[] array, int start, int end) {
906                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
907                            return array;
908                    }
909    
910                    int[] newArray = new int[end - start];
911    
912                    System.arraycopy(array, start, newArray, 0, end - start);
913    
914                    return newArray;
915            }
916    
917            public static long[] subset(long[] array, int start, int end) {
918                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
919                            return array;
920                    }
921    
922                    long[] newArray = new long[end - start];
923    
924                    System.arraycopy(array, start, newArray, 0, end - start);
925    
926                    return newArray;
927            }
928    
929            public static short[] subset(short[] array, int start, int end) {
930                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
931                            return array;
932                    }
933    
934                    short[] newArray = new short[end - start];
935    
936                    System.arraycopy(array, start, newArray, 0, end - start);
937    
938                    return newArray;
939            }
940    
941            public static <T> T[] subset(T[] array, int start, int end) {
942                    if ((start < 0) || (end < 0) || ((end - start) < 0)) {
943                            return array;
944                    }
945    
946                    Class<?> arrayClass = array.getClass();
947    
948                    T[] newArray = (T[])Array.newInstance(
949                            arrayClass.getComponentType(), end - start);
950    
951                    System.arraycopy(array, start, newArray, 0, end - start);
952    
953                    return newArray;
954            }
955    
956            public static Boolean[] toArray(boolean[] array) {
957                    Boolean[] newArray = new Boolean[array.length];
958    
959                    for (int i = 0; i < array.length; i++) {
960                            newArray[i] = Boolean.valueOf(array[i]);
961                    }
962    
963                    return newArray;
964            }
965    
966            public static boolean[] toArray(Boolean[] array) {
967                    boolean[] newArray = new boolean[array.length];
968    
969                    for (int i = 0; i < array.length; i++) {
970                            newArray[i] = array[i].booleanValue();
971                    }
972    
973                    return newArray;
974            }
975    
976            public static Byte[] toArray(byte[] array) {
977                    Byte[] newArray = new Byte[array.length];
978    
979                    for (int i = 0; i < array.length; i++) {
980                            newArray[i] = Byte.valueOf(array[i]);
981                    }
982    
983                    return newArray;
984            }
985    
986            public static byte[] toArray(Byte[] array) {
987                    byte[] newArray = new byte[array.length];
988    
989                    for (int i = 0; i < array.length; i++) {
990                            newArray[i] = array[i].byteValue();
991                    }
992    
993                    return newArray;
994            }
995    
996            public static Character[] toArray(char[] array) {
997                    Character[] newArray = new Character[array.length];
998    
999                    for (int i = 0; i < array.length; i++) {
1000                            newArray[i] = Character.valueOf(array[i]);
1001                    }
1002    
1003                    return newArray;
1004            }
1005    
1006            public static char[] toArray(Character[] array) {
1007                    char[] newArray = new char[array.length];
1008    
1009                    for (int i = 0; i < array.length; i++) {
1010                            newArray[i] = array[i].charValue();
1011                    }
1012    
1013                    return newArray;
1014            }
1015    
1016            public static Double[] toArray(double[] array) {
1017                    Double[] newArray = new Double[array.length];
1018    
1019                    for (int i = 0; i < array.length; i++) {
1020                            newArray[i] = new Double(array[i]);
1021                    }
1022    
1023                    return newArray;
1024            }
1025    
1026            public static double[] toArray(Double[] array) {
1027                    double[] newArray = new double[array.length];
1028    
1029                    for (int i = 0; i < array.length; i++) {
1030                            newArray[i] = array[i].doubleValue();
1031                    }
1032    
1033                    return newArray;
1034            }
1035    
1036            public static Float[] toArray(float[] array) {
1037                    Float[] newArray = new Float[array.length];
1038    
1039                    for (int i = 0; i < array.length; i++) {
1040                            newArray[i] = new Float(array[i]);
1041                    }
1042    
1043                    return newArray;
1044            }
1045    
1046            public static float[] toArray(Float[] array) {
1047                    float[] newArray = new float[array.length];
1048    
1049                    for (int i = 0; i < array.length; i++) {
1050                            newArray[i] = array[i].floatValue();
1051                    }
1052    
1053                    return newArray;
1054            }
1055    
1056            public static Integer[] toArray(int[] array) {
1057                    Integer[] newArray = new Integer[array.length];
1058    
1059                    for (int i = 0; i < array.length; i++) {
1060                            newArray[i] = new Integer(array[i]);
1061                    }
1062    
1063                    return newArray;
1064            }
1065    
1066            public static int[] toArray(Integer[] array) {
1067                    int[] newArray = new int[array.length];
1068    
1069                    for (int i = 0; i < array.length; i++) {
1070                            newArray[i] = array[i].intValue();
1071                    }
1072    
1073                    return newArray;
1074            }
1075    
1076            public static Long[] toArray(long[] array) {
1077                    Long[] newArray = new Long[array.length];
1078    
1079                    for (int i = 0; i < array.length; i++) {
1080                            newArray[i] = new Long(array[i]);
1081                    }
1082    
1083                    return newArray;
1084            }
1085    
1086            public static long[] toArray(Long[] array) {
1087                    long[] newArray = new long[array.length];
1088    
1089                    for (int i = 0; i < array.length; i++) {
1090                            newArray[i] = array[i].longValue();
1091                    }
1092    
1093                    return newArray;
1094            }
1095    
1096            public static Short[] toArray(short[] array) {
1097                    Short[] newArray = new Short[array.length];
1098    
1099                    for (int i = 0; i < array.length; i++) {
1100                            newArray[i] = new Short(array[i]);
1101                    }
1102    
1103                    return newArray;
1104            }
1105    
1106            public static short[] toArray(Short[] array) {
1107                    short[] newArray = new short[array.length];
1108    
1109                    for (int i = 0; i < array.length; i++) {
1110                            newArray[i] = array[i].shortValue();
1111                    }
1112    
1113                    return newArray;
1114            }
1115    
1116            public static Long[] toLongArray(Object[] array) {
1117                    Long[] newArray = new Long[array.length];
1118    
1119                    for (int i = 0; i < array.length; i++) {
1120                            newArray[i] = (Long)array[i];
1121                    }
1122    
1123                    return newArray;
1124            }
1125    
1126            /**
1127             * @see {@link ListUtil#toString(List, String)}
1128             */
1129            public static String toString(Object[] array, String param) {
1130                    return toString(array, param, StringPool.COMMA);
1131            }
1132    
1133            /**
1134             * @see {@link ListUtil#toString(List, String, String)}
1135             */
1136            public static String toString(
1137                    Object[] array, String param, String delimiter) {
1138    
1139                    if ((array == null) || (array.length == 0)) {
1140                            return StringPool.BLANK;
1141                    }
1142    
1143                    StringBundler sb = new StringBundler(2 * array.length - 1);
1144    
1145                    for (int i = 0; i < array.length; i++) {
1146                            Object bean = array[i];
1147    
1148                            Object value = BeanPropertiesUtil.getObject(bean, param);
1149    
1150                            if (value != null) {
1151                                    sb.append(value);
1152                            }
1153    
1154                            if ((i + 1) != array.length) {
1155                                    sb.append(delimiter);
1156                            }
1157                    }
1158    
1159                    return sb.toString();
1160            }
1161    
1162            /**
1163             * @see {@link ListUtil#toString(List, Accessor)}
1164             */
1165            public static <T, V> String toString(T[] list, Accessor<T, V> accessor) {
1166                    return toString(list, accessor, StringPool.COMMA);
1167            }
1168    
1169            /**
1170             * @see {@link ListUtil#toString(List, Accessor, String)}
1171             */
1172            public static <T, V> String toString(
1173                    T[] list, Accessor<T, V> accessor, String delimiter) {
1174    
1175                    if ((list == null) || (list.length == 0)) {
1176                            return StringPool.BLANK;
1177                    }
1178    
1179                    StringBundler sb = new StringBundler(2 * list.length - 1);
1180    
1181                    for (int i = 0; i < list.length; i++) {
1182                            T bean = list[i];
1183    
1184                            V value = accessor.get(bean);
1185    
1186                            if (value != null) {
1187                                    sb.append(value);
1188                            }
1189    
1190                            if ((i + 1) != list.length) {
1191                                    sb.append(delimiter);
1192                            }
1193                    }
1194    
1195                    return sb.toString();
1196            }
1197    
1198            public static String[] toStringArray(boolean[] array) {
1199                    String[] newArray = new String[array.length];
1200    
1201                    for (int i = 0; i < array.length; i++) {
1202                            newArray[i] = String.valueOf(array[i]);
1203                    }
1204    
1205                    return newArray;
1206            }
1207    
1208            public static String[] toStringArray(byte[] array) {
1209                    String[] newArray = new String[array.length];
1210    
1211                    for (int i = 0; i < array.length; i++) {
1212                            newArray[i] = String.valueOf(array[i]);
1213                    }
1214    
1215                    return newArray;
1216            }
1217    
1218            public static String[] toStringArray(char[] array) {
1219                    String[] newArray = new String[array.length];
1220    
1221                    for (int i = 0; i < array.length; i++) {
1222                            newArray[i] = String.valueOf(array[i]);
1223                    }
1224    
1225                    return newArray;
1226            }
1227    
1228            public static String[] toStringArray(Date[] array, DateFormat dateFormat) {
1229                    String[] newArray = new String[array.length];
1230    
1231                    for (int i = 0; i < array.length; i++) {
1232                            newArray[i] = dateFormat.format(array[i]);
1233                    }
1234    
1235                    return newArray;
1236            }
1237    
1238            public static String[] toStringArray(double[] array) {
1239                    String[] newArray = new String[array.length];
1240    
1241                    for (int i = 0; i < array.length; i++) {
1242                            newArray[i] = String.valueOf(array[i]);
1243                    }
1244    
1245                    return newArray;
1246            }
1247    
1248            public static String[] toStringArray(float[] array) {
1249                    String[] newArray = new String[array.length];
1250    
1251                    for (int i = 0; i < array.length; i++) {
1252                            newArray[i] = String.valueOf(array[i]);
1253                    }
1254    
1255                    return newArray;
1256            }
1257    
1258            public static String[] toStringArray(int[] array) {
1259                    String[] newArray = new String[array.length];
1260    
1261                    for (int i = 0; i < array.length; i++) {
1262                            newArray[i] = String.valueOf(array[i]);
1263                    }
1264    
1265                    return newArray;
1266            }
1267    
1268            public static String[] toStringArray(JSONArray array) {
1269                    String[] newArray = new String[array.length()];
1270    
1271                    for (int i = 0; i < array.length(); i++) {
1272                            newArray[i] = array.getString(i);
1273                    }
1274    
1275                    return newArray;
1276            }
1277    
1278            public static String[] toStringArray(long[] array) {
1279                    String[] newArray = new String[array.length];
1280    
1281                    for (int i = 0; i < array.length; i++) {
1282                            newArray[i] = String.valueOf(array[i]);
1283                    }
1284    
1285                    return newArray;
1286            }
1287    
1288            public static String[] toStringArray(Object[] array) {
1289                    String[] newArray = new String[array.length];
1290    
1291                    for (int i = 0; i < array.length; i++) {
1292                            newArray[i] = String.valueOf(array[i]);
1293                    }
1294    
1295                    return newArray;
1296            }
1297    
1298            public static String[] toStringArray(short[] array) {
1299                    String[] newArray = new String[array.length];
1300    
1301                    for (int i = 0; i < array.length; i++) {
1302                            newArray[i] = String.valueOf(array[i]);
1303                    }
1304    
1305                    return newArray;
1306            }
1307    
1308    }