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
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 public static boolean contains(byte[] array, byte value) {
459 if ((array == null) || (array.length == 0)) {
460 return false;
461 }
462
463 for (int i = 0; i < array.length; i++) {
464 if (value == array[i]) {
465 return true;
466 }
467 }
468
469 return false;
470 }
471
472 public static boolean contains(char[] array, char value) {
473 if ((array == null) || (array.length == 0)) {
474 return false;
475 }
476
477 for (int i = 0; i < array.length; i++) {
478 if (value == array[i]) {
479 return true;
480 }
481 }
482
483 return false;
484 }
485
486 public static boolean contains(double[] array, double value) {
487 if ((array == null) || (array.length == 0)) {
488 return false;
489 }
490
491 for (int i = 0; i < array.length; i++) {
492 if (value == array[i]) {
493 return true;
494 }
495 }
496
497 return false;
498 }
499
500 public static boolean contains(float[] array, float value) {
501 if ((array == null) || (array.length == 0)) {
502 return false;
503 }
504
505 for (int i = 0; i < array.length; i++) {
506 if (value == array[i]) {
507 return true;
508 }
509 }
510
511 return false;
512 }
513
514 public static boolean contains(int[] array, int value) {
515 if ((array == null) || (array.length == 0)) {
516 return false;
517 }
518
519 for (int i = 0; i < array.length; i++) {
520 if (value == array[i]) {
521 return true;
522 }
523 }
524
525 return false;
526 }
527
528 public static boolean contains(long[] array, long value) {
529 if ((array == null) || (array.length == 0)) {
530 return false;
531 }
532
533 for (int i = 0; i < array.length; i++) {
534 if (value == array[i]) {
535 return true;
536 }
537 }
538
539 return false;
540 }
541
542 public static boolean contains(Object[] array, Object value) {
543 if ((array == null) || (array.length == 0) || (value == null)) {
544 return false;
545 }
546
547 for (int i = 0; i < array.length; i++) {
548 if (value.equals(array[i])) {
549 return true;
550 }
551 }
552
553 return false;
554 }
555
556 public static boolean contains(short[] array, short value) {
557 if ((array == null) || (array.length == 0)) {
558 return false;
559 }
560
561 for (int i = 0; i < array.length; i++) {
562 if (value == array[i]) {
563 return true;
564 }
565 }
566
567 return false;
568 }
569
570 public static String[] distinct(String[] array) {
571 return distinct(array, null);
572 }
573
574 public static String[] distinct(
575 String[] array, Comparator<String> comparator) {
576
577 if ((array == null) || (array.length == 0)) {
578 return array;
579 }
580
581 Set<String> set = null;
582
583 if (comparator == null) {
584 set = new TreeSet<String>();
585 }
586 else {
587 set = new TreeSet<String>(comparator);
588 }
589
590 for (int i = 0; i < array.length; i++) {
591 String s = array[i];
592
593 if (!set.contains(s)) {
594 set.add(s);
595 }
596 }
597
598 return set.toArray(new String[set.size()]);
599 }
600
601 public static int getLength(Object[] array) {
602 if (array == null) {
603 return 0;
604 }
605 else {
606 return array.length;
607 }
608 }
609
610 public static Object getValue(Object[] array, int pos) {
611 if ((array == null) || (array.length <= pos)) {
612 return null;
613 }
614 else {
615 return array[pos];
616 }
617 }
618
619 public static boolean[] remove(boolean[] array, boolean value) {
620 List<Boolean> list = new ArrayList<Boolean>();
621
622 for (int i = 0; i < array.length; i++) {
623 if (value != array[i]) {
624 list.add(new Boolean(array[i]));
625 }
626 }
627
628 return toArray(list.toArray(new Boolean[list.size()]));
629 }
630
631 public static byte[] remove(byte[] array, byte value) {
632 List<Byte> list = new ArrayList<Byte>();
633
634 for (int i = 0; i < array.length; i++) {
635 if (value != array[i]) {
636 list.add(new Byte(array[i]));
637 }
638 }
639
640 return toArray(list.toArray(new Byte[list.size()]));
641 }
642
643 public static char[] remove(char[] array, char value) {
644 List<Character> list = new ArrayList<Character>();
645
646 for (int i = 0; i < array.length; i++) {
647 if (value != array[i]) {
648 list.add(new Character(array[i]));
649 }
650 }
651
652 return toArray(list.toArray(new Character[list.size()]));
653 }
654
655 public static double[] remove(double[] array, double value) {
656 List<Double> list = new ArrayList<Double>();
657
658 for (int i = 0; i < array.length; i++) {
659 if (value != array[i]) {
660 list.add(new Double(array[i]));
661 }
662 }
663
664 return toArray(list.toArray(new Double[list.size()]));
665 }
666
667 public static int[] remove(int[] array, int value) {
668 List<Integer> list = new ArrayList<Integer>();
669
670 for (int i = 0; i < array.length; i++) {
671 if (value != array[i]) {
672 list.add(new Integer(array[i]));
673 }
674 }
675
676 return toArray(list.toArray(new Integer[list.size()]));
677 }
678
679 public static long[] remove(long[] array, long value) {
680 List<Long> list = new ArrayList<Long>();
681
682 for (int i = 0; i < array.length; i++) {
683 if (value != array[i]) {
684 list.add(new Long(array[i]));
685 }
686 }
687
688 return toArray(list.toArray(new Long[list.size()]));
689 }
690
691 public static short[] remove(short[] array, short value) {
692 List<Short> list = new ArrayList<Short>();
693
694 for (int i = 0; i < array.length; i++) {
695 if (value != array[i]) {
696 list.add(new Short(array[i]));
697 }
698 }
699
700 return toArray(list.toArray(new Short[list.size()]));
701 }
702
703 public static String[] remove(String[] array, String value) {
704 List<String> list = new ArrayList<String>();
705
706 for (String s : array) {
707 if (!s.equals(value)) {
708 list.add(s);
709 }
710 }
711
712 return list.toArray(new String[list.size()]);
713 }
714
715 public static String[] removeByPrefix(String[] array, String prefix) {
716 List<String> list = new ArrayList<String>();
717
718 for (String s : array) {
719 if (!s.startsWith(prefix)) {
720 list.add(s);
721 }
722 }
723
724 return list.toArray(new String[list.size()]);
725 }
726
727 public static void reverse(String[] array) {
728 for (int left = 0, right = array.length - 1; left < right;
729 left++, right--) {
730
731 String value = array[left];
732
733 array[left] = array[right];
734 array[right] = value;
735 }
736 }
737
738 public static boolean[] subset(boolean[] array, int start, int end) {
739 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
740 return array;
741 }
742
743 boolean[] newArray = new boolean[end - start];
744
745 System.arraycopy(array, start, newArray, 0, end - start);
746
747 return newArray;
748 }
749
750 public static byte[] subset(byte[] array, int start, int end) {
751 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
752 return array;
753 }
754
755 byte[] newArray = new byte[end - start];
756
757 System.arraycopy(array, start, newArray, 0, end - start);
758
759 return newArray;
760 }
761
762 public static char[] subset(char[] array, int start, int end) {
763 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
764 return array;
765 }
766
767 char[] newArray = new char[end - start];
768
769 System.arraycopy(array, start, newArray, 0, end - start);
770
771 return newArray;
772 }
773
774 public static double[] subset(double[] array, int start, int end) {
775 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
776 return array;
777 }
778
779 double[] newArray = new double[end - start];
780
781 System.arraycopy(array, start, newArray, 0, end - start);
782
783 return newArray;
784 }
785
786 public static float[] subset(float[] array, int start, int end) {
787 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
788 return array;
789 }
790
791 float[] newArray = new float[end - start];
792
793 System.arraycopy(array, start, newArray, 0, end - start);
794
795 return newArray;
796 }
797
798 public static int[] subset(int[] array, int start, int end) {
799 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
800 return array;
801 }
802
803 int[] newArray = new int[end - start];
804
805 System.arraycopy(array, start, newArray, 0, end - start);
806
807 return newArray;
808 }
809
810 public static long[] subset(long[] array, int start, int end) {
811 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
812 return array;
813 }
814
815 long[] newArray = new long[end - start];
816
817 System.arraycopy(array, start, newArray, 0, end - start);
818
819 return newArray;
820 }
821
822 public static short[] subset(short[] array, int start, int end) {
823 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
824 return array;
825 }
826
827 short[] newArray = new short[end - start];
828
829 System.arraycopy(array, start, newArray, 0, end - start);
830
831 return newArray;
832 }
833
834 public static <T> T[] subset(T[] array, int start, int end) {
835 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
836 return array;
837 }
838
839 Class<?> arrayClass = array.getClass();
840
841 T[] newArray = (T[])Array.newInstance(
842 arrayClass.getComponentType(), end - start);
843
844 System.arraycopy(array, start, newArray, 0, end - start);
845
846 return newArray;
847 }
848
849 public static Boolean[] toArray(boolean[] array) {
850 Boolean[] newArray = new Boolean[array.length];
851
852 for (int i = 0; i < array.length; i++) {
853 newArray[i] = Boolean.valueOf(array[i]);
854 }
855
856 return newArray;
857 }
858
859 public static boolean[] toArray(Boolean[] array) {
860 boolean[] newArray = new boolean[array.length];
861
862 for (int i = 0; i < array.length; i++) {
863 newArray[i] = array[i].booleanValue();
864 }
865
866 return newArray;
867 }
868
869 public static Byte[] toArray(byte[] array) {
870 Byte[] newArray = new Byte[array.length];
871
872 for (int i = 0; i < array.length; i++) {
873 newArray[i] = Byte.valueOf(array[i]);
874 }
875
876 return newArray;
877 }
878
879 public static byte[] toArray(Byte[] array) {
880 byte[] newArray = new byte[array.length];
881
882 for (int i = 0; i < array.length; i++) {
883 newArray[i] = array[i].byteValue();
884 }
885
886 return newArray;
887 }
888
889 public static Character[] toArray(char[] array) {
890 Character[] newArray = new Character[array.length];
891
892 for (int i = 0; i < array.length; i++) {
893 newArray[i] = Character.valueOf(array[i]);
894 }
895
896 return newArray;
897 }
898
899 public static char[] toArray(Character[] array) {
900 char[] newArray = new char[array.length];
901
902 for (int i = 0; i < array.length; i++) {
903 newArray[i] = array[i].charValue();
904 }
905
906 return newArray;
907 }
908
909 public static Double[] toArray(double[] array) {
910 Double[] newArray = new Double[array.length];
911
912 for (int i = 0; i < array.length; i++) {
913 newArray[i] = new Double(array[i]);
914 }
915
916 return newArray;
917 }
918
919 public static double[] toArray(Double[] array) {
920 double[] newArray = new double[array.length];
921
922 for (int i = 0; i < array.length; i++) {
923 newArray[i] = array[i].doubleValue();
924 }
925
926 return newArray;
927 }
928
929 public static Float[] toArray(float[] array) {
930 Float[] newArray = new Float[array.length];
931
932 for (int i = 0; i < array.length; i++) {
933 newArray[i] = new Float(array[i]);
934 }
935
936 return newArray;
937 }
938
939 public static float[] toArray(Float[] array) {
940 float[] newArray = new float[array.length];
941
942 for (int i = 0; i < array.length; i++) {
943 newArray[i] = array[i].floatValue();
944 }
945
946 return newArray;
947 }
948
949 public static Integer[] toArray(int[] array) {
950 Integer[] newArray = new Integer[array.length];
951
952 for (int i = 0; i < array.length; i++) {
953 newArray[i] = new Integer(array[i]);
954 }
955
956 return newArray;
957 }
958
959 public static int[] toArray(Integer[] array) {
960 int[] newArray = new int[array.length];
961
962 for (int i = 0; i < array.length; i++) {
963 newArray[i] = array[i].intValue();
964 }
965
966 return newArray;
967 }
968
969 public static Long[] toArray(long[] array) {
970 Long[] newArray = new Long[array.length];
971
972 for (int i = 0; i < array.length; i++) {
973 newArray[i] = new Long(array[i]);
974 }
975
976 return newArray;
977 }
978
979 public static long[] toArray(Long[] array) {
980 long[] newArray = new long[array.length];
981
982 for (int i = 0; i < array.length; i++) {
983 newArray[i] = array[i].longValue();
984 }
985
986 return newArray;
987 }
988
989 public static Short[] toArray(short[] array) {
990 Short[] newArray = new Short[array.length];
991
992 for (int i = 0; i < array.length; i++) {
993 newArray[i] = new Short(array[i]);
994 }
995
996 return newArray;
997 }
998
999 public static short[] toArray(Short[] array) {
1000 short[] newArray = new short[array.length];
1001
1002 for (int i = 0; i < array.length; i++) {
1003 newArray[i] = array[i].shortValue();
1004 }
1005
1006 return newArray;
1007 }
1008
1009 public static Long[] toLongArray(Object[] array) {
1010 Long[] newArray = new Long[array.length];
1011
1012 for (int i = 0; i < array.length; i++) {
1013 newArray[i] = (Long)array[i];
1014 }
1015
1016 return newArray;
1017 }
1018
1019 public static String[] toStringArray(boolean[] array) {
1020 String[] newArray = new String[array.length];
1021
1022 for (int i = 0; i < array.length; i++) {
1023 newArray[i] = String.valueOf(array[i]);
1024 }
1025
1026 return newArray;
1027 }
1028
1029 public static String[] toStringArray(byte[] array) {
1030 String[] newArray = new String[array.length];
1031
1032 for (int i = 0; i < array.length; i++) {
1033 newArray[i] = String.valueOf(array[i]);
1034 }
1035
1036 return newArray;
1037 }
1038
1039 public static String[] toStringArray(char[] array) {
1040 String[] newArray = new String[array.length];
1041
1042 for (int i = 0; i < array.length; i++) {
1043 newArray[i] = String.valueOf(array[i]);
1044 }
1045
1046 return newArray;
1047 }
1048
1049 public static String[] toStringArray(Date[] array, DateFormat df) {
1050 String[] newArray = new String[array.length];
1051
1052 for (int i = 0; i < array.length; i++) {
1053 newArray[i] = df.format(array[i]);
1054 }
1055
1056 return newArray;
1057 }
1058
1059 public static String[] toStringArray(double[] array) {
1060 String[] newArray = new String[array.length];
1061
1062 for (int i = 0; i < array.length; i++) {
1063 newArray[i] = String.valueOf(array[i]);
1064 }
1065
1066 return newArray;
1067 }
1068
1069 public static String[] toStringArray(float[] array) {
1070 String[] newArray = new String[array.length];
1071
1072 for (int i = 0; i < array.length; i++) {
1073 newArray[i] = String.valueOf(array[i]);
1074 }
1075
1076 return newArray;
1077 }
1078
1079 public static String[] toStringArray(int[] array) {
1080 String[] newArray = new String[array.length];
1081
1082 for (int i = 0; i < array.length; i++) {
1083 newArray[i] = String.valueOf(array[i]);
1084 }
1085
1086 return newArray;
1087 }
1088
1089 public static String[] toStringArray(JSONArray array) {
1090 String[] newArray = new String[array.length()];
1091
1092 for (int i = 0; i < array.length(); i++) {
1093 newArray[i] = array.getString(i);
1094 }
1095
1096 return newArray;
1097 }
1098
1099 public static String[] toStringArray(long[] array) {
1100 String[] newArray = new String[array.length];
1101
1102 for (int i = 0; i < array.length; i++) {
1103 newArray[i] = String.valueOf(array[i]);
1104 }
1105
1106 return newArray;
1107 }
1108
1109 public static String[] toStringArray(Object[] array) {
1110 String[] newArray = new String[array.length];
1111
1112 for (int i = 0; i < array.length; i++) {
1113 newArray[i] = String.valueOf(array[i]);
1114 }
1115
1116 return newArray;
1117 }
1118
1119 public static String[] toStringArray(short[] array) {
1120 String[] newArray = new String[array.length];
1121
1122 for (int i = 0; i < array.length; i++) {
1123 newArray[i] = String.valueOf(array[i]);
1124 }
1125
1126 return newArray;
1127 }
1128
1129 }