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