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