hadoop StringUtil

sdtf08

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);
            } else {
                sb.append(OutputDelimiter);
                sb.append(stringArray);
            }
        }
        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;
            }
        }
        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 = inputArray1;
        }

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

        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, "");
        }
        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;
        }
    }

}