1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portal.kernel.util;
16  
17  import com.liferay.portal.kernel.json.JSONArray;
18  
19  import java.text.DateFormat;
20  
21  import java.util.ArrayList;
22  import java.util.Comparator;
23  import java.util.Date;
24  import java.util.List;
25  import java.util.Set;
26  import java.util.TreeSet;
27  
28  /**
29   * <a href="ArrayUtil.java.html"><b><i>View Source</i></b></a>
30   *
31   * @author Brian Wing Shun Chan
32   */
33  public class ArrayUtil {
34  
35      public static boolean[] append(boolean[] array, boolean value) {
36          boolean[] newArray = new boolean[array.length + 1];
37  
38          System.arraycopy(array, 0, newArray, 0, array.length);
39  
40          newArray[newArray.length - 1] = value;
41  
42          return newArray;
43      }
44  
45      public static boolean[] append(boolean[] array1, boolean[] array2) {
46          boolean[] newArray = new boolean[array1.length + array2.length];
47  
48          System.arraycopy(array1, 0, newArray, 0, array1.length);
49          System.arraycopy(array2, 0, newArray, array1.length, array2.length);
50  
51          return newArray;
52      }
53  
54      public static Boolean[] append(Boolean[] array, Boolean value) {
55          Boolean[] newArray = new Boolean[array.length + 1];
56  
57          System.arraycopy(array, 0, newArray, 0, array.length);
58  
59          newArray[newArray.length - 1] = value;
60  
61          return newArray;
62      }
63  
64      public static Boolean[] append(Boolean[] array1, Boolean[] array2) {
65          Boolean[] newArray = new Boolean[array1.length + array2.length];
66  
67          System.arraycopy(array1, 0, newArray, 0, array1.length);
68          System.arraycopy(array2, 0, newArray, array1.length, array2.length);
69  
70          return newArray;
71      }
72  
73      public static byte[] append(byte[] array, byte value) {
74          byte[] newArray = new byte[array.length + 1];
75  
76          System.arraycopy(array, 0, newArray, 0, array.length);
77  
78          newArray[newArray.length - 1] = value;
79  
80          return newArray;
81      }
82  
83      public static byte[] append(byte[] array1, byte[] array2) {
84          byte[] newArray = new byte[array1.length + array2.length];
85  
86          System.arraycopy(array1, 0, newArray, 0, array1.length);
87          System.arraycopy(array2, 0, newArray, array1.length, array2.length);
88  
89          return newArray;
90      }
91  
92      public static double[] append(double[] array, double value) {
93          double[] newArray = new double[array.length + 1];
94  
95          System.arraycopy(array, 0, newArray, 0, array.length);
96  
97          newArray[newArray.length - 1] = value;
98  
99          return newArray;
100     }
101 
102     public static double[] append(double[] array1, double[] array2) {
103         double[] newArray = new double[array1.length + array2.length];
104 
105         System.arraycopy(array1, 0, newArray, 0, array1.length);
106         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
107 
108         return newArray;
109     }
110 
111     public static Double[] append(Double[] array, Double value) {
112         Double[] newArray = new Double[array.length + 1];
113 
114         System.arraycopy(array, 0, newArray, 0, array.length);
115 
116         newArray[newArray.length - 1] = value;
117 
118         return newArray;
119     }
120 
121     public static Double[] append(Double[] array1, Double[] array2) {
122         Double[] newArray = new Double[array1.length + array2.length];
123 
124         System.arraycopy(array1, 0, newArray, 0, array1.length);
125         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
126 
127         return newArray;
128     }
129 
130     public static float[] append(float[] array, float value) {
131         float[] newArray = new float[array.length + 1];
132 
133         System.arraycopy(array, 0, newArray, 0, array.length);
134 
135         newArray[newArray.length - 1] = value;
136 
137         return newArray;
138     }
139 
140     public static float[] append(float[] array1, float[] array2) {
141         float[] newArray = new float[array1.length + array2.length];
142 
143         System.arraycopy(array1, 0, newArray, 0, array1.length);
144         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
145 
146         return newArray;
147     }
148 
149     public static Float[] append(Float[] array, Float value) {
150         Float[] newArray = new Float[array.length + 1];
151 
152         System.arraycopy(array, 0, newArray, 0, array.length);
153 
154         newArray[newArray.length - 1] = value;
155 
156         return newArray;
157     }
158 
159     public static Float[] append(Float[] array1, Float[] array2) {
160         Float[] newArray = new Float[array1.length + array2.length];
161 
162         System.arraycopy(array1, 0, newArray, 0, array1.length);
163         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
164 
165         return newArray;
166     }
167 
168     public static int[] append(int[] array, int value) {
169         int[] newArray = new int[array.length + 1];
170 
171         System.arraycopy(array, 0, newArray, 0, array.length);
172 
173         newArray[newArray.length - 1] = value;
174 
175         return newArray;
176     }
177 
178     public static int[] append(int[] array1, int[] array2) {
179         int[] newArray = new int[array1.length + array2.length];
180 
181         System.arraycopy(array1, 0, newArray, 0, array1.length);
182         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
183 
184         return newArray;
185     }
186 
187     public static Integer[] append(Integer[] array, Integer value) {
188         Integer[] newArray = new Integer[array.length + 1];
189 
190         System.arraycopy(array, 0, newArray, 0, array.length);
191 
192         newArray[newArray.length - 1] = value;
193 
194         return newArray;
195     }
196 
197     public static Integer[] append(Integer[] array1, Integer[] array2) {
198         Integer[] newArray = new Integer[array1.length + array2.length];
199 
200         System.arraycopy(array1, 0, newArray, 0, array1.length);
201         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
202 
203         return newArray;
204     }
205 
206     public static long[] append(long[] array, long value) {
207         long[] newArray = new long[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[] array1, long[] array2) {
217         long[] newArray = new long[array1.length + array2.length];
218 
219         System.arraycopy(array1, 0, newArray, 0, array1.length);
220         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
221 
222         return newArray;
223     }
224 
225     public static Long[] append(Long[] array, Long value) {
226         Long[] newArray = new Long[array.length + 1];
227 
228         System.arraycopy(array, 0, newArray, 0, array.length);
229 
230         newArray[newArray.length - 1] = value;
231 
232         return newArray;
233     }
234 
235     public static Long[] append(Long[] array1, Long[] array2) {
236         Long[] newArray = new Long[array1.length + array2.length];
237 
238         System.arraycopy(array1, 0, newArray, 0, array1.length);
239         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
240 
241         return newArray;
242     }
243 
244     public static Object[] append(Object[] array, Object value) {
245         Object[] newArray = new Object[array.length + 1];
246 
247         System.arraycopy(array, 0, newArray, 0, array.length);
248 
249         newArray[newArray.length - 1] = value;
250 
251         return newArray;
252     }
253 
254     public static Object[] append(Object[] array1, Object[] array2) {
255         Object[] newArray = new Object[array1.length + array2.length];
256 
257         System.arraycopy(array1, 0, newArray, 0, array1.length);
258         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
259 
260         return newArray;
261     }
262 
263     public static Object[][] append(Object[][] array, Object[] value) {
264         Object[][] newArray = new Object[array.length + 1][];
265 
266         System.arraycopy(array, 0, newArray, 0, array.length);
267 
268         newArray[newArray.length - 1] = value;
269 
270         return newArray;
271     }
272 
273     public static Object[][] append(Object[][] array1, Object[][] array2) {
274         Object[][] newArray = new Object[array1.length + array2.length][];
275 
276         System.arraycopy(array1, 0, newArray, 0, array1.length);
277         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
278 
279         return newArray;
280     }
281 
282     public static short[] append(short[] array, short value) {
283         short[] newArray = new short[array.length + 1];
284 
285         System.arraycopy(array, 0, newArray, 0, array.length);
286 
287         newArray[newArray.length - 1] = value;
288 
289         return newArray;
290     }
291 
292     public static short[] append(short[] array1, short[] array2) {
293         short[] newArray = new short[array1.length + array2.length];
294 
295         System.arraycopy(array1, 0, newArray, 0, array1.length);
296         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
297 
298         return newArray;
299     }
300 
301     public static Short[] append(Short[] array, Short value) {
302         Short[] newArray = new Short[array.length + 1];
303 
304         System.arraycopy(array, 0, newArray, 0, array.length);
305 
306         newArray[newArray.length - 1] = value;
307 
308         return newArray;
309     }
310 
311     public static Short[] append(Short[] array1, Short[] array2) {
312         Short[] newArray = new Short[array1.length + array2.length];
313 
314         System.arraycopy(array1, 0, newArray, 0, array1.length);
315         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
316 
317         return newArray;
318     }
319 
320     public static String[] append(String[] array, String value) {
321         String[] newArray = new String[array.length + 1];
322 
323         System.arraycopy(array, 0, newArray, 0, array.length);
324 
325         newArray[newArray.length - 1] = value;
326 
327         return newArray;
328     }
329 
330     public static String[] append(String[] array1, String[] array2) {
331         String[] newArray = new String[array1.length + array2.length];
332 
333         System.arraycopy(array1, 0, newArray, 0, array1.length);
334         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
335 
336         return newArray;
337     }
338 
339     public static String[][] append(String[][] array, String[] value) {
340         String[][] newArray = new String[array.length + 1][];
341 
342         System.arraycopy(array, 0, newArray, 0, array.length);
343 
344         newArray[newArray.length - 1] = value;
345 
346         return newArray;
347     }
348 
349     public static String[][] append(String[][] array1, String[][] array2) {
350         String[][] newArray = new String[array1.length + array2.length][];
351 
352         System.arraycopy(array1, 0, newArray, 0, array1.length);
353         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
354 
355         return newArray;
356     }
357 
358     public static boolean[] clone(boolean[] array) {
359         boolean[] newArray = new boolean[array.length];
360 
361         System.arraycopy(array, 0, newArray, 0, array.length);
362 
363         return newArray;
364     }
365 
366     public static Boolean[] clone(Boolean[] array) {
367         Boolean[] newArray = new Boolean[array.length];
368 
369         System.arraycopy(array, 0, newArray, 0, array.length);
370 
371         return newArray;
372     }
373 
374     public static byte[] clone(byte[] array) {
375         byte[] newArray = new byte[array.length];
376 
377         System.arraycopy(array, 0, newArray, 0, array.length);
378 
379         return newArray;
380     }
381 
382     public static double[] clone(double[] array) {
383         double[] newArray = new double[array.length];
384 
385         System.arraycopy(array, 0, newArray, 0, array.length);
386 
387         return newArray;
388     }
389 
390     public static Double[] clone(Double[] array) {
391         Double[] newArray = new Double[array.length];
392 
393         System.arraycopy(array, 0, newArray, 0, array.length);
394 
395         return newArray;
396     }
397 
398     public static float[] clone(float[] array) {
399         float[] newArray = new float[array.length];
400 
401         System.arraycopy(array, 0, newArray, 0, array.length);
402 
403         return newArray;
404     }
405 
406     public static Float[] clone(Float[] array) {
407         Float[] newArray = new Float[array.length];
408 
409         System.arraycopy(array, 0, newArray, 0, array.length);
410 
411         return newArray;
412     }
413 
414     public static int[] clone(int[] array) {
415         int[] newArray = new int[array.length];
416 
417         System.arraycopy(array, 0, newArray, 0, array.length);
418 
419         return newArray;
420     }
421 
422     public static Integer[] clone(Integer[] array) {
423         Integer[] newArray = new Integer[array.length];
424 
425         System.arraycopy(array, 0, newArray, 0, array.length);
426 
427         return newArray;
428     }
429 
430     public static long[] clone(long[] array) {
431         long[] newArray = new long[array.length];
432 
433         System.arraycopy(array, 0, newArray, 0, array.length);
434 
435         return newArray;
436     }
437 
438     public static Long[] clone(Long[] array) {
439         Long[] newArray = new Long[array.length];
440 
441         System.arraycopy(array, 0, newArray, 0, array.length);
442 
443         return newArray;
444     }
445 
446     public static Object[] clone(Object[] array) {
447         Object[] newArray = new Object[array.length];
448 
449         System.arraycopy(array, 0, newArray, 0, array.length);
450 
451         return newArray;
452     }
453 
454     public static Object[][] clone(Object[][] array) {
455         Object[][] newArray = new Object[array.length][];
456 
457         System.arraycopy(array, 0, newArray, 0, array.length);
458 
459         return newArray;
460     }
461 
462     public static short[] clone(short[] array) {
463         short[] newArray = new short[array.length];
464 
465         System.arraycopy(array, 0, newArray, 0, array.length);
466 
467         return newArray;
468     }
469 
470     public static Short[] clone(Short[] array) {
471         Short[] newArray = new Short[array.length];
472 
473         System.arraycopy(array, 0, newArray, 0, array.length);
474 
475         return newArray;
476     }
477 
478     public static String[] clone(String[] array) {
479         String[] newArray = new String[array.length];
480 
481         System.arraycopy(array, 0, newArray, 0, array.length);
482 
483         return newArray;
484     }
485 
486     public static String[][] clone(String[][] array) {
487         String[][] newArray = new String[array.length][];
488 
489         System.arraycopy(array, 0, newArray, 0, array.length);
490 
491         return newArray;
492     }
493 
494     public static void combine(
495         Object[] array1, Object[] array2, Object[] combinedArray) {
496 
497         System.arraycopy(array1, 0, combinedArray, 0, array1.length);
498 
499         System.arraycopy(
500             array2, 0, combinedArray, array1.length, array2.length);
501     }
502 
503     public static boolean contains(boolean[] array, boolean value) {
504         if ((array == null) || (array.length == 0)) {
505             return false;
506         }
507         else {
508             for (int i = 0; i < array.length; i++) {
509                 if (value == array[i]) {
510                     return true;
511                 }
512             }
513 
514             return false;
515         }
516     }
517 
518     public static boolean contains(byte[] array, byte value) {
519         if ((array == null) || (array.length == 0)) {
520             return false;
521         }
522         else {
523             for (int i = 0; i < array.length; i++) {
524                 if (value == array[i]) {
525                     return true;
526                 }
527             }
528 
529             return false;
530         }
531     }
532 
533     public static boolean contains(char[] array, char value) {
534         if ((array == null) || (array.length == 0)) {
535             return false;
536         }
537         else {
538             for (int i = 0; i < array.length; i++) {
539                 if (value == array[i]) {
540                     return true;
541                 }
542             }
543 
544             return false;
545         }
546     }
547 
548     public static boolean contains(double[] array, double value) {
549         if ((array == null) || (array.length == 0)) {
550             return false;
551         }
552         else {
553             for (int i = 0; i < array.length; i++) {
554                 if (value == array[i]) {
555                     return true;
556                 }
557             }
558 
559             return false;
560         }
561     }
562 
563     public static boolean contains(int[] array, int value) {
564         if ((array == null) || (array.length == 0)) {
565             return false;
566         }
567         else {
568             for (int i = 0; i < array.length; i++) {
569                 if (value == array[i]) {
570                     return true;
571                 }
572             }
573 
574             return false;
575         }
576     }
577 
578     public static boolean contains(long[] array, long value) {
579         if ((array == null) || (array.length == 0)) {
580             return false;
581         }
582         else {
583             for (int i = 0; i < array.length; i++) {
584                 if (value == array[i]) {
585                     return true;
586                 }
587             }
588 
589             return false;
590         }
591     }
592 
593     public static boolean contains(Object[] array, Object value) {
594         if ((array == null) || (array.length == 0) || (value == null)) {
595             return false;
596         }
597         else {
598             for (int i = 0; i < array.length; i++) {
599                 if (value.equals(array[i])) {
600                     return true;
601                 }
602             }
603 
604             return false;
605         }
606     }
607 
608     public static boolean contains(short[] array, short value) {
609         if ((array == null) || (array.length == 0)) {
610             return false;
611         }
612         else {
613             for (int i = 0; i < array.length; i++) {
614                 if (value == array[i]) {
615                     return true;
616                 }
617             }
618 
619             return false;
620         }
621     }
622 
623     public static String[] distinct(String[] array) {
624         return distinct(array, null);
625     }
626 
627     public static String[] distinct(
628         String[] array, Comparator<String> comparator) {
629 
630         if ((array == null) || (array.length == 0)) {
631             return array;
632         }
633 
634         Set<String> set = null;
635 
636         if (comparator == null) {
637             set = new TreeSet<String>();
638         }
639         else {
640             set = new TreeSet<String>(comparator);
641         }
642 
643         for (int i = 0; i < array.length; i++) {
644             String s = array[i];
645 
646             if (!set.contains(s)) {
647                 set.add(s);
648             }
649         }
650 
651         return set.toArray(new String[set.size()]);
652     }
653 
654     public static int getLength(Object[] array) {
655         if (array == null) {
656             return 0;
657         }
658         else {
659             return array.length;
660         }
661     }
662 
663     public static Object getValue(Object[] array, int pos) {
664         if ((array == null) || (array.length <= pos)) {
665             return null;
666         }
667         else {
668             return array[pos];
669         }
670     }
671 
672     public static boolean[] remove(boolean[] array, boolean value) {
673         List<Boolean> list = new ArrayList<Boolean>();
674 
675         for (int i = 0; i < array.length; i++) {
676             if (value != array[i]) {
677                 list.add(new Boolean(array[i]));
678             }
679         }
680 
681         return toArray(list.toArray(new Boolean[list.size()]));
682     }
683 
684     public static byte[] remove(byte[] array, byte value) {
685         List<Byte> list = new ArrayList<Byte>();
686 
687         for (int i = 0; i < array.length; i++) {
688             if (value != array[i]) {
689                 list.add(new Byte(array[i]));
690             }
691         }
692 
693         return toArray(list.toArray(new Byte[list.size()]));
694     }
695 
696     public static char[] remove(char[] array, char value) {
697         List<Character> list = new ArrayList<Character>();
698 
699         for (int i = 0; i < array.length; i++) {
700             if (value != array[i]) {
701                 list.add(new Character(array[i]));
702             }
703         }
704 
705         return toArray(list.toArray(new Character[list.size()]));
706     }
707 
708     public static double[] remove(double[] array, double value) {
709         List<Double> list = new ArrayList<Double>();
710 
711         for (int i = 0; i < array.length; i++) {
712             if (value != array[i]) {
713                 list.add(new Double(array[i]));
714             }
715         }
716 
717         return toArray(list.toArray(new Double[list.size()]));
718     }
719 
720     public static int[] remove(int[] array, int value) {
721         List<Integer> list = new ArrayList<Integer>();
722 
723         for (int i = 0; i < array.length; i++) {
724             if (value != array[i]) {
725                 list.add(new Integer(array[i]));
726             }
727         }
728 
729         return toArray(list.toArray(new Integer[list.size()]));
730     }
731 
732     public static long[] remove(long[] array, long value) {
733         List<Long> list = new ArrayList<Long>();
734 
735         for (int i = 0; i < array.length; i++) {
736             if (value != array[i]) {
737                 list.add(new Long(array[i]));
738             }
739         }
740 
741         return toArray(list.toArray(new Long[list.size()]));
742     }
743 
744     public static short[] remove(short[] array, short value) {
745         List<Short> list = new ArrayList<Short>();
746 
747         for (int i = 0; i < array.length; i++) {
748             if (value != array[i]) {
749                 list.add(new Short(array[i]));
750             }
751         }
752 
753         return toArray(list.toArray(new Short[list.size()]));
754     }
755 
756     public static String[] remove(String[] array, String value) {
757         List<String> list = new ArrayList<String>();
758 
759         for (String s : array) {
760             if (!s.equals(value)) {
761                 list.add(s);
762             }
763         }
764 
765         return list.toArray(new String[list.size()]);
766     }
767 
768     public static String[] removeByPrefix(String[] array, String prefix) {
769         List<String> list = new ArrayList<String>();
770 
771         for (String s : array) {
772             if (!s.startsWith(prefix)) {
773                 list.add(s);
774             }
775         }
776 
777         return list.toArray(new String[list.size()]);
778     }
779 
780     public static Boolean[] toArray(boolean[] array) {
781         Boolean[] newArray = new Boolean[array.length];
782 
783         for (int i = 0; i < array.length; i++) {
784             newArray[i] = Boolean.valueOf(array[i]);
785         }
786 
787         return newArray;
788     }
789 
790     public static boolean[] toArray(Boolean[] array) {
791         boolean[] newArray = new boolean[array.length];
792 
793         for (int i = 0; i < array.length; i++) {
794             newArray[i] = array[i].booleanValue();
795         }
796 
797         return newArray;
798     }
799 
800     public static Byte[] toArray(byte[] array) {
801         Byte[] newArray = new Byte[array.length];
802 
803         for (int i = 0; i < array.length; i++) {
804             newArray[i] = Byte.valueOf(array[i]);
805         }
806 
807         return newArray;
808     }
809 
810     public static byte[] toArray(Byte[] array) {
811         byte[] newArray = new byte[array.length];
812 
813         for (int i = 0; i < array.length; i++) {
814             newArray[i] = array[i].byteValue();
815         }
816 
817         return newArray;
818     }
819 
820     public static Character[] toArray(char[] array) {
821         Character[] newArray = new Character[array.length];
822 
823         for (int i = 0; i < array.length; i++) {
824             newArray[i] = Character.valueOf(array[i]);
825         }
826 
827         return newArray;
828     }
829 
830     public static char[] toArray(Character[] array) {
831         char[] newArray = new char[array.length];
832 
833         for (int i = 0; i < array.length; i++) {
834             newArray[i] = array[i].charValue();
835         }
836 
837         return newArray;
838     }
839 
840     public static Double[] toArray(double[] array) {
841         Double[] newArray = new Double[array.length];
842 
843         for (int i = 0; i < array.length; i++) {
844             newArray[i] = new Double(array[i]);
845         }
846 
847         return newArray;
848     }
849 
850     public static double[] toArray(Double[] array) {
851         double[] newArray = new double[array.length];
852 
853         for (int i = 0; i < array.length; i++) {
854             newArray[i] = array[i].doubleValue();
855         }
856 
857         return newArray;
858     }
859 
860     public static Float[] toArray(float[] array) {
861         Float[] newArray = new Float[array.length];
862 
863         for (int i = 0; i < array.length; i++) {
864             newArray[i] = new Float(array[i]);
865         }
866 
867         return newArray;
868     }
869 
870     public static float[] toArray(Float[] array) {
871         float[] newArray = new float[array.length];
872 
873         for (int i = 0; i < array.length; i++) {
874             newArray[i] = array[i].floatValue();
875         }
876 
877         return newArray;
878     }
879 
880     public static Integer[] toArray(int[] array) {
881         Integer[] newArray = new Integer[array.length];
882 
883         for (int i = 0; i < array.length; i++) {
884             newArray[i] = new Integer(array[i]);
885         }
886 
887         return newArray;
888     }
889 
890     public static int[] toArray(Integer[] array) {
891         int[] newArray = new int[array.length];
892 
893         for (int i = 0; i < array.length; i++) {
894             newArray[i] = array[i].intValue();
895         }
896 
897         return newArray;
898     }
899 
900     public static Long[] toArray(long[] array) {
901         Long[] newArray = new Long[array.length];
902 
903         for (int i = 0; i < array.length; i++) {
904             newArray[i] = new Long(array[i]);
905         }
906 
907         return newArray;
908     }
909 
910     public static long[] toArray(Long[] array) {
911         long[] newArray = new long[array.length];
912 
913         for (int i = 0; i < array.length; i++) {
914             newArray[i] = array[i].longValue();
915         }
916 
917         return newArray;
918     }
919 
920     public static Short[] toArray(short[] array) {
921         Short[] newArray = new Short[array.length];
922 
923         for (int i = 0; i < array.length; i++) {
924             newArray[i] = new Short(array[i]);
925         }
926 
927         return newArray;
928     }
929 
930     public static short[] toArray(Short[] array) {
931         short[] newArray = new short[array.length];
932 
933         for (int i = 0; i < array.length; i++) {
934             newArray[i] = array[i].shortValue();
935         }
936 
937         return newArray;
938     }
939 
940     public static String[] toStringArray(boolean[] array) {
941         String[] newArray = new String[array.length];
942 
943         for (int i = 0; i < array.length; i++) {
944             newArray[i] = String.valueOf(array[i]);
945         }
946 
947         return newArray;
948     }
949 
950     public static String[] toStringArray(byte[] array) {
951         String[] newArray = new String[array.length];
952 
953         for (int i = 0; i < array.length; i++) {
954             newArray[i] = String.valueOf(array[i]);
955         }
956 
957         return newArray;
958     }
959 
960     public static String[] toStringArray(char[] array) {
961         String[] newArray = new String[array.length];
962 
963         for (int i = 0; i < array.length; i++) {
964             newArray[i] = String.valueOf(array[i]);
965         }
966 
967         return newArray;
968     }
969 
970     public static String[] toStringArray(Date[] array, DateFormat df) {
971         String[] newArray = new String[array.length];
972 
973         for (int i = 0; i < array.length; i++) {
974             newArray[i] = df.format(array[i]);
975         }
976 
977         return newArray;
978     }
979 
980     public static String[] toStringArray(double[] array) {
981         String[] newArray = new String[array.length];
982 
983         for (int i = 0; i < array.length; i++) {
984             newArray[i] = String.valueOf(array[i]);
985         }
986 
987         return newArray;
988     }
989 
990     public static String[] toStringArray(float[] array) {
991         String[] newArray = new String[array.length];
992 
993         for (int i = 0; i < array.length; i++) {
994             newArray[i] = String.valueOf(array[i]);
995         }
996 
997         return newArray;
998     }
999 
1000    public static String[] toStringArray(int[] array) {
1001        String[] newArray = new String[array.length];
1002
1003        for (int i = 0; i < array.length; i++) {
1004            newArray[i] = String.valueOf(array[i]);
1005        }
1006
1007        return newArray;
1008    }
1009
1010    public static String[] toStringArray(JSONArray array) {
1011        String[] newArray = new String[array.length()];
1012
1013        for (int i = 0; i < array.length(); i++) {
1014            newArray[i] = array.getString(i);
1015        }
1016
1017        return newArray;
1018    }
1019
1020    public static String[] toStringArray(long[] array) {
1021        String[] newArray = new String[array.length];
1022
1023        for (int i = 0; i < array.length; i++) {
1024            newArray[i] = String.valueOf(array[i]);
1025        }
1026
1027        return newArray;
1028    }
1029
1030    public static String[] toStringArray(Object[] array) {
1031        String[] newArray = new String[array.length];
1032
1033        for (int i = 0; i < array.length; i++) {
1034            newArray[i] = String.valueOf(array[i]);
1035        }
1036
1037        return newArray;
1038    }
1039
1040    public static String[] toStringArray(short[] array) {
1041        String[] newArray = new String[array.length];
1042
1043        for (int i = 0; i < array.length; i++) {
1044            newArray[i] = String.valueOf(array[i]);
1045        }
1046
1047        return newArray;
1048    }
1049
1050}