001
014
015 package com.liferay.portal.kernel.util;
016
017 import com.liferay.portal.kernel.json.JSONArray;
018
019 import java.lang.reflect.Array;
020
021 import java.text.DateFormat;
022
023 import java.util.ArrayList;
024 import java.util.Comparator;
025 import java.util.Date;
026 import java.util.List;
027 import java.util.Set;
028 import java.util.TreeSet;
029
030
033 public class ArrayUtil {
034
035 public static boolean[] append(boolean[]... arrays) {
036 int length = 0;
037
038 for (boolean[] array : arrays) {
039 length += array.length;
040 }
041
042 boolean[] newArray = new boolean[length];
043
044 int previousLength = 0;
045
046 for (boolean[] array : arrays) {
047 System.arraycopy(array, 0, newArray, previousLength, array.length);
048
049 previousLength += array.length;
050 }
051
052 return newArray;
053 }
054
055 public static boolean[] append(boolean[] array, boolean value) {
056 boolean[] newArray = new boolean[array.length + 1];
057
058 System.arraycopy(array, 0, newArray, 0, array.length);
059
060 newArray[newArray.length - 1] = value;
061
062 return newArray;
063 }
064
065 public static byte[] append(byte[]... arrays) {
066 int length = 0;
067
068 for (byte[] array : arrays) {
069 length += array.length;
070 }
071
072 byte[] newArray = new byte[length];
073
074 int previousLength = 0;
075
076 for (byte[] array : arrays) {
077 System.arraycopy(array, 0, newArray, previousLength, array.length);
078
079 previousLength += array.length;
080 }
081
082 return newArray;
083 }
084
085 public static byte[] append(byte[] array, byte value) {
086 byte[] newArray = new byte[array.length + 1];
087
088 System.arraycopy(array, 0, newArray, 0, array.length);
089
090 newArray[newArray.length - 1] = value;
091
092 return newArray;
093 }
094
095 public static char[] append(char[]... arrays) {
096 int length = 0;
097
098 for (char[] array : arrays) {
099 length += array.length;
100 }
101
102 char[] newArray = new char[length];
103
104 int previousLength = 0;
105
106 for (char[] 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 char[] append(char[] array, char value) {
116 char[] newArray = new char[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 double[] append(double[]... arrays) {
126 int length = 0;
127
128 for (double[] array : arrays) {
129 length += array.length;
130 }
131
132 double[] newArray = new double[length];
133
134 int previousLength = 0;
135
136 for (double[] 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 double[] append(double[] array, double value) {
146 double[] newArray = new double[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 float[] append(float[]... arrays) {
156 int length = 0;
157
158 for (float[] array : arrays) {
159 length += array.length;
160 }
161
162 float[] newArray = new float[length];
163
164 int previousLength = 0;
165
166 for (float[] 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 float[] append(float[] array, float value) {
176 float[] newArray = new float[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 int[] append(int[]... arrays) {
186 int length = 0;
187
188 for (int[] array : arrays) {
189 length += array.length;
190 }
191
192 int[] newArray = new int[length];
193
194 int previousLength = 0;
195
196 for (int[] 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 int[] append(int[] array, int value) {
206 int[] newArray = new int[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 long[] append(long[]... arrays) {
216 int length = 0;
217
218 for (long[] array : arrays) {
219 length += array.length;
220 }
221
222 long[] newArray = new long[length];
223
224 int previousLength = 0;
225
226 for (long[] 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 long[] append(long[] array, long value) {
236 long[] newArray = new long[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 short[] append(short[]... arrays) {
246 int length = 0;
247
248 for (short[] array : arrays) {
249 length += array.length;
250 }
251
252 short[] newArray = new short[length];
253
254 int previousLength = 0;
255
256 for (short[] 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 short[] append(short[] array, short value) {
266 short[] newArray = new short[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 <T> T[] append(T[]... arrays) {
276 int length = 0;
277
278 for (T[] array : arrays) {
279 length += array.length;
280 }
281
282 Class<?> arraysClass = arrays.getClass();
283
284 T[] newArray = (T[])Array.newInstance(
285 arraysClass.getComponentType(), length);
286
287 int previousLength = 0;
288
289 for (T[] array : arrays) {
290 System.arraycopy(array, 0, newArray, previousLength, array.length);
291
292 previousLength += array.length;
293 }
294
295 return newArray;
296 }
297
298 public static <T> T[] append(T[] array, T value) {
299 Class<?> arrayClass = array.getClass();
300
301 T[] newArray = (T[])Array.newInstance(
302 arrayClass.getComponentType(), array.length + 1);
303
304 System.arraycopy(array, 0, newArray, 0, array.length);
305
306 newArray[array.length] = value;
307
308 return newArray;
309 }
310
311 public static <T> T[] append(T[] array1, T[] array2) {
312 Class<?> array1Class = array1.getClass();
313
314 T[] newArray = (T[])Array.newInstance(
315 array1Class.getComponentType(), array1.length + array2.length);
316
317 System.arraycopy(array1, 0, newArray, 0, array1.length);
318
319 System.arraycopy(array2, 0, newArray, array1.length, array2.length);
320
321 return newArray;
322 }
323
324 public static <T> T[][] append(T[][] array1, T[] value) {
325 Class<?> array1Class = array1.getClass();
326
327 T[][] newArray = (T[][])Array.newInstance(
328 array1Class.getComponentType(), array1.length + 1);
329
330 System.arraycopy(array1, 0, newArray, 0, array1.length);
331
332 newArray[array1.length] = value;
333
334 return newArray;
335 }
336
337 public static <T> T[][] append(T[][] array1, T[][] array2) {
338 Class<?> array1Class = array1.getClass();
339
340 T[][] newArray = (T[][])Array.newInstance(
341 array1Class.getComponentType(), array1.length + array2.length);
342
343 System.arraycopy(array1, 0, newArray, 0, array1.length);
344 System.arraycopy(array2, 0, newArray, array1.length, array2.length);
345
346 return newArray;
347 }
348
349 public static boolean[] clone(boolean[] array) {
350 boolean[] newArray = new boolean[array.length];
351
352 System.arraycopy(array, 0, newArray, 0, array.length);
353
354 return newArray;
355 }
356
357 public static byte[] clone(byte[] array) {
358 byte[] newArray = new byte[array.length];
359
360 System.arraycopy(array, 0, newArray, 0, array.length);
361
362 return newArray;
363 }
364
365 public static char[] clone(char[] array) {
366 char[] newArray = new char[array.length];
367
368 System.arraycopy(array, 0, newArray, 0, array.length);
369
370 return newArray;
371 }
372
373 public static double[] clone(double[] array) {
374 double[] newArray = new double[array.length];
375
376 System.arraycopy(array, 0, newArray, 0, array.length);
377
378 return newArray;
379 }
380
381 public static float[] clone(float[] array) {
382 float[] newArray = new float[array.length];
383
384 System.arraycopy(array, 0, newArray, 0, array.length);
385
386 return newArray;
387 }
388
389 public static int[] clone(int[] array) {
390 int[] newArray = new int[array.length];
391
392 System.arraycopy(array, 0, newArray, 0, array.length);
393
394 return newArray;
395 }
396
397 public static long[] clone(long[] array) {
398 long[] newArray = new long[array.length];
399
400 System.arraycopy(array, 0, newArray, 0, array.length);
401
402 return newArray;
403 }
404
405 public static short[] clone(short[] array) {
406 short[] newArray = new short[array.length];
407
408 System.arraycopy(array, 0, newArray, 0, array.length);
409
410 return newArray;
411 }
412
413 public static <T> T[] clone(T[] array) {
414 Class<?> arrayClass = array.getClass();
415
416 T[] newArray = (T[])Array.newInstance(
417 arrayClass.getComponentType(), array.length);
418
419 System.arraycopy(array, 0, newArray, 0, array.length);
420
421 return newArray;
422 }
423
424 public static <T> T[][] clone(T[][] array) {
425 Class<?> arrayClass = array.getClass();
426
427 T[][] newArray = (T[][])Array.newInstance(
428 arrayClass.getComponentType(), array.length);
429
430 System.arraycopy(array, 0, newArray, 0, array.length);
431
432 return newArray;
433 }
434
435 public static void combine(
436 Object[] array1, Object[] array2, Object[] combinedArray) {
437
438 System.arraycopy(array1, 0, combinedArray, 0, array1.length);
439
440 System.arraycopy(
441 array2, 0, combinedArray, array1.length, array2.length);
442 }
443
444 public static boolean contains(boolean[] array, boolean value) {
445 if ((array == null) || (array.length == 0)) {
446 return false;
447 }
448 else {
449 for (int i = 0; i < array.length; i++) {
450 if (value == array[i]) {
451 return true;
452 }
453 }
454
455 return false;
456 }
457 }
458
459 public static boolean contains(byte[] array, byte value) {
460 if ((array == null) || (array.length == 0)) {
461 return false;
462 }
463 else {
464 for (int i = 0; i < array.length; i++) {
465 if (value == array[i]) {
466 return true;
467 }
468 }
469
470 return false;
471 }
472 }
473
474 public static boolean contains(char[] array, char value) {
475 if ((array == null) || (array.length == 0)) {
476 return false;
477 }
478 else {
479 for (int i = 0; i < array.length; i++) {
480 if (value == array[i]) {
481 return true;
482 }
483 }
484
485 return false;
486 }
487 }
488
489 public static boolean contains(double[] array, double value) {
490 if ((array == null) || (array.length == 0)) {
491 return false;
492 }
493 else {
494 for (int i = 0; i < array.length; i++) {
495 if (value == array[i]) {
496 return true;
497 }
498 }
499
500 return false;
501 }
502 }
503
504 public static boolean contains(float[] array, float value) {
505 if ((array == null) || (array.length == 0)) {
506 return false;
507 }
508 else {
509 for (int i = 0; i < array.length; i++) {
510 if (value == array[i]) {
511 return true;
512 }
513 }
514
515 return false;
516 }
517 }
518
519 public static boolean contains(int[] array, int value) {
520 if ((array == null) || (array.length == 0)) {
521 return false;
522 }
523 else {
524 for (int i = 0; i < array.length; i++) {
525 if (value == array[i]) {
526 return true;
527 }
528 }
529
530 return false;
531 }
532 }
533
534 public static boolean contains(long[] array, long value) {
535 if ((array == null) || (array.length == 0)) {
536 return false;
537 }
538 else {
539 for (int i = 0; i < array.length; i++) {
540 if (value == array[i]) {
541 return true;
542 }
543 }
544
545 return false;
546 }
547 }
548
549 public static boolean contains(Object[] array, Object value) {
550 if ((array == null) || (array.length == 0) || (value == null)) {
551 return false;
552 }
553 else {
554 for (int i = 0; i < array.length; i++) {
555 if (value.equals(array[i])) {
556 return true;
557 }
558 }
559
560 return false;
561 }
562 }
563
564 public static boolean contains(short[] array, short value) {
565 if ((array == null) || (array.length == 0)) {
566 return false;
567 }
568 else {
569 for (int i = 0; i < array.length; i++) {
570 if (value == array[i]) {
571 return true;
572 }
573 }
574
575 return false;
576 }
577 }
578
579 public static String[] distinct(String[] array) {
580 return distinct(array, null);
581 }
582
583 public static String[] distinct(
584 String[] array, Comparator<String> comparator) {
585
586 if ((array == null) || (array.length == 0)) {
587 return array;
588 }
589
590 Set<String> set = null;
591
592 if (comparator == null) {
593 set = new TreeSet<String>();
594 }
595 else {
596 set = new TreeSet<String>(comparator);
597 }
598
599 for (int i = 0; i < array.length; i++) {
600 String s = array[i];
601
602 if (!set.contains(s)) {
603 set.add(s);
604 }
605 }
606
607 return set.toArray(new String[set.size()]);
608 }
609
610 public static int getLength(Object[] array) {
611 if (array == null) {
612 return 0;
613 }
614 else {
615 return array.length;
616 }
617 }
618
619 public static Object getValue(Object[] array, int pos) {
620 if ((array == null) || (array.length <= pos)) {
621 return null;
622 }
623 else {
624 return array[pos];
625 }
626 }
627
628 public static boolean[] remove(boolean[] array, boolean value) {
629 List<Boolean> list = new ArrayList<Boolean>();
630
631 for (int i = 0; i < array.length; i++) {
632 if (value != array[i]) {
633 list.add(new Boolean(array[i]));
634 }
635 }
636
637 return toArray(list.toArray(new Boolean[list.size()]));
638 }
639
640 public static byte[] remove(byte[] array, byte value) {
641 List<Byte> list = new ArrayList<Byte>();
642
643 for (int i = 0; i < array.length; i++) {
644 if (value != array[i]) {
645 list.add(new Byte(array[i]));
646 }
647 }
648
649 return toArray(list.toArray(new Byte[list.size()]));
650 }
651
652 public static char[] remove(char[] array, char value) {
653 List<Character> list = new ArrayList<Character>();
654
655 for (int i = 0; i < array.length; i++) {
656 if (value != array[i]) {
657 list.add(new Character(array[i]));
658 }
659 }
660
661 return toArray(list.toArray(new Character[list.size()]));
662 }
663
664 public static double[] remove(double[] array, double value) {
665 List<Double> list = new ArrayList<Double>();
666
667 for (int i = 0; i < array.length; i++) {
668 if (value != array[i]) {
669 list.add(new Double(array[i]));
670 }
671 }
672
673 return toArray(list.toArray(new Double[list.size()]));
674 }
675
676 public static int[] remove(int[] array, int value) {
677 List<Integer> list = new ArrayList<Integer>();
678
679 for (int i = 0; i < array.length; i++) {
680 if (value != array[i]) {
681 list.add(new Integer(array[i]));
682 }
683 }
684
685 return toArray(list.toArray(new Integer[list.size()]));
686 }
687
688 public static long[] remove(long[] array, long value) {
689 List<Long> list = new ArrayList<Long>();
690
691 for (int i = 0; i < array.length; i++) {
692 if (value != array[i]) {
693 list.add(new Long(array[i]));
694 }
695 }
696
697 return toArray(list.toArray(new Long[list.size()]));
698 }
699
700 public static short[] remove(short[] array, short value) {
701 List<Short> list = new ArrayList<Short>();
702
703 for (int i = 0; i < array.length; i++) {
704 if (value != array[i]) {
705 list.add(new Short(array[i]));
706 }
707 }
708
709 return toArray(list.toArray(new Short[list.size()]));
710 }
711
712 public static String[] remove(String[] array, String value) {
713 List<String> list = new ArrayList<String>();
714
715 for (String s : array) {
716 if (!s.equals(value)) {
717 list.add(s);
718 }
719 }
720
721 return list.toArray(new String[list.size()]);
722 }
723
724 public static String[] removeByPrefix(String[] array, String prefix) {
725 List<String> list = new ArrayList<String>();
726
727 for (String s : array) {
728 if (!s.startsWith(prefix)) {
729 list.add(s);
730 }
731 }
732
733 return list.toArray(new String[list.size()]);
734 }
735
736 public static void reverse(String[] array) {
737 for (int left = 0, right = array.length - 1; left < right;
738 left++, right--) {
739
740 String value = array[left];
741
742 array[left] = array[right];
743 array[right] = value;
744 }
745 }
746
747 public static boolean[] subset(boolean[] array, int start, int end) {
748 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
749 return array;
750 }
751
752 boolean[] newArray = new boolean[end - start];
753
754 System.arraycopy(array, start, newArray, 0, end - start);
755
756 return newArray;
757 }
758
759 public static byte[] subset(byte[] array, int start, int end) {
760 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
761 return array;
762 }
763
764 byte[] newArray = new byte[end - start];
765
766 System.arraycopy(array, start, newArray, 0, end - start);
767
768 return newArray;
769 }
770
771 public static char[] subset(char[] array, int start, int end) {
772 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
773 return array;
774 }
775
776 char[] newArray = new char[end - start];
777
778 System.arraycopy(array, start, newArray, 0, end - start);
779
780 return newArray;
781 }
782
783 public static double[] subset(double[] array, int start, int end) {
784 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
785 return array;
786 }
787
788 double[] newArray = new double[end - start];
789
790 System.arraycopy(array, start, newArray, 0, end - start);
791
792 return newArray;
793 }
794
795 public static float[] subset(float[] array, int start, int end) {
796 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
797 return array;
798 }
799
800 float[] newArray = new float[end - start];
801
802 System.arraycopy(array, start, newArray, 0, end - start);
803
804 return newArray;
805 }
806
807 public static int[] subset(int[] array, int start, int end) {
808 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
809 return array;
810 }
811
812 int[] newArray = new int[end - start];
813
814 System.arraycopy(array, start, newArray, 0, end - start);
815
816 return newArray;
817 }
818
819 public static long[] subset(long[] array, int start, int end) {
820 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
821 return array;
822 }
823
824 long[] newArray = new long[end - start];
825
826 System.arraycopy(array, start, newArray, 0, end - start);
827
828 return newArray;
829 }
830
831 public static short[] subset(short[] array, int start, int end) {
832 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
833 return array;
834 }
835
836 short[] newArray = new short[end - start];
837
838 System.arraycopy(array, start, newArray, 0, end - start);
839
840 return newArray;
841 }
842
843 public static <T> T[] subset(T[] array, int start, int end) {
844 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
845 return array;
846 }
847
848 Class<?> arrayClass = array.getClass();
849
850 T[] newArray = (T[])Array.newInstance(
851 arrayClass.getComponentType(), end - start);
852
853 System.arraycopy(array, start, newArray, 0, end - start);
854
855 return newArray;
856 }
857
858 public static Boolean[] toArray(boolean[] array) {
859 Boolean[] newArray = new Boolean[array.length];
860
861 for (int i = 0; i < array.length; i++) {
862 newArray[i] = Boolean.valueOf(array[i]);
863 }
864
865 return newArray;
866 }
867
868 public static boolean[] toArray(Boolean[] array) {
869 boolean[] newArray = new boolean[array.length];
870
871 for (int i = 0; i < array.length; i++) {
872 newArray[i] = array[i].booleanValue();
873 }
874
875 return newArray;
876 }
877
878 public static Byte[] toArray(byte[] array) {
879 Byte[] newArray = new Byte[array.length];
880
881 for (int i = 0; i < array.length; i++) {
882 newArray[i] = Byte.valueOf(array[i]);
883 }
884
885 return newArray;
886 }
887
888 public static byte[] toArray(Byte[] array) {
889 byte[] newArray = new byte[array.length];
890
891 for (int i = 0; i < array.length; i++) {
892 newArray[i] = array[i].byteValue();
893 }
894
895 return newArray;
896 }
897
898 public static Character[] toArray(char[] array) {
899 Character[] newArray = new Character[array.length];
900
901 for (int i = 0; i < array.length; i++) {
902 newArray[i] = Character.valueOf(array[i]);
903 }
904
905 return newArray;
906 }
907
908 public static char[] toArray(Character[] array) {
909 char[] newArray = new char[array.length];
910
911 for (int i = 0; i < array.length; i++) {
912 newArray[i] = array[i].charValue();
913 }
914
915 return newArray;
916 }
917
918 public static Double[] toArray(double[] array) {
919 Double[] newArray = new Double[array.length];
920
921 for (int i = 0; i < array.length; i++) {
922 newArray[i] = new Double(array[i]);
923 }
924
925 return newArray;
926 }
927
928 public static double[] toArray(Double[] array) {
929 double[] newArray = new double[array.length];
930
931 for (int i = 0; i < array.length; i++) {
932 newArray[i] = array[i].doubleValue();
933 }
934
935 return newArray;
936 }
937
938 public static Float[] toArray(float[] array) {
939 Float[] newArray = new Float[array.length];
940
941 for (int i = 0; i < array.length; i++) {
942 newArray[i] = new Float(array[i]);
943 }
944
945 return newArray;
946 }
947
948 public static float[] toArray(Float[] array) {
949 float[] newArray = new float[array.length];
950
951 for (int i = 0; i < array.length; i++) {
952 newArray[i] = array[i].floatValue();
953 }
954
955 return newArray;
956 }
957
958 public static Integer[] toArray(int[] array) {
959 Integer[] newArray = new Integer[array.length];
960
961 for (int i = 0; i < array.length; i++) {
962 newArray[i] = new Integer(array[i]);
963 }
964
965 return newArray;
966 }
967
968 public static int[] toArray(Integer[] array) {
969 int[] newArray = new int[array.length];
970
971 for (int i = 0; i < array.length; i++) {
972 newArray[i] = array[i].intValue();
973 }
974
975 return newArray;
976 }
977
978 public static Long[] toArray(long[] array) {
979 Long[] newArray = new Long[array.length];
980
981 for (int i = 0; i < array.length; i++) {
982 newArray[i] = new Long(array[i]);
983 }
984
985 return newArray;
986 }
987
988 public static long[] toArray(Long[] array) {
989 long[] newArray = new long[array.length];
990
991 for (int i = 0; i < array.length; i++) {
992 newArray[i] = array[i].longValue();
993 }
994
995 return newArray;
996 }
997
998 public static Short[] toArray(short[] array) {
999 Short[] newArray = new Short[array.length];
1000
1001 for (int i = 0; i < array.length; i++) {
1002 newArray[i] = new Short(array[i]);
1003 }
1004
1005 return newArray;
1006 }
1007
1008 public static short[] toArray(Short[] array) {
1009 short[] newArray = new short[array.length];
1010
1011 for (int i = 0; i < array.length; i++) {
1012 newArray[i] = array[i].shortValue();
1013 }
1014
1015 return newArray;
1016 }
1017
1018 public static Long[] toLongArray(Object[] array) {
1019 Long[] newArray = new Long[array.length];
1020
1021 for (int i = 0; i < array.length; i++) {
1022 newArray[i] = (Long)array[i];
1023 }
1024
1025 return newArray;
1026 }
1027
1028 public static String[] toStringArray(boolean[] array) {
1029 String[] newArray = new String[array.length];
1030
1031 for (int i = 0; i < array.length; i++) {
1032 newArray[i] = String.valueOf(array[i]);
1033 }
1034
1035 return newArray;
1036 }
1037
1038 public static String[] toStringArray(byte[] array) {
1039 String[] newArray = new String[array.length];
1040
1041 for (int i = 0; i < array.length; i++) {
1042 newArray[i] = String.valueOf(array[i]);
1043 }
1044
1045 return newArray;
1046 }
1047
1048 public static String[] toStringArray(char[] array) {
1049 String[] newArray = new String[array.length];
1050
1051 for (int i = 0; i < array.length; i++) {
1052 newArray[i] = String.valueOf(array[i]);
1053 }
1054
1055 return newArray;
1056 }
1057
1058 public static String[] toStringArray(Date[] array, DateFormat df) {
1059 String[] newArray = new String[array.length];
1060
1061 for (int i = 0; i < array.length; i++) {
1062 newArray[i] = df.format(array[i]);
1063 }
1064
1065 return newArray;
1066 }
1067
1068 public static String[] toStringArray(double[] array) {
1069 String[] newArray = new String[array.length];
1070
1071 for (int i = 0; i < array.length; i++) {
1072 newArray[i] = String.valueOf(array[i]);
1073 }
1074
1075 return newArray;
1076 }
1077
1078 public static String[] toStringArray(float[] array) {
1079 String[] newArray = new String[array.length];
1080
1081 for (int i = 0; i < array.length; i++) {
1082 newArray[i] = String.valueOf(array[i]);
1083 }
1084
1085 return newArray;
1086 }
1087
1088 public static String[] toStringArray(int[] array) {
1089 String[] newArray = new String[array.length];
1090
1091 for (int i = 0; i < array.length; i++) {
1092 newArray[i] = String.valueOf(array[i]);
1093 }
1094
1095 return newArray;
1096 }
1097
1098 public static String[] toStringArray(JSONArray array) {
1099 String[] newArray = new String[array.length()];
1100
1101 for (int i = 0; i < array.length(); i++) {
1102 newArray[i] = array.getString(i);
1103 }
1104
1105 return newArray;
1106 }
1107
1108 public static String[] toStringArray(long[] array) {
1109 String[] newArray = new String[array.length];
1110
1111 for (int i = 0; i < array.length; i++) {
1112 newArray[i] = String.valueOf(array[i]);
1113 }
1114
1115 return newArray;
1116 }
1117
1118 public static String[] toStringArray(Object[] array) {
1119 String[] newArray = new String[array.length];
1120
1121 for (int i = 0; i < array.length; i++) {
1122 newArray[i] = String.valueOf(array[i]);
1123 }
1124
1125 return newArray;
1126 }
1127
1128 public static String[] toStringArray(short[] array) {
1129 String[] newArray = new String[array.length];
1130
1131 for (int i = 0; i < array.length; i++) {
1132 newArray[i] = String.valueOf(array[i]);
1133 }
1134
1135 return newArray;
1136 }
1137
1138 }