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(
348         String[] array, Comparator<String> comparator) {
349 
350         if ((array == null) || (array.length == 0)) {
351             return array;
352         }
353 
354         Set<String> set = null;
355 
356         if (comparator == null) {
357             set = new TreeSet<String>();
358         }
359         else {
360             set = new TreeSet<String>(comparator);
361         }
362 
363         for (int i = 0; i < array.length; i++) {
364             String s = array[i];
365 
366             if (!set.contains(s)) {
367                 set.add(s);
368             }
369         }
370 
371         return set.toArray(new String[set.size()]);
372     }
373 
374     public static int getLength(Object[] array) {
375         if (array == null) {
376             return 0;
377         }
378         else {
379             return array.length;
380         }
381     }
382 
383     public static Object getValue(Object[] array, int pos) {
384         if ((array == null) || (array.length <= pos)) {
385             return null;
386         }
387         else {
388             return array[pos];
389         }
390     }
391 
392     public static String[] removeByPrefix(String[] array, String prefix) {
393         List<String> list = new ArrayList<String>();
394 
395         for (int i = 0; i < array.length; i++) {
396             String s = array[i];
397 
398             if (!s.startsWith(prefix)) {
399                 list.add(s);
400             }
401         }
402 
403         return list.toArray(new String[list.size()]);
404     }
405 
406     public static Boolean[] toArray(boolean[] array) {
407         Boolean[] newArray = new Boolean[array.length];
408 
409         for (int i = 0; i < array.length; i++) {
410             newArray[i] = Boolean.valueOf(array[i]);
411         }
412 
413         return newArray;
414     }
415 
416     public static Double[] toArray(double[] array) {
417         Double[] newArray = new Double[array.length];
418 
419         for (int i = 0; i < array.length; i++) {
420             newArray[i] = new Double(array[i]);
421         }
422 
423         return newArray;
424     }
425 
426     public static Float[] toArray(float[] array) {
427         Float[] newArray = new Float[array.length];
428 
429         for (int i = 0; i < array.length; i++) {
430             newArray[i] = new Float(array[i]);
431         }
432 
433         return newArray;
434     }
435 
436     public static Integer[] toArray(int[] array) {
437         Integer[] newArray = new Integer[array.length];
438 
439         for (int i = 0; i < array.length; i++) {
440             newArray[i] = new Integer(array[i]);
441         }
442 
443         return newArray;
444     }
445 
446     public static Long[] toArray(long[] array) {
447         Long[] newArray = new Long[array.length];
448 
449         for (int i = 0; i < array.length; i++) {
450             newArray[i] = new Long(array[i]);
451         }
452 
453         return newArray;
454     }
455 
456     public static Short[] toArray(short[] array) {
457         Short[] newArray = new Short[array.length];
458 
459         for (int i = 0; i < array.length; i++) {
460             newArray[i] = new Short(array[i]);
461         }
462 
463         return newArray;
464     }
465 
466     public static boolean[] toArray(Boolean[] array) {
467         boolean[] newArray = new boolean[array.length];
468 
469         for (int i = 0; i < array.length; i++) {
470             newArray[i] = array[i].booleanValue();
471         }
472 
473         return newArray;
474     }
475 
476     public static double[] toArray(Double[] array) {
477         double[] newArray = new double[array.length];
478 
479         for (int i = 0; i < array.length; i++) {
480             newArray[i] = array[i].doubleValue();
481         }
482 
483         return newArray;
484     }
485 
486     public static float[] toArray(Float[] array) {
487         float[] newArray = new float[array.length];
488 
489         for (int i = 0; i < array.length; i++) {
490             newArray[i] = array[i].floatValue();
491         }
492 
493         return newArray;
494     }
495 
496     public static int[] toArray(Integer[] array) {
497         int[] newArray = new int[array.length];
498 
499         for (int i = 0; i < array.length; i++) {
500             newArray[i] = array[i].intValue();
501         }
502 
503         return newArray;
504     }
505 
506     public static long[] toArray(Long[] array) {
507         long[] newArray = new long[array.length];
508 
509         for (int i = 0; i < array.length; i++) {
510             newArray[i] = array[i].longValue();
511         }
512 
513         return newArray;
514     }
515 
516     public static short[] toArray(Short[] array) {
517         short[] newArray = new short[array.length];
518 
519         for (int i = 0; i < array.length; i++) {
520             newArray[i] = array[i].shortValue();
521         }
522 
523         return newArray;
524     }
525 
526     public static Boolean[] toArray(List<Boolean> list) {
527         Boolean[] array = new Boolean[list.size()];
528 
529         for (int i = 0; i < list.size(); i++) {
530             array[i] = list.get(i);
531         }
532 
533         return array;
534     }
535 
536     public static Double[] toArray(List<Double> list) {
537         Double[] array = new Double[list.size()];
538 
539         for (int i = 0; i < list.size(); i++) {
540             array[i] = list.get(i);
541         }
542 
543         return array;
544     }
545 
546     public static Float[] toArray(List<Float> list) {
547         Float[] array = new Float[list.size()];
548 
549         for (int i = 0; i < list.size(); i++) {
550             array[i] = list.get(i);
551         }
552 
553         return array;
554     }
555 
556     public static Integer[] toArray(List<Integer> list) {
557         Integer[] array = new Integer[list.size()];
558 
559         for (int i = 0; i < list.size(); i++) {
560             array[i] = list.get(i);
561         }
562 
563         return array;
564     }
565 
566     public static Long[] toArray(List<Long> list) {
567         Long[] array = new Long[list.size()];
568 
569         for (int i = 0; i < list.size(); i++) {
570             array[i] = list.get(i);
571         }
572 
573         return array;
574     }
575 
576     public static Short[] toArray(List<Short> list) {
577         Short[] array = new Short[list.size()];
578 
579         for (int i = 0; i < list.size(); i++) {
580             array[i] = list.get(i);
581         }
582 
583         return array;
584     }
585 
586 }