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 obj) {
40          Boolean[] newArray = new Boolean[array.length + 1];
41  
42          System.arraycopy(array, 0, newArray, 0, array.length);
43  
44          newArray[newArray.length - 1] = obj;
45  
46          return newArray;
47      }
48  
49      public static Double[] append(Double[] array, Double obj) {
50          Double[] newArray = new Double[array.length + 1];
51  
52          System.arraycopy(array, 0, newArray, 0, array.length);
53  
54          newArray[newArray.length - 1] = obj;
55  
56          return newArray;
57      }
58  
59      public static Float[] append(Float[] array, Float obj) {
60          Float[] newArray = new Float[array.length + 1];
61  
62          System.arraycopy(array, 0, newArray, 0, array.length);
63  
64          newArray[newArray.length - 1] = obj;
65  
66          return newArray;
67      }
68  
69      public static Integer[] append(Integer[] array, Integer obj) {
70          Integer[] newArray = new Integer[array.length + 1];
71  
72          System.arraycopy(array, 0, newArray, 0, array.length);
73  
74          newArray[newArray.length - 1] = obj;
75  
76          return newArray;
77      }
78  
79      public static Long[] append(Long[] array, Long obj) {
80          Long[] newArray = new Long[array.length + 1];
81  
82          System.arraycopy(array, 0, newArray, 0, array.length);
83  
84          newArray[newArray.length - 1] = obj;
85  
86          return newArray;
87      }
88  
89      public static Object[] append(Object[] array, Object obj) {
90          Object[] newArray = new Object[array.length + 1];
91  
92          System.arraycopy(array, 0, newArray, 0, array.length);
93  
94          newArray[newArray.length - 1] = obj;
95  
96          return newArray;
97      }
98  
99      public static Object[][] append(Object[][] array, Object[] obj) {
100         Object[][] newArray = new Object[array.length + 1][];
101 
102         System.arraycopy(array, 0, newArray, 0, array.length);
103 
104         newArray[newArray.length - 1] = obj;
105 
106         return newArray;
107     }
108 
109     public static Short[] append(Short[] array, Short obj) {
110         Short[] newArray = new Short[array.length + 1];
111 
112         System.arraycopy(array, 0, newArray, 0, array.length);
113 
114         newArray[newArray.length - 1] = obj;
115 
116         return newArray;
117     }
118 
119     public static String[] append(String[] array, String obj) {
120         String[] newArray = new String[array.length + 1];
121 
122         System.arraycopy(array, 0, newArray, 0, array.length);
123 
124         newArray[newArray.length - 1] = obj;
125 
126         return newArray;
127     }
128 
129     public static String[][] append(String[][] array, String[] obj) {
130         String[][] newArray = new String[array.length + 1][];
131 
132         System.arraycopy(array, 0, newArray, 0, array.length);
133 
134         newArray[newArray.length - 1] = obj;
135 
136         return newArray;
137     }
138 
139     public static Boolean[] append(Boolean[] array1, Boolean[] array2) {
140         Boolean[] newArray = new Boolean[array1.length + array2.length];
141 
142         System.arraycopy(array1, 0, newArray, 0, array1.length);
143         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
144 
145         return newArray;
146     }
147 
148     public static Double[] append(Double[] array1, Double[] array2) {
149         Double[] newArray = new Double[array1.length + array2.length];
150 
151         System.arraycopy(array1, 0, newArray, 0, array1.length);
152         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
153 
154         return newArray;
155     }
156 
157     public static Float[] append(Float[] array1, Float[] array2) {
158         Float[] newArray = new Float[array1.length + array2.length];
159 
160         System.arraycopy(array1, 0, newArray, 0, array1.length);
161         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
162 
163         return newArray;
164     }
165 
166     public static Integer[] append(Integer[] array1, Integer[] array2) {
167         Integer[] newArray = new Integer[array1.length + array2.length];
168 
169         System.arraycopy(array1, 0, newArray, 0, array1.length);
170         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
171 
172         return newArray;
173     }
174 
175     public static Long[] append(Long[] array1, Long[] array2) {
176         Long[] newArray = new Long[array1.length + array2.length];
177 
178         System.arraycopy(array1, 0, newArray, 0, array1.length);
179         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
180 
181         return newArray;
182     }
183 
184     public static Object[] append(Object[] array1, Object[] array2) {
185         Object[] newArray = new Object[array1.length + array2.length];
186 
187         System.arraycopy(array1, 0, newArray, 0, array1.length);
188         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
189 
190         return newArray;
191     }
192 
193     public static Object[][] append(Object[][] array1, Object[][] array2) {
194         Object[][] newArray = new Object[array1.length + array2.length][];
195 
196         System.arraycopy(array1, 0, newArray, 0, array1.length);
197         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
198 
199         return newArray;
200     }
201 
202     public static Short[] append(Short[] array1, Short[] array2) {
203         Short[] newArray = new Short[array1.length + array2.length];
204 
205         System.arraycopy(array1, 0, newArray, 0, array1.length);
206         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
207 
208         return newArray;
209     }
210 
211     public static String[] append(String[] array1, String[] array2) {
212         String[] newArray = new String[array1.length + array2.length];
213 
214         System.arraycopy(array1, 0, newArray, 0, array1.length);
215         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
216 
217         return newArray;
218     }
219 
220     public static String[][] append(String[][] array1, String[][] array2) {
221         String[][] newArray = new String[array1.length + array2.length][];
222 
223         System.arraycopy(array1, 0, newArray, 0, array1.length);
224         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
225 
226         return newArray;
227     }
228 
229     public static void combine(
230         Object[] array1, Object[] array2, Object[] combinedArray) {
231 
232         System.arraycopy(array1, 0, combinedArray, 0, array1.length);
233 
234         System.arraycopy(
235             array2, 0, combinedArray, array1.length, array2.length);
236     }
237 
238     public static boolean contains(boolean[] array, boolean value) {
239         if ((array == null) || (array.length == 0)) {
240             return false;
241         }
242         else {
243             for (int i = 0; i < array.length; i++) {
244                 if (value == array[i]) {
245                     return true;
246                 }
247             }
248 
249             return false;
250         }
251     }
252 
253     public static boolean contains(char[] array, char value) {
254         if ((array == null) || (array.length == 0)) {
255             return false;
256         }
257         else {
258             for (int i = 0; i < array.length; i++) {
259                 if (value == array[i]) {
260                     return true;
261                 }
262             }
263 
264             return false;
265         }
266     }
267 
268     public static boolean contains(double[] array, double value) {
269         if ((array == null) || (array.length == 0)) {
270             return false;
271         }
272         else {
273             for (int i = 0; i < array.length; i++) {
274                 if (value == array[i]) {
275                     return true;
276                 }
277             }
278 
279             return false;
280         }
281     }
282 
283     public static boolean contains(long[] array, long value) {
284         if ((array == null) || (array.length == 0)) {
285             return false;
286         }
287         else {
288             for (int i = 0; i < array.length; i++) {
289                 if (value == array[i]) {
290                     return true;
291                 }
292             }
293 
294             return false;
295         }
296     }
297 
298     public static boolean contains(int[] array, int value) {
299         if ((array == null) || (array.length == 0)) {
300             return false;
301         }
302         else {
303             for (int i = 0; i < array.length; i++) {
304                 if (value == array[i]) {
305                     return true;
306                 }
307             }
308 
309             return false;
310         }
311     }
312 
313     public static boolean contains(short[] array, short value) {
314         if ((array == null) || (array.length == 0)) {
315             return false;
316         }
317         else {
318             for (int i = 0; i < array.length; i++) {
319                 if (value == array[i]) {
320                     return true;
321                 }
322             }
323 
324             return false;
325         }
326     }
327 
328     public static boolean contains(Object[] array, Object value) {
329         if ((array == null) || (array.length == 0) || (value == null)) {
330             return false;
331         }
332         else {
333             for (int i = 0; i < array.length; i++) {
334                 if (value.equals(array[i])) {
335                     return true;
336                 }
337             }
338 
339             return false;
340         }
341     }
342 
343     public static String[] distinct(String[] array) {
344         return distinct(array, null);
345     }
346 
347     public static String[] distinct(String[] array, Comparator comparator) {
348         if ((array == null) || (array.length == 0)) {
349             return array;
350         }
351 
352         Set set = null;
353 
354         if (comparator == null) {
355             set = new TreeSet();
356         }
357         else {
358             set = new TreeSet(comparator);
359         }
360 
361         for (int i = 0; i < array.length; i++) {
362             Object obj = array[i];
363 
364             if (!set.contains(obj)) {
365                 set.add(obj);
366             }
367         }
368 
369         return (String[])set.toArray(new String[0]);
370     }
371 
372     public static int getLength(Object[] array) {
373         if (array == null) {
374             return 0;
375         }
376         else {
377             return array.length;
378         }
379     }
380 
381     public static Object getValue(Object[] array, int pos) {
382         if ((array == null) || (array.length <= pos)) {
383             return null;
384         }
385         else {
386             return array[pos];
387         }
388     }
389 
390     public static String[] removeByPrefix(String[] array, String prefix) {
391         List list = new ArrayList();
392 
393         for (int i = 0; i < array.length; i++) {
394             String s = array[i];
395 
396             if (!s.startsWith(prefix)) {
397                 list.add(s);
398             }
399         }
400 
401         return (String[])list.toArray(new String[list.size()]);
402     }
403 
404     public static Boolean[] toArray(boolean[] array) {
405         Boolean[] newArray = new Boolean[array.length];
406 
407         for (int i = 0; i < array.length; i++) {
408             newArray[i] = Boolean.valueOf(array[i]);
409         }
410 
411         return newArray;
412     }
413 
414     public static Double[] toArray(double[] array) {
415         Double[] newArray = new Double[array.length];
416 
417         for (int i = 0; i < array.length; i++) {
418             newArray[i] = new Double(array[i]);
419         }
420 
421         return newArray;
422     }
423 
424     public static Float[] toArray(float[] array) {
425         Float[] newArray = new Float[array.length];
426 
427         for (int i = 0; i < array.length; i++) {
428             newArray[i] = new Float(array[i]);
429         }
430 
431         return newArray;
432     }
433 
434     public static Integer[] toArray(int[] array) {
435         Integer[] newArray = new Integer[array.length];
436 
437         for (int i = 0; i < array.length; i++) {
438             newArray[i] = new Integer(array[i]);
439         }
440 
441         return newArray;
442     }
443 
444     public static Long[] toArray(long[] array) {
445         Long[] newArray = new Long[array.length];
446 
447         for (int i = 0; i < array.length; i++) {
448             newArray[i] = new Long(array[i]);
449         }
450 
451         return newArray;
452     }
453 
454     public static Short[] toArray(short[] array) {
455         Short[] newArray = new Short[array.length];
456 
457         for (int i = 0; i < array.length; i++) {
458             newArray[i] = new Short(array[i]);
459         }
460 
461         return newArray;
462     }
463 
464     public static boolean[] toArray(Boolean[] array) {
465         boolean[] newArray = new boolean[array.length];
466 
467         for (int i = 0; i < array.length; i++) {
468             newArray[i] = array[i].booleanValue();
469         }
470 
471         return newArray;
472     }
473 
474     public static double[] toArray(Double[] array) {
475         double[] newArray = new double[array.length];
476 
477         for (int i = 0; i < array.length; i++) {
478             newArray[i] = array[i].doubleValue();
479         }
480 
481         return newArray;
482     }
483 
484     public static float[] toArray(Float[] array) {
485         float[] newArray = new float[array.length];
486 
487         for (int i = 0; i < array.length; i++) {
488             newArray[i] = array[i].floatValue();
489         }
490 
491         return newArray;
492     }
493 
494     public static int[] toArray(Integer[] array) {
495         int[] newArray = new int[array.length];
496 
497         for (int i = 0; i < array.length; i++) {
498             newArray[i] = array[i].intValue();
499         }
500 
501         return newArray;
502     }
503 
504     public static long[] toArray(Long[] array) {
505         long[] newArray = new long[array.length];
506 
507         for (int i = 0; i < array.length; i++) {
508             newArray[i] = array[i].longValue();
509         }
510 
511         return newArray;
512     }
513 
514     public static short[] toArray(Short[] array) {
515         short[] newArray = new short[array.length];
516 
517         for (int i = 0; i < array.length; i++) {
518             newArray[i] = array[i].shortValue();
519         }
520 
521         return newArray;
522     }
523 
524     public static Boolean[] toArray(List<Boolean> list) {
525         Boolean[] array = new Boolean[list.size()];
526 
527         for (int i = 0; i < list.size(); i++) {
528             array[i] = list.get(i);
529         }
530 
531         return array;
532     }
533 
534     public static Double[] toArray(List<Double> list) {
535         Double[] array = new Double[list.size()];
536 
537         for (int i = 0; i < list.size(); i++) {
538             array[i] = list.get(i);
539         }
540 
541         return array;
542     }
543 
544     public static Float[] toArray(List<Float> list) {
545         Float[] array = new Float[list.size()];
546 
547         for (int i = 0; i < list.size(); i++) {
548             array[i] = list.get(i);
549         }
550 
551         return array;
552     }
553 
554     public static Integer[] toArray(List<Integer> list) {
555         Integer[] array = new Integer[list.size()];
556 
557         for (int i = 0; i < list.size(); i++) {
558             array[i] = list.get(i);
559         }
560 
561         return array;
562     }
563 
564     public static Long[] toArray(List<Long> list) {
565         Long[] array = new Long[list.size()];
566 
567         for (int i = 0; i < list.size(); i++) {
568             array[i] = list.get(i);
569         }
570 
571         return array;
572     }
573 
574     public static Short[] toArray(List<Short> list) {
575         Short[] array = new Short[list.size()];
576 
577         for (int i = 0; i < list.size(); i++) {
578             array[i] = list.get(i);
579         }
580 
581         return array;
582     }
583 
584 }