1 /*
2  * Copyright (C) 2011 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.android.tradefed.util;
17 
18 import java.util.ArrayList;
19 import java.util.Arrays;
20 import java.util.Collection;
21 import java.util.Iterator;
22 import java.util.List;
23 
24 /**
25  * Utility methods for arrays
26  */
27 public class ArrayUtil {
28 
ArrayUtil()29     private ArrayUtil() {
30     }
31 
32     /**
33      * Build an array from the provided contents.
34      *
35      * <p>
36      * The resulting array will be the concatenation of <var>arrays</var> input arrays, in their
37      * original order.
38      * </p>
39      *
40      * @param arrays the arrays to concatenate
41      * @return the newly constructed array
42      */
buildArray(String[].... arrays)43     public static String[] buildArray(String[]... arrays) {
44         int length = 0;
45         for (String[] array : arrays) {
46             length += array.length;
47         }
48         String[] newArray = new String[length];
49         int offset = 0;
50         for (String[] array : arrays) {
51             System.arraycopy(array, 0, newArray, offset, array.length);
52             offset += array.length;
53         }
54         return newArray;
55     }
56 
57     /**
58      * Convert a varargs list/array to an {@link List}.  This is useful for building instances of
59      * {@link List} by hand.  Note that this differs from {@link java.util.Arrays#asList} in that
60      * the returned array is mutable.
61      *
62      * @param inputAry an array, or a varargs list
63      * @return a {@link List} instance with the identical contents
64      */
65     @SafeVarargs
list(T... inputAry)66     public static <T> List<T> list(T... inputAry) {
67         List<T> retList = new ArrayList<T>(inputAry.length);
68         for (T item : inputAry) {
69             retList.add(item);
70         }
71         return retList;
72     }
73 
internalJoin(String sep, Collection<Object> pieces)74     private static String internalJoin(String sep, Collection<Object> pieces) {
75         StringBuilder sb = new StringBuilder();
76         boolean skipSep = true;
77         Iterator<Object> iter = pieces.iterator();
78         while (iter.hasNext()) {
79             if (skipSep) {
80                 skipSep = false;
81             } else {
82                 sb.append(sep);
83             }
84 
85             Object obj = iter.next();
86             if (obj == null) {
87                 sb.append("null");
88             } else {
89                 sb.append(obj.toString());
90             }
91         }
92         return sb.toString();
93     }
94 
95     /**
96      * Turns a sequence of objects into a string, delimited by {@code sep}.  If a single
97      * {@code Collection} is passed, it is assumed that the elements of that Collection are to be
98      * joined.  Otherwise, wraps the passed {@link Object}(s) in a {@link List} and joins the
99      * generated list.
100      *
101      * @param sep the string separator to delimit the different output segments.
102      * @param pieces A {@link Collection} or a varargs {@code Array} of objects.
103      */
104     @SuppressWarnings("unchecked")
join(String sep, Object... pieces)105     public static String join(String sep, Object... pieces) {
106         if ((pieces.length == 1) && (pieces[0] instanceof Collection)) {
107             // Don't re-wrap the Collection
108             return internalJoin(sep, (Collection<Object>) pieces[0]);
109         } else {
110             return internalJoin(sep, Arrays.asList(pieces));
111         }
112     }
113 }
114 
115