1
14
15 package com.liferay.portal.kernel.util;
16
17 import com.liferay.portal.kernel.json.JSONArray;
18
19 import java.lang.reflect.Array;
20
21 import java.text.DateFormat;
22
23 import java.util.ArrayList;
24 import java.util.Comparator;
25 import java.util.Date;
26 import java.util.List;
27 import java.util.Set;
28 import java.util.TreeSet;
29
30
35 public class ArrayUtil {
36
37 public static boolean[] append(boolean[]... arrays) {
38 int length = 0;
39
40 for (boolean[] array : arrays) {
41 length += array.length;
42 }
43
44 boolean[] newArray = new boolean[length];
45
46 int previousLength = 0;
47
48 for (boolean[] array : arrays) {
49 System.arraycopy(array, 0, newArray, previousLength, array.length);
50
51 previousLength += array.length;
52 }
53
54 return newArray;
55 }
56
57 public static boolean[] append(boolean[] array, boolean value) {
58 boolean[] newArray = new boolean[array.length + 1];
59
60 System.arraycopy(array, 0, newArray, 0, array.length);
61
62 newArray[newArray.length - 1] = value;
63
64 return newArray;
65 }
66
67 public static byte[] append(byte[]... arrays) {
68 int length = 0;
69
70 for (byte[] array : arrays) {
71 length += array.length;
72 }
73
74 byte[] newArray = new byte[length];
75
76 int previousLength = 0;
77
78 for (byte[] array : arrays) {
79 System.arraycopy(array, 0, newArray, previousLength, array.length);
80
81 previousLength += array.length;
82 }
83
84 return newArray;
85 }
86
87 public static byte[] append(byte[] array, byte value) {
88 byte[] newArray = new byte[array.length + 1];
89
90 System.arraycopy(array, 0, newArray, 0, array.length);
91
92 newArray[newArray.length - 1] = value;
93
94 return newArray;
95 }
96
97 public static char[] append(char[]... arrays) {
98 int length = 0;
99
100 for (char[] array : arrays) {
101 length += array.length;
102 }
103
104 char[] newArray = new char[length];
105
106 int previousLength = 0;
107
108 for (char[] array : arrays) {
109 System.arraycopy(array, 0, newArray, previousLength, array.length);
110
111 previousLength += array.length;
112 }
113
114 return newArray;
115 }
116
117 public static char[] append(char[] array, char value) {
118 char[] newArray = new char[array.length + 1];
119
120 System.arraycopy(array, 0, newArray, 0, array.length);
121
122 newArray[newArray.length - 1] = value;
123
124 return newArray;
125 }
126
127 public static double[] append(double[]... arrays) {
128 int length = 0;
129
130 for (double[] array : arrays) {
131 length += array.length;
132 }
133
134 double[] newArray = new double[length];
135
136 int previousLength = 0;
137
138 for (double[] array : arrays) {
139 System.arraycopy(array, 0, newArray, previousLength, array.length);
140
141 previousLength += array.length;
142 }
143
144 return newArray;
145 }
146
147 public static double[] append(double[] array, double value) {
148 double[] newArray = new double[array.length + 1];
149
150 System.arraycopy(array, 0, newArray, 0, array.length);
151
152 newArray[newArray.length - 1] = value;
153
154 return newArray;
155 }
156
157 public static float[] append(float[]... arrays) {
158 int length = 0;
159
160 for (float[] array : arrays) {
161 length += array.length;
162 }
163
164 float[] newArray = new float[length];
165
166 int previousLength = 0;
167
168 for (float[] array : arrays) {
169 System.arraycopy(array, 0, newArray, previousLength, array.length);
170
171 previousLength += array.length;
172 }
173
174 return newArray;
175 }
176
177 public static float[] append(float[] array, float value) {
178 float[] newArray = new float[array.length + 1];
179
180 System.arraycopy(array, 0, newArray, 0, array.length);
181
182 newArray[newArray.length - 1] = value;
183
184 return newArray;
185 }
186
187 public static int[] append(int[]... arrays) {
188 int length = 0;
189
190 for (int[] array : arrays) {
191 length += array.length;
192 }
193
194 int[] newArray = new int[length];
195
196 int previousLength = 0;
197
198 for (int[] array : arrays) {
199 System.arraycopy(array, 0, newArray, previousLength, array.length);
200
201 previousLength += array.length;
202 }
203
204 return newArray;
205 }
206
207 public static int[] append(int[] array, int value) {
208 int[] newArray = new int[array.length + 1];
209
210 System.arraycopy(array, 0, newArray, 0, array.length);
211
212 newArray[newArray.length - 1] = value;
213
214 return newArray;
215 }
216
217 public static long[] append(long[]... arrays) {
218 int length = 0;
219
220 for (long[] array : arrays) {
221 length += array.length;
222 }
223
224 long[] newArray = new long[length];
225
226 int previousLength = 0;
227
228 for (long[] array : arrays) {
229 System.arraycopy(array, 0, newArray, previousLength, array.length);
230
231 previousLength += array.length;
232 }
233
234 return newArray;
235 }
236
237 public static long[] append(long[] array, long value) {
238 long[] newArray = new long[array.length + 1];
239
240 System.arraycopy(array, 0, newArray, 0, array.length);
241
242 newArray[newArray.length - 1] = value;
243
244 return newArray;
245 }
246
247 public static short[] append(short[]... arrays) {
248 int length = 0;
249
250 for (short[] array : arrays) {
251 length += array.length;
252 }
253
254 short[] newArray = new short[length];
255
256 int previousLength = 0;
257
258 for (short[] array : arrays) {
259 System.arraycopy(array, 0, newArray, previousLength, array.length);
260
261 previousLength += array.length;
262 }
263
264 return newArray;
265 }
266
267 public static short[] append(short[] array, short value) {
268 short[] newArray = new short[array.length + 1];
269
270 System.arraycopy(array, 0, newArray, 0, array.length);
271
272 newArray[newArray.length - 1] = value;
273
274 return newArray;
275 }
276
277 public static <T> T[] append(T[]... arrays) {
278 int length = 0;
279
280 for (T[] array : arrays) {
281 length += array.length;
282 }
283
284 Class<?> arraysClass = arrays.getClass();
285
286 T[] newArray = (T[])Array.newInstance(
287 arraysClass.getComponentType(), length);
288
289 int previousLength = 0;
290
291 for (T[] array : arrays) {
292 System.arraycopy(array, 0, newArray, previousLength, array.length);
293
294 previousLength += array.length;
295 }
296
297 return newArray;
298 }
299
300 public static <T> T[] append(T[] array, T value) {
301 Class<?> arrayClass = array.getClass();
302
303 T[] newArray = (T[])Array.newInstance(
304 arrayClass.getComponentType(), array.length + 1);
305
306 System.arraycopy(array, 0, newArray, 0, array.length);
307
308 newArray[array.length] = value;
309
310 return newArray;
311 }
312
313 public static <T> T[] append(T[] array1, T[] array2) {
314 Class<?> array1Class = array1.getClass();
315
316 T[] newArray = (T[])Array.newInstance(
317 array1Class.getComponentType(), array1.length + array2.length);
318
319 System.arraycopy(array1, 0, newArray, 0, array1.length);
320
321 System.arraycopy(array2, 0, newArray, array1.length, array2.length);
322
323 return newArray;
324 }
325
326 public static <T> T[][] append(T[][] array1, T[] value) {
327 Class<?> array1Class = array1.getClass();
328
329 T[][] newArray = (T[][])Array.newInstance(
330 array1Class.getComponentType(), array1.length + 1);
331
332 System.arraycopy(array1, 0, newArray, 0, array1.length);
333
334 newArray[array1.length] = value;
335
336 return newArray;
337 }
338
339 public static <T> T[][] append(T[][] array1, T[][] array2) {
340 Class<?> array1Class = array1.getClass();
341
342 T[][] newArray = (T[][])Array.newInstance(
343 array1Class.getComponentType(), array1.length + array2.length);
344
345 System.arraycopy(array1, 0, newArray, 0, array1.length);
346 System.arraycopy(array2, 0, newArray, array1.length, array2.length);
347
348 return newArray;
349 }
350
351 public static boolean[] clone(boolean[] array) {
352 boolean[] newArray = new boolean[array.length];
353
354 System.arraycopy(array, 0, newArray, 0, array.length);
355
356 return newArray;
357 }
358
359 public static byte[] clone(byte[] array) {
360 byte[] newArray = new byte[array.length];
361
362 System.arraycopy(array, 0, newArray, 0, array.length);
363
364 return newArray;
365 }
366
367 public static char[] clone(char[] array) {
368 char[] newArray = new char[array.length];
369
370 System.arraycopy(array, 0, newArray, 0, array.length);
371
372 return newArray;
373 }
374
375 public static double[] clone(double[] array) {
376 double[] newArray = new double[array.length];
377
378 System.arraycopy(array, 0, newArray, 0, array.length);
379
380 return newArray;
381 }
382
383 public static float[] clone(float[] array) {
384 float[] newArray = new float[array.length];
385
386 System.arraycopy(array, 0, newArray, 0, array.length);
387
388 return newArray;
389 }
390
391 public static int[] clone(int[] array) {
392 int[] newArray = new int[array.length];
393
394 System.arraycopy(array, 0, newArray, 0, array.length);
395
396 return newArray;
397 }
398
399 public static long[] clone(long[] array) {
400 long[] newArray = new long[array.length];
401
402 System.arraycopy(array, 0, newArray, 0, array.length);
403
404 return newArray;
405 }
406
407 public static short[] clone(short[] array) {
408 short[] newArray = new short[array.length];
409
410 System.arraycopy(array, 0, newArray, 0, array.length);
411
412 return newArray;
413 }
414
415 public static <T> T[] clone(T[] array) {
416 Class<?> arrayClass = array.getClass();
417
418 T[] newArray = (T[])Array.newInstance(
419 arrayClass.getComponentType(), array.length + 1);
420
421 System.arraycopy(array, 0, newArray, 0, array.length);
422
423 return newArray;
424 }
425
426 public static <T> T[][] clone(T[][] array) {
427 Class<?> arrayClass = array.getClass();
428
429 T[][] newArray = (T[][])Array.newInstance(
430 arrayClass.getComponentType(), array.length + 1);
431
432 System.arraycopy(array, 0, newArray, 0, array.length);
433
434 return newArray;
435 }
436
437 public static void combine(
438 Object[] array1, Object[] array2, Object[] combinedArray) {
439
440 System.arraycopy(array1, 0, combinedArray, 0, array1.length);
441
442 System.arraycopy(
443 array2, 0, combinedArray, array1.length, array2.length);
444 }
445
446 public static boolean contains(boolean[] array, boolean value) {
447 if ((array == null) || (array.length == 0)) {
448 return false;
449 }
450 else {
451 for (int i = 0; i < array.length; i++) {
452 if (value == array[i]) {
453 return true;
454 }
455 }
456
457 return false;
458 }
459 }
460
461 public static boolean contains(byte[] array, byte value) {
462 if ((array == null) || (array.length == 0)) {
463 return false;
464 }
465 else {
466 for (int i = 0; i < array.length; i++) {
467 if (value == array[i]) {
468 return true;
469 }
470 }
471
472 return false;
473 }
474 }
475
476 public static boolean contains(char[] array, char value) {
477 if ((array == null) || (array.length == 0)) {
478 return false;
479 }
480 else {
481 for (int i = 0; i < array.length; i++) {
482 if (value == array[i]) {
483 return true;
484 }
485 }
486
487 return false;
488 }
489 }
490
491 public static boolean contains(double[] array, double value) {
492 if ((array == null) || (array.length == 0)) {
493 return false;
494 }
495 else {
496 for (int i = 0; i < array.length; i++) {
497 if (value == array[i]) {
498 return true;
499 }
500 }
501
502 return false;
503 }
504 }
505
506 public static boolean contains(int[] array, int value) {
507 if ((array == null) || (array.length == 0)) {
508 return false;
509 }
510 else {
511 for (int i = 0; i < array.length; i++) {
512 if (value == array[i]) {
513 return true;
514 }
515 }
516
517 return false;
518 }
519 }
520
521 public static boolean contains(long[] array, long value) {
522 if ((array == null) || (array.length == 0)) {
523 return false;
524 }
525 else {
526 for (int i = 0; i < array.length; i++) {
527 if (value == array[i]) {
528 return true;
529 }
530 }
531
532 return false;
533 }
534 }
535
536 public static boolean contains(Object[] array, Object value) {
537 if ((array == null) || (array.length == 0) || (value == null)) {
538 return false;
539 }
540 else {
541 for (int i = 0; i < array.length; i++) {
542 if (value.equals(array[i])) {
543 return true;
544 }
545 }
546
547 return false;
548 }
549 }
550
551 public static boolean contains(short[] array, short value) {
552 if ((array == null) || (array.length == 0)) {
553 return false;
554 }
555 else {
556 for (int i = 0; i < array.length; i++) {
557 if (value == array[i]) {
558 return true;
559 }
560 }
561
562 return false;
563 }
564 }
565
566 public static String[] distinct(String[] array) {
567 return distinct(array, null);
568 }
569
570 public static String[] distinct(
571 String[] array, Comparator<String> comparator) {
572
573 if ((array == null) || (array.length == 0)) {
574 return array;
575 }
576
577 Set<String> set = null;
578
579 if (comparator == null) {
580 set = new TreeSet<String>();
581 }
582 else {
583 set = new TreeSet<String>(comparator);
584 }
585
586 for (int i = 0; i < array.length; i++) {
587 String s = array[i];
588
589 if (!set.contains(s)) {
590 set.add(s);
591 }
592 }
593
594 return set.toArray(new String[set.size()]);
595 }
596
597 public static int getLength(Object[] array) {
598 if (array == null) {
599 return 0;
600 }
601 else {
602 return array.length;
603 }
604 }
605
606 public static Object getValue(Object[] array, int pos) {
607 if ((array == null) || (array.length <= pos)) {
608 return null;
609 }
610 else {
611 return array[pos];
612 }
613 }
614
615 public static boolean[] remove(boolean[] array, boolean value) {
616 List<Boolean> list = new ArrayList<Boolean>();
617
618 for (int i = 0; i < array.length; i++) {
619 if (value != array[i]) {
620 list.add(new Boolean(array[i]));
621 }
622 }
623
624 return toArray(list.toArray(new Boolean[list.size()]));
625 }
626
627 public static byte[] remove(byte[] array, byte value) {
628 List<Byte> list = new ArrayList<Byte>();
629
630 for (int i = 0; i < array.length; i++) {
631 if (value != array[i]) {
632 list.add(new Byte(array[i]));
633 }
634 }
635
636 return toArray(list.toArray(new Byte[list.size()]));
637 }
638
639 public static char[] remove(char[] array, char value) {
640 List<Character> list = new ArrayList<Character>();
641
642 for (int i = 0; i < array.length; i++) {
643 if (value != array[i]) {
644 list.add(new Character(array[i]));
645 }
646 }
647
648 return toArray(list.toArray(new Character[list.size()]));
649 }
650
651 public static double[] remove(double[] array, double value) {
652 List<Double> list = new ArrayList<Double>();
653
654 for (int i = 0; i < array.length; i++) {
655 if (value != array[i]) {
656 list.add(new Double(array[i]));
657 }
658 }
659
660 return toArray(list.toArray(new Double[list.size()]));
661 }
662
663 public static int[] remove(int[] array, int value) {
664 List<Integer> list = new ArrayList<Integer>();
665
666 for (int i = 0; i < array.length; i++) {
667 if (value != array[i]) {
668 list.add(new Integer(array[i]));
669 }
670 }
671
672 return toArray(list.toArray(new Integer[list.size()]));
673 }
674
675 public static long[] remove(long[] array, long value) {
676 List<Long> list = new ArrayList<Long>();
677
678 for (int i = 0; i < array.length; i++) {
679 if (value != array[i]) {
680 list.add(new Long(array[i]));
681 }
682 }
683
684 return toArray(list.toArray(new Long[list.size()]));
685 }
686
687 public static short[] remove(short[] array, short value) {
688 List<Short> list = new ArrayList<Short>();
689
690 for (int i = 0; i < array.length; i++) {
691 if (value != array[i]) {
692 list.add(new Short(array[i]));
693 }
694 }
695
696 return toArray(list.toArray(new Short[list.size()]));
697 }
698
699 public static String[] remove(String[] array, String value) {
700 List<String> list = new ArrayList<String>();
701
702 for (String s : array) {
703 if (!s.equals(value)) {
704 list.add(s);
705 }
706 }
707
708 return list.toArray(new String[list.size()]);
709 }
710
711 public static String[] removeByPrefix(String[] array, String prefix) {
712 List<String> list = new ArrayList<String>();
713
714 for (String s : array) {
715 if (!s.startsWith(prefix)) {
716 list.add(s);
717 }
718 }
719
720 return list.toArray(new String[list.size()]);
721 }
722
723 public static void reverse(String[] array) {
724 for (int left = 0, right = array.length - 1; left < right;
725 left++, right--) {
726
727 String value = array[left];
728
729 array[left] = array[right];
730 array[right] = value;
731 }
732 }
733
734 public static Boolean[] toArray(boolean[] array) {
735 Boolean[] newArray = new Boolean[array.length];
736
737 for (int i = 0; i < array.length; i++) {
738 newArray[i] = Boolean.valueOf(array[i]);
739 }
740
741 return newArray;
742 }
743
744 public static boolean[] toArray(Boolean[] array) {
745 boolean[] newArray = new boolean[array.length];
746
747 for (int i = 0; i < array.length; i++) {
748 newArray[i] = array[i].booleanValue();
749 }
750
751 return newArray;
752 }
753
754 public static Byte[] toArray(byte[] array) {
755 Byte[] newArray = new Byte[array.length];
756
757 for (int i = 0; i < array.length; i++) {
758 newArray[i] = Byte.valueOf(array[i]);
759 }
760
761 return newArray;
762 }
763
764 public static byte[] toArray(Byte[] array) {
765 byte[] newArray = new byte[array.length];
766
767 for (int i = 0; i < array.length; i++) {
768 newArray[i] = array[i].byteValue();
769 }
770
771 return newArray;
772 }
773
774 public static Character[] toArray(char[] array) {
775 Character[] newArray = new Character[array.length];
776
777 for (int i = 0; i < array.length; i++) {
778 newArray[i] = Character.valueOf(array[i]);
779 }
780
781 return newArray;
782 }
783
784 public static char[] toArray(Character[] array) {
785 char[] newArray = new char[array.length];
786
787 for (int i = 0; i < array.length; i++) {
788 newArray[i] = array[i].charValue();
789 }
790
791 return newArray;
792 }
793
794 public static Double[] toArray(double[] array) {
795 Double[] newArray = new Double[array.length];
796
797 for (int i = 0; i < array.length; i++) {
798 newArray[i] = new Double(array[i]);
799 }
800
801 return newArray;
802 }
803
804 public static double[] toArray(Double[] array) {
805 double[] newArray = new double[array.length];
806
807 for (int i = 0; i < array.length; i++) {
808 newArray[i] = array[i].doubleValue();
809 }
810
811 return newArray;
812 }
813
814 public static Float[] toArray(float[] array) {
815 Float[] newArray = new Float[array.length];
816
817 for (int i = 0; i < array.length; i++) {
818 newArray[i] = new Float(array[i]);
819 }
820
821 return newArray;
822 }
823
824 public static float[] toArray(Float[] array) {
825 float[] newArray = new float[array.length];
826
827 for (int i = 0; i < array.length; i++) {
828 newArray[i] = array[i].floatValue();
829 }
830
831 return newArray;
832 }
833
834 public static Integer[] toArray(int[] array) {
835 Integer[] newArray = new Integer[array.length];
836
837 for (int i = 0; i < array.length; i++) {
838 newArray[i] = new Integer(array[i]);
839 }
840
841 return newArray;
842 }
843
844 public static int[] toArray(Integer[] array) {
845 int[] newArray = new int[array.length];
846
847 for (int i = 0; i < array.length; i++) {
848 newArray[i] = array[i].intValue();
849 }
850
851 return newArray;
852 }
853
854 public static Long[] toArray(long[] array) {
855 Long[] newArray = new Long[array.length];
856
857 for (int i = 0; i < array.length; i++) {
858 newArray[i] = new Long(array[i]);
859 }
860
861 return newArray;
862 }
863
864 public static long[] toArray(Long[] array) {
865 long[] newArray = new long[array.length];
866
867 for (int i = 0; i < array.length; i++) {
868 newArray[i] = array[i].longValue();
869 }
870
871 return newArray;
872 }
873
874 public static Short[] toArray(short[] array) {
875 Short[] newArray = new Short[array.length];
876
877 for (int i = 0; i < array.length; i++) {
878 newArray[i] = new Short(array[i]);
879 }
880
881 return newArray;
882 }
883
884 public static short[] toArray(Short[] array) {
885 short[] newArray = new short[array.length];
886
887 for (int i = 0; i < array.length; i++) {
888 newArray[i] = array[i].shortValue();
889 }
890
891 return newArray;
892 }
893
894 public static String[] toStringArray(boolean[] array) {
895 String[] newArray = new String[array.length];
896
897 for (int i = 0; i < array.length; i++) {
898 newArray[i] = String.valueOf(array[i]);
899 }
900
901 return newArray;
902 }
903
904 public static String[] toStringArray(byte[] array) {
905 String[] newArray = new String[array.length];
906
907 for (int i = 0; i < array.length; i++) {
908 newArray[i] = String.valueOf(array[i]);
909 }
910
911 return newArray;
912 }
913
914 public static String[] toStringArray(char[] array) {
915 String[] newArray = new String[array.length];
916
917 for (int i = 0; i < array.length; i++) {
918 newArray[i] = String.valueOf(array[i]);
919 }
920
921 return newArray;
922 }
923
924 public static String[] toStringArray(Date[] array, DateFormat df) {
925 String[] newArray = new String[array.length];
926
927 for (int i = 0; i < array.length; i++) {
928 newArray[i] = df.format(array[i]);
929 }
930
931 return newArray;
932 }
933
934 public static String[] toStringArray(double[] array) {
935 String[] newArray = new String[array.length];
936
937 for (int i = 0; i < array.length; i++) {
938 newArray[i] = String.valueOf(array[i]);
939 }
940
941 return newArray;
942 }
943
944 public static String[] toStringArray(float[] array) {
945 String[] newArray = new String[array.length];
946
947 for (int i = 0; i < array.length; i++) {
948 newArray[i] = String.valueOf(array[i]);
949 }
950
951 return newArray;
952 }
953
954 public static String[] toStringArray(int[] array) {
955 String[] newArray = new String[array.length];
956
957 for (int i = 0; i < array.length; i++) {
958 newArray[i] = String.valueOf(array[i]);
959 }
960
961 return newArray;
962 }
963
964 public static String[] toStringArray(JSONArray array) {
965 String[] newArray = new String[array.length()];
966
967 for (int i = 0; i < array.length(); i++) {
968 newArray[i] = array.getString(i);
969 }
970
971 return newArray;
972 }
973
974 public static String[] toStringArray(long[] array) {
975 String[] newArray = new String[array.length];
976
977 for (int i = 0; i < array.length; i++) {
978 newArray[i] = String.valueOf(array[i]);
979 }
980
981 return newArray;
982 }
983
984 public static String[] toStringArray(Object[] array) {
985 String[] newArray = new String[array.length];
986
987 for (int i = 0; i < array.length; i++) {
988 newArray[i] = String.valueOf(array[i]);
989 }
990
991 return newArray;
992 }
993
994 public static String[] toStringArray(short[] array) {
995 String[] newArray = new String[array.length];
996
997 for (int i = 0; i < array.length; i++) {
998 newArray[i] = String.valueOf(array[i]);
999 }
1000
1001 return newArray;
1002 }
1003
1004}