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 boolean[] append(boolean[] array1, boolean[] array2) {
50          boolean[] newArray = new boolean[array1.length + array2.length];
51  
52          System.arraycopy(array1, 0, newArray, 0, array1.length);
53          System.arraycopy(array2, 0, newArray, array1.length, array2.length);
54  
55          return newArray;
56      }
57  
58      public static Boolean[] append(Boolean[] array, Boolean value) {
59          Boolean[] newArray = new Boolean[array.length + 1];
60  
61          System.arraycopy(array, 0, newArray, 0, array.length);
62  
63          newArray[newArray.length - 1] = value;
64  
65          return newArray;
66      }
67  
68      public static Boolean[] append(Boolean[] array1, Boolean[] array2) {
69          Boolean[] newArray = new Boolean[array1.length + array2.length];
70  
71          System.arraycopy(array1, 0, newArray, 0, array1.length);
72          System.arraycopy(array2, 0, newArray, array1.length, array2.length);
73  
74          return newArray;
75      }
76  
77      public static byte[] append(byte[] array, byte value) {
78          byte[] newArray = new byte[array.length + 1];
79  
80          System.arraycopy(array, 0, newArray, 0, array.length);
81  
82          newArray[newArray.length - 1] = value;
83  
84          return newArray;
85      }
86  
87      public static byte[] append(byte[] array1, byte[] array2) {
88          byte[] newArray = new byte[array1.length + array2.length];
89  
90          System.arraycopy(array1, 0, newArray, 0, array1.length);
91          System.arraycopy(array2, 0, newArray, array1.length, array2.length);
92  
93          return newArray;
94      }
95  
96      public static double[] append(double[] array, double value) {
97          double[] newArray = new double[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 double[] append(double[] array1, double[] array2) {
107         double[] newArray = new double[array1.length + array2.length];
108 
109         System.arraycopy(array1, 0, newArray, 0, array1.length);
110         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
111 
112         return newArray;
113     }
114 
115     public static Double[] append(Double[] array, Double value) {
116         Double[] newArray = new Double[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 Double[] append(Double[] array1, Double[] array2) {
126         Double[] newArray = new Double[array1.length + array2.length];
127 
128         System.arraycopy(array1, 0, newArray, 0, array1.length);
129         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
130 
131         return newArray;
132     }
133 
134     public static float[] append(float[] array, float value) {
135         float[] newArray = new float[array.length + 1];
136 
137         System.arraycopy(array, 0, newArray, 0, array.length);
138 
139         newArray[newArray.length - 1] = value;
140 
141         return newArray;
142     }
143 
144     public static float[] append(float[] array1, float[] array2) {
145         float[] newArray = new float[array1.length + array2.length];
146 
147         System.arraycopy(array1, 0, newArray, 0, array1.length);
148         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
149 
150         return newArray;
151     }
152 
153     public static Float[] append(Float[] array, Float value) {
154         Float[] newArray = new Float[array.length + 1];
155 
156         System.arraycopy(array, 0, newArray, 0, array.length);
157 
158         newArray[newArray.length - 1] = value;
159 
160         return newArray;
161     }
162 
163     public static Float[] append(Float[] array1, Float[] array2) {
164         Float[] newArray = new Float[array1.length + array2.length];
165 
166         System.arraycopy(array1, 0, newArray, 0, array1.length);
167         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
168 
169         return newArray;
170     }
171 
172     public static int[] append(int[] array, int value) {
173         int[] newArray = new int[array.length + 1];
174 
175         System.arraycopy(array, 0, newArray, 0, array.length);
176 
177         newArray[newArray.length - 1] = value;
178 
179         return newArray;
180     }
181 
182     public static int[] append(int[] array1, int[] array2) {
183         int[] newArray = new int[array1.length + array2.length];
184 
185         System.arraycopy(array1, 0, newArray, 0, array1.length);
186         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
187 
188         return newArray;
189     }
190 
191     public static Integer[] append(Integer[] array, Integer value) {
192         Integer[] newArray = new Integer[array.length + 1];
193 
194         System.arraycopy(array, 0, newArray, 0, array.length);
195 
196         newArray[newArray.length - 1] = value;
197 
198         return newArray;
199     }
200 
201     public static Integer[] append(Integer[] array1, Integer[] array2) {
202         Integer[] newArray = new Integer[array1.length + array2.length];
203 
204         System.arraycopy(array1, 0, newArray, 0, array1.length);
205         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
206 
207         return newArray;
208     }
209 
210     public static long[] append(long[] array, long value) {
211         long[] newArray = new long[array.length + 1];
212 
213         System.arraycopy(array, 0, newArray, 0, array.length);
214 
215         newArray[newArray.length - 1] = value;
216 
217         return newArray;
218     }
219 
220     public static long[] append(long[] array1, long[] array2) {
221         long[] newArray = new long[array1.length + array2.length];
222 
223         System.arraycopy(array1, 0, newArray, 0, array1.length);
224         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
225 
226         return newArray;
227     }
228 
229     public static Long[] append(Long[] array, Long value) {
230         Long[] newArray = new Long[array.length + 1];
231 
232         System.arraycopy(array, 0, newArray, 0, array.length);
233 
234         newArray[newArray.length - 1] = value;
235 
236         return newArray;
237     }
238 
239     public static Long[] append(Long[] array1, Long[] array2) {
240         Long[] newArray = new Long[array1.length + array2.length];
241 
242         System.arraycopy(array1, 0, newArray, 0, array1.length);
243         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
244 
245         return newArray;
246     }
247 
248     public static Object[] append(Object[] array, Object value) {
249         Object[] newArray = new Object[array.length + 1];
250 
251         System.arraycopy(array, 0, newArray, 0, array.length);
252 
253         newArray[newArray.length - 1] = value;
254 
255         return newArray;
256     }
257 
258     public static Object[] append(Object[] array1, Object[] array2) {
259         Object[] newArray = new Object[array1.length + array2.length];
260 
261         System.arraycopy(array1, 0, newArray, 0, array1.length);
262         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
263 
264         return newArray;
265     }
266 
267     public static Object[][] append(Object[][] array, Object[] value) {
268         Object[][] newArray = new Object[array.length + 1][];
269 
270         System.arraycopy(array, 0, newArray, 0, array.length);
271 
272         newArray[newArray.length - 1] = value;
273 
274         return newArray;
275     }
276 
277     public static Object[][] append(Object[][] array1, Object[][] array2) {
278         Object[][] newArray = new Object[array1.length + array2.length][];
279 
280         System.arraycopy(array1, 0, newArray, 0, array1.length);
281         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
282 
283         return newArray;
284     }
285 
286     public static short[] append(short[] array, short value) {
287         short[] newArray = new short[array.length + 1];
288 
289         System.arraycopy(array, 0, newArray, 0, array.length);
290 
291         newArray[newArray.length - 1] = value;
292 
293         return newArray;
294     }
295 
296     public static short[] append(short[] array1, short[] array2) {
297         short[] newArray = new short[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 Short[] append(Short[] array, Short value) {
306         Short[] newArray = new Short[array.length + 1];
307 
308         System.arraycopy(array, 0, newArray, 0, array.length);
309 
310         newArray[newArray.length - 1] = value;
311 
312         return newArray;
313     }
314 
315     public static Short[] append(Short[] array1, Short[] array2) {
316         Short[] newArray = new Short[array1.length + array2.length];
317 
318         System.arraycopy(array1, 0, newArray, 0, array1.length);
319         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
320 
321         return newArray;
322     }
323 
324     public static String[] append(String[] array, String value) {
325         String[] newArray = new String[array.length + 1];
326 
327         System.arraycopy(array, 0, newArray, 0, array.length);
328 
329         newArray[newArray.length - 1] = value;
330 
331         return newArray;
332     }
333 
334     public static String[] append(String[] array1, String[] array2) {
335         String[] newArray = new String[array1.length + array2.length];
336 
337         System.arraycopy(array1, 0, newArray, 0, array1.length);
338         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
339 
340         return newArray;
341     }
342 
343     public static String[][] append(String[][] array, String[] value) {
344         String[][] newArray = new String[array.length + 1][];
345 
346         System.arraycopy(array, 0, newArray, 0, array.length);
347 
348         newArray[newArray.length - 1] = value;
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(Object[] array, Object value) {
462         if ((array == null) || (array.length == 0) || (value == null)) {
463             return false;
464         }
465         else {
466             for (int i = 0; i < array.length; i++) {
467                 if (value.equals(array[i])) {
468                     return true;
469                 }
470             }
471 
472             return false;
473         }
474     }
475 
476     public static boolean contains(short[] array, short value) {
477         if ((array == null) || (array.length == 0)) {
478             return false;
479         }
480         else {
481             for (int i = 0; i < array.length; i++) {
482                 if (value == 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 boolean[] toArray(Boolean[] array) {
659         boolean[] newArray = new boolean[array.length];
660 
661         for (int i = 0; i < array.length; i++) {
662             newArray[i] = array[i].booleanValue();
663         }
664 
665         return newArray;
666     }
667 
668     public static Byte[] toArray(byte[] array) {
669         Byte[] newArray = new Byte[array.length];
670 
671         for (int i = 0; i < array.length; i++) {
672             newArray[i] = Byte.valueOf(array[i]);
673         }
674 
675         return newArray;
676     }
677 
678     public static byte[] toArray(Byte[] array) {
679         byte[] newArray = new byte[array.length];
680 
681         for (int i = 0; i < array.length; i++) {
682             newArray[i] = array[i].byteValue();
683         }
684 
685         return newArray;
686     }
687 
688     public static Character[] toArray(char[] array) {
689         Character[] newArray = new Character[array.length];
690 
691         for (int i = 0; i < array.length; i++) {
692             newArray[i] = Character.valueOf(array[i]);
693         }
694 
695         return newArray;
696     }
697 
698     public static char[] toArray(Character[] array) {
699         char[] newArray = new char[array.length];
700 
701         for (int i = 0; i < array.length; i++) {
702             newArray[i] = array[i].charValue();
703         }
704 
705         return newArray;
706     }
707 
708     public static Double[] toArray(double[] array) {
709         Double[] newArray = new Double[array.length];
710 
711         for (int i = 0; i < array.length; i++) {
712             newArray[i] = new Double(array[i]);
713         }
714 
715         return newArray;
716     }
717 
718     public static double[] toArray(Double[] array) {
719         double[] newArray = new double[array.length];
720 
721         for (int i = 0; i < array.length; i++) {
722             newArray[i] = array[i].doubleValue();
723         }
724 
725         return newArray;
726     }
727 
728     public static Float[] toArray(float[] array) {
729         Float[] newArray = new Float[array.length];
730 
731         for (int i = 0; i < array.length; i++) {
732             newArray[i] = new Float(array[i]);
733         }
734 
735         return newArray;
736     }
737 
738     public static float[] toArray(Float[] array) {
739         float[] newArray = new float[array.length];
740 
741         for (int i = 0; i < array.length; i++) {
742             newArray[i] = array[i].floatValue();
743         }
744 
745         return newArray;
746     }
747 
748     public static Integer[] toArray(int[] array) {
749         Integer[] newArray = new Integer[array.length];
750 
751         for (int i = 0; i < array.length; i++) {
752             newArray[i] = new Integer(array[i]);
753         }
754 
755         return newArray;
756     }
757 
758     public static int[] toArray(Integer[] array) {
759         int[] newArray = new int[array.length];
760 
761         for (int i = 0; i < array.length; i++) {
762             newArray[i] = array[i].intValue();
763         }
764 
765         return newArray;
766     }
767 
768     public static Long[] toArray(long[] array) {
769         Long[] newArray = new Long[array.length];
770 
771         for (int i = 0; i < array.length; i++) {
772             newArray[i] = new Long(array[i]);
773         }
774 
775         return newArray;
776     }
777 
778     public static long[] toArray(Long[] array) {
779         long[] newArray = new long[array.length];
780 
781         for (int i = 0; i < array.length; i++) {
782             newArray[i] = array[i].longValue();
783         }
784 
785         return newArray;
786     }
787 
788     public static Short[] toArray(short[] array) {
789         Short[] newArray = new Short[array.length];
790 
791         for (int i = 0; i < array.length; i++) {
792             newArray[i] = new Short(array[i]);
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(Object[] 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(short[] 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 }