hadoop StringUtil

import java.util.*;

public class StringUtil {

/**
* Converts an array of string to a string.
*/
public static String arrayToString(String[] stringArray, String OutputDelimiter) {
int linenum = 0;
StringBuffer sb = new StringBuffer();
for (int i = 0; i < stringArray.length; i++) {
linenum++;
if (linenum == 1) {
sb.append(stringArray[i]);
} else {
sb.append(OutputDelimiter);
sb.append(stringArray[i]);
}
}
return sb.toString();
}

/**
* This method takes an input string and returns the default value if the input string is null.
*
* @param input The string that needs to be checked for null
* @defaultValueIfInputIsNull If the "input" is null then replace it by this default value.
*/

public static String ifNull(String input, String defaultValueIfInputIsNull) {
String output = null;

if (input == null) {
output = defaultValueIfInputIsNull;
} else {
output = input;
}
return output;


}

/**
* This method splits a string by the delimiter and returns the value at the given position
*
* @param str The input string
* @param delimiter The delimiter that separates different values of the string
* @param tokenNumber The value of the string at the given tokenNumber. It works with 0 index.
* @return Returns null if the tokenNumber is greater than the total number of tokens in the string
* <p/>
* <b>Example:</b> For string "a:b:c:d:e:f:g", if the method is run with delimiter=":" and tokenNumber=1, it
* will return "b"
*/
public static String getValueAtToken(String str, String delimiter, int tokenNumber) {
String[] tokens = str.split(delimiter, -1);
String returnString = null;
for (int i = 0; i < tokens.length; i++) {
if (tokenNumber == i) {
returnString = tokens[i];
}
}
return returnString;
}

/**
* This method merges 2 input string arrays and returns the merged array as output
*
* @param inputArray1 Input Array 1 that needs to be merged
* @param inputArray2 Input Array 2 that needs to be merged
* @return Returns merged Array that contains all elements of inputArray1 followed by elements of inputArray2
* <p/>
* <b>Example:</b> The following are the input array
* <p/>
* inputArray1 contains elements ("a","b","c")
* <p/>
* inputArray2 contains element ("b","e")
* <p/>
* then the output array contains elements
* <p/>
* ("a","b","c","b","e")
*/
public static String[] mergeArrays(String[] inputArray1, String[] inputArray2) {
String[] outputArray = new String[inputArray1.length + inputArray2.length];
/**
* Copy first array to outputArray
*/
for (int i = 0; i < inputArray1.length; i++) {
outputArray[i] = inputArray1[i];
}

/**
* Copy second array to outputArray
*/
int outputArrayLength = inputArray1.length;
for (int i = 0; i < inputArray2.length; i++) {
outputArray[i + outputArrayLength] = inputArray2[i];
}

return outputArray;
}

/**
* This method returns the dedupe list of elements in the array
* e.g. supose an array has element 1,2,3,4,2,1
* then this method returns
* 1,2,3,4
*
* @param inputArray Input array
* @param outputDelimiter The delimiter used to separate output values
* @return Dedupe list of values in the array
* @throws MalformedLineException
*/
public static String dedupe(String[] inputArray, String outputDelimiter)
throws MalformedLineException {
TrafficEtlHashMap tehm = new TrafficEtlHashMap();
for (int i = 0; i < inputArray.length; i++) {
tehm.put(inputArray[i], "");
}
return tehm.getAllKeys(outputDelimiter);
}

/**
* Same as method dedupe(String[] inputArray, String outputDelimiter) except the input
* is different
*/
public static String dedupe(String inputList, String inputDelimiter, String outputDelimiter)
throws MalformedLineException {
String[] inputArray = inputList.split(inputDelimiter, -1);
return StringUtil.dedupe(inputArray, outputDelimiter);
}


/**
* Get property value from resource bundle
*
* @param rb ResourceBundle instance
* @param propertyName property name
* @return property value
*/
public static String getPropertyValue(ResourceBundle rb, String propertyName) {
String propertyValue = null;
try {
propertyValue = rb.getString(propertyName);
} catch (MissingResourceException ex) {
System.err.println("Could not find value for property: " + propertyName);
}
return propertyValue;
}

/**
* This method parses a string and return true if its an integer else it return false
*
* @param input
* @return
*/
public static boolean isInteger(String input) {
try {
Integer.parseInt(input);
return true;
} catch (Exception e) {
return false;
}
}

}