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