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 import com.liferay.portal.kernel.language.LanguageUtil;
020
021 import java.lang.reflect.Array;
022
023 import java.text.DateFormat;
024
025 import java.util.ArrayList;
026 import java.util.Arrays;
027 import java.util.Collection;
028 import java.util.Comparator;
029 import java.util.Date;
030 import java.util.Iterator;
031 import java.util.LinkedHashSet;
032 import java.util.List;
033 import java.util.Locale;
034 import java.util.Set;
035 import java.util.TreeSet;
036
037
040 public class ArrayUtil {
041
042 public static boolean[] append(boolean[]... arrays) {
043 int length = 0;
044
045 for (boolean[] array : arrays) {
046 length += array.length;
047 }
048
049 boolean[] newArray = new boolean[length];
050
051 int previousLength = 0;
052
053 for (boolean[] array : arrays) {
054 System.arraycopy(array, 0, newArray, previousLength, array.length);
055
056 previousLength += array.length;
057 }
058
059 return newArray;
060 }
061
062 public static boolean[] append(boolean[] array, boolean value) {
063 boolean[] newArray = new boolean[array.length + 1];
064
065 System.arraycopy(array, 0, newArray, 0, array.length);
066
067 newArray[newArray.length - 1] = value;
068
069 return newArray;
070 }
071
072 public static byte[] append(byte[]... arrays) {
073 int length = 0;
074
075 for (byte[] array : arrays) {
076 length += array.length;
077 }
078
079 byte[] newArray = new byte[length];
080
081 int previousLength = 0;
082
083 for (byte[] array : arrays) {
084 System.arraycopy(array, 0, newArray, previousLength, array.length);
085
086 previousLength += array.length;
087 }
088
089 return newArray;
090 }
091
092 public static byte[] append(byte[] array, byte value) {
093 byte[] newArray = new byte[array.length + 1];
094
095 System.arraycopy(array, 0, newArray, 0, array.length);
096
097 newArray[newArray.length - 1] = value;
098
099 return newArray;
100 }
101
102 public static char[] append(char[]... arrays) {
103 int length = 0;
104
105 for (char[] array : arrays) {
106 length += array.length;
107 }
108
109 char[] newArray = new char[length];
110
111 int previousLength = 0;
112
113 for (char[] array : arrays) {
114 System.arraycopy(array, 0, newArray, previousLength, array.length);
115
116 previousLength += array.length;
117 }
118
119 return newArray;
120 }
121
122 public static char[] append(char[] array, char value) {
123 char[] newArray = new char[array.length + 1];
124
125 System.arraycopy(array, 0, newArray, 0, array.length);
126
127 newArray[newArray.length - 1] = value;
128
129 return newArray;
130 }
131
132 public static double[] append(double[]... arrays) {
133 int length = 0;
134
135 for (double[] array : arrays) {
136 length += array.length;
137 }
138
139 double[] newArray = new double[length];
140
141 int previousLength = 0;
142
143 for (double[] array : arrays) {
144 System.arraycopy(array, 0, newArray, previousLength, array.length);
145
146 previousLength += array.length;
147 }
148
149 return newArray;
150 }
151
152 public static double[] append(double[] array, double value) {
153 double[] newArray = new double[array.length + 1];
154
155 System.arraycopy(array, 0, newArray, 0, array.length);
156
157 newArray[newArray.length - 1] = value;
158
159 return newArray;
160 }
161
162 public static float[] append(float[]... arrays) {
163 int length = 0;
164
165 for (float[] array : arrays) {
166 length += array.length;
167 }
168
169 float[] newArray = new float[length];
170
171 int previousLength = 0;
172
173 for (float[] array : arrays) {
174 System.arraycopy(array, 0, newArray, previousLength, array.length);
175
176 previousLength += array.length;
177 }
178
179 return newArray;
180 }
181
182 public static float[] append(float[] array, float value) {
183 float[] newArray = new float[array.length + 1];
184
185 System.arraycopy(array, 0, newArray, 0, array.length);
186
187 newArray[newArray.length - 1] = value;
188
189 return newArray;
190 }
191
192 public static int[] append(int[]... arrays) {
193 int length = 0;
194
195 for (int[] array : arrays) {
196 length += array.length;
197 }
198
199 int[] newArray = new int[length];
200
201 int previousLength = 0;
202
203 for (int[] array : arrays) {
204 System.arraycopy(array, 0, newArray, previousLength, array.length);
205
206 previousLength += array.length;
207 }
208
209 return newArray;
210 }
211
212 public static int[] append(int[] array, int value) {
213 int[] newArray = new int[array.length + 1];
214
215 System.arraycopy(array, 0, newArray, 0, array.length);
216
217 newArray[newArray.length - 1] = value;
218
219 return newArray;
220 }
221
222 public static long[] append(long[]... arrays) {
223 int length = 0;
224
225 for (long[] array : arrays) {
226 length += array.length;
227 }
228
229 long[] newArray = new long[length];
230
231 int previousLength = 0;
232
233 for (long[] array : arrays) {
234 System.arraycopy(array, 0, newArray, previousLength, array.length);
235
236 previousLength += array.length;
237 }
238
239 return newArray;
240 }
241
242 public static long[] append(long[] array, long value) {
243 long[] newArray = new long[array.length + 1];
244
245 System.arraycopy(array, 0, newArray, 0, array.length);
246
247 newArray[newArray.length - 1] = value;
248
249 return newArray;
250 }
251
252 public static short[] append(short[]... arrays) {
253 int length = 0;
254
255 for (short[] array : arrays) {
256 length += array.length;
257 }
258
259 short[] newArray = new short[length];
260
261 int previousLength = 0;
262
263 for (short[] array : arrays) {
264 System.arraycopy(array, 0, newArray, previousLength, array.length);
265
266 previousLength += array.length;
267 }
268
269 return newArray;
270 }
271
272 public static short[] append(short[] array, short value) {
273 short[] newArray = new short[array.length + 1];
274
275 System.arraycopy(array, 0, newArray, 0, array.length);
276
277 newArray[newArray.length - 1] = value;
278
279 return newArray;
280 }
281
282 public static <T> T[] append(T[]... arrays) {
283 int length = 0;
284
285 for (T[] array : arrays) {
286 length += array.length;
287 }
288
289 Class<?> arraysClass = arrays[0].getClass();
290
291 T[] newArray = (T[])Array.newInstance(
292 arraysClass.getComponentType(), length);
293
294 int previousLength = 0;
295
296 for (T[] array : arrays) {
297 System.arraycopy(array, 0, newArray, previousLength, array.length);
298
299 previousLength += array.length;
300 }
301
302 return newArray;
303 }
304
305 public static <T> T[] append(T[] array, T value) {
306 Class<?> arrayClass = array.getClass();
307
308 T[] newArray = (T[])Array.newInstance(
309 arrayClass.getComponentType(), array.length + 1);
310
311 System.arraycopy(array, 0, newArray, 0, array.length);
312
313 newArray[array.length] = value;
314
315 return newArray;
316 }
317
318 public static <T> T[] append(T[] array1, T[] array2) {
319 Class<?> array1Class = array1.getClass();
320
321 T[] newArray = (T[])Array.newInstance(
322 array1Class.getComponentType(), array1.length + array2.length);
323
324 System.arraycopy(array1, 0, newArray, 0, array1.length);
325
326 System.arraycopy(array2, 0, newArray, array1.length, array2.length);
327
328 return newArray;
329 }
330
331 public static <T> T[][] append(T[][] array1, T[] value) {
332 Class<?> array1Class = array1.getClass();
333
334 T[][] newArray = (T[][])Array.newInstance(
335 array1Class.getComponentType(), array1.length + 1);
336
337 System.arraycopy(array1, 0, newArray, 0, array1.length);
338
339 newArray[array1.length] = value;
340
341 return newArray;
342 }
343
344 public static <T> T[][] append(T[][] array1, T[][] array2) {
345 Class<?> array1Class = array1.getClass();
346
347 T[][] newArray = (T[][])Array.newInstance(
348 array1Class.getComponentType(), array1.length + array2.length);
349
350 System.arraycopy(array1, 0, newArray, 0, array1.length);
351 System.arraycopy(array2, 0, newArray, array1.length, array2.length);
352
353 return newArray;
354 }
355
356 public static boolean[] clone(boolean[] array) {
357 boolean[] newArray = new boolean[array.length];
358
359 System.arraycopy(array, 0, newArray, 0, array.length);
360
361 return newArray;
362 }
363
364 public static boolean[] clone(boolean[] array, int from, int to) {
365 boolean[] newArray = new boolean[to - from];
366
367 System.arraycopy(
368 array, from, newArray, 0,
369 Math.min(array.length - from, newArray.length));
370
371 return newArray;
372 }
373
374 public static byte[] clone(byte[] array) {
375 byte[] newArray = new byte[array.length];
376
377 System.arraycopy(array, 0, newArray, 0, array.length);
378
379 return newArray;
380 }
381
382 public static byte[] clone(byte[] array, int from, int to) {
383 byte[] newArray = new byte[to - from];
384
385 System.arraycopy(
386 array, from, newArray, 0,
387 Math.min(array.length - from, newArray.length));
388
389 return newArray;
390 }
391
392 public static char[] clone(char[] array) {
393 char[] newArray = new char[array.length];
394
395 System.arraycopy(array, 0, newArray, 0, array.length);
396
397 return newArray;
398 }
399
400 public static char[] clone(char[] array, int from, int to) {
401 char[] newArray = new char[to - from];
402
403 System.arraycopy(
404 array, from, newArray, 0,
405 Math.min(array.length - from, newArray.length));
406
407 return newArray;
408 }
409
410 public static double[] clone(double[] array) {
411 double[] newArray = new double[array.length];
412
413 System.arraycopy(array, 0, newArray, 0, array.length);
414
415 return newArray;
416 }
417
418 public static double[] clone(double[] array, int from, int to) {
419 double[] newArray = new double[to - from];
420
421 System.arraycopy(
422 array, from, newArray, 0,
423 Math.min(array.length - from, newArray.length));
424
425 return newArray;
426 }
427
428 public static float[] clone(float[] array) {
429 float[] newArray = new float[array.length];
430
431 System.arraycopy(array, 0, newArray, 0, array.length);
432
433 return newArray;
434 }
435
436 public static float[] clone(float[] array, int from, int to) {
437 float[] newArray = new float[to - from];
438
439 System.arraycopy(
440 array, from, newArray, 0,
441 Math.min(array.length - from, newArray.length));
442
443 return newArray;
444 }
445
446 public static int[] clone(int[] array) {
447 int[] newArray = new int[array.length];
448
449 System.arraycopy(array, 0, newArray, 0, array.length);
450
451 return newArray;
452 }
453
454 public static int[] clone(int[] array, int from, int to) {
455 int[] newArray = new int[to - from];
456
457 System.arraycopy(
458 array, from, newArray, 0,
459 Math.min(array.length - from, newArray.length));
460
461 return newArray;
462 }
463
464 public static long[] clone(long[] array) {
465 long[] newArray = new long[array.length];
466
467 System.arraycopy(array, 0, newArray, 0, array.length);
468
469 return newArray;
470 }
471
472 public static long[] clone(long[] array, int from, int to) {
473 long[] newArray = new long[to - from];
474
475 System.arraycopy(
476 array, from, newArray, 0,
477 Math.min(array.length - from, newArray.length));
478
479 return newArray;
480 }
481
482 public static short[] clone(short[] array) {
483 short[] newArray = new short[array.length];
484
485 System.arraycopy(array, 0, newArray, 0, array.length);
486
487 return newArray;
488 }
489
490 public static short[] clone(short[] array, int from, int to) {
491 short[] newArray = new short[to - from];
492
493 System.arraycopy(
494 array, from, newArray, 0,
495 Math.min(array.length - from, newArray.length));
496
497 return newArray;
498 }
499
500 public static <T> T[] clone(T[] array) {
501 Class<?> arrayClass = array.getClass();
502
503 T[] newArray = (T[])Array.newInstance(
504 arrayClass.getComponentType(), array.length);
505
506 System.arraycopy(array, 0, newArray, 0, array.length);
507
508 return newArray;
509 }
510
511 public static <T> T[] clone(T[] array, int from, int to) {
512 Class<?> arrayClass = array.getClass();
513
514 T[] newArray = (T[])Array.newInstance(
515 arrayClass.getComponentType(), to - from);
516
517 System.arraycopy(
518 array, from, newArray, 0,
519 Math.min(array.length - from, newArray.length));
520
521 return newArray;
522 }
523
524 public static <T> T[][] clone(T[][] array) {
525 Class<?> arrayClass = array.getClass();
526
527 T[][] newArray = (T[][])Array.newInstance(
528 arrayClass.getComponentType(), array.length);
529
530 System.arraycopy(array, 0, newArray, 0, array.length);
531
532 return newArray;
533 }
534
535 public static <T> T[][] clone(T[][] array, int from, int to) {
536 Class<?> arrayClass = array.getClass();
537
538 T[][] newArray = (T[][])Array.newInstance(
539 arrayClass.getComponentType(), to - from);
540
541 System.arraycopy(
542 array, from, newArray, 0,
543 Math.min(array.length - from, newArray.length));
544
545 return newArray;
546 }
547
548 public static void combine(
549 Object[] array1, Object[] array2, Object[] combinedArray) {
550
551 System.arraycopy(array1, 0, combinedArray, 0, array1.length);
552
553 System.arraycopy(
554 array2, 0, combinedArray, array1.length, array2.length);
555 }
556
557 public static boolean contains(boolean[] array, boolean value) {
558 if (isEmpty(array)) {
559 return false;
560 }
561
562 for (int i = 0; i < array.length; i++) {
563 if (value == array[i]) {
564 return true;
565 }
566 }
567
568 return false;
569 }
570
571 public static boolean contains(byte[] array, byte value) {
572 if (isEmpty(array)) {
573 return false;
574 }
575
576 for (int i = 0; i < array.length; i++) {
577 if (value == array[i]) {
578 return true;
579 }
580 }
581
582 return false;
583 }
584
585 public static boolean contains(char[] array, char value) {
586 if (isEmpty(array)) {
587 return false;
588 }
589
590 for (int i = 0; i < array.length; i++) {
591 if (value == array[i]) {
592 return true;
593 }
594 }
595
596 return false;
597 }
598
599 public static boolean contains(double[] array, double value) {
600 if (isEmpty(array)) {
601 return false;
602 }
603
604 for (int i = 0; i < array.length; i++) {
605 if (value == array[i]) {
606 return true;
607 }
608 }
609
610 return false;
611 }
612
613 public static boolean contains(float[] array, float value) {
614 if (isEmpty(array)) {
615 return false;
616 }
617
618 for (int i = 0; i < array.length; i++) {
619 if (value == array[i]) {
620 return true;
621 }
622 }
623
624 return false;
625 }
626
627 public static boolean contains(int[] array, int value) {
628 if (isEmpty(array)) {
629 return false;
630 }
631
632 for (int i = 0; i < array.length; i++) {
633 if (value == array[i]) {
634 return true;
635 }
636 }
637
638 return false;
639 }
640
641 public static boolean contains(long[] array, long value) {
642 if (isEmpty(array)) {
643 return false;
644 }
645
646 for (int i = 0; i < array.length; i++) {
647 if (value == array[i]) {
648 return true;
649 }
650 }
651
652 return false;
653 }
654
655 public static boolean contains(Object[] array, Object value) {
656 if (isEmpty(array)) {
657 return false;
658 }
659
660 for (int i = 0; i < array.length; i++) {
661 if (Validator.equals(value, array[i])) {
662 return true;
663 }
664 }
665
666 return false;
667 }
668
669 public static boolean contains(short[] array, short value) {
670 if (isEmpty(array)) {
671 return false;
672 }
673
674 for (int i = 0; i < array.length; i++) {
675 if (value == array[i]) {
676 return true;
677 }
678 }
679
680 return false;
681 }
682
683 public static boolean contains(
684 String[] array, String value, boolean ignoreCase) {
685
686 if (isEmpty(array)) {
687 return false;
688 }
689
690 for (int i = 0; i < array.length; i++) {
691 if (ignoreCase) {
692 if (StringUtil.equalsIgnoreCase(array[i], value)) {
693 return true;
694 }
695 }
696 else {
697 if (Validator.equals(array[i], value)) {
698 return true;
699 }
700 }
701 }
702
703 return false;
704 }
705
706 public static boolean containsAll(boolean[] array1, boolean[] array2) {
707 if (isEmpty(array1) || isEmpty(array2)) {
708 return false;
709 }
710
711 for (int i = 0; i < array2.length; i++) {
712 if (!contains(array1, array2[i])) {
713 return false;
714 }
715 }
716
717 return true;
718 }
719
720 public static boolean containsAll(byte[] array1, byte[] array2) {
721 if (isEmpty(array1) || isEmpty(array2)) {
722 return false;
723 }
724
725 for (int i = 0; i < array2.length; i++) {
726 if (!contains(array1, array2[i])) {
727 return false;
728 }
729 }
730
731 return true;
732 }
733
734 public static boolean containsAll(char[] array1, char[] array2) {
735 if (isEmpty(array1) || isEmpty(array2)) {
736 return false;
737 }
738
739 for (int i = 0; i < array2.length; i++) {
740 if (!contains(array1, array2[i])) {
741 return false;
742 }
743 }
744
745 return true;
746 }
747
748 public static boolean containsAll(double[] array1, double[] array2) {
749 if (isEmpty(array1) || isEmpty(array2)) {
750 return false;
751 }
752
753 for (int i = 0; i < array2.length; i++) {
754 if (!contains(array1, array2[i])) {
755 return false;
756 }
757 }
758
759 return true;
760 }
761
762 public static boolean containsAll(float[] array1, float[] array2) {
763 if (isEmpty(array1) || isEmpty(array2)) {
764 return false;
765 }
766
767 for (int i = 0; i < array2.length; i++) {
768 if (!contains(array1, array2[i])) {
769 return false;
770 }
771 }
772
773 return true;
774 }
775
776 public static boolean containsAll(int[] array1, int[] array2) {
777 if (isEmpty(array1) || isEmpty(array2)) {
778 return false;
779 }
780
781 for (int i = 0; i < array2.length; i++) {
782 if (!contains(array1, array2[i])) {
783 return false;
784 }
785 }
786
787 return true;
788 }
789
790 public static boolean containsAll(long[] array1, long[] array2) {
791 if (isEmpty(array1) || isEmpty(array2)) {
792 return false;
793 }
794
795 for (int i = 0; i < array2.length; i++) {
796 if (!contains(array1, array2[i])) {
797 return false;
798 }
799 }
800
801 return true;
802 }
803
804 public static boolean containsAll(Object[] array1, Object[] array2) {
805 if (isEmpty(array1) || isEmpty(array2)) {
806 return false;
807 }
808
809 for (int i = 0; i < array2.length; i++) {
810 if (!contains(array1, array2[i])) {
811 return false;
812 }
813 }
814
815 return true;
816 }
817
818 public static boolean containsAll(short[] array1, short[] array2) {
819 if (isEmpty(array1) || isEmpty(array2)) {
820 return false;
821 }
822
823 for (int i = 0; i < array2.length; i++) {
824 if (!contains(array1, array2[i])) {
825 return false;
826 }
827 }
828
829 return true;
830 }
831
832 public static <T> int count(T[] array, PredicateFilter<T> predicateFilter) {
833 if (isEmpty(array)) {
834 return 0;
835 }
836
837 int count = 0;
838
839 for (T t : array) {
840 if (predicateFilter.filter(t)) {
841 count++;
842 }
843 }
844
845 return count;
846 }
847
848 public static String[] distinct(String[] array) {
849 return distinct(array, null);
850 }
851
852 public static String[] distinct(
853 String[] array, Comparator<String> comparator) {
854
855 if (isEmpty(array)) {
856 return array;
857 }
858
859 Set<String> set = null;
860
861 if (comparator == null) {
862 set = new TreeSet<>();
863 }
864 else {
865 set = new TreeSet<>(comparator);
866 }
867
868 for (String s : array) {
869 set.add(s);
870 }
871
872 return set.toArray(new String[set.size()]);
873 }
874
875 public static <T> boolean exists(
876 T[] array, PredicateFilter<T> predicateFilter) {
877
878 if (isEmpty(array)) {
879 return false;
880 }
881
882 for (T t : array) {
883 if (predicateFilter.filter(t)) {
884 return true;
885 }
886 }
887
888 return false;
889 }
890
891 public static boolean[] filter(
892 boolean[] array, PredicateFilter<Boolean> predicateFilter) {
893
894 if (isEmpty(array)) {
895 return array;
896 }
897
898 List<Boolean> filteredList = new ArrayList<>();
899
900 for (boolean b : array) {
901 if (predicateFilter.filter(b)) {
902 filteredList.add(b);
903 }
904 }
905
906 return toArray(filteredList.toArray(new Boolean[filteredList.size()]));
907 }
908
909 public static byte[] filter(
910 byte[] array, PredicateFilter<Byte> predicateFilter) {
911
912 if (isEmpty(array)) {
913 return array;
914 }
915
916 List<Byte> filteredList = new ArrayList<>();
917
918 for (byte b : array) {
919 if (predicateFilter.filter(b)) {
920 filteredList.add(b);
921 }
922 }
923
924 return toArray(filteredList.toArray(new Byte[filteredList.size()]));
925 }
926
927 public static char[] filter(
928 char[] array, PredicateFilter<Character> predicateFilter) {
929
930 if (isEmpty(array)) {
931 return array;
932 }
933
934 List<Character> filteredList = new ArrayList<>();
935
936 for (char c : array) {
937 if (predicateFilter.filter(c)) {
938 filteredList.add(c);
939 }
940 }
941
942 return toArray(
943 filteredList.toArray(new Character[filteredList.size()]));
944 }
945
946 public static double[] filter(
947 double[] array, PredicateFilter<Double> predicateFilter) {
948
949 if (isEmpty(array)) {
950 return array;
951 }
952
953 List<Double> filteredList = new ArrayList<>();
954
955 for (double d : array) {
956 if (predicateFilter.filter(d)) {
957 filteredList.add(d);
958 }
959 }
960
961 return toArray(filteredList.toArray(new Double[filteredList.size()]));
962 }
963
964 public static float[] filter(
965 float[] array, PredicateFilter<Float> predicateFilter) {
966
967 if (isEmpty(array)) {
968 return array;
969 }
970
971 List<Float> filteredList = new ArrayList<>();
972
973 for (float f : array) {
974 if (predicateFilter.filter(f)) {
975 filteredList.add(f);
976 }
977 }
978
979 return toArray(filteredList.toArray(new Float[filteredList.size()]));
980 }
981
982 public static int[] filter(
983 int[] array, PredicateFilter<Integer> predicateFilter) {
984
985 if (isEmpty(array)) {
986 return array;
987 }
988
989 List<Integer> filteredList = new ArrayList<>();
990
991 for (int i : array) {
992 if (predicateFilter.filter(i)) {
993 filteredList.add(i);
994 }
995 }
996
997 return toArray(filteredList.toArray(new Integer[filteredList.size()]));
998 }
999
1000 public static long[] filter(
1001 long[] array, PredicateFilter<Long> predicateFilter) {
1002
1003 if (isEmpty(array)) {
1004 return array;
1005 }
1006
1007 List<Long> filteredList = new ArrayList<>();
1008
1009 for (long l : array) {
1010 if (predicateFilter.filter(l)) {
1011 filteredList.add(l);
1012 }
1013 }
1014
1015 return toArray(filteredList.toArray(new Long[filteredList.size()]));
1016 }
1017
1018 public static short[] filter(
1019 short[] array, PredicateFilter<Short> predicateFilter) {
1020
1021 if (isEmpty(array)) {
1022 return array;
1023 }
1024
1025 List<Short> filteredList = new ArrayList<>();
1026
1027 for (short s : array) {
1028 if (predicateFilter.filter(s)) {
1029 filteredList.add(s);
1030 }
1031 }
1032
1033 return toArray(filteredList.toArray(new Short[filteredList.size()]));
1034 }
1035
1036 public static <T> T[] filter(
1037 T[] array, PredicateFilter<T> filterPredicate) {
1038
1039 if (isEmpty(array)) {
1040 return array;
1041 }
1042
1043 List<T> filteredList = new ArrayList<>();
1044
1045 for (T t : array) {
1046 if (filterPredicate.filter(t)) {
1047 filteredList.add(t);
1048 }
1049 }
1050
1051 Object[] filteredArray = filteredList.toArray();
1052
1053 return (T[])Arrays.copyOf(
1054 filteredArray, filteredArray.length, array.getClass());
1055 }
1056
1057 public static int getLength(Object[] array) {
1058 if (array == null) {
1059 return 0;
1060 }
1061 else {
1062 return array.length;
1063 }
1064 }
1065
1066 public static Object getValue(Object[] array, int pos) {
1067 if ((array == null) || (array.length <= pos)) {
1068 return null;
1069 }
1070 else {
1071 return array[pos];
1072 }
1073 }
1074
1075 public static boolean isEmpty(boolean[] array) {
1076 if ((array == null) || (array.length == 0)) {
1077 return true;
1078 }
1079
1080 return false;
1081 }
1082
1083 public static boolean isEmpty(byte[] array) {
1084 if ((array == null) || (array.length == 0)) {
1085 return true;
1086 }
1087
1088 return false;
1089 }
1090
1091 public static boolean isEmpty(char[] array) {
1092 if ((array == null) || (array.length == 0)) {
1093 return true;
1094 }
1095
1096 return false;
1097 }
1098
1099 public static boolean isEmpty(double[] array) {
1100 if ((array == null) || (array.length == 0)) {
1101 return true;
1102 }
1103
1104 return false;
1105 }
1106
1107 public static boolean isEmpty(float[] array) {
1108 if ((array == null) || (array.length == 0)) {
1109 return true;
1110 }
1111
1112 return false;
1113 }
1114
1115 public static boolean isEmpty(int[] array) {
1116 if ((array == null) || (array.length == 0)) {
1117 return true;
1118 }
1119
1120 return false;
1121 }
1122
1123 public static boolean isEmpty(long[] array) {
1124 if ((array == null) || (array.length == 0)) {
1125 return true;
1126 }
1127
1128 return false;
1129 }
1130
1131 public static boolean isEmpty(Object[] array) {
1132 if ((array == null) || (array.length == 0)) {
1133 return true;
1134 }
1135
1136 return false;
1137 }
1138
1139 public static boolean isEmpty(short[] array) {
1140 if ((array == null) || (array.length == 0)) {
1141 return true;
1142 }
1143
1144 return false;
1145 }
1146
1147 public static boolean isNotEmpty(boolean[] array) {
1148 return !isEmpty(array);
1149 }
1150
1151 public static boolean isNotEmpty(byte[] array) {
1152 return !isEmpty(array);
1153 }
1154
1155 public static boolean isNotEmpty(char[] array) {
1156 return !isEmpty(array);
1157 }
1158
1159 public static boolean isNotEmpty(double[] array) {
1160 return !isEmpty(array);
1161 }
1162
1163 public static boolean isNotEmpty(float[] array) {
1164 return !isEmpty(array);
1165 }
1166
1167 public static boolean isNotEmpty(int[] array) {
1168 return !isEmpty(array);
1169 }
1170
1171 public static boolean isNotEmpty(long[] array) {
1172 return !isEmpty(array);
1173 }
1174
1175 public static boolean isNotEmpty(Object[] array) {
1176 return !isEmpty(array);
1177 }
1178
1179 public static boolean isNotEmpty(short[] array) {
1180 return !isEmpty(array);
1181 }
1182
1183 public static boolean[] remove(boolean[] array, boolean value) {
1184 if (isEmpty(array)) {
1185 return array;
1186 }
1187
1188 List<Boolean> list = new ArrayList<>();
1189
1190 for (int i = 0; i < array.length; i++) {
1191 if (value != array[i]) {
1192 list.add(array[i]);
1193 }
1194 }
1195
1196 return toArray(list.toArray(new Boolean[list.size()]));
1197 }
1198
1199 public static byte[] remove(byte[] array, byte value) {
1200 if (isEmpty(array)) {
1201 return array;
1202 }
1203
1204 List<Byte> list = new ArrayList<>();
1205
1206 for (int i = 0; i < array.length; i++) {
1207 if (value != array[i]) {
1208 list.add(Byte.valueOf(array[i]));
1209 }
1210 }
1211
1212 return toArray(list.toArray(new Byte[list.size()]));
1213 }
1214
1215 public static char[] remove(char[] array, char value) {
1216 if (isEmpty(array)) {
1217 return array;
1218 }
1219
1220 List<Character> list = new ArrayList<>();
1221
1222 for (int i = 0; i < array.length; i++) {
1223 if (value != array[i]) {
1224 list.add(Character.valueOf(array[i]));
1225 }
1226 }
1227
1228 return toArray(list.toArray(new Character[list.size()]));
1229 }
1230
1231 public static double[] remove(double[] array, double value) {
1232 if (isEmpty(array)) {
1233 return array;
1234 }
1235
1236 List<Double> list = new ArrayList<>();
1237
1238 for (int i = 0; i < array.length; i++) {
1239 if (value != array[i]) {
1240 list.add(Double.valueOf(array[i]));
1241 }
1242 }
1243
1244 return toArray(list.toArray(new Double[list.size()]));
1245 }
1246
1247 public static float[] remove(float[] array, float value) {
1248 if (isEmpty(array)) {
1249 return array;
1250 }
1251
1252 List<Float> list = new ArrayList<>();
1253
1254 for (int i = 0; i < array.length; i++) {
1255 if (value != array[i]) {
1256 list.add(Float.valueOf(array[i]));
1257 }
1258 }
1259
1260 return toArray(list.toArray(new Float[list.size()]));
1261 }
1262
1263 public static int[] remove(int[] array, int value) {
1264 if (isEmpty(array)) {
1265 return array;
1266 }
1267
1268 List<Integer> list = new ArrayList<>();
1269
1270 for (int i = 0; i < array.length; i++) {
1271 if (value != array[i]) {
1272 list.add(Integer.valueOf(array[i]));
1273 }
1274 }
1275
1276 return toArray(list.toArray(new Integer[list.size()]));
1277 }
1278
1279 public static long[] remove(long[] array, long value) {
1280 if (isEmpty(array)) {
1281 return array;
1282 }
1283
1284 List<Long> list = new ArrayList<>();
1285
1286 for (int i = 0; i < array.length; i++) {
1287 if (value != array[i]) {
1288 list.add(Long.valueOf(array[i]));
1289 }
1290 }
1291
1292 return toArray(list.toArray(new Long[list.size()]));
1293 }
1294
1295 public static short[] remove(short[] array, short value) {
1296 if (isEmpty(array)) {
1297 return array;
1298 }
1299
1300 List<Short> list = new ArrayList<>();
1301
1302 for (int i = 0; i < array.length; i++) {
1303 if (value != array[i]) {
1304 list.add(Short.valueOf(array[i]));
1305 }
1306 }
1307
1308 return toArray(list.toArray(new Short[list.size()]));
1309 }
1310
1311 public static String[] remove(String[] array, String value) {
1312 if (isEmpty(array)) {
1313 return array;
1314 }
1315
1316 List<String> list = new ArrayList<>();
1317
1318 for (String s : array) {
1319 if (!s.equals(value)) {
1320 list.add(s);
1321 }
1322 }
1323
1324 return list.toArray(new String[list.size()]);
1325 }
1326
1327 public static <T> T[] remove(T[] array, T value) {
1328 if (isEmpty(array)) {
1329 return array;
1330 }
1331
1332 List<T> list = new ArrayList<>();
1333
1334 for (int i = 0; i < array.length; i++) {
1335 if (value != array[i]) {
1336 list.add(array[i]);
1337 }
1338 }
1339
1340 if (array.length == list.size()) {
1341 return array;
1342 }
1343
1344 Class<?> arrayClass = array.getClass();
1345
1346 return list.toArray(
1347 (T[])Array.newInstance(arrayClass.getComponentType(), list.size()));
1348 }
1349
1350 public static String[] removeByPrefix(String[] array, String prefix) {
1351 List<String> list = new ArrayList<>();
1352
1353 for (String s : array) {
1354 if (!s.startsWith(prefix)) {
1355 list.add(s);
1356 }
1357 }
1358
1359 return list.toArray(new String[list.size()]);
1360 }
1361
1362 public static void replace(
1363 String[] values, String oldValue, String newValue) {
1364
1365 for (int i = 0; i < values.length; i++) {
1366 if (values[i].equals(oldValue)) {
1367 values[i] = newValue;
1368 }
1369 }
1370 }
1371
1372 public static void reverse(boolean[] array) {
1373 for (int left = 0, right = array.length - 1; left < right;
1374 left++, right--) {
1375
1376 boolean value = array[left];
1377
1378 array[left] = array[right];
1379 array[right] = value;
1380 }
1381 }
1382
1383 public static void reverse(char[] array) {
1384 for (int left = 0, right = array.length - 1; left < right;
1385 left++, right--) {
1386
1387 char value = array[left];
1388
1389 array[left] = array[right];
1390 array[right] = value;
1391 }
1392 }
1393
1394 public static void reverse(double[] array) {
1395 for (int left = 0, right = array.length - 1; left < right;
1396 left++, right--) {
1397
1398 double value = array[left];
1399
1400 array[left] = array[right];
1401 array[right] = value;
1402 }
1403 }
1404
1405 public static void reverse(int[] array) {
1406 for (int left = 0, right = array.length - 1; left < right;
1407 left++, right--) {
1408
1409 int value = array[left];
1410
1411 array[left] = array[right];
1412 array[right] = value;
1413 }
1414 }
1415
1416 public static void reverse(long[] array) {
1417 for (int left = 0, right = array.length - 1; left < right;
1418 left++, right--) {
1419
1420 long value = array[left];
1421
1422 array[left] = array[right];
1423 array[right] = value;
1424 }
1425 }
1426
1427 public static void reverse(short[] array) {
1428 for (int left = 0, right = array.length - 1; left < right;
1429 left++, right--) {
1430
1431 short value = array[left];
1432
1433 array[left] = array[right];
1434 array[right] = value;
1435 }
1436 }
1437
1438 public static <T> void reverse(T[] array) {
1439 for (int left = 0, right = array.length - 1; left < right;
1440 left++, right--) {
1441
1442 T value = array[left];
1443
1444 array[left] = array[right];
1445 array[right] = value;
1446 }
1447 }
1448
1449 public static boolean[] subset(boolean[] array, int start, int end) {
1450 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1451 return array;
1452 }
1453
1454 boolean[] newArray = new boolean[end - start];
1455
1456 System.arraycopy(array, start, newArray, 0, end - start);
1457
1458 return newArray;
1459 }
1460
1461 public static byte[] subset(byte[] array, int start, int end) {
1462 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1463 return array;
1464 }
1465
1466 byte[] newArray = new byte[end - start];
1467
1468 System.arraycopy(array, start, newArray, 0, end - start);
1469
1470 return newArray;
1471 }
1472
1473 public static char[] subset(char[] array, int start, int end) {
1474 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1475 return array;
1476 }
1477
1478 char[] newArray = new char[end - start];
1479
1480 System.arraycopy(array, start, newArray, 0, end - start);
1481
1482 return newArray;
1483 }
1484
1485 public static double[] subset(double[] array, int start, int end) {
1486 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1487 return array;
1488 }
1489
1490 double[] newArray = new double[end - start];
1491
1492 System.arraycopy(array, start, newArray, 0, end - start);
1493
1494 return newArray;
1495 }
1496
1497 public static float[] subset(float[] array, int start, int end) {
1498 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1499 return array;
1500 }
1501
1502 float[] newArray = new float[end - start];
1503
1504 System.arraycopy(array, start, newArray, 0, end - start);
1505
1506 return newArray;
1507 }
1508
1509 public static int[] subset(int[] array, int start, int end) {
1510 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1511 return array;
1512 }
1513
1514 int[] newArray = new int[end - start];
1515
1516 System.arraycopy(array, start, newArray, 0, end - start);
1517
1518 return newArray;
1519 }
1520
1521 public static long[] subset(long[] array, int start, int end) {
1522 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1523 return array;
1524 }
1525
1526 long[] newArray = new long[end - start];
1527
1528 System.arraycopy(array, start, newArray, 0, end - start);
1529
1530 return newArray;
1531 }
1532
1533 public static short[] subset(short[] array, int start, int end) {
1534 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1535 return array;
1536 }
1537
1538 short[] newArray = new short[end - start];
1539
1540 System.arraycopy(array, start, newArray, 0, end - start);
1541
1542 return newArray;
1543 }
1544
1545 public static <T> T[] subset(T[] array, int start, int end) {
1546 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1547 return array;
1548 }
1549
1550 Class<?> arrayClass = array.getClass();
1551
1552 T[] newArray = (T[])Array.newInstance(
1553 arrayClass.getComponentType(), end - start);
1554
1555 System.arraycopy(array, start, newArray, 0, end - start);
1556
1557 return newArray;
1558 }
1559
1560 public static Boolean[] toArray(boolean[] array) {
1561 Boolean[] newArray = new Boolean[array.length];
1562
1563 for (int i = 0; i < array.length; i++) {
1564 newArray[i] = Boolean.valueOf(array[i]);
1565 }
1566
1567 return newArray;
1568 }
1569
1570 public static boolean[] toArray(Boolean[] array) {
1571 boolean[] newArray = new boolean[array.length];
1572
1573 for (int i = 0; i < array.length; i++) {
1574 newArray[i] = array[i].booleanValue();
1575 }
1576
1577 return newArray;
1578 }
1579
1580 public static Byte[] toArray(byte[] array) {
1581 Byte[] newArray = new Byte[array.length];
1582
1583 for (int i = 0; i < array.length; i++) {
1584 newArray[i] = Byte.valueOf(array[i]);
1585 }
1586
1587 return newArray;
1588 }
1589
1590 public static byte[] toArray(Byte[] array) {
1591 byte[] newArray = new byte[array.length];
1592
1593 for (int i = 0; i < array.length; i++) {
1594 newArray[i] = array[i].byteValue();
1595 }
1596
1597 return newArray;
1598 }
1599
1600 public static Character[] toArray(char[] array) {
1601 Character[] newArray = new Character[array.length];
1602
1603 for (int i = 0; i < array.length; i++) {
1604 newArray[i] = Character.valueOf(array[i]);
1605 }
1606
1607 return newArray;
1608 }
1609
1610 public static char[] toArray(Character[] array) {
1611 char[] newArray = new char[array.length];
1612
1613 for (int i = 0; i < array.length; i++) {
1614 newArray[i] = array[i].charValue();
1615 }
1616
1617 return newArray;
1618 }
1619
1620 public static Double[] toArray(double[] array) {
1621 Double[] newArray = new Double[array.length];
1622
1623 for (int i = 0; i < array.length; i++) {
1624 newArray[i] = Double.valueOf(array[i]);
1625 }
1626
1627 return newArray;
1628 }
1629
1630 public static double[] toArray(Double[] array) {
1631 double[] newArray = new double[array.length];
1632
1633 for (int i = 0; i < array.length; i++) {
1634 newArray[i] = array[i].doubleValue();
1635 }
1636
1637 return newArray;
1638 }
1639
1640 public static Float[] toArray(float[] array) {
1641 Float[] newArray = new Float[array.length];
1642
1643 for (int i = 0; i < array.length; i++) {
1644 newArray[i] = Float.valueOf(array[i]);
1645 }
1646
1647 return newArray;
1648 }
1649
1650 public static float[] toArray(Float[] array) {
1651 float[] newArray = new float[array.length];
1652
1653 for (int i = 0; i < array.length; i++) {
1654 newArray[i] = array[i].floatValue();
1655 }
1656
1657 return newArray;
1658 }
1659
1660 public static Integer[] toArray(int[] array) {
1661 Integer[] newArray = new Integer[array.length];
1662
1663 for (int i = 0; i < array.length; i++) {
1664 newArray[i] = Integer.valueOf(array[i]);
1665 }
1666
1667 return newArray;
1668 }
1669
1670 public static int[] toArray(Integer[] array) {
1671 int[] newArray = new int[array.length];
1672
1673 for (int i = 0; i < array.length; i++) {
1674 newArray[i] = array[i].intValue();
1675 }
1676
1677 return newArray;
1678 }
1679
1680 public static Long[] toArray(long[] array) {
1681 Long[] newArray = new Long[array.length];
1682
1683 for (int i = 0; i < array.length; i++) {
1684 newArray[i] = Long.valueOf(array[i]);
1685 }
1686
1687 return newArray;
1688 }
1689
1690 public static long[] toArray(Long[] array) {
1691 long[] newArray = new long[array.length];
1692
1693 for (int i = 0; i < array.length; i++) {
1694 newArray[i] = array[i].longValue();
1695 }
1696
1697 return newArray;
1698 }
1699
1700 public static Short[] toArray(short[] array) {
1701 Short[] newArray = new Short[array.length];
1702
1703 for (int i = 0; i < array.length; i++) {
1704 newArray[i] = Short.valueOf(array[i]);
1705 }
1706
1707 return newArray;
1708 }
1709
1710 public static short[] toArray(Short[] array) {
1711 short[] newArray = new short[array.length];
1712
1713 for (int i = 0; i < array.length; i++) {
1714 newArray[i] = array[i].shortValue();
1715 }
1716
1717 return newArray;
1718 }
1719
1720 public static String[] toArray(String[] array) {
1721 String[] newArray = new String[array.length];
1722
1723 for (int i = 0; i < array.length; i++) {
1724 newArray[i] = array[i].toString();
1725 }
1726
1727 return newArray;
1728 }
1729
1730 public static <T, A> A[] toArray(T[] list, Accessor<T, A> accessor) {
1731 A[] aArray = (A[])Array.newInstance(
1732 accessor.getAttributeClass(), list.length);
1733
1734 for (int i = 0; i < list.length; i++) {
1735 aArray[i] = accessor.get(list[i]);
1736 }
1737
1738 return aArray;
1739 }
1740
1741 public static double[] toDoubleArray(
1742 Collection<? extends Number> collection) {
1743
1744 double[] newArray = new double[collection.size()];
1745
1746 if (collection instanceof List) {
1747 List<Number> list = (List<Number>)collection;
1748
1749 for (int i = 0; i < list.size(); i++) {
1750 Number value = list.get(i);
1751
1752 newArray[i] = value.doubleValue();
1753 }
1754 }
1755 else {
1756 int i = 0;
1757
1758 Iterator<? extends Number> iterator = collection.iterator();
1759
1760 while (iterator.hasNext()) {
1761 Number value = iterator.next();
1762
1763 newArray[i++] = value.doubleValue();
1764 }
1765 }
1766
1767 return newArray;
1768 }
1769
1770 public static float[] toFloatArray(
1771 Collection<? extends Number> collection) {
1772
1773 float[] newArray = new float[collection.size()];
1774
1775 if (collection instanceof List) {
1776 List<Number> list = (List<Number>)collection;
1777
1778 for (int i = 0; i < list.size(); i++) {
1779 Number value = list.get(i);
1780
1781 newArray[i] = value.floatValue();
1782 }
1783 }
1784 else {
1785 int i = 0;
1786
1787 Iterator<? extends Number> iterator = collection.iterator();
1788
1789 while (iterator.hasNext()) {
1790 Number value = iterator.next();
1791
1792 newArray[i++] = value.floatValue();
1793 }
1794 }
1795
1796 return newArray;
1797 }
1798
1799 public static int[] toIntArray(Collection<? extends Number> collection) {
1800 int[] newArray = new int[collection.size()];
1801
1802 if (collection instanceof List) {
1803 List<Number> list = (List<Number>)collection;
1804
1805 for (int i = 0; i < list.size(); i++) {
1806 Number value = list.get(i);
1807
1808 newArray[i] = value.intValue();
1809 }
1810 }
1811 else {
1812 int i = 0;
1813
1814 Iterator<? extends Number> iterator = collection.iterator();
1815
1816 while (iterator.hasNext()) {
1817 Number value = iterator.next();
1818
1819 newArray[i++] = value.intValue();
1820 }
1821 }
1822
1823 return newArray;
1824 }
1825
1826 public static long[] toLongArray(Collection<? extends Number> collection) {
1827 long[] newArray = new long[collection.size()];
1828
1829 if (collection instanceof List) {
1830 List<Number> list = (List<Number>)collection;
1831
1832 for (int i = 0; i < list.size(); i++) {
1833 Number value = list.get(i);
1834
1835 newArray[i] = value.longValue();
1836 }
1837 }
1838 else {
1839 int i = 0;
1840
1841 Iterator<? extends Number> iterator = collection.iterator();
1842
1843 while (iterator.hasNext()) {
1844 Number value = iterator.next();
1845
1846 newArray[i++] = value.longValue();
1847 }
1848 }
1849
1850 return newArray;
1851 }
1852
1853 public static Long[] toLongArray(int[] array) {
1854 Long[] newArray = new Long[array.length];
1855
1856 for (int i = 0; i < array.length; i++) {
1857 newArray[i] = (long)array[i];
1858 }
1859
1860 return newArray;
1861 }
1862
1863 public static Long[] toLongArray(long[] array) {
1864 Long[] newArray = new Long[array.length];
1865
1866 for (int i = 0; i < array.length; i++) {
1867 newArray[i] = array[i];
1868 }
1869
1870 return newArray;
1871 }
1872
1873 public static Long[] toLongArray(Object[] array) {
1874 Long[] newArray = new Long[array.length];
1875
1876 for (int i = 0; i < array.length; i++) {
1877 newArray[i] = (Long)array[i];
1878 }
1879
1880 return newArray;
1881 }
1882
1883 public static short[] toShortArray(Collection<Short> collection) {
1884 short[] newArray = new short[collection.size()];
1885
1886 if (collection instanceof List) {
1887 List<Short> list = (List<Short>)collection;
1888
1889 for (int i = 0; i < list.size(); i++) {
1890 Short value = list.get(i);
1891
1892 newArray[i] = value.shortValue();
1893 }
1894 }
1895 else {
1896 int i = 0;
1897
1898 Iterator<Short> iterator = collection.iterator();
1899
1900 while (iterator.hasNext()) {
1901 Short value = iterator.next();
1902
1903 newArray[i++] = value.shortValue();
1904 }
1905 }
1906
1907 return newArray;
1908 }
1909
1910
1913 public static String toString(Object[] array, String param) {
1914 return toString(array, param, StringPool.COMMA);
1915 }
1916
1917
1920 public static String toString(
1921 Object[] array, String param, String delimiter) {
1922
1923 return toString(array, param, delimiter, null);
1924 }
1925
1926 public static String toString(
1927 Object[] array, String param, String delimiter, Locale locale) {
1928
1929 if (isEmpty(array)) {
1930 return StringPool.BLANK;
1931 }
1932
1933 StringBundler sb = new StringBundler(2 * array.length - 1);
1934
1935 for (int i = 0; i < array.length; i++) {
1936 Object bean = array[i];
1937
1938 Object value = BeanPropertiesUtil.getObject(bean, param);
1939
1940 if (value != null) {
1941 if (locale != null) {
1942 sb.append(LanguageUtil.get(locale, value.toString()));
1943 }
1944 else {
1945 sb.append(value);
1946 }
1947 }
1948
1949 if ((i + 1) != array.length) {
1950 sb.append(delimiter);
1951 }
1952 }
1953
1954 return sb.toString();
1955 }
1956
1957
1960 public static <T, A> String toString(T[] list, Accessor<T, A> accessor) {
1961 return toString(list, accessor, StringPool.COMMA);
1962 }
1963
1964
1967 public static <T, A> String toString(
1968 T[] list, Accessor<T, A> accessor, String delimiter) {
1969
1970 return toString(list, accessor, delimiter, null);
1971 }
1972
1973 public static <T, A> String toString(
1974 T[] list, Accessor<T, A> accessor, String delimiter, Locale locale) {
1975
1976 if (isEmpty(list)) {
1977 return StringPool.BLANK;
1978 }
1979
1980 StringBundler sb = new StringBundler(2 * list.length - 1);
1981
1982 for (int i = 0; i < list.length; i++) {
1983 T bean = list[i];
1984
1985 A attribute = accessor.get(bean);
1986
1987 if (attribute != null) {
1988 if (locale != null) {
1989 sb.append(LanguageUtil.get(locale, attribute.toString()));
1990 }
1991 else {
1992 sb.append(attribute);
1993 }
1994 }
1995
1996 if ((i + 1) != list.length) {
1997 sb.append(delimiter);
1998 }
1999 }
2000
2001 return sb.toString();
2002 }
2003
2004 public static String[] toStringArray(boolean[] array) {
2005 String[] newArray = new String[array.length];
2006
2007 for (int i = 0; i < array.length; i++) {
2008 newArray[i] = String.valueOf(array[i]);
2009 }
2010
2011 return newArray;
2012 }
2013
2014 public static String[] toStringArray(byte[] array) {
2015 String[] newArray = new String[array.length];
2016
2017 for (int i = 0; i < array.length; i++) {
2018 newArray[i] = String.valueOf(array[i]);
2019 }
2020
2021 return newArray;
2022 }
2023
2024 public static String[] toStringArray(char[] array) {
2025 String[] newArray = new String[array.length];
2026
2027 for (int i = 0; i < array.length; i++) {
2028 newArray[i] = String.valueOf(array[i]);
2029 }
2030
2031 return newArray;
2032 }
2033
2034 public static String[] toStringArray(Collection<String> collection) {
2035 String[] newArray = new String[collection.size()];
2036
2037 if (collection instanceof List) {
2038 List<String> list = (List<String>)collection;
2039
2040 for (int i = 0; i < list.size(); i++) {
2041 String value = list.get(i);
2042
2043 newArray[i] = String.valueOf(value);
2044 }
2045 }
2046 else {
2047 int i = 0;
2048
2049 Iterator<String> iterator = collection.iterator();
2050
2051 while (iterator.hasNext()) {
2052 String value = iterator.next();
2053
2054 newArray[i++] = String.valueOf(value);
2055 }
2056 }
2057
2058 return newArray;
2059 }
2060
2061 public static String[] toStringArray(Date[] array, DateFormat dateFormat) {
2062 String[] newArray = new String[array.length];
2063
2064 for (int i = 0; i < array.length; i++) {
2065 newArray[i] = dateFormat.format(array[i]);
2066 }
2067
2068 return newArray;
2069 }
2070
2071 public static String[] toStringArray(double[] array) {
2072 String[] newArray = new String[array.length];
2073
2074 for (int i = 0; i < array.length; i++) {
2075 newArray[i] = String.valueOf(array[i]);
2076 }
2077
2078 return newArray;
2079 }
2080
2081 public static String[] toStringArray(float[] array) {
2082 String[] newArray = new String[array.length];
2083
2084 for (int i = 0; i < array.length; i++) {
2085 newArray[i] = String.valueOf(array[i]);
2086 }
2087
2088 return newArray;
2089 }
2090
2091 public static String[] toStringArray(int[] array) {
2092 String[] newArray = new String[array.length];
2093
2094 for (int i = 0; i < array.length; i++) {
2095 newArray[i] = String.valueOf(array[i]);
2096 }
2097
2098 return newArray;
2099 }
2100
2101 public static String[] toStringArray(JSONArray array) {
2102 String[] newArray = new String[array.length()];
2103
2104 for (int i = 0; i < array.length(); i++) {
2105 newArray[i] = array.getString(i);
2106 }
2107
2108 return newArray;
2109 }
2110
2111 public static String[] toStringArray(long[] array) {
2112 String[] newArray = new String[array.length];
2113
2114 for (int i = 0; i < array.length; i++) {
2115 newArray[i] = String.valueOf(array[i]);
2116 }
2117
2118 return newArray;
2119 }
2120
2121 public static String[] toStringArray(Object[] array) {
2122 String[] newArray = new String[array.length];
2123
2124 for (int i = 0; i < array.length; i++) {
2125 newArray[i] = String.valueOf(array[i]);
2126 }
2127
2128 return newArray;
2129 }
2130
2131 public static String[] toStringArray(short[] array) {
2132 String[] newArray = new String[array.length];
2133
2134 for (int i = 0; i < array.length; i++) {
2135 newArray[i] = String.valueOf(array[i]);
2136 }
2137
2138 return newArray;
2139 }
2140
2141 public static byte[] unique(byte[] array) {
2142 Set<Byte> set = new LinkedHashSet<>();
2143
2144 for (int i = 0; i < array.length; i++) {
2145 set.add(array[i]);
2146 }
2147
2148 return toArray(set.toArray(new Byte[set.size()]));
2149 }
2150
2151 public static double[] unique(double[] array) {
2152 Set<Double> set = new LinkedHashSet<>();
2153
2154 for (int i = 0; i < array.length; i++) {
2155 set.add(array[i]);
2156 }
2157
2158 return toArray(set.toArray(new Double[set.size()]));
2159 }
2160
2161 public static float[] unique(float[] array) {
2162 Set<Float> set = new LinkedHashSet<>();
2163
2164 for (int i = 0; i < array.length; i++) {
2165 set.add(array[i]);
2166 }
2167
2168 return toArray(set.toArray(new Float[set.size()]));
2169 }
2170
2171 public static int[] unique(int[] array) {
2172 Set<Integer> set = new LinkedHashSet<>();
2173
2174 for (int i = 0; i < array.length; i++) {
2175 set.add(array[i]);
2176 }
2177
2178 return toArray(set.toArray(new Integer[set.size()]));
2179 }
2180
2181 public static long[] unique(long[] array) {
2182 Set<Long> set = new LinkedHashSet<>();
2183
2184 for (int i = 0; i < array.length; i++) {
2185 set.add(array[i]);
2186 }
2187
2188 return toArray(set.toArray(new Long[set.size()]));
2189 }
2190
2191 public static short[] unique(short[] array) {
2192 Set<Short> set = new LinkedHashSet<>();
2193
2194 for (int i = 0; i < array.length; i++) {
2195 set.add(array[i]);
2196 }
2197
2198 return toArray(set.toArray(new Short[set.size()]));
2199 }
2200
2201 public static String[] unique(String[] array) {
2202 Set<String> set = new LinkedHashSet<>();
2203
2204 for (int i = 0; i < array.length; i++) {
2205 set.add(array[i]);
2206 }
2207
2208 return toArray(set.toArray(new String[set.size()]));
2209 }
2210
2211 }