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