A functional, generic class to show how to get String values from an array and return such values converted to the generic type. This class provides default implementations for converting from String to classes representing primitive types.

Option3.java

import java.util.Arrays;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.function.Function;
import java.lang.reflect.Array;

public class Option3<T>{
    private int length;
    private String defaultValue;
    private final Class<T> klass;
    private final Function<String, T> conversionFunction;

    /**
     * Creates an Option3 that consider the values are primitives and therefore
     * can be automatically converted from String internally.
     * If the values aren't primitives, use the overloaded constructor to provide a conversion {@link Function}.
     * 
     * @throws RuntimeException when the generic type isn't a class representing a primitive value
     */
    public Option3(final Class<T> klass){
        this(klass, Option3.<T>getDefaultConversionFunction(klass));
    }

    public Option3(final Class<T> klass, final Function<String, T> conversionFunction){
        Objects.requireNonNull(conversionFunction);
        this.conversionFunction = conversionFunction;
        this.klass = klass;
    }

    @SuppressWarnings("unchecked")
    private static <T extends Object> Function<String, T> getDefaultConversionFunction(final Class<T> klass){
        //If the generic type is String, there is no need for conversion
        if(klass == String.class)
            return value -> (T)value; 
        else if(klass == Short.class)
            return value -> (T)Short.valueOf(value); 
        else if(klass == Integer.class)
            return value -> (T)Integer.valueOf(value);
        else if(klass == Long.class)
            return value -> (T)Long.valueOf(value);
        else if(klass == Float.class)
            return value -> (T)Float.valueOf(value);
        else if(klass == Double.class)
            return value -> (T)Double.valueOf(value); 
        else
            throw new RuntimeException(
                "There is no way to convert option values from String to " + klass.getSimpleName() +
                ". Use the overloaded constructors to pass a conversion Function.");
    }

    public T getFirstValue(final String[] values){
        return getValues(values)[0];
    }  

    /**
     * Gets the values of the Option3, excluding the Option3 name (the 0th element).
     * @return an array containing the values (without the 0th element), if the values' length isn't as expected; 
     *         or an array containing the default value if the length isn't as expected and there is a default value.
     * @throws IllegalStateException when the length of values isn't as expected and there isn't a default value
     */
    public T[] getValues(final String[] values){
        if(defaultValue == null && values.length != length){
            throw new IllegalStateException("Wrong Option3 line passed, string options do only have 2 values");
        }

        if(values.length == length) {
            return createGenericArray(values, 1);
        } 
        
        return  createGenericArray(new String[]{defaultValue});
    }

    private T[] createGenericArray(final String[] values){
        return createGenericArray(values, 0);
    }
    
    @SuppressWarnings("unchecked")
    private T[] createGenericArray(final String[] values, final int startInclusive){
        final T[] array = (T[])Array.newInstance(klass, values.length-startInclusive);
        //It was required to convert to list then to array in order to get an array of the generic type.
        Arrays
            .stream(values, startInclusive, values.length)
            .map(this.conversionFunction)
            .collect(Collectors.toList())
            .toArray(array);
        return array;
    }

    /* Trying the implementation. */
    public static void main(String[] args) {
        System.out.println();

        //Creates an Option3 of String values, which doesn't require a conversion Function.
        Option3<String> strOpt = new Option3<>(String.class);
        strOpt.length = 3;
        String[] values = new String[]{"-o", "1", "2"};
        System.out.println("First String Value: " + strOpt.getFirstValue(values));
        System.out.println("String Values: " + Arrays.toString(strOpt.getValues(values)));

        try{
            values = new String[]{"-o", "1"};
            //Error because the length of values isn't equal to 3
            System.out.println("First String Value: " + strOpt.getFirstValue(values));
        } catch(Exception e){
            System.out.println("\nError: " + e.getMessage() + "\n");
        }

        strOpt.length = 2;
        strOpt.defaultValue = "default value";
        values = new String[]{"-o"};
        System.out.println("First String Value: " + strOpt.getFirstValue(values));
        System.out.println("String Values: " + Arrays.toString(strOpt.getValues(values)) + "\n");        

        //Creates an Option3 of Integer values, which will be automatically converted internally from String to Integer.
        Option3<Integer> intOpt = new Option3<>(Integer.class);
        intOpt.length = 3;
        values = new String[]{"-o", "1", "2"};
        System.out.println("\nFirst Int Value: " + intOpt.getFirstValue(values));
        Integer[] intValues = intOpt.getValues(values);
        System.out.println("Int Values: ");
        for(Integer i: intValues){
            System.out.println(i);
        }
        System.out.println();

        values = new String[]{"-o", "99", "this value isn't a number and will throw an exception"};
        try {
            System.out.println("First Int Value: " + intOpt.getFirstValue(values));
            intValues = intOpt.getValues(values);
            System.out.println("Int Values: ");
            for(Integer i: intValues){
                System.out.println(i);
            }
        }catch(RuntimeException e){
            System.out.println(e.getMessage());
        }
    }
}