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