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 String[] removeByPrefix(String[] array, String prefix) {
1328 List<String> list = new ArrayList<>();
1329
1330 for (String s : array) {
1331 if (!s.startsWith(prefix)) {
1332 list.add(s);
1333 }
1334 }
1335
1336 return list.toArray(new String[list.size()]);
1337 }
1338
1339 public static void replace(
1340 String[] values, String oldValue, String newValue) {
1341
1342 for (int i = 0; i < values.length; i++) {
1343 if (values[i].equals(oldValue)) {
1344 values[i] = newValue;
1345 }
1346 }
1347 }
1348
1349 public static void reverse(boolean[] array) {
1350 for (int left = 0, right = array.length - 1; left < right;
1351 left++, right--) {
1352
1353 boolean value = array[left];
1354
1355 array[left] = array[right];
1356 array[right] = value;
1357 }
1358 }
1359
1360 public static void reverse(char[] array) {
1361 for (int left = 0, right = array.length - 1; left < right;
1362 left++, right--) {
1363
1364 char value = array[left];
1365
1366 array[left] = array[right];
1367 array[right] = value;
1368 }
1369 }
1370
1371 public static void reverse(double[] array) {
1372 for (int left = 0, right = array.length - 1; left < right;
1373 left++, right--) {
1374
1375 double value = array[left];
1376
1377 array[left] = array[right];
1378 array[right] = value;
1379 }
1380 }
1381
1382 public static void reverse(int[] array) {
1383 for (int left = 0, right = array.length - 1; left < right;
1384 left++, right--) {
1385
1386 int value = array[left];
1387
1388 array[left] = array[right];
1389 array[right] = value;
1390 }
1391 }
1392
1393 public static void reverse(long[] array) {
1394 for (int left = 0, right = array.length - 1; left < right;
1395 left++, right--) {
1396
1397 long value = array[left];
1398
1399 array[left] = array[right];
1400 array[right] = value;
1401 }
1402 }
1403
1404 public static void reverse(short[] array) {
1405 for (int left = 0, right = array.length - 1; left < right;
1406 left++, right--) {
1407
1408 short value = array[left];
1409
1410 array[left] = array[right];
1411 array[right] = value;
1412 }
1413 }
1414
1415 public static <T> void reverse(T[] array) {
1416 for (int left = 0, right = array.length - 1; left < right;
1417 left++, right--) {
1418
1419 T value = array[left];
1420
1421 array[left] = array[right];
1422 array[right] = value;
1423 }
1424 }
1425
1426 public static boolean[] subset(boolean[] array, int start, int end) {
1427 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1428 return array;
1429 }
1430
1431 boolean[] newArray = new boolean[end - start];
1432
1433 System.arraycopy(array, start, newArray, 0, end - start);
1434
1435 return newArray;
1436 }
1437
1438 public static byte[] subset(byte[] array, int start, int end) {
1439 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1440 return array;
1441 }
1442
1443 byte[] newArray = new byte[end - start];
1444
1445 System.arraycopy(array, start, newArray, 0, end - start);
1446
1447 return newArray;
1448 }
1449
1450 public static char[] subset(char[] array, int start, int end) {
1451 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1452 return array;
1453 }
1454
1455 char[] newArray = new char[end - start];
1456
1457 System.arraycopy(array, start, newArray, 0, end - start);
1458
1459 return newArray;
1460 }
1461
1462 public static double[] subset(double[] array, int start, int end) {
1463 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1464 return array;
1465 }
1466
1467 double[] newArray = new double[end - start];
1468
1469 System.arraycopy(array, start, newArray, 0, end - start);
1470
1471 return newArray;
1472 }
1473
1474 public static float[] subset(float[] array, int start, int end) {
1475 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1476 return array;
1477 }
1478
1479 float[] newArray = new float[end - start];
1480
1481 System.arraycopy(array, start, newArray, 0, end - start);
1482
1483 return newArray;
1484 }
1485
1486 public static int[] subset(int[] array, int start, int end) {
1487 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1488 return array;
1489 }
1490
1491 int[] newArray = new int[end - start];
1492
1493 System.arraycopy(array, start, newArray, 0, end - start);
1494
1495 return newArray;
1496 }
1497
1498 public static long[] subset(long[] array, int start, int end) {
1499 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1500 return array;
1501 }
1502
1503 long[] newArray = new long[end - start];
1504
1505 System.arraycopy(array, start, newArray, 0, end - start);
1506
1507 return newArray;
1508 }
1509
1510 public static short[] subset(short[] array, int start, int end) {
1511 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1512 return array;
1513 }
1514
1515 short[] newArray = new short[end - start];
1516
1517 System.arraycopy(array, start, newArray, 0, end - start);
1518
1519 return newArray;
1520 }
1521
1522 public static <T> T[] subset(T[] array, int start, int end) {
1523 if ((start < 0) || (end < 0) || ((end - start) < 0)) {
1524 return array;
1525 }
1526
1527 Class<?> arrayClass = array.getClass();
1528
1529 T[] newArray = (T[])Array.newInstance(
1530 arrayClass.getComponentType(), end - start);
1531
1532 System.arraycopy(array, start, newArray, 0, end - start);
1533
1534 return newArray;
1535 }
1536
1537 public static Boolean[] toArray(boolean[] array) {
1538 Boolean[] newArray = new Boolean[array.length];
1539
1540 for (int i = 0; i < array.length; i++) {
1541 newArray[i] = Boolean.valueOf(array[i]);
1542 }
1543
1544 return newArray;
1545 }
1546
1547 public static boolean[] toArray(Boolean[] array) {
1548 boolean[] newArray = new boolean[array.length];
1549
1550 for (int i = 0; i < array.length; i++) {
1551 newArray[i] = array[i].booleanValue();
1552 }
1553
1554 return newArray;
1555 }
1556
1557 public static Byte[] toArray(byte[] array) {
1558 Byte[] newArray = new Byte[array.length];
1559
1560 for (int i = 0; i < array.length; i++) {
1561 newArray[i] = Byte.valueOf(array[i]);
1562 }
1563
1564 return newArray;
1565 }
1566
1567 public static byte[] toArray(Byte[] array) {
1568 byte[] newArray = new byte[array.length];
1569
1570 for (int i = 0; i < array.length; i++) {
1571 newArray[i] = array[i].byteValue();
1572 }
1573
1574 return newArray;
1575 }
1576
1577 public static Character[] toArray(char[] array) {
1578 Character[] newArray = new Character[array.length];
1579
1580 for (int i = 0; i < array.length; i++) {
1581 newArray[i] = Character.valueOf(array[i]);
1582 }
1583
1584 return newArray;
1585 }
1586
1587 public static char[] toArray(Character[] array) {
1588 char[] newArray = new char[array.length];
1589
1590 for (int i = 0; i < array.length; i++) {
1591 newArray[i] = array[i].charValue();
1592 }
1593
1594 return newArray;
1595 }
1596
1597 public static Double[] toArray(double[] array) {
1598 Double[] newArray = new Double[array.length];
1599
1600 for (int i = 0; i < array.length; i++) {
1601 newArray[i] = Double.valueOf(array[i]);
1602 }
1603
1604 return newArray;
1605 }
1606
1607 public static double[] toArray(Double[] array) {
1608 double[] newArray = new double[array.length];
1609
1610 for (int i = 0; i < array.length; i++) {
1611 newArray[i] = array[i].doubleValue();
1612 }
1613
1614 return newArray;
1615 }
1616
1617 public static Float[] toArray(float[] array) {
1618 Float[] newArray = new Float[array.length];
1619
1620 for (int i = 0; i < array.length; i++) {
1621 newArray[i] = Float.valueOf(array[i]);
1622 }
1623
1624 return newArray;
1625 }
1626
1627 public static float[] toArray(Float[] array) {
1628 float[] newArray = new float[array.length];
1629
1630 for (int i = 0; i < array.length; i++) {
1631 newArray[i] = array[i].floatValue();
1632 }
1633
1634 return newArray;
1635 }
1636
1637 public static Integer[] toArray(int[] array) {
1638 Integer[] newArray = new Integer[array.length];
1639
1640 for (int i = 0; i < array.length; i++) {
1641 newArray[i] = Integer.valueOf(array[i]);
1642 }
1643
1644 return newArray;
1645 }
1646
1647 public static int[] toArray(Integer[] array) {
1648 int[] newArray = new int[array.length];
1649
1650 for (int i = 0; i < array.length; i++) {
1651 newArray[i] = array[i].intValue();
1652 }
1653
1654 return newArray;
1655 }
1656
1657 public static Long[] toArray(long[] array) {
1658 Long[] newArray = new Long[array.length];
1659
1660 for (int i = 0; i < array.length; i++) {
1661 newArray[i] = Long.valueOf(array[i]);
1662 }
1663
1664 return newArray;
1665 }
1666
1667 public static long[] toArray(Long[] array) {
1668 long[] newArray = new long[array.length];
1669
1670 for (int i = 0; i < array.length; i++) {
1671 newArray[i] = array[i].longValue();
1672 }
1673
1674 return newArray;
1675 }
1676
1677 public static Short[] toArray(short[] array) {
1678 Short[] newArray = new Short[array.length];
1679
1680 for (int i = 0; i < array.length; i++) {
1681 newArray[i] = Short.valueOf(array[i]);
1682 }
1683
1684 return newArray;
1685 }
1686
1687 public static short[] toArray(Short[] array) {
1688 short[] newArray = new short[array.length];
1689
1690 for (int i = 0; i < array.length; i++) {
1691 newArray[i] = array[i].shortValue();
1692 }
1693
1694 return newArray;
1695 }
1696
1697 public static String[] toArray(String[] array) {
1698 String[] newArray = new String[array.length];
1699
1700 for (int i = 0; i < array.length; i++) {
1701 newArray[i] = array[i].toString();
1702 }
1703
1704 return newArray;
1705 }
1706
1707 public static <T, A> A[] toArray(T[] list, Accessor<T, A> accessor) {
1708 A[] aArray = (A[])Array.newInstance(
1709 accessor.getAttributeClass(), list.length);
1710
1711 for (int i = 0; i < list.length; i++) {
1712 aArray[i] = accessor.get(list[i]);
1713 }
1714
1715 return aArray;
1716 }
1717
1718 public static double[] toDoubleArray(
1719 Collection<? extends Number> collection) {
1720
1721 double[] newArray = new double[collection.size()];
1722
1723 if (collection instanceof List) {
1724 List<Number> list = (List<Number>)collection;
1725
1726 for (int i = 0; i < list.size(); i++) {
1727 Number value = list.get(i);
1728
1729 newArray[i] = value.doubleValue();
1730 }
1731 }
1732 else {
1733 int i = 0;
1734
1735 Iterator<? extends Number> iterator = collection.iterator();
1736
1737 while (iterator.hasNext()) {
1738 Number value = iterator.next();
1739
1740 newArray[i++] = value.doubleValue();
1741 }
1742 }
1743
1744 return newArray;
1745 }
1746
1747 public static float[] toFloatArray(
1748 Collection<? extends Number> collection) {
1749
1750 float[] newArray = new float[collection.size()];
1751
1752 if (collection instanceof List) {
1753 List<Number> list = (List<Number>)collection;
1754
1755 for (int i = 0; i < list.size(); i++) {
1756 Number value = list.get(i);
1757
1758 newArray[i] = value.floatValue();
1759 }
1760 }
1761 else {
1762 int i = 0;
1763
1764 Iterator<? extends Number> iterator = collection.iterator();
1765
1766 while (iterator.hasNext()) {
1767 Number value = iterator.next();
1768
1769 newArray[i++] = value.floatValue();
1770 }
1771 }
1772
1773 return newArray;
1774 }
1775
1776 public static int[] toIntArray(Collection<? extends Number> collection) {
1777 int[] newArray = new int[collection.size()];
1778
1779 if (collection instanceof List) {
1780 List<Number> list = (List<Number>)collection;
1781
1782 for (int i = 0; i < list.size(); i++) {
1783 Number value = list.get(i);
1784
1785 newArray[i] = value.intValue();
1786 }
1787 }
1788 else {
1789 int i = 0;
1790
1791 Iterator<? extends Number> iterator = collection.iterator();
1792
1793 while (iterator.hasNext()) {
1794 Number value = iterator.next();
1795
1796 newArray[i++] = value.intValue();
1797 }
1798 }
1799
1800 return newArray;
1801 }
1802
1803 public static long[] toLongArray(Collection<? extends Number> collection) {
1804 long[] newArray = new long[collection.size()];
1805
1806 if (collection instanceof List) {
1807 List<Number> list = (List<Number>)collection;
1808
1809 for (int i = 0; i < list.size(); i++) {
1810 Number value = list.get(i);
1811
1812 newArray[i] = value.longValue();
1813 }
1814 }
1815 else {
1816 int i = 0;
1817
1818 Iterator<? extends Number> iterator = collection.iterator();
1819
1820 while (iterator.hasNext()) {
1821 Number value = iterator.next();
1822
1823 newArray[i++] = value.longValue();
1824 }
1825 }
1826
1827 return newArray;
1828 }
1829
1830 public static Long[] toLongArray(int[] array) {
1831 Long[] newArray = new Long[array.length];
1832
1833 for (int i = 0; i < array.length; i++) {
1834 newArray[i] = (long)array[i];
1835 }
1836
1837 return newArray;
1838 }
1839
1840 public static Long[] toLongArray(long[] array) {
1841 Long[] newArray = new Long[array.length];
1842
1843 for (int i = 0; i < array.length; i++) {
1844 newArray[i] = array[i];
1845 }
1846
1847 return newArray;
1848 }
1849
1850 public static Long[] toLongArray(Object[] array) {
1851 Long[] newArray = new Long[array.length];
1852
1853 for (int i = 0; i < array.length; i++) {
1854 newArray[i] = (Long)array[i];
1855 }
1856
1857 return newArray;
1858 }
1859
1860 public static short[] toShortArray(Collection<Short> collection) {
1861 short[] newArray = new short[collection.size()];
1862
1863 if (collection instanceof List) {
1864 List<Short> list = (List<Short>)collection;
1865
1866 for (int i = 0; i < list.size(); i++) {
1867 Short value = list.get(i);
1868
1869 newArray[i] = value.shortValue();
1870 }
1871 }
1872 else {
1873 int i = 0;
1874
1875 Iterator<Short> iterator = collection.iterator();
1876
1877 while (iterator.hasNext()) {
1878 Short value = iterator.next();
1879
1880 newArray[i++] = value.shortValue();
1881 }
1882 }
1883
1884 return newArray;
1885 }
1886
1887
1890 public static String toString(Object[] array, String param) {
1891 return toString(array, param, StringPool.COMMA);
1892 }
1893
1894
1897 public static String toString(
1898 Object[] array, String param, String delimiter) {
1899
1900 return toString(array, param, delimiter, null);
1901 }
1902
1903 public static String toString(
1904 Object[] array, String param, String delimiter, Locale locale) {
1905
1906 if (isEmpty(array)) {
1907 return StringPool.BLANK;
1908 }
1909
1910 StringBundler sb = new StringBundler(2 * array.length - 1);
1911
1912 for (int i = 0; i < array.length; i++) {
1913 Object bean = array[i];
1914
1915 Object value = BeanPropertiesUtil.getObject(bean, param);
1916
1917 if (value != null) {
1918 if (locale != null) {
1919 sb.append(LanguageUtil.get(locale, value.toString()));
1920 }
1921 else {
1922 sb.append(value);
1923 }
1924 }
1925
1926 if ((i + 1) != array.length) {
1927 sb.append(delimiter);
1928 }
1929 }
1930
1931 return sb.toString();
1932 }
1933
1934
1937 public static <T, A> String toString(T[] list, Accessor<T, A> accessor) {
1938 return toString(list, accessor, StringPool.COMMA);
1939 }
1940
1941
1944 public static <T, A> String toString(
1945 T[] list, Accessor<T, A> accessor, String delimiter) {
1946
1947 return toString(list, accessor, delimiter, null);
1948 }
1949
1950 public static <T, A> String toString(
1951 T[] list, Accessor<T, A> accessor, String delimiter, Locale locale) {
1952
1953 if (isEmpty(list)) {
1954 return StringPool.BLANK;
1955 }
1956
1957 StringBundler sb = new StringBundler(2 * list.length - 1);
1958
1959 for (int i = 0; i < list.length; i++) {
1960 T bean = list[i];
1961
1962 A attribute = accessor.get(bean);
1963
1964 if (attribute != null) {
1965 if (locale != null) {
1966 sb.append(LanguageUtil.get(locale, attribute.toString()));
1967 }
1968 else {
1969 sb.append(attribute);
1970 }
1971 }
1972
1973 if ((i + 1) != list.length) {
1974 sb.append(delimiter);
1975 }
1976 }
1977
1978 return sb.toString();
1979 }
1980
1981 public static String[] toStringArray(boolean[] array) {
1982 String[] newArray = new String[array.length];
1983
1984 for (int i = 0; i < array.length; i++) {
1985 newArray[i] = String.valueOf(array[i]);
1986 }
1987
1988 return newArray;
1989 }
1990
1991 public static String[] toStringArray(byte[] array) {
1992 String[] newArray = new String[array.length];
1993
1994 for (int i = 0; i < array.length; i++) {
1995 newArray[i] = String.valueOf(array[i]);
1996 }
1997
1998 return newArray;
1999 }
2000
2001 public static String[] toStringArray(char[] array) {
2002 String[] newArray = new String[array.length];
2003
2004 for (int i = 0; i < array.length; i++) {
2005 newArray[i] = String.valueOf(array[i]);
2006 }
2007
2008 return newArray;
2009 }
2010
2011 public static String[] toStringArray(Collection<String> collection) {
2012 String[] newArray = new String[collection.size()];
2013
2014 if (collection instanceof List) {
2015 List<String> list = (List<String>)collection;
2016
2017 for (int i = 0; i < list.size(); i++) {
2018 String value = list.get(i);
2019
2020 newArray[i] = String.valueOf(value);
2021 }
2022 }
2023 else {
2024 int i = 0;
2025
2026 Iterator<String> iterator = collection.iterator();
2027
2028 while (iterator.hasNext()) {
2029 String value = iterator.next();
2030
2031 newArray[i++] = String.valueOf(value);
2032 }
2033 }
2034
2035 return newArray;
2036 }
2037
2038 public static String[] toStringArray(Date[] array, DateFormat dateFormat) {
2039 String[] newArray = new String[array.length];
2040
2041 for (int i = 0; i < array.length; i++) {
2042 newArray[i] = dateFormat.format(array[i]);
2043 }
2044
2045 return newArray;
2046 }
2047
2048 public static String[] toStringArray(double[] array) {
2049 String[] newArray = new String[array.length];
2050
2051 for (int i = 0; i < array.length; i++) {
2052 newArray[i] = String.valueOf(array[i]);
2053 }
2054
2055 return newArray;
2056 }
2057
2058 public static String[] toStringArray(float[] array) {
2059 String[] newArray = new String[array.length];
2060
2061 for (int i = 0; i < array.length; i++) {
2062 newArray[i] = String.valueOf(array[i]);
2063 }
2064
2065 return newArray;
2066 }
2067
2068 public static String[] toStringArray(int[] array) {
2069 String[] newArray = new String[array.length];
2070
2071 for (int i = 0; i < array.length; i++) {
2072 newArray[i] = String.valueOf(array[i]);
2073 }
2074
2075 return newArray;
2076 }
2077
2078 public static String[] toStringArray(JSONArray array) {
2079 String[] newArray = new String[array.length()];
2080
2081 for (int i = 0; i < array.length(); i++) {
2082 newArray[i] = array.getString(i);
2083 }
2084
2085 return newArray;
2086 }
2087
2088 public static String[] toStringArray(long[] array) {
2089 String[] newArray = new String[array.length];
2090
2091 for (int i = 0; i < array.length; i++) {
2092 newArray[i] = String.valueOf(array[i]);
2093 }
2094
2095 return newArray;
2096 }
2097
2098 public static String[] toStringArray(Object[] array) {
2099 String[] newArray = new String[array.length];
2100
2101 for (int i = 0; i < array.length; i++) {
2102 newArray[i] = String.valueOf(array[i]);
2103 }
2104
2105 return newArray;
2106 }
2107
2108 public static String[] toStringArray(short[] array) {
2109 String[] newArray = new String[array.length];
2110
2111 for (int i = 0; i < array.length; i++) {
2112 newArray[i] = String.valueOf(array[i]);
2113 }
2114
2115 return newArray;
2116 }
2117
2118 public static byte[] unique(byte[] array) {
2119 Set<Byte> set = new LinkedHashSet<>();
2120
2121 for (int i = 0; i < array.length; i++) {
2122 set.add(array[i]);
2123 }
2124
2125 return toArray(set.toArray(new Byte[set.size()]));
2126 }
2127
2128 public static double[] unique(double[] array) {
2129 Set<Double> set = new LinkedHashSet<>();
2130
2131 for (int i = 0; i < array.length; i++) {
2132 set.add(array[i]);
2133 }
2134
2135 return toArray(set.toArray(new Double[set.size()]));
2136 }
2137
2138 public static float[] unique(float[] array) {
2139 Set<Float> set = new LinkedHashSet<>();
2140
2141 for (int i = 0; i < array.length; i++) {
2142 set.add(array[i]);
2143 }
2144
2145 return toArray(set.toArray(new Float[set.size()]));
2146 }
2147
2148 public static int[] unique(int[] array) {
2149 Set<Integer> set = new LinkedHashSet<>();
2150
2151 for (int i = 0; i < array.length; i++) {
2152 set.add(array[i]);
2153 }
2154
2155 return toArray(set.toArray(new Integer[set.size()]));
2156 }
2157
2158 public static long[] unique(long[] array) {
2159 Set<Long> set = new LinkedHashSet<>();
2160
2161 for (int i = 0; i < array.length; i++) {
2162 set.add(array[i]);
2163 }
2164
2165 return toArray(set.toArray(new Long[set.size()]));
2166 }
2167
2168 public static short[] unique(short[] array) {
2169 Set<Short> set = new LinkedHashSet<>();
2170
2171 for (int i = 0; i < array.length; i++) {
2172 set.add(array[i]);
2173 }
2174
2175 return toArray(set.toArray(new Short[set.size()]));
2176 }
2177
2178 public static String[] unique(String[] array) {
2179 Set<String> set = new LinkedHashSet<>();
2180
2181 for (int i = 0; i < array.length; i++) {
2182 set.add(array[i]);
2183 }
2184
2185 return toArray(set.toArray(new String[set.size()]));
2186 }
2187
2188 }