1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portal.kernel.util;
24  
25  import java.util.ArrayList;
26  import java.util.Comparator;
27  import java.util.List;
28  import java.util.Set;
29  import java.util.TreeSet;
30  
31  /**
32   * <a href="ArrayUtil.java.html"><b><i>View Source</i></b></a>
33   *
34   * @author Brian Wing Shun Chan
35   *
36   */
37  public class ArrayUtil {
38  
39      public static boolean[] append(boolean[] array, boolean value) {
40          boolean[] newArray = new boolean[array.length + 1];
41  
42          System.arraycopy(array, 0, newArray, 0, array.length);
43  
44          newArray[newArray.length - 1] = value;
45  
46          return newArray;
47      }
48  
49      public static byte[] append(byte[] array, byte value) {
50          byte[] newArray = new byte[array.length + 1];
51  
52          System.arraycopy(array, 0, newArray, 0, array.length);
53  
54          newArray[newArray.length - 1] = value;
55  
56          return newArray;
57      }
58  
59      public static double[] append(double[] array, double value) {
60          double[] newArray = new double[array.length + 1];
61  
62          System.arraycopy(array, 0, newArray, 0, array.length);
63  
64          newArray[newArray.length - 1] = value;
65  
66          return newArray;
67      }
68  
69      public static float[] append(float[] array, float value) {
70          float[] newArray = new float[array.length + 1];
71  
72          System.arraycopy(array, 0, newArray, 0, array.length);
73  
74          newArray[newArray.length - 1] = value;
75  
76          return newArray;
77      }
78  
79      public static int[] append(int[] array, int value) {
80          int[] newArray = new int[array.length + 1];
81  
82          System.arraycopy(array, 0, newArray, 0, array.length);
83  
84          newArray[newArray.length - 1] = value;
85  
86          return newArray;
87      }
88  
89      public static long[] append(long[] array, long value) {
90          long[] newArray = new long[array.length + 1];
91  
92          System.arraycopy(array, 0, newArray, 0, array.length);
93  
94          newArray[newArray.length - 1] = value;
95  
96          return newArray;
97      }
98  
99      public static short[] append(short[] array, short value) {
100         short[] newArray = new short[array.length + 1];
101 
102         System.arraycopy(array, 0, newArray, 0, array.length);
103 
104         newArray[newArray.length - 1] = value;
105 
106         return newArray;
107     }
108 
109     public static Boolean[] append(Boolean[] array, Boolean value) {
110         Boolean[] newArray = new Boolean[array.length + 1];
111 
112         System.arraycopy(array, 0, newArray, 0, array.length);
113 
114         newArray[newArray.length - 1] = value;
115 
116         return newArray;
117     }
118 
119     public static Double[] append(Double[] array, Double value) {
120         Double[] newArray = new Double[array.length + 1];
121 
122         System.arraycopy(array, 0, newArray, 0, array.length);
123 
124         newArray[newArray.length - 1] = value;
125 
126         return newArray;
127     }
128 
129     public static Float[] append(Float[] array, Float value) {
130         Float[] newArray = new Float[array.length + 1];
131 
132         System.arraycopy(array, 0, newArray, 0, array.length);
133 
134         newArray[newArray.length - 1] = value;
135 
136         return newArray;
137     }
138 
139     public static Integer[] append(Integer[] array, Integer value) {
140         Integer[] newArray = new Integer[array.length + 1];
141 
142         System.arraycopy(array, 0, newArray, 0, array.length);
143 
144         newArray[newArray.length - 1] = value;
145 
146         return newArray;
147     }
148 
149     public static Long[] append(Long[] array, Long value) {
150         Long[] newArray = new Long[array.length + 1];
151 
152         System.arraycopy(array, 0, newArray, 0, array.length);
153 
154         newArray[newArray.length - 1] = value;
155 
156         return newArray;
157     }
158 
159     public static Object[] append(Object[] array, Object value) {
160         Object[] newArray = new Object[array.length + 1];
161 
162         System.arraycopy(array, 0, newArray, 0, array.length);
163 
164         newArray[newArray.length - 1] = value;
165 
166         return newArray;
167     }
168 
169     public static Object[][] append(Object[][] array, Object[] value) {
170         Object[][] newArray = new Object[array.length + 1][];
171 
172         System.arraycopy(array, 0, newArray, 0, array.length);
173 
174         newArray[newArray.length - 1] = value;
175 
176         return newArray;
177     }
178 
179     public static Short[] append(Short[] array, Short value) {
180         Short[] newArray = new Short[array.length + 1];
181 
182         System.arraycopy(array, 0, newArray, 0, array.length);
183 
184         newArray[newArray.length - 1] = value;
185 
186         return newArray;
187     }
188 
189     public static String[] append(String[] array, String value) {
190         String[] newArray = new String[array.length + 1];
191 
192         System.arraycopy(array, 0, newArray, 0, array.length);
193 
194         newArray[newArray.length - 1] = value;
195 
196         return newArray;
197     }
198 
199     public static String[][] append(String[][] array, String[] value) {
200         String[][] newArray = new String[array.length + 1][];
201 
202         System.arraycopy(array, 0, newArray, 0, array.length);
203 
204         newArray[newArray.length - 1] = value;
205 
206         return newArray;
207     }
208 
209     public static boolean[] append(boolean[] array1, boolean[] array2) {
210         boolean[] newArray = new boolean[array1.length + array2.length];
211 
212         System.arraycopy(array1, 0, newArray, 0, array1.length);
213         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
214 
215         return newArray;
216     }
217 
218     public static byte[] append(byte[] array1, byte[] array2) {
219         byte[] newArray = new byte[array1.length + array2.length];
220 
221         System.arraycopy(array1, 0, newArray, 0, array1.length);
222         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
223 
224         return newArray;
225     }
226 
227     public static double[] append(double[] array1, double[] array2) {
228         double[] newArray = new double[array1.length + array2.length];
229 
230         System.arraycopy(array1, 0, newArray, 0, array1.length);
231         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
232 
233         return newArray;
234     }
235 
236     public static float[] append(float[] array1, float[] array2) {
237         float[] newArray = new float[array1.length + array2.length];
238 
239         System.arraycopy(array1, 0, newArray, 0, array1.length);
240         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
241 
242         return newArray;
243     }
244 
245     public static int[] append(int[] array1, int[] array2) {
246         int[] newArray = new int[array1.length + array2.length];
247 
248         System.arraycopy(array1, 0, newArray, 0, array1.length);
249         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
250 
251         return newArray;
252     }
253 
254     public static long[] append(long[] array1, long[] array2) {
255         long[] newArray = new long[array1.length + array2.length];
256 
257         System.arraycopy(array1, 0, newArray, 0, array1.length);
258         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
259 
260         return newArray;
261     }
262 
263     public static short[] append(short[] array1, short[] array2) {
264         short[] newArray = new short[array1.length + array2.length];
265 
266         System.arraycopy(array1, 0, newArray, 0, array1.length);
267         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
268 
269         return newArray;
270     }
271 
272     public static Boolean[] append(Boolean[] array1, Boolean[] array2) {
273         Boolean[] newArray = new Boolean[array1.length + array2.length];
274 
275         System.arraycopy(array1, 0, newArray, 0, array1.length);
276         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
277 
278         return newArray;
279     }
280 
281     public static Double[] append(Double[] array1, Double[] array2) {
282         Double[] newArray = new Double[array1.length + array2.length];
283 
284         System.arraycopy(array1, 0, newArray, 0, array1.length);
285         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
286 
287         return newArray;
288     }
289 
290     public static Float[] append(Float[] array1, Float[] array2) {
291         Float[] newArray = new Float[array1.length + array2.length];
292 
293         System.arraycopy(array1, 0, newArray, 0, array1.length);
294         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
295 
296         return newArray;
297     }
298 
299     public static Integer[] append(Integer[] array1, Integer[] array2) {
300         Integer[] newArray = new Integer[array1.length + array2.length];
301 
302         System.arraycopy(array1, 0, newArray, 0, array1.length);
303         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
304 
305         return newArray;
306     }
307 
308     public static Long[] append(Long[] array1, Long[] array2) {
309         Long[] newArray = new Long[array1.length + array2.length];
310 
311         System.arraycopy(array1, 0, newArray, 0, array1.length);
312         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
313 
314         return newArray;
315     }
316 
317     public static Object[] append(Object[] array1, Object[] array2) {
318         Object[] newArray = new Object[array1.length + array2.length];
319 
320         System.arraycopy(array1, 0, newArray, 0, array1.length);
321         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
322 
323         return newArray;
324     }
325 
326     public static Object[][] append(Object[][] array1, Object[][] array2) {
327         Object[][] newArray = new Object[array1.length + array2.length][];
328 
329         System.arraycopy(array1, 0, newArray, 0, array1.length);
330         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
331 
332         return newArray;
333     }
334 
335     public static Short[] append(Short[] array1, Short[] array2) {
336         Short[] newArray = new Short[array1.length + array2.length];
337 
338         System.arraycopy(array1, 0, newArray, 0, array1.length);
339         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
340 
341         return newArray;
342     }
343 
344     public static String[] append(String[] array1, String[] array2) {
345         String[] newArray = new String[array1.length + array2.length];
346 
347         System.arraycopy(array1, 0, newArray, 0, array1.length);
348         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
349 
350         return newArray;
351     }
352 
353     public static String[][] append(String[][] array1, String[][] array2) {
354         String[][] newArray = new String[array1.length + array2.length][];
355 
356         System.arraycopy(array1, 0, newArray, 0, array1.length);
357         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
358 
359         return newArray;
360     }
361 
362     public static void combine(
363         Object[] array1, Object[] array2, Object[] combinedArray) {
364 
365         System.arraycopy(array1, 0, combinedArray, 0, array1.length);
366 
367         System.arraycopy(
368             array2, 0, combinedArray, array1.length, array2.length);
369     }
370 
371     public static boolean contains(boolean[] array, boolean value) {
372         if ((array == null) || (array.length == 0)) {
373             return false;
374         }
375         else {
376             for (int i = 0; i < array.length; i++) {
377                 if (value == array[i]) {
378                     return true;
379                 }
380             }
381 
382             return false;
383         }
384     }
385 
386     public static boolean contains(byte[] array, byte value) {
387         if ((array == null) || (array.length == 0)) {
388             return false;
389         }
390         else {
391             for (int i = 0; i < array.length; i++) {
392                 if (value == array[i]) {
393                     return true;
394                 }
395             }
396 
397             return false;
398         }
399     }
400 
401     public static boolean contains(char[] array, char value) {
402         if ((array == null) || (array.length == 0)) {
403             return false;
404         }
405         else {
406             for (int i = 0; i < array.length; i++) {
407                 if (value == array[i]) {
408                     return true;
409                 }
410             }
411 
412             return false;
413         }
414     }
415 
416     public static boolean contains(double[] array, double value) {
417         if ((array == null) || (array.length == 0)) {
418             return false;
419         }
420         else {
421             for (int i = 0; i < array.length; i++) {
422                 if (value == array[i]) {
423                     return true;
424                 }
425             }
426 
427             return false;
428         }
429     }
430 
431     public static boolean contains(long[] array, long value) {
432         if ((array == null) || (array.length == 0)) {
433             return false;
434         }
435         else {
436             for (int i = 0; i < array.length; i++) {
437                 if (value == array[i]) {
438                     return true;
439                 }
440             }
441 
442             return false;
443         }
444     }
445 
446     public static boolean contains(int[] array, int 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(short[] array, short 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(Object[] array, Object value) {
477         if ((array == null) || (array.length == 0) || (value == null)) {
478             return false;
479         }
480         else {
481             for (int i = 0; i < array.length; i++) {
482                 if (value.equals(array[i])) {
483                     return true;
484                 }
485             }
486 
487             return false;
488         }
489     }
490 
491     public static String[] distinct(String[] array) {
492         return distinct(array, null);
493     }
494 
495     public static String[] distinct(
496         String[] array, Comparator<String> comparator) {
497 
498         if ((array == null) || (array.length == 0)) {
499             return array;
500         }
501 
502         Set<String> set = null;
503 
504         if (comparator == null) {
505             set = new TreeSet<String>();
506         }
507         else {
508             set = new TreeSet<String>(comparator);
509         }
510 
511         for (int i = 0; i < array.length; i++) {
512             String s = array[i];
513 
514             if (!set.contains(s)) {
515                 set.add(s);
516             }
517         }
518 
519         return set.toArray(new String[set.size()]);
520     }
521 
522     public static int getLength(Object[] array) {
523         if (array == null) {
524             return 0;
525         }
526         else {
527             return array.length;
528         }
529     }
530 
531     public static Object getValue(Object[] array, int pos) {
532         if ((array == null) || (array.length <= pos)) {
533             return null;
534         }
535         else {
536             return array[pos];
537         }
538     }
539 
540     public static String[] remove(String[] array, String value) {
541         List<String> list = new ArrayList<String>();
542 
543         for (String s : array) {
544             if (!s.equals(value)) {
545                 list.add(s);
546             }
547         }
548 
549         return list.toArray(new String[list.size()]);
550     }
551 
552     public static String[] removeByPrefix(String[] array, String prefix) {
553         List<String> list = new ArrayList<String>();
554 
555         for (String s : array) {
556             if (!s.startsWith(prefix)) {
557                 list.add(s);
558             }
559         }
560 
561         return list.toArray(new String[list.size()]);
562     }
563 
564     public static Boolean[] toArray(boolean[] array) {
565         Boolean[] newArray = new Boolean[array.length];
566 
567         for (int i = 0; i < array.length; i++) {
568             newArray[i] = Boolean.valueOf(array[i]);
569         }
570 
571         return newArray;
572     }
573 
574     public static Byte[] toArray(byte[] array) {
575         Byte[] newArray = new Byte[array.length];
576 
577         for (int i = 0; i < array.length; i++) {
578             newArray[i] = Byte.valueOf(array[i]);
579         }
580 
581         return newArray;
582     }
583 
584     public static Character[] toArray(char[] array) {
585         Character[] newArray = new Character[array.length];
586 
587         for (int i = 0; i < array.length; i++) {
588             newArray[i] = Character.valueOf(array[i]);
589         }
590 
591         return newArray;
592     }
593 
594     public static Double[] toArray(double[] array) {
595         Double[] newArray = new Double[array.length];
596 
597         for (int i = 0; i < array.length; i++) {
598             newArray[i] = new Double(array[i]);
599         }
600 
601         return newArray;
602     }
603 
604     public static Float[] toArray(float[] array) {
605         Float[] newArray = new Float[array.length];
606 
607         for (int i = 0; i < array.length; i++) {
608             newArray[i] = new Float(array[i]);
609         }
610 
611         return newArray;
612     }
613 
614     public static Integer[] toArray(int[] array) {
615         Integer[] newArray = new Integer[array.length];
616 
617         for (int i = 0; i < array.length; i++) {
618             newArray[i] = new Integer(array[i]);
619         }
620 
621         return newArray;
622     }
623 
624     public static Long[] toArray(long[] array) {
625         Long[] newArray = new Long[array.length];
626 
627         for (int i = 0; i < array.length; i++) {
628             newArray[i] = new Long(array[i]);
629         }
630 
631         return newArray;
632     }
633 
634     public static Short[] toArray(short[] array) {
635         Short[] newArray = new Short[array.length];
636 
637         for (int i = 0; i < array.length; i++) {
638             newArray[i] = new Short(array[i]);
639         }
640 
641         return newArray;
642     }
643 
644     public static boolean[] toArray(Boolean[] array) {
645         boolean[] newArray = new boolean[array.length];
646 
647         for (int i = 0; i < array.length; i++) {
648             newArray[i] = array[i].booleanValue();
649         }
650 
651         return newArray;
652     }
653 
654     public static byte[] toArray(Byte[] array) {
655         byte[] newArray = new byte[array.length];
656 
657         for (int i = 0; i < array.length; i++) {
658             newArray[i] = array[i].byteValue();
659         }
660 
661         return newArray;
662     }
663 
664     public static char[] toArray(Character[] array) {
665         char[] newArray = new char[array.length];
666 
667         for (int i = 0; i < array.length; i++) {
668             newArray[i] = array[i].charValue();
669         }
670 
671         return newArray;
672     }
673 
674     public static double[] toArray(Double[] array) {
675         double[] newArray = new double[array.length];
676 
677         for (int i = 0; i < array.length; i++) {
678             newArray[i] = array[i].doubleValue();
679         }
680 
681         return newArray;
682     }
683 
684     public static float[] toArray(Float[] array) {
685         float[] newArray = new float[array.length];
686 
687         for (int i = 0; i < array.length; i++) {
688             newArray[i] = array[i].floatValue();
689         }
690 
691         return newArray;
692     }
693 
694     public static int[] toArray(Integer[] array) {
695         int[] newArray = new int[array.length];
696 
697         for (int i = 0; i < array.length; i++) {
698             newArray[i] = array[i].intValue();
699         }
700 
701         return newArray;
702     }
703 
704     public static long[] toArray(Long[] array) {
705         long[] newArray = new long[array.length];
706 
707         for (int i = 0; i < array.length; i++) {
708             newArray[i] = array[i].longValue();
709         }
710 
711         return newArray;
712     }
713 
714     public static short[] toArray(Short[] array) {
715         short[] newArray = new short[array.length];
716 
717         for (int i = 0; i < array.length; i++) {
718             newArray[i] = array[i].shortValue();
719         }
720 
721         return newArray;
722     }
723 
724     public static String[] toStringArray(boolean[] array) {
725         String[] newArray = new String[array.length];
726 
727         for (int i = 0; i < array.length; i++) {
728             newArray[i] = String.valueOf(array[i]);
729         }
730 
731         return newArray;
732     }
733 
734     public static String[] toStringArray(byte[] array) {
735         String[] newArray = new String[array.length];
736 
737         for (int i = 0; i < array.length; i++) {
738             newArray[i] = String.valueOf(array[i]);
739         }
740 
741         return newArray;
742     }
743 
744     public static String[] toStringArray(char[] array) {
745         String[] newArray = new String[array.length];
746 
747         for (int i = 0; i < array.length; i++) {
748             newArray[i] = String.valueOf(array[i]);
749         }
750 
751         return newArray;
752     }
753 
754     public static String[] toStringArray(double[] array) {
755         String[] newArray = new String[array.length];
756 
757         for (int i = 0; i < array.length; i++) {
758             newArray[i] = String.valueOf(array[i]);
759         }
760 
761         return newArray;
762     }
763 
764     public static String[] toStringArray(float[] array) {
765         String[] newArray = new String[array.length];
766 
767         for (int i = 0; i < array.length; i++) {
768             newArray[i] = String.valueOf(array[i]);
769         }
770 
771         return newArray;
772     }
773 
774     public static String[] toStringArray(int[] array) {
775         String[] newArray = new String[array.length];
776 
777         for (int i = 0; i < array.length; i++) {
778             newArray[i] = String.valueOf(array[i]);
779         }
780 
781         return newArray;
782     }
783 
784     public static String[] toStringArray(long[] array) {
785         String[] newArray = new String[array.length];
786 
787         for (int i = 0; i < array.length; i++) {
788             newArray[i] = String.valueOf(array[i]);
789         }
790 
791         return newArray;
792     }
793 
794     public static String[] toStringArray(short[] array) {
795         String[] newArray = new String[array.length];
796 
797         for (int i = 0; i < array.length; i++) {
798             newArray[i] = String.valueOf(array[i]);
799         }
800 
801         return newArray;
802     }
803 
804     public static String[] toStringArray(Object[] array) {
805         String[] newArray = new String[array.length];
806 
807         for (int i = 0; i < array.length; i++) {
808             newArray[i] = String.valueOf(array[i]);
809         }
810 
811         return newArray;
812     }
813 
814 }