1   /**
2    * Copyright (c) 2000-2010 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   *
12   *
13   */
14  
15  package com.liferay.portal.kernel.util;
16  
17  import com.liferay.portal.kernel.json.JSONArray;
18  
19  import java.lang.reflect.Array;
20  
21  import java.text.DateFormat;
22  
23  import java.util.ArrayList;
24  import java.util.Comparator;
25  import java.util.Date;
26  import java.util.List;
27  import java.util.Set;
28  import java.util.TreeSet;
29  
30  /**
31   * <a href="ArrayUtil.java.html"><b><i>View Source</i></b></a>
32   *
33   * @author Brian Wing Shun Chan
34   */
35  public class ArrayUtil {
36  
37      public static boolean[] append(boolean[]... arrays) {
38          int length = 0;
39  
40          for (boolean[] array : arrays) {
41              length += array.length;
42          }
43  
44          boolean[] newArray = new boolean[length];
45  
46          int previousLength = 0;
47  
48          for (boolean[] array : arrays) {
49              System.arraycopy(array, 0, newArray, previousLength, array.length);
50  
51              previousLength += array.length;
52          }
53  
54          return newArray;
55      }
56  
57      public static boolean[] append(boolean[] array, boolean value) {
58          boolean[] newArray = new boolean[array.length + 1];
59  
60          System.arraycopy(array, 0, newArray, 0, array.length);
61  
62          newArray[newArray.length - 1] = value;
63  
64          return newArray;
65      }
66  
67      public static byte[] append(byte[]... arrays) {
68          int length = 0;
69  
70          for (byte[] array : arrays) {
71              length += array.length;
72          }
73  
74          byte[] newArray = new byte[length];
75  
76          int previousLength = 0;
77  
78          for (byte[] array : arrays) {
79              System.arraycopy(array, 0, newArray, previousLength, array.length);
80  
81              previousLength += array.length;
82          }
83  
84          return newArray;
85      }
86  
87      public static byte[] append(byte[] array, byte value) {
88          byte[] newArray = new byte[array.length + 1];
89  
90          System.arraycopy(array, 0, newArray, 0, array.length);
91  
92          newArray[newArray.length - 1] = value;
93  
94          return newArray;
95      }
96  
97      public static char[] append(char[]... arrays) {
98          int length = 0;
99  
100         for (char[] array : arrays) {
101             length += array.length;
102         }
103 
104         char[] newArray = new char[length];
105 
106         int previousLength = 0;
107 
108         for (char[] array : arrays) {
109             System.arraycopy(array, 0, newArray, previousLength, array.length);
110 
111             previousLength += array.length;
112         }
113 
114         return newArray;
115     }
116 
117     public static char[] append(char[] array, char value) {
118         char[] newArray = new char[array.length + 1];
119 
120         System.arraycopy(array, 0, newArray, 0, array.length);
121 
122         newArray[newArray.length - 1] = value;
123 
124         return newArray;
125     }
126 
127     public static double[] append(double[]... arrays) {
128         int length = 0;
129 
130         for (double[] array : arrays) {
131             length += array.length;
132         }
133 
134         double[] newArray = new double[length];
135 
136         int previousLength = 0;
137 
138         for (double[] array : arrays) {
139             System.arraycopy(array, 0, newArray, previousLength, array.length);
140 
141             previousLength += array.length;
142         }
143 
144         return newArray;
145     }
146 
147     public static double[] append(double[] array, double value) {
148         double[] newArray = new double[array.length + 1];
149 
150         System.arraycopy(array, 0, newArray, 0, array.length);
151 
152         newArray[newArray.length - 1] = value;
153 
154         return newArray;
155     }
156 
157     public static float[] append(float[]... arrays) {
158         int length = 0;
159 
160         for (float[] array : arrays) {
161             length += array.length;
162         }
163 
164         float[] newArray = new float[length];
165 
166         int previousLength = 0;
167 
168         for (float[] array : arrays) {
169             System.arraycopy(array, 0, newArray, previousLength, array.length);
170 
171             previousLength += array.length;
172         }
173 
174         return newArray;
175     }
176 
177     public static float[] append(float[] array, float value) {
178         float[] newArray = new float[array.length + 1];
179 
180         System.arraycopy(array, 0, newArray, 0, array.length);
181 
182         newArray[newArray.length - 1] = value;
183 
184         return newArray;
185     }
186 
187     public static int[] append(int[]... arrays) {
188         int length = 0;
189 
190         for (int[] array : arrays) {
191             length += array.length;
192         }
193 
194         int[] newArray = new int[length];
195 
196         int previousLength = 0;
197 
198         for (int[] array : arrays) {
199             System.arraycopy(array, 0, newArray, previousLength, array.length);
200 
201             previousLength += array.length;
202         }
203 
204         return newArray;
205     }
206 
207     public static int[] append(int[] array, int value) {
208         int[] newArray = new int[array.length + 1];
209 
210         System.arraycopy(array, 0, newArray, 0, array.length);
211 
212         newArray[newArray.length - 1] = value;
213 
214         return newArray;
215     }
216 
217     public static long[] append(long[]... arrays) {
218         int length = 0;
219 
220         for (long[] array : arrays) {
221             length += array.length;
222         }
223 
224         long[] newArray = new long[length];
225 
226         int previousLength = 0;
227 
228         for (long[] array : arrays) {
229             System.arraycopy(array, 0, newArray, previousLength, array.length);
230 
231             previousLength += array.length;
232         }
233 
234         return newArray;
235     }
236 
237     public static long[] append(long[] array, long value) {
238         long[] newArray = new long[array.length + 1];
239 
240         System.arraycopy(array, 0, newArray, 0, array.length);
241 
242         newArray[newArray.length - 1] = value;
243 
244         return newArray;
245     }
246 
247     public static short[] append(short[]... arrays) {
248         int length = 0;
249 
250         for (short[] array : arrays) {
251             length += array.length;
252         }
253 
254         short[] newArray = new short[length];
255 
256         int previousLength = 0;
257 
258         for (short[] array : arrays) {
259             System.arraycopy(array, 0, newArray, previousLength, array.length);
260 
261             previousLength += array.length;
262         }
263 
264         return newArray;
265     }
266 
267     public static short[] append(short[] array, short value) {
268         short[] newArray = new short[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 <T> T[] append(T[]... arrays) {
278         int length = 0;
279 
280         for (T[] array : arrays) {
281             length += array.length;
282         }
283 
284         Class<?> arraysClass = arrays.getClass();
285 
286         T[] newArray = (T[])Array.newInstance(
287             arraysClass.getComponentType(), length);
288 
289         int previousLength = 0;
290 
291         for (T[] array : arrays) {
292             System.arraycopy(array, 0, newArray, previousLength, array.length);
293 
294             previousLength += array.length;
295         }
296 
297         return newArray;
298     }
299 
300     public static <T> T[] append(T[] array, T value) {
301         Class<?> arrayClass = array.getClass();
302 
303         T[] newArray = (T[])Array.newInstance(
304             arrayClass.getComponentType(), array.length + 1);
305 
306         System.arraycopy(array, 0, newArray, 0, array.length);
307 
308         newArray[array.length] = value;
309 
310         return newArray;
311     }
312 
313     public static <T> T[] append(T[] array1, T[] array2) {
314         Class<?> array1Class = array1.getClass();
315 
316         T[] newArray = (T[])Array.newInstance(
317             array1Class.getComponentType(), array1.length + array2.length);
318 
319         System.arraycopy(array1, 0, newArray, 0, array1.length);
320 
321         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
322 
323         return newArray;
324     }
325 
326     public static <T> T[][] append(T[][] array1, T[] value) {
327         Class<?> array1Class = array1.getClass();
328 
329         T[][] newArray = (T[][])Array.newInstance(
330             array1Class.getComponentType(), array1.length + 1);
331 
332         System.arraycopy(array1, 0, newArray, 0, array1.length);
333 
334         newArray[array1.length] = value;
335 
336         return newArray;
337     }
338 
339     public static <T> T[][] append(T[][] array1, T[][] array2) {
340         Class<?> array1Class = array1.getClass();
341 
342         T[][] newArray = (T[][])Array.newInstance(
343             array1Class.getComponentType(), array1.length + array2.length);
344 
345         System.arraycopy(array1, 0, newArray, 0, array1.length);
346         System.arraycopy(array2, 0, newArray, array1.length, array2.length);
347 
348         return newArray;
349     }
350 
351     public static boolean[] clone(boolean[] array) {
352         boolean[] newArray = new boolean[array.length];
353 
354         System.arraycopy(array, 0, newArray, 0, array.length);
355 
356         return newArray;
357     }
358 
359     public static byte[] clone(byte[] array) {
360         byte[] newArray = new byte[array.length];
361 
362         System.arraycopy(array, 0, newArray, 0, array.length);
363 
364         return newArray;
365     }
366 
367     public static char[] clone(char[] array) {
368         char[] newArray = new char[array.length];
369 
370         System.arraycopy(array, 0, newArray, 0, array.length);
371 
372         return newArray;
373     }
374 
375     public static double[] clone(double[] array) {
376         double[] newArray = new double[array.length];
377 
378         System.arraycopy(array, 0, newArray, 0, array.length);
379 
380         return newArray;
381     }
382 
383     public static float[] clone(float[] array) {
384         float[] newArray = new float[array.length];
385 
386         System.arraycopy(array, 0, newArray, 0, array.length);
387 
388         return newArray;
389     }
390 
391     public static int[] clone(int[] array) {
392         int[] newArray = new int[array.length];
393 
394         System.arraycopy(array, 0, newArray, 0, array.length);
395 
396         return newArray;
397     }
398 
399     public static long[] clone(long[] array) {
400         long[] newArray = new long[array.length];
401 
402         System.arraycopy(array, 0, newArray, 0, array.length);
403 
404         return newArray;
405     }
406 
407     public static short[] clone(short[] array) {
408         short[] newArray = new short[array.length];
409 
410         System.arraycopy(array, 0, newArray, 0, array.length);
411 
412         return newArray;
413     }
414 
415     public static <T> T[] clone(T[] array) {
416         Class<?> arrayClass = array.getClass();
417 
418         T[] newArray = (T[])Array.newInstance(
419             arrayClass.getComponentType(), array.length + 1);
420 
421         System.arraycopy(array, 0, newArray, 0, array.length);
422 
423         return newArray;
424     }
425 
426     public static <T> T[][] clone(T[][] array) {
427         Class<?> arrayClass = array.getClass();
428 
429         T[][] newArray = (T[][])Array.newInstance(
430             arrayClass.getComponentType(), array.length + 1);
431 
432         System.arraycopy(array, 0, newArray, 0, array.length);
433 
434         return newArray;
435     }
436 
437     public static void combine(
438         Object[] array1, Object[] array2, Object[] combinedArray) {
439 
440         System.arraycopy(array1, 0, combinedArray, 0, array1.length);
441 
442         System.arraycopy(
443             array2, 0, combinedArray, array1.length, array2.length);
444     }
445 
446     public static boolean contains(boolean[] array, boolean 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(byte[] array, byte 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(char[] array, char 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 boolean contains(double[] array, double value) {
492         if ((array == null) || (array.length == 0)) {
493             return false;
494         }
495         else {
496             for (int i = 0; i < array.length; i++) {
497                 if (value == array[i]) {
498                     return true;
499                 }
500             }
501 
502             return false;
503         }
504     }
505 
506     public static boolean contains(int[] array, int value) {
507         if ((array == null) || (array.length == 0)) {
508             return false;
509         }
510         else {
511             for (int i = 0; i < array.length; i++) {
512                 if (value == array[i]) {
513                     return true;
514                 }
515             }
516 
517             return false;
518         }
519     }
520 
521     public static boolean contains(long[] array, long value) {
522         if ((array == null) || (array.length == 0)) {
523             return false;
524         }
525         else {
526             for (int i = 0; i < array.length; i++) {
527                 if (value == array[i]) {
528                     return true;
529                 }
530             }
531 
532             return false;
533         }
534     }
535 
536     public static boolean contains(Object[] array, Object value) {
537         if ((array == null) || (array.length == 0) || (value == null)) {
538             return false;
539         }
540         else {
541             for (int i = 0; i < array.length; i++) {
542                 if (value.equals(array[i])) {
543                     return true;
544                 }
545             }
546 
547             return false;
548         }
549     }
550 
551     public static boolean contains(short[] array, short value) {
552         if ((array == null) || (array.length == 0)) {
553             return false;
554         }
555         else {
556             for (int i = 0; i < array.length; i++) {
557                 if (value == array[i]) {
558                     return true;
559                 }
560             }
561 
562             return false;
563         }
564     }
565 
566     public static String[] distinct(String[] array) {
567         return distinct(array, null);
568     }
569 
570     public static String[] distinct(
571         String[] array, Comparator<String> comparator) {
572 
573         if ((array == null) || (array.length == 0)) {
574             return array;
575         }
576 
577         Set<String> set = null;
578 
579         if (comparator == null) {
580             set = new TreeSet<String>();
581         }
582         else {
583             set = new TreeSet<String>(comparator);
584         }
585 
586         for (int i = 0; i < array.length; i++) {
587             String s = array[i];
588 
589             if (!set.contains(s)) {
590                 set.add(s);
591             }
592         }
593 
594         return set.toArray(new String[set.size()]);
595     }
596 
597     public static int getLength(Object[] array) {
598         if (array == null) {
599             return 0;
600         }
601         else {
602             return array.length;
603         }
604     }
605 
606     public static Object getValue(Object[] array, int pos) {
607         if ((array == null) || (array.length <= pos)) {
608             return null;
609         }
610         else {
611             return array[pos];
612         }
613     }
614 
615     public static boolean[] remove(boolean[] array, boolean value) {
616         List<Boolean> list = new ArrayList<Boolean>();
617 
618         for (int i = 0; i < array.length; i++) {
619             if (value != array[i]) {
620                 list.add(new Boolean(array[i]));
621             }
622         }
623 
624         return toArray(list.toArray(new Boolean[list.size()]));
625     }
626 
627     public static byte[] remove(byte[] array, byte value) {
628         List<Byte> list = new ArrayList<Byte>();
629 
630         for (int i = 0; i < array.length; i++) {
631             if (value != array[i]) {
632                 list.add(new Byte(array[i]));
633             }
634         }
635 
636         return toArray(list.toArray(new Byte[list.size()]));
637     }
638 
639     public static char[] remove(char[] array, char value) {
640         List<Character> list = new ArrayList<Character>();
641 
642         for (int i = 0; i < array.length; i++) {
643             if (value != array[i]) {
644                 list.add(new Character(array[i]));
645             }
646         }
647 
648         return toArray(list.toArray(new Character[list.size()]));
649     }
650 
651     public static double[] remove(double[] array, double value) {
652         List<Double> list = new ArrayList<Double>();
653 
654         for (int i = 0; i < array.length; i++) {
655             if (value != array[i]) {
656                 list.add(new Double(array[i]));
657             }
658         }
659 
660         return toArray(list.toArray(new Double[list.size()]));
661     }
662 
663     public static int[] remove(int[] array, int value) {
664         List<Integer> list = new ArrayList<Integer>();
665 
666         for (int i = 0; i < array.length; i++) {
667             if (value != array[i]) {
668                 list.add(new Integer(array[i]));
669             }
670         }
671 
672         return toArray(list.toArray(new Integer[list.size()]));
673     }
674 
675     public static long[] remove(long[] array, long value) {
676         List<Long> list = new ArrayList<Long>();
677 
678         for (int i = 0; i < array.length; i++) {
679             if (value != array[i]) {
680                 list.add(new Long(array[i]));
681             }
682         }
683 
684         return toArray(list.toArray(new Long[list.size()]));
685     }
686 
687     public static short[] remove(short[] array, short value) {
688         List<Short> list = new ArrayList<Short>();
689 
690         for (int i = 0; i < array.length; i++) {
691             if (value != array[i]) {
692                 list.add(new Short(array[i]));
693             }
694         }
695 
696         return toArray(list.toArray(new Short[list.size()]));
697     }
698 
699     public static String[] remove(String[] array, String value) {
700         List<String> list = new ArrayList<String>();
701 
702         for (String s : array) {
703             if (!s.equals(value)) {
704                 list.add(s);
705             }
706         }
707 
708         return list.toArray(new String[list.size()]);
709     }
710 
711     public static String[] removeByPrefix(String[] array, String prefix) {
712         List<String> list = new ArrayList<String>();
713 
714         for (String s : array) {
715             if (!s.startsWith(prefix)) {
716                 list.add(s);
717             }
718         }
719 
720         return list.toArray(new String[list.size()]);
721     }
722 
723     public static void reverse(String[] array) {
724         for (int left = 0, right = array.length - 1; left < right;
725                 left++, right--) {
726 
727             String value = array[left];
728 
729             array[left] = array[right];
730             array[right] = value;
731         }
732     }
733 
734     public static Boolean[] toArray(boolean[] array) {
735         Boolean[] newArray = new Boolean[array.length];
736 
737         for (int i = 0; i < array.length; i++) {
738             newArray[i] = Boolean.valueOf(array[i]);
739         }
740 
741         return newArray;
742     }
743 
744     public static boolean[] toArray(Boolean[] array) {
745         boolean[] newArray = new boolean[array.length];
746 
747         for (int i = 0; i < array.length; i++) {
748             newArray[i] = array[i].booleanValue();
749         }
750 
751         return newArray;
752     }
753 
754     public static Byte[] toArray(byte[] array) {
755         Byte[] newArray = new Byte[array.length];
756 
757         for (int i = 0; i < array.length; i++) {
758             newArray[i] = Byte.valueOf(array[i]);
759         }
760 
761         return newArray;
762     }
763 
764     public static byte[] toArray(Byte[] array) {
765         byte[] newArray = new byte[array.length];
766 
767         for (int i = 0; i < array.length; i++) {
768             newArray[i] = array[i].byteValue();
769         }
770 
771         return newArray;
772     }
773 
774     public static Character[] toArray(char[] array) {
775         Character[] newArray = new Character[array.length];
776 
777         for (int i = 0; i < array.length; i++) {
778             newArray[i] = Character.valueOf(array[i]);
779         }
780 
781         return newArray;
782     }
783 
784     public static char[] toArray(Character[] array) {
785         char[] newArray = new char[array.length];
786 
787         for (int i = 0; i < array.length; i++) {
788             newArray[i] = array[i].charValue();
789         }
790 
791         return newArray;
792     }
793 
794     public static Double[] toArray(double[] array) {
795         Double[] newArray = new Double[array.length];
796 
797         for (int i = 0; i < array.length; i++) {
798             newArray[i] = new Double(array[i]);
799         }
800 
801         return newArray;
802     }
803 
804     public static double[] toArray(Double[] array) {
805         double[] newArray = new double[array.length];
806 
807         for (int i = 0; i < array.length; i++) {
808             newArray[i] = array[i].doubleValue();
809         }
810 
811         return newArray;
812     }
813 
814     public static Float[] toArray(float[] array) {
815         Float[] newArray = new Float[array.length];
816 
817         for (int i = 0; i < array.length; i++) {
818             newArray[i] = new Float(array[i]);
819         }
820 
821         return newArray;
822     }
823 
824     public static float[] toArray(Float[] array) {
825         float[] newArray = new float[array.length];
826 
827         for (int i = 0; i < array.length; i++) {
828             newArray[i] = array[i].floatValue();
829         }
830 
831         return newArray;
832     }
833 
834     public static Integer[] toArray(int[] array) {
835         Integer[] newArray = new Integer[array.length];
836 
837         for (int i = 0; i < array.length; i++) {
838             newArray[i] = new Integer(array[i]);
839         }
840 
841         return newArray;
842     }
843 
844     public static int[] toArray(Integer[] array) {
845         int[] newArray = new int[array.length];
846 
847         for (int i = 0; i < array.length; i++) {
848             newArray[i] = array[i].intValue();
849         }
850 
851         return newArray;
852     }
853 
854     public static Long[] toArray(long[] array) {
855         Long[] newArray = new Long[array.length];
856 
857         for (int i = 0; i < array.length; i++) {
858             newArray[i] = new Long(array[i]);
859         }
860 
861         return newArray;
862     }
863 
864     public static long[] toArray(Long[] array) {
865         long[] newArray = new long[array.length];
866 
867         for (int i = 0; i < array.length; i++) {
868             newArray[i] = array[i].longValue();
869         }
870 
871         return newArray;
872     }
873 
874     public static Short[] toArray(short[] array) {
875         Short[] newArray = new Short[array.length];
876 
877         for (int i = 0; i < array.length; i++) {
878             newArray[i] = new Short(array[i]);
879         }
880 
881         return newArray;
882     }
883 
884     public static short[] toArray(Short[] array) {
885         short[] newArray = new short[array.length];
886 
887         for (int i = 0; i < array.length; i++) {
888             newArray[i] = array[i].shortValue();
889         }
890 
891         return newArray;
892     }
893 
894     public static String[] toStringArray(boolean[] array) {
895         String[] newArray = new String[array.length];
896 
897         for (int i = 0; i < array.length; i++) {
898             newArray[i] = String.valueOf(array[i]);
899         }
900 
901         return newArray;
902     }
903 
904     public static String[] toStringArray(byte[] array) {
905         String[] newArray = new String[array.length];
906 
907         for (int i = 0; i < array.length; i++) {
908             newArray[i] = String.valueOf(array[i]);
909         }
910 
911         return newArray;
912     }
913 
914     public static String[] toStringArray(char[] array) {
915         String[] newArray = new String[array.length];
916 
917         for (int i = 0; i < array.length; i++) {
918             newArray[i] = String.valueOf(array[i]);
919         }
920 
921         return newArray;
922     }
923 
924     public static String[] toStringArray(Date[] array, DateFormat df) {
925         String[] newArray = new String[array.length];
926 
927         for (int i = 0; i < array.length; i++) {
928             newArray[i] = df.format(array[i]);
929         }
930 
931         return newArray;
932     }
933 
934     public static String[] toStringArray(double[] array) {
935         String[] newArray = new String[array.length];
936 
937         for (int i = 0; i < array.length; i++) {
938             newArray[i] = String.valueOf(array[i]);
939         }
940 
941         return newArray;
942     }
943 
944     public static String[] toStringArray(float[] array) {
945         String[] newArray = new String[array.length];
946 
947         for (int i = 0; i < array.length; i++) {
948             newArray[i] = String.valueOf(array[i]);
949         }
950 
951         return newArray;
952     }
953 
954     public static String[] toStringArray(int[] array) {
955         String[] newArray = new String[array.length];
956 
957         for (int i = 0; i < array.length; i++) {
958             newArray[i] = String.valueOf(array[i]);
959         }
960 
961         return newArray;
962     }
963 
964     public static String[] toStringArray(JSONArray array) {
965         String[] newArray = new String[array.length()];
966 
967         for (int i = 0; i < array.length(); i++) {
968             newArray[i] = array.getString(i);
969         }
970 
971         return newArray;
972     }
973 
974     public static String[] toStringArray(long[] array) {
975         String[] newArray = new String[array.length];
976 
977         for (int i = 0; i < array.length; i++) {
978             newArray[i] = String.valueOf(array[i]);
979         }
980 
981         return newArray;
982     }
983 
984     public static String[] toStringArray(Object[] array) {
985         String[] newArray = new String[array.length];
986 
987         for (int i = 0; i < array.length; i++) {
988             newArray[i] = String.valueOf(array[i]);
989         }
990 
991         return newArray;
992     }
993 
994     public static String[] toStringArray(short[] array) {
995         String[] newArray = new String[array.length];
996 
997         for (int i = 0; i < array.length; i++) {
998             newArray[i] = String.valueOf(array[i]);
999         }
1000
1001        return newArray;
1002    }
1003
1004}