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