for (Map.Entry<Class, String> entry : args.entrySet()) {
            switch (entry.getKey().toString()) {
                case "boolean"  : result.add(Boolean.parseBoolean(entry.getValue()));   break;
                case "long"     : result.add(Long.parseLong(entry.getValue()));         break;
                case "int"      : result.add(Integer.parseInt(entry.getValue()));       break;

                default         : result.add(getInstance(entry.getKey(), entry.getValue()));
            }
}

private static<T> T getInstance(Class<T> tClass, String value) throws Exception {
        return (T)tClass.getConstructor(String.class).newInstance(value);
}

package timesheet;

import java.io.File;
import java.io.FileNotFoundException;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Scanner;
import java.lang.reflect.InvocationTargetException;
import java.text.ParseException;
import java.util.List;
import java.lang.reflect.Constructor;
import java.util.Date;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.hibernate.Session;

import static java.lang.System.out;
import static java.util.Arrays.asList;

public class ImportTextFile {

    private Session session;
    private String fileName;
    private Class anyClass;

    public ImportTextFile(Session session, Class anyClass, String fileName, boolean execute) throws Exception {
        setSession(session);
        setAnyClass(anyClass);
        setFileName(fileName);
        if (execute) {
            executeImport();
        }
    }

    public final void executeImport() throws FileNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, ParseException {
        if (anyClass == null || fileName == null) { return; }
        try (Scanner scanFile = new Scanner(new File(fileName))) {
            if (!scanFile.hasNext()) { return; }

            HashMap<String, String> listHead = new HashMap<>();

            while (scanFile.hasNext()) {
                String lineHead = scanFile.nextLine();
                if (lineHead.contains("[Data]")) {
                    break;
                }
                String[] splited = lineHead.split("=");
                if (splited.length > 1) {
                    listHead.put(splited[0], splited[1]);
                }
            }

            List<String> listTitle = asList(listHead.get("FieldList").split(listHead.get("FieldDelimiter")));
            HashMap<Integer, Method> listEqual = new HashMap<>();

            for (Method itemMethod : anyClass.getDeclaredMethods()) {
                if (itemMethod.isAnnotationPresent(ImportField.class)) {
                    int i = listTitle.indexOf(itemMethod.getAnnotation(ImportField.class).name());
                    if (i > -1 && itemMethod.getName().matches("set.*") && itemMethod.getParameterTypes().length == 1) {
                        listEqual.put(i, itemMethod);
                    }
                }
            }
            while (scanFile.hasNext()) {
                String[] lineData = scanFile.nextLine().split(listHead.get("FieldDelimiter"));
                Object instance = anyClass.newInstance();
                for (Entry<Integer, Method> itemEqual : listEqual.entrySet()) {
                    String string = lineData[itemEqual.getKey()];
                    Method method = itemEqual.getValue();
                    
                    Class firstParam = method.getParameterTypes()[0];
                    method.invoke(instance,
                            (firstParam != Date.class)
                            ? instantiate(firstParam, string)
                            : new SimpleDateFormat(listHead.get("DateTimeFormat")).parse(string));
                }

                Method //методы могут быть не публичными?
                        naim = anyClass.getDeclaredMethod("getNaim"),
                        kind = anyClass.getDeclaredMethod("getKind"),
                        time = anyClass.getDeclaredMethod("getTime"),
                        day  = anyClass.getDeclaredMethod("getDay");

                printlnSpaceSeparated(naim.invoke(instance), kind.invoke(instance), time.invoke(instance), day.invoke(instance));
                //Class anyClass = Class.forName(className);
                //setMethod = anyClass.getDeclaredMethod(itemEntry.getValue().getName(), new Class[] { String.class/Date.class/int });
                //session.saveOrUpdate(anyObject);
            }

        }
    }


    //<editor-fold defaultstate="collapsed" desc="instantiation">
    private static final Map<Class, Constructor> CONSTRUCTORS = initConstructors();
    private static Map<Class, Constructor> initConstructors() {
        Map<Class, Constructor> map = new HashMap<>();
        try {
            Constructor
                    booleanC = getConstructor(Boolean.class),
                    byteC    = getConstructor(Byte.class),
                    shortC   = getConstructor(Short.class),
                    integerC = getConstructor(Integer.class),
                    longC    = getConstructor(Long.class),
                    floatC   = getConstructor(Float.class),
                    doubleC  = getConstructor(Double.class);

            map.put(boolean.class, booleanC);
            map.put(Boolean.class, booleanC);
            map.put(byte.class, byteC);
            map.put(Byte.class, byteC);
            map.put(short.class, shortC);
            map.put(Short.class, shortC);
            map.put(int.class, integerC);
            map.put(Integer.class, integerC);
            map.put(long.class, longC);
            map.put(Long.class, longC);
            map.put(float.class, floatC);
            map.put(Float.class, floatC);
            map.put(double.class, doubleC);
            map.put(Double.class, doubleC);

            map.put(String.class, getConstructor(String.class));
        } catch (Exception ex) {
            Logger.getLogger(ImportTextFile.class.getName()).log(Level.SEVERE, null, ex);
            return null;
        }
        return map;
    }

    private static <T> Constructor<T> getConstructor(Class<T> cls) throws NoSuchMethodException {
        return cls.getConstructor(String.class);
    }

    private static <T> T instantiate(Class<T> cls, String value) throws NoSuchMethodException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        Constructor<T> constructor = CONSTRUCTORS.get(cls);
        if (constructor == null) {
            CONSTRUCTORS.put(cls, constructor = getConstructor(cls));
        }
        return constructor.newInstance(value);
    }
    //</editor-fold>


    private static void printlnSpaceSeparated(Object... objects) {
        if (objects.length > 0) {
            out.print(objects[0]);
        }
        for (int i = 1; i < objects.length; ++i) {
            out.print(" ");
            out.print(objects[i]);
        }
        out.println();
    }

    public Session getSession() {
        return session;
    }

    public final void setSession(Session session) {
        this.session = session;
    }

    public String getFileName() {
        return fileName;
    }

    public final void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public Class getAnyClass() {
        return anyClass;
    }

    public final void setAnyClass(Class anyClass) {
        this.anyClass = anyClass;
    }
}

package timesheet;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Inherited
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ImportField {

    String name();
    String format() default "";
}