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