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