1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portal.kernel.util;
16  
17  import com.liferay.portal.kernel.json.JSONArray;
18  
19  import java.text.DateFormat;
20  
21  import java.util.ArrayList;
22  import java.util.Comparator;
23  import java.util.Date;
24  import java.util.List;
25  import java.util.Set;
26  import java.util.TreeSet;
27  
28  /**
29   * <a href="ArrayUtil.java.html"><b><i>View Source</i></b></a>
30   *
31   * @author Brian Wing Shun Chan
32   */
33  public class ArrayUtil {
34  
35      public static boolean[] append(boolean[]... arrays) {
36          int length = 0;
37  
38          for (boolean[] array : arrays) {
39              length += array.length;
40          }
41  
42          boolean[] newArray = new boolean[length];
43  
44          int previousLength = 0;
45  
46          for (boolean[] array : arrays) {
47              System.arraycopy(array, 0, newArray, previousLength, array.length);
48  
49              previousLength += array.length;
50          }
51  
52          return newArray;
53      }
54  
55      public static boolean[] append(boolean[] array, boolean value) {
56          boolean[] newArray = new boolean[array.length + 1];
57  
58          System.arraycopy(array, 0, newArray, 0, array.length);
59  
60          newArray[newArray.length - 1] = value;
61  
62          return newArray;
63      }
64  
65      public static Boolean[] append(Boolean[]... arrays) {
66          int length = 0;
67  
68          for (Boolean[] array : arrays) {
69              length += array.length;
70          }
71  
72          Boolean[] newArray = new Boolean[length];
73  
74          int previousLength = 0;
75  
76          for (Boolean[] array : arrays) {
77              System.arraycopy(array, 0, newArray, previousLength, array.length);
78  
79              previousLength += array.length;
80          }
81  
82          return newArray;
83      }
84  
85      public static Boolean[] append(Boolean[] array, Boolean value) {
86          Boolean[] newArray = new Boolean[array.length + 1];
87  
88          System.arraycopy(array, 0, newArray, 0, array.length);
89  
90          newArray[newArray.length - 1] = value;
91  
92          return newArray;
93      }
94  
95      public static byte[] append(byte[]... arrays) {
96          int length = 0;
97  
98          for (byte[] array : arrays) {
99              length += array.length;
100         }
101 
102         byte[] newArray = new byte[length];
103 
104         int previousLength = 0;
105 
106         for (byte[] 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 byte[] append(byte[] array, byte value) {
116         byte[] newArray = new byte[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 Byte[] append(Byte[]... arrays) {
126         int length = 0;
127 
128         for (Byte[] array : arrays) {
129             length += array.length;
130         }
131 
132         Byte[] newArray = new Byte[length];
133 
134         int previousLength = 0;
135 
136         for (Byte[] 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 Byte[] append(Byte[] array, Byte value) {
146         Byte[] newArray = new Byte[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 char[] append(char[]... arrays) {
156         int length = 0;
157 
158         for (char[] array : arrays) {
159             length += array.length;
160         }
161 
162         char[] newArray = new char[length];
163 
164         int previousLength = 0;
165 
166         for (char[] 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 char[] append(char[] array, char value) {
176         char[] newArray = new char[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 Character[] append(Character[]... arrays) {
186         int length = 0;
187 
188         for (Character[] array : arrays) {
189             length += array.length;
190         }
191 
192         Character[] newArray = new Character[length];
193 
194         int previousLength = 0;
195 
196         for (Character[] 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 Character[] append(Character[] array, Character value) {
206         Character[] newArray = new Character[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 double[] append(double[]... arrays) {
216         int length = 0;
217 
218         for (double[] array : arrays) {
219             length += array.length;
220         }
221 
222         double[] newArray = new double[length];
223 
224         int previousLength = 0;
225 
226         for (double[] 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 double[] append(double[] array, double value) {
236         double[] newArray = new double[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 Double[] append(Double[]... arrays) {
246         int length = 0;
247 
248         for (Double[] array : arrays) {
249             length += array.length;
250         }
251 
252         Double[] newArray = new Double[length];
253 
254         int previousLength = 0;
255 
256         for (Double[] 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 Double[] append(Double[] array, Double value) {
266         Double[] newArray = new Double[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 float[] append(float[]... arrays) {
276         int length = 0;
277 
278         for (float[] array : arrays) {
279             length += array.length;
280         }
281 
282         float[] newArray = new float[length];
283 
284         int previousLength = 0;
285 
286         for (float[] array : arrays) {
287             System.arraycopy(array, 0, newArray, previousLength, array.length);
288 
289             previousLength += array.length;
290         }
291 
292         return newArray;
293     }
294 
295     public static float[] append(float[] array, float value) {
296         float[] newArray = new float[array.length + 1];
297 
298         System.arraycopy(array, 0, newArray, 0, array.length);
299 
300         newArray[newArray.length - 1] = value;
301 
302         return newArray;
303     }
304 
305     public static Float[] append(Float[]... arrays) {
306         int length = 0;
307 
308         for (Float[] array : arrays) {
309             length += array.length;
310         }
311 
312         Float[] newArray = new Float[length];
313 
314         int previousLength = 0;
315 
316         for (Float[] array : arrays) {
317             System.arraycopy(array, 0, newArray, previousLength, array.length);
318 
319             previousLength += array.length;
320         }
321 
322         return newArray;
323     }
324 
325     public static Float[] append(Float[] array, Float value) {
326         Float[] newArray = new Float[array.length + 1];
327 
328         System.arraycopy(array, 0, newArray, 0, array.length);
329 
330         newArray[newArray.length - 1] = value;
331 
332         return newArray;
333     }
334 
335     public static int[] append(int[]... arrays) {
336         int length = 0;
337 
338         for (int[] array : arrays) {
339             length += array.length;
340         }
341 
342         int[] newArray = new int[length];
343 
344         int previousLength = 0;
345 
346         for (int[] array : arrays) {
347             System.arraycopy(array, 0, newArray, previousLength, array.length);
348 
349             previousLength += array.length;
350         }
351 
352         return newArray;
353     }
354 
355     public static int[] append(int[] array, int value) {
356         int[] newArray = new int[array.length + 1];
357 
358         System.arraycopy(array, 0, newArray, 0, array.length);
359 
360         newArray[newArray.length - 1] = value;
361 
362         return newArray;
363     }
364 
365     public static Integer[] append(Integer[]... arrays) {
366         int length = 0;
367 
368         for (Integer[] array : arrays) {
369             length += array.length;
370         }
371 
372         Integer[] newArray = new Integer[length];
373 
374         int previousLength = 0;
375 
376         for (Integer[] array : arrays) {
377             System.arraycopy(array, 0, newArray, previousLength, array.length);
378 
379             previousLength += array.length;
380         }
381 
382         return newArray;
383     }
384 
385     public static Integer[] append(Integer[] array, Integer value) {
386         Integer[] newArray = new Integer[array.length + 1];
387 
388         System.arraycopy(array, 0, newArray, 0, array.length);
389 
390         newArray[newArray.length - 1] = value;
391 
392         return newArray;
393     }
394 
395     public static long[] append(long[]... arrays) {
396         int length = 0;
397 
398         for (long[] array : arrays) {
399             length += array.length;
400         }
401 
402         long[] newArray = new long[length];
403 
404         int previousLength = 0;
405 
406         for (long[] array : arrays) {
407             System.arraycopy(array, 0, newArray, previousLength, array.length);
408 
409             previousLength += array.length;
410         }
411 
412         return newArray;
413     }
414 
415     public static long[] append(long[] array, long value) {
416         long[] newArray = new long[array.length + 1];
417 
418         System.arraycopy(array, 0, newArray, 0, array.length);
419 
420         newArray[newArray.length - 1] = value;
421 
422         return newArray;
423     }
424 
425     public static Long[] append(Long[]... arrays) {
426         int length = 0;
427 
428         for (Long[] array : arrays) {
429             length += array.length;
430         }
431 
432         Long[] newArray = new Long[length];
433 
434         int previousLength = 0;
435 
436         for (Long[] array : arrays) {
437             System.arraycopy(array, 0, newArray, previousLength, array.length);
438 
439             previousLength += array.length;
440         }
441 
442         return newArray;
443     }
444 
445     public static Long[] append(Long[] array, Long value) {
446         Long[] newArray = new Long[array.length + 1];
447 
448         System.arraycopy(array, 0, newArray, 0, array.length);
449 
450         newArray[newArray.length - 1] = value;
451 
452         return newArray;
453     }
454 
455     public static Object[] append(Object[] array, Object value) {
456         Object[] newArray = new Object[array.length + 1];
457 
458         System.arraycopy(array, 0, newArray, 0, array.length);
459 
460         newArray[newArray.length - 1] = value;
461 
462         return newArray;
463     }
464 
465     public static Object[] append(Object[] array1, Object[] array2) {
466         Object[] newArray = new Object[array1.length + array2.length];
467 
468         System.arraycopy(array1, 0, newArray, 0, array1.length);
469         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
470 
471         return newArray;
472     }
473 
474     public static Object[][] append(Object[][] array, Object[] value) {
475         Object[][] newArray = new Object[array.length + 1][];
476 
477         System.arraycopy(array, 0, newArray, 0, array.length);
478 
479         newArray[newArray.length - 1] = value;
480 
481         return newArray;
482     }
483 
484     public static Object[][] append(Object[][] array1, Object[][] array2) {
485         Object[][] newArray = new Object[array1.length + array2.length][];
486 
487         System.arraycopy(array1, 0, newArray, 0, array1.length);
488         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
489 
490         return newArray;
491     }
492 
493     public static short[] append(short[]... arrays) {
494         int length = 0;
495 
496         for (short[] array : arrays) {
497             length += array.length;
498         }
499 
500         short[] newArray = new short[length];
501 
502         int previousLength = 0;
503 
504         for (short[] array : arrays) {
505             System.arraycopy(array, 0, newArray, previousLength, array.length);
506 
507             previousLength += array.length;
508         }
509 
510         return newArray;
511     }
512 
513     public static short[] append(short[] array, short value) {
514         short[] newArray = new short[array.length + 1];
515 
516         System.arraycopy(array, 0, newArray, 0, array.length);
517 
518         newArray[newArray.length - 1] = value;
519 
520         return newArray;
521     }
522 
523     public static Short[] append(Short[]... arrays) {
524         int length = 0;
525 
526         for (Short[] array : arrays) {
527             length += array.length;
528         }
529 
530         Short[] newArray = new Short[length];
531 
532         int previousLength = 0;
533 
534         for (Short[] array : arrays) {
535             System.arraycopy(array, 0, newArray, previousLength, array.length);
536 
537             previousLength += array.length;
538         }
539 
540         return newArray;
541     }
542 
543     public static Short[] append(Short[] array, Short value) {
544         Short[] newArray = new Short[array.length + 1];
545 
546         System.arraycopy(array, 0, newArray, 0, array.length);
547 
548         newArray[newArray.length - 1] = value;
549 
550         return newArray;
551     }
552 
553     public static String[] append(String[] array, String value) {
554         String[] newArray = new String[array.length + 1];
555 
556         System.arraycopy(array, 0, newArray, 0, array.length);
557 
558         newArray[newArray.length - 1] = value;
559 
560         return newArray;
561     }
562 
563     public static String[] append(String[] array1, String[] array2) {
564         String[] newArray = new String[array1.length + array2.length];
565 
566         System.arraycopy(array1, 0, newArray, 0, array1.length);
567         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
568 
569         return newArray;
570     }
571 
572     public static String[][] append(String[][] array, String[] value) {
573         String[][] newArray = new String[array.length + 1][];
574 
575         System.arraycopy(array, 0, newArray, 0, array.length);
576 
577         newArray[newArray.length - 1] = value;
578 
579         return newArray;
580     }
581 
582     public static String[][] append(String[][] array1, String[][] array2) {
583         String[][] newArray = new String[array1.length + array2.length][];
584 
585         System.arraycopy(array1, 0, newArray, 0, array1.length);
586         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
587 
588         return newArray;
589     }
590 
591     public static boolean[] clone(boolean[] array) {
592         boolean[] newArray = new boolean[array.length];
593 
594         System.arraycopy(array, 0, newArray, 0, array.length);
595 
596         return newArray;
597     }
598 
599     public static Boolean[] clone(Boolean[] array) {
600         Boolean[] newArray = new Boolean[array.length];
601 
602         System.arraycopy(array, 0, newArray, 0, array.length);
603 
604         return newArray;
605     }
606 
607     public static byte[] clone(byte[] array) {
608         byte[] newArray = new byte[array.length];
609 
610         System.arraycopy(array, 0, newArray, 0, array.length);
611 
612         return newArray;
613     }
614 
615     public static Byte[] clone(Byte[] array) {
616         Byte[] newArray = new Byte[array.length];
617 
618         System.arraycopy(array, 0, newArray, 0, array.length);
619 
620         return newArray;
621     }
622 
623     public static char[] clone(char[] array) {
624         char[] newArray = new char[array.length];
625 
626         System.arraycopy(array, 0, newArray, 0, array.length);
627 
628         return newArray;
629     }
630 
631     public static Character[] clone(Character[] array) {
632         Character[] newArray = new Character[array.length];
633 
634         System.arraycopy(array, 0, newArray, 0, array.length);
635 
636         return newArray;
637     }
638 
639     public static double[] clone(double[] array) {
640         double[] newArray = new double[array.length];
641 
642         System.arraycopy(array, 0, newArray, 0, array.length);
643 
644         return newArray;
645     }
646 
647     public static Double[] clone(Double[] array) {
648         Double[] newArray = new Double[array.length];
649 
650         System.arraycopy(array, 0, newArray, 0, array.length);
651 
652         return newArray;
653     }
654 
655     public static float[] clone(float[] array) {
656         float[] newArray = new float[array.length];
657 
658         System.arraycopy(array, 0, newArray, 0, array.length);
659 
660         return newArray;
661     }
662 
663     public static Float[] clone(Float[] array) {
664         Float[] newArray = new Float[array.length];
665 
666         System.arraycopy(array, 0, newArray, 0, array.length);
667 
668         return newArray;
669     }
670 
671     public static int[] clone(int[] array) {
672         int[] newArray = new int[array.length];
673 
674         System.arraycopy(array, 0, newArray, 0, array.length);
675 
676         return newArray;
677     }
678 
679     public static Integer[] clone(Integer[] array) {
680         Integer[] newArray = new Integer[array.length];
681 
682         System.arraycopy(array, 0, newArray, 0, array.length);
683 
684         return newArray;
685     }
686 
687     public static long[] clone(long[] array) {
688         long[] newArray = new long[array.length];
689 
690         System.arraycopy(array, 0, newArray, 0, array.length);
691 
692         return newArray;
693     }
694 
695     public static Long[] clone(Long[] array) {
696         Long[] newArray = new Long[array.length];
697 
698         System.arraycopy(array, 0, newArray, 0, array.length);
699 
700         return newArray;
701     }
702 
703     public static Object[] clone(Object[] array) {
704         Object[] newArray = new Object[array.length];
705 
706         System.arraycopy(array, 0, newArray, 0, array.length);
707 
708         return newArray;
709     }
710 
711     public static Object[][] clone(Object[][] array) {
712         Object[][] newArray = new Object[array.length][];
713 
714         System.arraycopy(array, 0, newArray, 0, array.length);
715 
716         return newArray;
717     }
718 
719     public static short[] clone(short[] array) {
720         short[] newArray = new short[array.length];
721 
722         System.arraycopy(array, 0, newArray, 0, array.length);
723 
724         return newArray;
725     }
726 
727     public static Short[] clone(Short[] array) {
728         Short[] newArray = new Short[array.length];
729 
730         System.arraycopy(array, 0, newArray, 0, array.length);
731 
732         return newArray;
733     }
734 
735     public static String[] clone(String[] array) {
736         String[] newArray = new String[array.length];
737 
738         System.arraycopy(array, 0, newArray, 0, array.length);
739 
740         return newArray;
741     }
742 
743     public static String[][] clone(String[][] array) {
744         String[][] newArray = new String[array.length][];
745 
746         System.arraycopy(array, 0, newArray, 0, array.length);
747 
748         return newArray;
749     }
750 
751     public static void combine(
752         Object[] array1, Object[] array2, Object[] combinedArray) {
753 
754         System.arraycopy(array1, 0, combinedArray, 0, array1.length);
755 
756         System.arraycopy(
757             array2, 0, combinedArray, array1.length, array2.length);
758     }
759 
760     public static boolean contains(boolean[] array, boolean value) {
761         if ((array == null) || (array.length == 0)) {
762             return false;
763         }
764         else {
765             for (int i = 0; i < array.length; i++) {
766                 if (value == array[i]) {
767                     return true;
768                 }
769             }
770 
771             return false;
772         }
773     }
774 
775     public static boolean contains(byte[] array, byte value) {
776         if ((array == null) || (array.length == 0)) {
777             return false;
778         }
779         else {
780             for (int i = 0; i < array.length; i++) {
781                 if (value == array[i]) {
782                     return true;
783                 }
784             }
785 
786             return false;
787         }
788     }
789 
790     public static boolean contains(char[] array, char value) {
791         if ((array == null) || (array.length == 0)) {
792             return false;
793         }
794         else {
795             for (int i = 0; i < array.length; i++) {
796                 if (value == array[i]) {
797                     return true;
798                 }
799             }
800 
801             return false;
802         }
803     }
804 
805     public static boolean contains(double[] array, double value) {
806         if ((array == null) || (array.length == 0)) {
807             return false;
808         }
809         else {
810             for (int i = 0; i < array.length; i++) {
811                 if (value == array[i]) {
812                     return true;
813                 }
814             }
815 
816             return false;
817         }
818     }
819 
820     public static boolean contains(int[] array, int value) {
821         if ((array == null) || (array.length == 0)) {
822             return false;
823         }
824         else {
825             for (int i = 0; i < array.length; i++) {
826                 if (value == array[i]) {
827                     return true;
828                 }
829             }
830 
831             return false;
832         }
833     }
834 
835     public static boolean contains(long[] array, long value) {
836         if ((array == null) || (array.length == 0)) {
837             return false;
838         }
839         else {
840             for (int i = 0; i < array.length; i++) {
841                 if (value == array[i]) {
842                     return true;
843                 }
844             }
845 
846             return false;
847         }
848     }
849 
850     public static boolean contains(Object[] array, Object value) {
851         if ((array == null) || (array.length == 0) || (value == null)) {
852             return false;
853         }
854         else {
855             for (int i = 0; i < array.length; i++) {
856                 if (value.equals(array[i])) {
857                     return true;
858                 }
859             }
860 
861             return false;
862         }
863     }
864 
865     public static boolean contains(short[] array, short value) {
866         if ((array == null) || (array.length == 0)) {
867             return false;
868         }
869         else {
870             for (int i = 0; i < array.length; i++) {
871                 if (value == array[i]) {
872                     return true;
873                 }
874             }
875 
876             return false;
877         }
878     }
879 
880     public static String[] distinct(String[] array) {
881         return distinct(array, null);
882     }
883 
884     public static String[] distinct(
885         String[] array, Comparator<String> comparator) {
886 
887         if ((array == null) || (array.length == 0)) {
888             return array;
889         }
890 
891         Set<String> set = null;
892 
893         if (comparator == null) {
894             set = new TreeSet<String>();
895         }
896         else {
897             set = new TreeSet<String>(comparator);
898         }
899 
900         for (int i = 0; i < array.length; i++) {
901             String s = array[i];
902 
903             if (!set.contains(s)) {
904                 set.add(s);
905             }
906         }
907 
908         return set.toArray(new String[set.size()]);
909     }
910 
911     public static int getLength(Object[] array) {
912         if (array == null) {
913             return 0;
914         }
915         else {
916             return array.length;
917         }
918     }
919 
920     public static Object getValue(Object[] array, int pos) {
921         if ((array == null) || (array.length <= pos)) {
922             return null;
923         }
924         else {
925             return array[pos];
926         }
927     }
928 
929     public static boolean[] remove(boolean[] array, boolean value) {
930         List<Boolean> list = new ArrayList<Boolean>();
931 
932         for (int i = 0; i < array.length; i++) {
933             if (value != array[i]) {
934                 list.add(new Boolean(array[i]));
935             }
936         }
937 
938         return toArray(list.toArray(new Boolean[list.size()]));
939     }
940 
941     public static byte[] remove(byte[] array, byte value) {
942         List<Byte> list = new ArrayList<Byte>();
943 
944         for (int i = 0; i < array.length; i++) {
945             if (value != array[i]) {
946                 list.add(new Byte(array[i]));
947             }
948         }
949 
950         return toArray(list.toArray(new Byte[list.size()]));
951     }
952 
953     public static char[] remove(char[] array, char value) {
954         List<Character> list = new ArrayList<Character>();
955 
956         for (int i = 0; i < array.length; i++) {
957             if (value != array[i]) {
958                 list.add(new Character(array[i]));
959             }
960         }
961 
962         return toArray(list.toArray(new Character[list.size()]));
963     }
964 
965     public static double[] remove(double[] array, double value) {
966         List<Double> list = new ArrayList<Double>();
967 
968         for (int i = 0; i < array.length; i++) {
969             if (value != array[i]) {
970                 list.add(new Double(array[i]));
971             }
972         }
973 
974         return toArray(list.toArray(new Double[list.size()]));
975     }
976 
977     public static int[] remove(int[] array, int value) {
978         List<Integer> list = new ArrayList<Integer>();
979 
980         for (int i = 0; i < array.length; i++) {
981             if (value != array[i]) {
982                 list.add(new Integer(array[i]));
983             }
984         }
985 
986         return toArray(list.toArray(new Integer[list.size()]));
987     }
988 
989     public static long[] remove(long[] array, long value) {
990         List<Long> list = new ArrayList<Long>();
991 
992         for (int i = 0; i < array.length; i++) {
993             if (value != array[i]) {
994                 list.add(new Long(array[i]));
995             }
996         }
997 
998         return toArray(list.toArray(new Long[list.size()]));
999     }
1000
1001    public static short[] remove(short[] array, short value) {
1002        List<Short> list = new ArrayList<Short>();
1003
1004        for (int i = 0; i < array.length; i++) {
1005            if (value != array[i]) {
1006                list.add(new Short(array[i]));
1007            }
1008        }
1009
1010        return toArray(list.toArray(new Short[list.size()]));
1011    }
1012
1013    public static String[] remove(String[] array, String value) {
1014        List<String> list = new ArrayList<String>();
1015
1016        for (String s : array) {
1017            if (!s.equals(value)) {
1018                list.add(s);
1019            }
1020        }
1021
1022        return list.toArray(new String[list.size()]);
1023    }
1024
1025    public static String[] removeByPrefix(String[] array, String prefix) {
1026        List<String> list = new ArrayList<String>();
1027
1028        for (String s : array) {
1029            if (!s.startsWith(prefix)) {
1030                list.add(s);
1031            }
1032        }
1033
1034        return list.toArray(new String[list.size()]);
1035    }
1036
1037    public static void reverse(String[] array) {
1038        for (int left = 0, right = array.length - 1; left < right;
1039                left++, right--) {
1040
1041            String value = array[left];
1042
1043            array[left] = array[right];
1044            array[right] = value;
1045        }
1046    }
1047
1048    public static Boolean[] toArray(boolean[] array) {
1049        Boolean[] newArray = new Boolean[array.length];
1050
1051        for (int i = 0; i < array.length; i++) {
1052            newArray[i] = Boolean.valueOf(array[i]);
1053        }
1054
1055        return newArray;
1056    }
1057
1058    public static boolean[] toArray(Boolean[] array) {
1059        boolean[] newArray = new boolean[array.length];
1060
1061        for (int i = 0; i < array.length; i++) {
1062            newArray[i] = array[i].booleanValue();
1063        }
1064
1065        return newArray;
1066    }
1067
1068    public static Byte[] toArray(byte[] array) {
1069        Byte[] newArray = new Byte[array.length];
1070
1071        for (int i = 0; i < array.length; i++) {
1072            newArray[i] = Byte.valueOf(array[i]);
1073        }
1074
1075        return newArray;
1076    }
1077
1078    public static byte[] toArray(Byte[] array) {
1079        byte[] newArray = new byte[array.length];
1080
1081        for (int i = 0; i < array.length; i++) {
1082            newArray[i] = array[i].byteValue();
1083        }
1084
1085        return newArray;
1086    }
1087
1088    public static Character[] toArray(char[] array) {
1089        Character[] newArray = new Character[array.length];
1090
1091        for (int i = 0; i < array.length; i++) {
1092            newArray[i] = Character.valueOf(array[i]);
1093        }
1094
1095        return newArray;
1096    }
1097
1098    public static char[] toArray(Character[] array) {
1099        char[] newArray = new char[array.length];
1100
1101        for (int i = 0; i < array.length; i++) {
1102            newArray[i] = array[i].charValue();
1103        }
1104
1105        return newArray;
1106    }
1107
1108    public static Double[] toArray(double[] array) {
1109        Double[] newArray = new Double[array.length];
1110
1111        for (int i = 0; i < array.length; i++) {
1112            newArray[i] = new Double(array[i]);
1113        }
1114
1115        return newArray;
1116    }
1117
1118    public static double[] toArray(Double[] array) {
1119        double[] newArray = new double[array.length];
1120
1121        for (int i = 0; i < array.length; i++) {
1122            newArray[i] = array[i].doubleValue();
1123        }
1124
1125        return newArray;
1126    }
1127
1128    public static Float[] toArray(float[] array) {
1129        Float[] newArray = new Float[array.length];
1130
1131        for (int i = 0; i < array.length; i++) {
1132            newArray[i] = new Float(array[i]);
1133        }
1134
1135        return newArray;
1136    }
1137
1138    public static float[] toArray(Float[] array) {
1139        float[] newArray = new float[array.length];
1140
1141        for (int i = 0; i < array.length; i++) {
1142            newArray[i] = array[i].floatValue();
1143        }
1144
1145        return newArray;
1146    }
1147
1148    public static Integer[] toArray(int[] array) {
1149        Integer[] newArray = new Integer[array.length];
1150
1151        for (int i = 0; i < array.length; i++) {
1152            newArray[i] = new Integer(array[i]);
1153        }
1154
1155        return newArray;
1156    }
1157
1158    public static int[] toArray(Integer[] array) {
1159        int[] newArray = new int[array.length];
1160
1161        for (int i = 0; i < array.length; i++) {
1162            newArray[i] = array[i].intValue();
1163        }
1164
1165        return newArray;
1166    }
1167
1168    public static Long[] toArray(long[] array) {
1169        Long[] newArray = new Long[array.length];
1170
1171        for (int i = 0; i < array.length; i++) {
1172            newArray[i] = new Long(array[i]);
1173        }
1174
1175        return newArray;
1176    }
1177
1178    public static long[] toArray(Long[] array) {
1179        long[] newArray = new long[array.length];
1180
1181        for (int i = 0; i < array.length; i++) {
1182            newArray[i] = array[i].longValue();
1183        }
1184
1185        return newArray;
1186    }
1187
1188    public static Short[] toArray(short[] array) {
1189        Short[] newArray = new Short[array.length];
1190
1191        for (int i = 0; i < array.length; i++) {
1192            newArray[i] = new Short(array[i]);
1193        }
1194
1195        return newArray;
1196    }
1197
1198    public static short[] toArray(Short[] array) {
1199        short[] newArray = new short[array.length];
1200
1201        for (int i = 0; i < array.length; i++) {
1202            newArray[i] = array[i].shortValue();
1203        }
1204
1205        return newArray;
1206    }
1207
1208    public static String[] toStringArray(boolean[] array) {
1209        String[] newArray = new String[array.length];
1210
1211        for (int i = 0; i < array.length; i++) {
1212            newArray[i] = String.valueOf(array[i]);
1213        }
1214
1215        return newArray;
1216    }
1217
1218    public static String[] toStringArray(byte[] array) {
1219        String[] newArray = new String[array.length];
1220
1221        for (int i = 0; i < array.length; i++) {
1222            newArray[i] = String.valueOf(array[i]);
1223        }
1224
1225        return newArray;
1226    }
1227
1228    public static String[] toStringArray(char[] array) {
1229        String[] newArray = new String[array.length];
1230
1231        for (int i = 0; i < array.length; i++) {
1232            newArray[i] = String.valueOf(array[i]);
1233        }
1234
1235        return newArray;
1236    }
1237
1238    public static String[] toStringArray(Date[] array, DateFormat df) {
1239        String[] newArray = new String[array.length];
1240
1241        for (int i = 0; i < array.length; i++) {
1242            newArray[i] = df.format(array[i]);
1243        }
1244
1245        return newArray;
1246    }
1247
1248    public static String[] toStringArray(double[] array) {
1249        String[] newArray = new String[array.length];
1250
1251        for (int i = 0; i < array.length; i++) {
1252            newArray[i] = String.valueOf(array[i]);
1253        }
1254
1255        return newArray;
1256    }
1257
1258    public static String[] toStringArray(float[] array) {
1259        String[] newArray = new String[array.length];
1260
1261        for (int i = 0; i < array.length; i++) {
1262            newArray[i] = String.valueOf(array[i]);
1263        }
1264
1265        return newArray;
1266    }
1267
1268    public static String[] toStringArray(int[] array) {
1269        String[] newArray = new String[array.length];
1270
1271        for (int i = 0; i < array.length; i++) {
1272            newArray[i] = String.valueOf(array[i]);
1273        }
1274
1275        return newArray;
1276    }
1277
1278    public static String[] toStringArray(JSONArray array) {
1279        String[] newArray = new String[array.length()];
1280
1281        for (int i = 0; i < array.length(); i++) {
1282            newArray[i] = array.getString(i);
1283        }
1284
1285        return newArray;
1286    }
1287
1288    public static String[] toStringArray(long[] array) {
1289        String[] newArray = new String[array.length];
1290
1291        for (int i = 0; i < array.length; i++) {
1292            newArray[i] = String.valueOf(array[i]);
1293        }
1294
1295        return newArray;
1296    }
1297
1298    public static String[] toStringArray(Object[] array) {
1299        String[] newArray = new String[array.length];
1300
1301        for (int i = 0; i < array.length; i++) {
1302            newArray[i] = String.valueOf(array[i]);
1303        }
1304
1305        return newArray;
1306    }
1307
1308    public static String[] toStringArray(short[] array) {
1309        String[] newArray = new String[array.length];
1310
1311        for (int i = 0; i < array.length; i++) {
1312            newArray[i] = String.valueOf(array[i]);
1313        }
1314
1315        return newArray;
1316    }
1317
1318}