示例#1
0
 /**
  * Concatenate the given String arrays into one, with overlapping array elements included twice.
  *
  * <p>The order of elements in the original arrays is preserved.
  *
  * @param array1 the first array (can be {@code null})
  * @param array2 the second array (can be {@code null})
  * @return the new array ({@code null} if both given arrays were {@code null})
  */
 public static String[] concatenateStringArrays(String[] array1, String[] array2) {
   if (org.springframework.util.ObjectUtils.isEmpty(array1)) {
     return array2;
   }
   if (org.springframework.util.ObjectUtils.isEmpty(array2)) {
     return array1;
   }
   String[] newArr = new String[array1.length + array2.length];
   System.arraycopy(array1, 0, newArr, 0, array1.length);
   System.arraycopy(array2, 0, newArr, array1.length, array2.length);
   return newArr;
 }
示例#2
0
 /**
  * Turn given source String array into sorted array.
  *
  * @param array the source array
  * @return the sorted array (never {@code null})
  */
 public static String[] sortStringArray(String[] array) {
   if (org.springframework.util.ObjectUtils.isEmpty(array)) {
     return new String[0];
   }
   Arrays.sort(array);
   return array;
 }
示例#3
0
 /**
  * Merge the given String arrays into one, with overlapping array elements only included once.
  *
  * <p>The order of elements in the original arrays is preserved (with the exception of overlapping
  * elements, which are only included on their first occurrence).
  *
  * @param array1 the first array (can be {@code null})
  * @param array2 the second array (can be {@code null})
  * @return the new array ({@code null} if both given arrays were {@code null})
  */
 public static String[] mergeStringArrays(String[] array1, String[] array2) {
   if (org.springframework.util.ObjectUtils.isEmpty(array1)) {
     return array2;
   }
   if (org.springframework.util.ObjectUtils.isEmpty(array2)) {
     return array1;
   }
   List<String> result = new ArrayList<String>();
   result.addAll(Arrays.asList(array1));
   for (String str : array2) {
     if (!result.contains(str)) {
       result.add(str);
     }
   }
   return toStringArray(result);
 }
示例#4
0
 /**
  * Convenience method to return a String array as a delimited (e.g. CSV) String. E.g. useful for
  * {@code toString()} implementations.
  *
  * @param arr the array to display
  * @param delim the delimiter to use (probably a ",")
  * @return the delimited String
  */
 public static String arrayToDelimitedString(Object[] arr, String delim) {
   if (org.springframework.util.ObjectUtils.isEmpty(arr)) {
     return "";
   }
   if (arr.length == 1) {
     return org.springframework.util.ObjectUtils.nullSafeToString(arr[0]);
   }
   StringBuilder sb = new StringBuilder();
   for (int i = 0; i < arr.length; i++) {
     if (i > 0) {
       sb.append(delim);
     }
     sb.append(arr[i]);
   }
   return sb.toString();
 }
示例#5
0
 /**
  * Append the given String to the given String array, returning a new array consisting of the
  * input array contents plus the given String.
  *
  * @param array the array to append to (can be {@code null})
  * @param str the String to append
  * @return the new array (never {@code null})
  */
 public static String[] addStringToArray(String[] array, String str) {
   if (org.springframework.util.ObjectUtils.isEmpty(array)) {
     return new String[] {str};
   }
   String[] newArr = new String[array.length + 1];
   System.arraycopy(array, 0, newArr, 0, array.length);
   newArr[array.length] = str;
   return newArr;
 }
示例#6
0
 /**
  * Remove duplicate Strings from the given array. Also sorts the array, as it uses a TreeSet.
  *
  * @param array the String array
  * @return an array without duplicates, in natural sort order
  */
 public static String[] removeDuplicateStrings(String[] array) {
   if (org.springframework.util.ObjectUtils.isEmpty(array)) {
     return array;
   }
   Set<String> set = new TreeSet<String>();
   for (String element : array) {
     set.add(element);
   }
   return toStringArray(set);
 }
示例#7
0
 /**
  * Trim the elements of the given String array, calling {@code String.trim()} on each of them.
  *
  * @param array the original String array
  * @return the resulting array (of the same size) with trimmed elements
  */
 public static String[] trimArrayElements(String[] array) {
   if (org.springframework.util.ObjectUtils.isEmpty(array)) {
     return new String[0];
   }
   String[] result = new String[array.length];
   for (int i = 0; i < array.length; i++) {
     String element = array[i];
     result[i] = (element != null ? element.trim() : null);
   }
   return result;
 }
示例#8
0
  /**
   * Take an array Strings and split each element based on the given delimiter. A {@code Properties}
   * instance is then generated, with the left of the delimiter providing the key, and the right of
   * the delimiter providing the value.
   *
   * <p>Will trim both the key and value before adding them to the {@code Properties} instance.
   *
   * @param array the array to process
   * @param delimiter to split each element using (typically the equals symbol)
   * @param charsToDelete one or more characters to remove from each element prior to attempting the
   *     split operation (typically the quotation mark symbol), or {@code null} if no removal should
   *     occur
   * @return a {@code Properties} instance representing the array contents, or {@code null} if the
   *     array to process was {@code null} or empty
   */
  public static Properties splitArrayElementsIntoProperties(
      String[] array, String delimiter, String charsToDelete) {

    if (org.springframework.util.ObjectUtils.isEmpty(array)) {
      return null;
    }
    Properties result = new Properties();
    for (String element : array) {
      if (charsToDelete != null) {
        element = deleteAny(element, charsToDelete);
      }
      String[] splittedElement = split(element, delimiter);
      if (splittedElement == null) {
        continue;
      }
      result.setProperty(splittedElement[0].trim(), splittedElement[1].trim());
    }
    return result;
  }