1   /**
2    * Copyright (c) 2000-2008 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(char[] array, char 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(double[] array, double 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(long[] array, long 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(int[] array, int 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(short[] array, short 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(Object[] array, Object value) {
462         if ((array == null) || (array.length == 0) || (value == null)) {
463             return false;
464         }
465         else {
466             for (int i = 0; i < array.length; i++) {
467                 if (value.equals(array[i])) {
468                     return true;
469                 }
470             }
471 
472             return false;
473         }
474     }
475 
476     public static String[] distinct(String[] array) {
477         return distinct(array, null);
478     }
479 
480     public static String[] distinct(
481         String[] array, Comparator<String> comparator) {
482 
483         if ((array == null) || (array.length == 0)) {
484             return array;
485         }
486 
487         Set<String> set = null;
488 
489         if (comparator == null) {
490             set = new TreeSet<String>();
491         }
492         else {
493             set = new TreeSet<String>(comparator);
494         }
495 
496         for (int i = 0; i < array.length; i++) {
497             String s = array[i];
498 
499             if (!set.contains(s)) {
500                 set.add(s);
501             }
502         }
503 
504         return set.toArray(new String[set.size()]);
505     }
506 
507     public static int getLength(Object[] array) {
508         if (array == null) {
509             return 0;
510         }
511         else {
512             return array.length;
513         }
514     }
515 
516     public static Object getValue(Object[] array, int pos) {
517         if ((array == null) || (array.length <= pos)) {
518             return null;
519         }
520         else {
521             return array[pos];
522         }
523     }
524 
525     public static String[] removeByPrefix(String[] array, String prefix) {
526         List<String> list = new ArrayList<String>();
527 
528         for (int i = 0; i < array.length; i++) {
529             String s = array[i];
530 
531             if (!s.startsWith(prefix)) {
532                 list.add(s);
533             }
534         }
535 
536         return list.toArray(new String[list.size()]);
537     }
538 
539     public static Boolean[] toArray(boolean[] array) {
540         Boolean[] newArray = new Boolean[array.length];
541 
542         for (int i = 0; i < array.length; i++) {
543             newArray[i] = Boolean.valueOf(array[i]);
544         }
545 
546         return newArray;
547     }
548 
549     public static Double[] toArray(double[] array) {
550         Double[] newArray = new Double[array.length];
551 
552         for (int i = 0; i < array.length; i++) {
553             newArray[i] = new Double(array[i]);
554         }
555 
556         return newArray;
557     }
558 
559     public static Float[] toArray(float[] array) {
560         Float[] newArray = new Float[array.length];
561 
562         for (int i = 0; i < array.length; i++) {
563             newArray[i] = new Float(array[i]);
564         }
565 
566         return newArray;
567     }
568 
569     public static Integer[] toArray(int[] array) {
570         Integer[] newArray = new Integer[array.length];
571 
572         for (int i = 0; i < array.length; i++) {
573             newArray[i] = new Integer(array[i]);
574         }
575 
576         return newArray;
577     }
578 
579     public static Long[] toArray(long[] array) {
580         Long[] newArray = new Long[array.length];
581 
582         for (int i = 0; i < array.length; i++) {
583             newArray[i] = new Long(array[i]);
584         }
585 
586         return newArray;
587     }
588 
589     public static Short[] toArray(short[] array) {
590         Short[] newArray = new Short[array.length];
591 
592         for (int i = 0; i < array.length; i++) {
593             newArray[i] = new Short(array[i]);
594         }
595 
596         return newArray;
597     }
598 
599     public static boolean[] toArray(Boolean[] array) {
600         boolean[] newArray = new boolean[array.length];
601 
602         for (int i = 0; i < array.length; i++) {
603             newArray[i] = array[i].booleanValue();
604         }
605 
606         return newArray;
607     }
608 
609     public static double[] toArray(Double[] array) {
610         double[] newArray = new double[array.length];
611 
612         for (int i = 0; i < array.length; i++) {
613             newArray[i] = array[i].doubleValue();
614         }
615 
616         return newArray;
617     }
618 
619     public static float[] toArray(Float[] array) {
620         float[] newArray = new float[array.length];
621 
622         for (int i = 0; i < array.length; i++) {
623             newArray[i] = array[i].floatValue();
624         }
625 
626         return newArray;
627     }
628 
629     public static int[] toArray(Integer[] array) {
630         int[] newArray = new int[array.length];
631 
632         for (int i = 0; i < array.length; i++) {
633             newArray[i] = array[i].intValue();
634         }
635 
636         return newArray;
637     }
638 
639     public static long[] toArray(Long[] array) {
640         long[] newArray = new long[array.length];
641 
642         for (int i = 0; i < array.length; i++) {
643             newArray[i] = array[i].longValue();
644         }
645 
646         return newArray;
647     }
648 
649     public static short[] toArray(Short[] array) {
650         short[] newArray = new short[array.length];
651 
652         for (int i = 0; i < array.length; i++) {
653             newArray[i] = array[i].shortValue();
654         }
655 
656         return newArray;
657     }
658 
659     public static Boolean[] toArray(List<Boolean> list) {
660         Boolean[] array = new Boolean[list.size()];
661 
662         for (int i = 0; i < list.size(); i++) {
663             array[i] = list.get(i);
664         }
665 
666         return array;
667     }
668 
669     public static Double[] toArray(List<Double> list) {
670         Double[] array = new Double[list.size()];
671 
672         for (int i = 0; i < list.size(); i++) {
673             array[i] = list.get(i);
674         }
675 
676         return array;
677     }
678 
679     public static Float[] toArray(List<Float> list) {
680         Float[] array = new Float[list.size()];
681 
682         for (int i = 0; i < list.size(); i++) {
683             array[i] = list.get(i);
684         }
685 
686         return array;
687     }
688 
689     public static Integer[] toArray(List<Integer> list) {
690         Integer[] array = new Integer[list.size()];
691 
692         for (int i = 0; i < list.size(); i++) {
693             array[i] = list.get(i);
694         }
695 
696         return array;
697     }
698 
699     public static Long[] toArray(List<Long> list) {
700         Long[] array = new Long[list.size()];
701 
702         for (int i = 0; i < list.size(); i++) {
703             array[i] = list.get(i);
704         }
705 
706         return array;
707     }
708 
709     public static Short[] toArray(List<Short> list) {
710         Short[] array = new Short[list.size()];
711 
712         for (int i = 0; i < list.size(); i++) {
713             array[i] = list.get(i);
714         }
715 
716         return array;
717     }
718 
719 }